@sqg/sqg 0.1.1

package/dist/templates/better-sqlite3.hbs

@@ -0,0 +1,96 @@
+// {{generatedComment}}
+import type { Database, RunResult, Statement } from 'better-sqlite3';
+
+export class {{className}} {
+    private statements = new Map<string, Statement>();
+
+    constructor(private db: Database) {}
+
+    private prepare<BindParameters extends unknown[] | {} = unknown[], Result = unknown>(id: string, query: string, isPluck = false) {
+        let stmt = this.statements.get(id);
+        if (!stmt) {
+            stmt = this.db.prepare(query);
+            if (isPluck) {
+                stmt = stmt.pluck();
+            }
+            this.statements.set(id, stmt);
+        }
+        return stmt as Statement<BindParameters, Result>;
+    }
+
+    static getMigrations(): string[] {   
+        return [
+            {{#each migrations}}
+            {{{quote sqlQuery}}},
+            {{/each}}
+        ];
+    }
+
+    static getQueryNames(): Map<string, keyof {{className}}> {
+        return new Map([
+            {{#each queries}} {{#unless skipGenerateFunction}}
+            ["{{id}}", "{{functionName}}"],{{/unless}}{{/each}}]
+        );
+    }
+    
+    {{#each queries}}
+    {{#unless skipGenerateFunction}}
+    {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): {{> returnType }} {
+        const stmt = this.prepare<[{{> paramTypes}}], {{> resultType}}>('{{id}}', 
+            {{{quote sqlQuery}}}{{#if isPluck}}, true{{/if}});
+        {{> execute}}
+    }
+    {{/unless}}
+    {{/each}}
+}
+
+{{#*inline "params"}}{{#each parameterNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "paramTypes"}}{{#each parameters}}{{type}} {{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "columnTypes"}}{{#each columns}}{{name}}: {{mapType .}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "rowType"}}
+{{#if isQuery~}}
+{{#if isPluck~}}
+{{#if columns.length~}} {{mapType (lookup columns 0)}} {{else}}any{{/if~}}
+{{~else~}}
+{{#if columns.length}}{ {{> columnTypes}} }{{else}}any{{/if~}}
+{{/if~}}
+{{~else~}}
+any
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "resultType"}}
+{{#if isQuery~}}
+{{> rowType}}
+{{~else~}}
+any
+{{~/if~}}
+{{/inline~}}
+
+
+{{#*inline "returnType"}}
+{{#if isQuery~}}
+{{#if isOne~}}
+{{> rowType}} | undefined
+{{~else~}}
+{{> rowType}}[]
+{{/if~}}
+{{~else~}}
+RunResult
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "execute"}}
+{{#if isQuery}}
+{{#if isOne}}
+return stmt.get({{> params}});
+{{else}}
+return stmt.all({{> params}});
+{{/if}}
+{{else}}
+return stmt.run({{> params}});
+{{/if}}
+{{/inline}}

package/dist/templates/java-duckdb-arrow.hbs

@@ -0,0 +1,106 @@
+// {{generatedComment}}
+package {{config.package}};
+
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.*;
+import org.apache.arrow.vector.complex.ListVector;
+import org.apache.arrow.vector.ipc.ArrowReader;
+import org.duckdb.DuckDBConnection;
+import org.duckdb.DuckDBResultSet;
+import {{config.package}}.{{className}}Jdbc.*;
+
+public class {{className}} {
+    private final DuckDBConnection connection;
+    private final {{className}}Jdbc jdbc;
+
+    public {{className}}(DuckDBConnection connection) {
+        this.connection = connection;
+        this.jdbc = new {{className}}Jdbc(connection);
+    }
+
+
+    public static List<String> getMigrations() {   
+        return {{className}}Jdbc.getMigrations();
+    }
+
+    {{#each queries}}
+    {{#unless skipGenerateFunction}}
+    {{#if isOne}}
+    public {{> returnType}} {{functionName}}({{#each variables}}{{type}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
+        return jdbc.{{functionName}}({{#each variables}}{{name}}{{#unless @last}}, {{/unless}}{{/each}});
+    }
+    {{else}}
+    {{>columnTypesRecord}}
+    public {{> returnType}} {{functionName}}({{#each variables}}{{type}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException, IOException {
+        var stmt = connection.prepareStatement("""
+{{{sqlQuery}}}""");
+    {{> execute}}
+    }
+    {{/if}}
+    {{/unless}}
+    {{/each}}
+}
+
+
+
+
+{{#*inline "columnTypesRecord"}}
+{{#if isQuery}}
+{{#if isOne}}
+public record {{rowType}}({{#each columns}}{{type}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
+{{else}}
+public record {{rowType}}(PreparedStatement statement, RootAllocator allocator, ArrowReader reader,
+{{#each columns}}{{mapType this}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) implements AutoCloseable {
+    public boolean loadNextBatch() throws IOException {
+        return reader.loadNextBatch();
+    }
+    
+    public int getRowCount() throws IOException {
+        return reader.getVectorSchemaRoot().getRowCount();
+    }
+
+    public void close() throws IOException, SQLException {
+        reader.close();
+        allocator.close();
+        statement.close();
+    }
+}
+{{/if}}
+{{/if}}
+{{/inline}}
+
+{{#*inline "returnType"}}
+{{#if isQuery~}}
+{{functionReturnType}}
+{{~else~}}
+int
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "readVectors"}}
+var root = reader.getVectorSchemaRoot();
+
+return new {{rowType}}(stmt, allocator, reader, {{#each columns}}({{mapType this}})root.getVector("{{name}}"){{#unless @last}}, {{/unless}}{{/each}});
+
+{{/inline~}}
+
+
+{{#*inline "execute"}}
+{{#each parameterNames}}stmt.setObject({{plusOne @index}}, {{this}});
+{{/each}}
+{{#if isQuery}}
+    var rs = (DuckDBResultSet) stmt.executeQuery();
+    var allocator = new RootAllocator();
+    var reader = (ArrowReader) rs.arrowExportStream(allocator, 65536);
+    {{> readVectors}}
+    {{else}}
+    return stmt.executeUpdate();
+{{/if}}
+{{/inline}}

package/dist/templates/java-jdbc.hbs

@@ -0,0 +1,169 @@
+// {{generatedComment}}
+package {{config.package}};
+
+import java.sql.Array;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Struct;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Collections;
+import java.util.UUID;
+import java.util.function.Function;
+
+public class {{className}} {
+    private final Connection connection;
+
+    public {{className}}(Connection connection) {
+        this.connection = connection;
+    }
+
+    private static Object[] getObjectArray(Array array) {
+        if (array == null) {
+            return null;
+        }
+        try {
+            return (Object[]) array.getArray();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    private static Object[] getAttr(Struct struct) {
+        if (struct == null) {
+            return null;
+        }
+        try {
+            return struct.getAttributes();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    private static <K> List<K> arrayToList(
+        Array array,
+        Class<? extends K[]> baseType
+    )  {
+        var objectArray = getObjectArray(array);
+        if (objectArray == null) {
+            return null;
+        }
+        return Collections.unmodifiableList(
+            Arrays.asList(
+                Arrays.copyOf(objectArray, objectArray.length, baseType)
+            )
+        );
+    }
+
+    private static <K> List<K> arrayOfStructToList(
+        Array array,
+        Function<Object[], K> convert
+    )  {
+        var objectArray = getObjectArray(array);
+        if (objectArray == null) {
+            return null;
+        }
+        var list = new ArrayList<K>(objectArray.length);
+        for (Object obj : objectArray) {
+            list.add(obj != null ? convert.apply(getAttr((Struct)obj)) : null);
+        }
+        return Collections.unmodifiableList(list);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <K> List<List<K>> multiDimArrayToList(
+        Array array,
+        Class<? extends K[]> baseType
+    )  {
+        var objectArray = getObjectArray(array);
+        if (objectArray == null) {
+            return null;
+        }
+        var list = new ArrayList<List<K>>(objectArray.length);
+        for (Object obj : objectArray) {
+            if (obj == null) {
+                list.add(null);
+            } else if (obj instanceof Array) {
+                list.add(arrayToList((Array)obj, baseType));
+            } else if (obj instanceof Object[]) {
+                var inner = (Object[]) obj;
+                list.add(Collections.unmodifiableList(
+                    Arrays.asList(Arrays.copyOf(inner, inner.length, baseType))
+                ));
+            } else {
+                throw new RuntimeException("Unexpected type in multi-dimensional array: " + obj.getClass());
+            }
+        }
+        return Collections.unmodifiableList(list);
+    }
+
+    private static final List<String> migrations = List.of(
+        {{#each migrations}}"""
+{{{sqlQuery}}}"""{{#unless @last}},{{/unless}}
+        {{/each}}
+    );
+
+    public static List<String> getMigrations() {   
+        return migrations;
+    }
+
+    {{#each queries}}
+    {{#unless skipGenerateFunction}}
+    {{>columnTypesRecord}}
+    public {{> returnType}} {{functionName}}({{#each variables}}{{{type}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
+        try (var stmt = connection.prepareStatement({{{partsToString sqlQueryParts}}})) {
+            {{> execute}}
+        }
+    }
+    {{/unless}}
+    {{/each}}
+}
+
+
+{{#*inline "columnTypesRecord"}}
+{{#if isQuery}}
+{{{declareTypes this}}}
+{{/if}}
+{{/inline}}
+
+{{#*inline "returnType"}}
+{{#if isQuery~}}
+{{functionReturnType}}
+{{~else~}}
+int
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "readRow"}}
+{{{readColumns this}}}
+{{/inline~}}
+
+{{#*inline "execute"}}
+{{#each parameterNames}}stmt.setObject({{plusOne @index}}, {{this}});
+{{/each}}
+{{#if isQuery}}
+try(var rs = stmt.executeQuery()) {
+{{#if isOne}}
+        return rs.next() ? {{> readRow}} : null;    
+{{else}}
+var results = new ArrayList<{{rowType}}>();
+while (rs.next()) {
+    results.add({{> readRow}});
+}
+return results;
+{{/if}}
+}
+{{else}}
+return stmt.executeUpdate();
+{{/if}}
+{{/inline}}

package/dist/templates/typescript-duckdb.hbs

@@ -0,0 +1,89 @@
+// {{generatedComment}}
+import type { DuckDBConnection, DuckDBMaterializedResult } from "@duckdb/node-api";
+
+export class {{className}} {
+    
+    constructor(private conn: DuckDBConnection) {}
+
+    static getMigrations(): string[] {   
+        return [
+            {{#each migrations}}
+            {{{quote sqlQuery}}},
+            {{/each}}
+        ];
+    }
+
+    static getQueryNames(): Map<string, keyof {{className}}> {
+        return new Map([
+            {{#each queries}} {{#unless skipGenerateFunction}}
+            ["{{id}}", "{{functionName}}"],{{/unless}}{{/each}}]
+        );
+    }
+
+    {{#each queries}}
+    {{#unless skipGenerateFunction}}
+    async {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): Promise<{{> returnType }}> {
+        const sql = {{{quote sqlQuery}}};
+        {{#if isQuery}}
+        const reader = await this.conn.runAndReadAll(sql,[{{> params}}]);
+        {{#if isPluck}}
+        {{#if isOne}}
+        return reader.getRows()[0]?.[0] as {{> rowType}} | undefined;
+        {{else}}
+        return reader.getRows().map((row) => row[0] as {{> rowType}});
+        {{/if}}
+        {{else}}
+        {{#if isOne}}
+        return reader.getRowObjects()[0] as {{> rowType}} | undefined;
+        {{else}}
+        return reader.getRowObjects() as {{> rowType}}[];
+        {{/if}}
+        {{/if}}
+        {{else}}
+        return await this.conn.run(sql,[{{> params}}]);
+        {{/if}}
+    }
+    {{/unless}}
+
+    {{/each}}
+}
+
+{{#*inline "params"}}{{#each parameterNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "paramTypes"}}{{#each parameters}}{{type}} {{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "columnTypes"}}{{#each columns}}{{name}}: {{{tsType .}}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}
+
+{{#*inline "rowType"}}
+{{#if isQuery~}}
+{{#if isPluck~}}
+{{#if columns.length~}} {{{tsType (lookup columns 0)}}} {{else}}any{{/if~}}
+{{~else~}}
+{{#if columns.length}}{ {{> columnTypes}} }{{else}}any{{/if~}}
+{{/if~}}
+{{~else~}}
+any
+{{~/if~}}
+{{/inline~}}
+
+{{#*inline "resultType"}}
+{{#if isQuery~}}
+{{> rowType}}
+{{~else~}}
+any
+{{~/if~}}
+{{/inline~}}
+
+
+{{#*inline "returnType"}}
+{{#if isQuery~}}
+{{#if isOne~}}
+{{> rowType}} | undefined
+{{~else~}}
+({{> rowType}})[]
+{{/if~}}
+{{~else~}}
+DuckDBMaterializedResult
+{{~/if~}}
+{{/inline~}}
+

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@sqg/sqg",
+  "version": "0.1.1",
+  "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
+  "type": "module",
+  "bin": {
+    "sqg": "./dist/sqg.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sqg-dev/sqg.git"
+  },
+  "homepage": "https://sqg.dev",
+  "bugs": {
+    "url": "https://github.com/sqg-dev/sqg/issues"
+  },
+  "keywords": [],
+  "author": "Uwe Maurer",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@biomejs/biome": "2.3.3",
+    "@duckdb/node-api": "1.4.3-r.2",
+    "@duckdb/node-bindings-linux-x64": "1.4.3-r.2",
+    "@lezer-unofficial/printer": "^1.0.1",
+    "@lezer/common": "^1.5.0",
+    "@lezer/generator": "^1.8.0",
+    "@lezer/lr": "^1.4.6",
+    "better-sqlite3": "^12.5.0",
+    "commander": "^14.0.2",
+    "consola": "^3.4.2",
+    "dotenv": "^17.2.3",
+    "es-toolkit": "^1.43.0",
+    "handlebars": "^4.7.8",
+    "pg": "^8.16.3",
+    "pg-types": "^4.1.0",
+    "prettier": "^3.7.4",
+    "prettier-plugin-java": "^2.7.7",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.3",
+    "@types/pg": "^8.16.0",
+    "@vitest/ui": "^4.0.16",
+    "tsdown": "0.18.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "scripts": {
+    "build": "tsc --noEmit && tsdown && cp -r src/templates dist",
+    "lezer-gen": "lezer-generator src/parser/sql.grammar -o src/parser/sql-parser.ts",
+    "test-grammar": "tsx src/test-grammar.ts",
+    "check": "biome check --write src/",
+    "check:errors": "pnpm biome check --write --diagnostic-level=error src/",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "sqg": "tsx src/sqg.ts"
+  }
+}