Sqlc: Compile SQL to type-safe code

1. sqlc

   1 182 15,023 9.0 Go

   Generate type-safe code from SQL

   

   I missed this too. However, I've found you can work around it pretty easily with clauses like CASE WHEN @field != "" THEN column = @field ELSE true END.

   Example from the sqlc creator (https://github.com/sqlc-dev/sqlc/discussions/364#discussionc...):

     -- name: FilterFoo :many

2. InfluxDB

   www.influxdata.com featured

   InfluxDB – Built for High-Performance Time Series Workloads. InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.

   

3. services

   2 1 15 8.4 Go

   helpwave's microservices (by helpwave)

   

   Migrated from GORM to sqlc. We like the code generation approach with the simplistic abstractions.

   https://github.com/helpwave/services/tree/main/services/task...

4. xo

   3 17 3,817 7.0 Go

   Command line tool to generate idiomatic Go code for SQL databases supporting PostgreSQL, MySQL, SQLite, Oracle, and Microsoft SQL Server

   

   XO doesn’t have them built-in, but it uses easily customizable templates.

   I added support for a bunch of postgres fancy stuff in a previous app, it wasn’t too difficult

   https://github.com/xo/xo

5. potygen

   4 4 103 2.8 TypeScript

   Postgres SQL Parser and type generator

   

   There was a saying that before learning postgres in depth, the db is just a dumb store of data for devs, once you spend time to learn the tools it provides though, most applications just look like a very thin layer on top of the sql.

   There is so much more to rdbms (especially pg) than just joins - common table expressions, window functions, various views, let alone all the extensibility - extensions, custom types, even enums.

   All of that can enable writing performant, type safe and very compact applications.

   I am yet to see libs that embrace the elegance of it all - I’ve attempted this once - https://github.com/ivank/potygen but didn’t get much traction. I’m now just waiting for someone more determined to pick up those ideas - a client lib that exposes the type safety and intellisence at compile time and allows you to easily compose those sql queries.

   I think this project has some ways to go to reach that though, but thankfully it is a step in the right direction.

6. squiller

   5 2 10 2.8 Rust

   Generate boilerplate from annotated SQL queries

   

   To add one to the mix: https://docs.ruuda.nl/squiller/

7. jOOQ

   6 99 6,382 9.8 Java

   jOOQ is the best way to write SQL in Java

   

8. feldera

   7 14 1,376 10.0 Rust

   The Feldera Incremental Computation Engine

   

   This is somewhat common when high performance is needed it seems: e.g., https://github.com/feldera/feldera comes to mind which uses the same approach to compile SQL to type-safe incremental query plans in rust.

9. SaaSHub

   www.saashub.com featured

   SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

   

10. cornucopia

    8 22 968 3.1 Rust

    Generate type-checked Rust from your PostgreSQL.

    

11. kysely

    9 42 12,001 9.1 TypeScript

    A type-safe TypeScript SQL query builder

    

    Surprised nobody has mentioned “Kysely” (https://kysely.dev).

    It is a query builder (not an ORM), that (ab)-uses the Typescript type system to give you full type safety, intellisense, autocomplete etc.

    Crucially it doesn’t require any build/compile step for your queries which is fantastic.

12. slonik

    10 74 4,741 8.8 TypeScript

    A Node.js PostgreSQL client with runtime and build time type safety, and composable SQL.

    

    Didn’t use myself, but AFAIK slonik library is doing what you’ve described: https://github.com/gajus/slonik

13. SQLDelight

    11 33 6,440 9.1 Kotlin

    SQLDelight - Generates typesafe Kotlin APIs from SQL

    

14. crawshaw

    12 1 23 4.9 C

    Low-level Go interface to SQLite 3 using cgo

    

    Not everything. Most SQL databases differ enough that it's worth using bindings specific to them. For example https://github.com/go-llsqlite/crawshaw?tab=readme-ov-file for SQLite.

    I can't get behind something like SQL because if it doesn't support your language or SQL dialect or the feature you need you're worse off than not using it.

15. sqlx

    13 151 14,748 9.2 Rust

    🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite. (by launchbadge)

    

    This looks like a less ergonomic version of Rust's SQLx (https://github.com/launchbadge/sqlx) but a more robust version of TypeScript's sqlx-ts (https://jasonshin.github.io/sqlx-ts/). Sqlc seems to copy the latter's unfortunate lack of inline SQL statements. Still, seems promising.

Suggest a related project