@malloydata/db-duckdb 0.0.336 → 0.0.338

package/dist/duckdb_common.d.ts

@@ -1,4 +1,4 @@
-import type { MalloyQueryData, PersistSQLResults, PooledConnection, QueryDataRow, QueryOptionsReader, QueryRunStats, RunSQLOptions, StreamingConnection, StructDef, TestableConnection, SQLSourceDef, TableSourceDef, SQLSourceRequest } from '@malloydata/malloy';
+import type { MalloyQueryData, PersistSQLResults, PooledConnection, QueryRecord, QueryOptionsReader, QueryRunStats, RunSQLOptions, StreamingConnection, StructDef, TestableConnection, SQLSourceDef, TableSourceDef, SQLSourceRequest } from '@malloydata/malloy';
 import { BaseConnection } from '@malloydata/malloy/connection';
 export interface DuckDBQueryOptions {
     rowLimit: number;
@@ -7,6 +7,7 @@ export declare abstract class DuckDBCommon extends BaseConnection implements Tes
     protected queryOptions?: QueryOptionsReader | undefined;
     protected isMotherDuck: boolean;
     protected motherDuckToken: string | undefined;
+    protected setupSQL: string | undefined;
     private readonly dialect;
     static DEFAULT_QUERY_OPTIONS: DuckDBQueryOptions;
     readonly name: string;
@@ -18,15 +19,15 @@ export declare abstract class DuckDBCommon extends BaseConnection implements Tes
     abstract getDigest(): string;
     protected abstract setup(): Promise<void>;
     protected abstract runDuckDBQuery(sql: string): Promise<{
-        rows: QueryDataRow[];
+        rows: QueryRecord[];
         totalRows: number;
     }>;
     runRawSQL(sql: string): Promise<{
-        rows: QueryDataRow[];
+        rows: QueryRecord[];
         totalRows: number;
     }>;
     runSQL(sql: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-    abstract runSQLStream(sql: string, options: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
+    abstract runSQLStream(sql: string, options: RunSQLOptions): AsyncIterableIterator<QueryRecord>;
     fetchSelectSchema(sqlRef: SQLSourceRequest): Promise<SQLSourceDef | string>;
     estimateQueryCost(_: string): Promise<QueryRunStats>;
     fillStructDefFromTypeMap(structDef: StructDef, typeMap: {
@@ -36,7 +37,6 @@ export declare abstract class DuckDBCommon extends BaseConnection implements Tes
     fetchTableSchema(tableKey: string, tablePath: string): Promise<TableSourceDef>;
     canStream(): this is StreamingConnection;
     test(): Promise<void>;
-    abstract createHash(sqlCommand: string): Promise<string>;
     manifestTemporaryTable(sqlCommand: string): Promise<string>;
     abstract close(): Promise<void>;
 }

package/dist/duckdb_common.js

@@ -137,8 +137,8 @@ class DuckDBCommon extends connection_1.BaseConnection {
         await this.runRawSQL('SELECT 1');
     }
     async manifestTemporaryTable(sqlCommand) {
-        const hash = await this.createHash(sqlCommand);
-        const tableName = `tt${hash}`;
+        const hash = (0, malloy_1.makeDigest)(sqlCommand);
+        const tableName = `tt${hash.slice(0, this.dialect.maxIdentifierLength - 2)}`;
         const cmd = `CREATE TEMPORARY TABLE IF NOT EXISTS ${tableName} AS (${sqlCommand});`;
         // console.log(cmd);
         await this.runRawSQL(cmd);

package/dist/duckdb_connection.d.ts

@@ -1,13 +1,14 @@
 import { DuckDBCommon } from './duckdb_common';
 import { DuckDBInstance } from '@duckdb/node-api';
 import type { DuckDBConnection as DuckDBNodeConnection } from '@duckdb/node-api';
-import type { ConnectionConfig, QueryDataRow, QueryOptionsReader, RunSQLOptions } from '@malloydata/malloy';
+import type { ConnectionConfig, QueryRecord, QueryOptionsReader, RunSQLOptions } from '@malloydata/malloy';
 export interface DuckDBConnectionOptions extends ConnectionConfig {
     additionalExtensions?: string[];
     databasePath?: string;
     motherDuckToken?: string;
     workingDirectory?: string;
     readOnly?: boolean;
+    setupSQL?: string;
 }
 interface ActiveDB {
     instance: DuckDBInstance;
@@ -31,11 +32,10 @@ export declare class DuckDBConnection extends DuckDBCommon {
     loadExtension(ext: string): Promise<void>;
     protected setup(): Promise<void>;
     protected runDuckDBQuery(sql: string): Promise<{
-        rows: QueryDataRow[];
+        rows: QueryRecord[];
         totalRows: number;
     }>;
-    runSQLStream(sql: string, { rowLimit, abortSignal }?: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
-    createHash(sqlCommand: string): Promise<string>;
+    runSQLStream(sql: string, { rowLimit, abortSignal }?: RunSQLOptions): AsyncIterableIterator<QueryRecord>;
     close(): Promise<void>;
     /**
      * Forcefully close all cached DuckDB instances. Useful for test cleanup

package/dist/duckdb_connection.js

@@ -70,6 +70,9 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
             if (Array.isArray(arg.additionalExtensions)) {
                 this.additionalExtensions = arg.additionalExtensions;
             }
+            if (typeof arg.setupSQL === 'string') {
+                this.setupSQL = arg.setupSQL;
+            }
         }
         if (this.databasePath === ':memory:') {
             this.readOnly = false;
@@ -80,8 +83,8 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         this.connecting = this.init();
     }
     getDigest() {
-        const data = `duckdb:${this.databasePath}:${this.workingDirectory}`;
-        return (0, malloy_1.makeDigest)(data);
+        var _a;
+        return (0, malloy_1.makeDigest)('duckdb', this.databasePath, this.workingDirectory, (_a = this.setupSQL) !== null && _a !== void 0 ? _a : '');
     }
     async init() {
         try {
@@ -161,6 +164,14 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
                     console.error(`duckdb setup ${cmd} => ${error}`);
                 }
             }
+            if (this.setupSQL) {
+                for (const stmt of this.setupSQL.split(';\n')) {
+                    const trimmed = stmt.trim();
+                    if (trimmed) {
+                        await this.runDuckDBQuery(trimmed);
+                    }
+                }
+            }
         };
         await this.connecting;
         if (!this.isSetup) {
@@ -205,9 +216,6 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
             }
         }
     }
-    async createHash(sqlCommand) {
-        return (0, malloy_1.makeDigest)(sqlCommand);
-    }
     async close() {
         const activeDB = DuckDBConnection.activeDBs[this.databasePath];
         if (activeDB) {

package/dist/duckdb_wasm_connection.d.ts

@@ -1,5 +1,5 @@
 import * as duckdb from '@duckdb/duckdb-wasm';
-import type { FetchSchemaOptions, QueryDataRow, QueryOptionsReader, RunSQLOptions, SQLSourceDef, ConnectionConfig, TableSourceDef, SQLSourceRequest } from '@malloydata/malloy';
+import type { FetchSchemaOptions, QueryRecord, QueryOptionsReader, RunSQLOptions, SQLSourceDef, ConnectionConfig, TableSourceDef, SQLSourceRequest } from '@malloydata/malloy';
 import { DuckDBCommon } from './duckdb_common';
 type RemoteFileCallback = (tableName: string) => Promise<Uint8Array | undefined>;
 export interface DuckDBWasmOptions extends ConnectionConfig {
@@ -7,6 +7,7 @@ export interface DuckDBWasmOptions extends ConnectionConfig {
     databasePath?: string;
     motherDuckToken: string | undefined;
     workingDirectory?: string;
+    setupSQL?: string;
 }
 export declare abstract class DuckDBWASMConnection extends DuckDBCommon {
     readonly arg: string | DuckDBWasmOptions;
@@ -31,10 +32,10 @@ export declare abstract class DuckDBWASMConnection extends DuckDBCommon {
     loadExtension(ext: string): Promise<void>;
     protected setup(): Promise<void>;
     protected runDuckDBQuery(sql: string, abortSignal?: AbortSignal): Promise<{
-        rows: QueryDataRow[];
+        rows: QueryRecord[];
         totalRows: number;
     }>;
-    runSQLStream(sql: string, { rowLimit, abortSignal }?: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
+    runSQLStream(sql: string, { rowLimit, abortSignal }?: RunSQLOptions): AsyncIterableIterator<QueryRecord>;
     private findTables;
     fetchSchemaForSQLStruct(sqlRef: SQLSourceRequest, options: FetchSchemaOptions): Promise<{
         structDef: SQLSourceDef;

package/dist/duckdb_wasm_connection.js

@@ -161,18 +161,24 @@ function unwrapStruct(value, children) {
     return result;
 }
 function unwrapPrimitive(value) {
+    if (value === null || value === undefined)
+        return null;
     if (value instanceof Date)
         return value;
     if (typeof value === 'bigint')
         return safeNumber(value);
-    if (typeof value !== 'object' || value === null)
+    if (typeof value === 'string' || typeof value === 'number')
+        return value;
+    if (typeof value === 'boolean')
         return value;
+    if (typeof value !== 'object')
+        return String(value);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const obj = value;
     if (obj[Symbol.toPrimitive]) {
         return safeNumber(obj[Symbol.toPrimitive]());
     }
-    return value;
+    return String(value);
 }
 function safeNumber(value) {
     if (typeof value === 'number') {
@@ -209,19 +215,18 @@ function formatDecimalString(str, scale, isNegative) {
     return isNegative ? '-' + result : result;
 }
 /**
- * Process a single Arrow result row into a Malloy QueryDataRow.
+ * Process a single Arrow result row into a Malloy QueryRecord.
  */
 function unwrapRow(row, schema) {
     const json = row.toJSON();
     const result = {};
     for (const field of schema.fields) {
-        // Cast is safe: unwrapValue returns QueryValue-compatible types
         result[field.name] = unwrapValue(json[field.name], field.type);
     }
     return result;
 }
 /**
- * Process a DuckDB Table into an array of Malloy QueryDataRows.
+ * Process a DuckDB Table into an array of Malloy QueryRecords.
  */
 function unwrapTable(table) {
     return table.toArray().map(row => unwrapRow(row, table.schema));
@@ -269,6 +274,9 @@ class DuckDBWASMConnection extends duckdb_common_1.DuckDBCommon {
             if (Array.isArray(arg.additionalExtensions)) {
                 this.additionalExtensions = arg.additionalExtensions;
             }
+            if (typeof arg.setupSQL === 'string') {
+                this.setupSQL = arg.setupSQL;
+            }
         }
         this.isMotherDuck =
             ((_a = this.databasePath) === null || _a === void 0 ? void 0 : _a.startsWith('md:')) ||
@@ -277,8 +285,8 @@ class DuckDBWASMConnection extends duckdb_common_1.DuckDBCommon {
         this.connecting = this.init();
     }
     getDigest() {
-        var _a;
-        return (0, malloy_1.makeDigest)('duckdb-wasm', (_a = this.databasePath) !== null && _a !== void 0 ? _a : ':memory:', this.workingDirectory);
+        var _a, _b;
+        return (0, malloy_1.makeDigest)('duckdb-wasm', (_a = this.databasePath) !== null && _a !== void 0 ? _a : ':memory:', this.workingDirectory, (_b = this.setupSQL) !== null && _b !== void 0 ? _b : '');
     }
     async init() {
         // Select a bundle based on browser checks
@@ -342,6 +350,14 @@ class DuckDBWASMConnection extends duckdb_common_1.DuckDBCommon {
                     console.error(`duckdb setup ${cmd} => ${error}`);
                 }
             }
+            if (this.setupSQL) {
+                for (const stmt of this.setupSQL.split(';\n')) {
+                    const trimmed = stmt.trim();
+                    if (trimmed) {
+                        await this.runDuckDBQuery(trimmed);
+                    }
+                }
+            }
         };
         await this.connecting;
         if (!this.isSetup) {

package/dist/duckdb_wasm_connection_browser.d.ts

@@ -1,15 +1,14 @@
 import * as duckdb from '@duckdb/duckdb-wasm';
 import { DuckDBWASMConnection as DuckDBWASMConnectionBase } from './duckdb_wasm_connection';
 import { MDConnection } from '@motherduck/wasm-client';
-import type { QueryDataRow } from '@malloydata/malloy';
+import type { QueryRecord } from '@malloydata/malloy';
 export declare class DuckDBWASMConnection extends DuckDBWASMConnectionBase {
     protected _mdConnection: MDConnection | null;
     getBundles(): duckdb.DuckDBBundles;
     init(): Promise<void>;
     setup(): Promise<void>;
     protected runDuckDBQuery(sql: string, abortSignal?: AbortSignal): Promise<{
-        rows: QueryDataRow[];
+        rows: QueryRecord[];
         totalRows: number;
     }>;
-    createHash(sqlCommand: string): Promise<string>;
 }

package/dist/duckdb_wasm_connection_browser.js

@@ -59,7 +59,6 @@ exports.DuckDBWASMConnection = void 0;
 const duckdb = __importStar(require("@duckdb/duckdb-wasm"));
 const duckdb_wasm_connection_1 = require("./duckdb_wasm_connection");
 const wasm_client_1 = require("@motherduck/wasm-client");
-const malloy_1 = require("@malloydata/malloy");
 function unwrapMotherDuck(value) {
     let result = null;
     if (value !== null && typeof value === 'object') {
@@ -198,9 +197,6 @@ class DuckDBWASMConnection extends duckdb_wasm_connection_1.DuckDBWASMConnection
             return super.runDuckDBQuery(sql, abortSignal);
         }
     }
-    async createHash(sqlCommand) {
-        return (0, malloy_1.makeDigest)(sqlCommand);
-    }
 }
 exports.DuckDBWASMConnection = DuckDBWASMConnection;
 //# sourceMappingURL=duckdb_wasm_connection_browser.js.map

package/dist/duckdb_wasm_connection_node.d.ts

@@ -2,5 +2,4 @@ import type { DuckDBBundles } from '@duckdb/duckdb-wasm';
 import { DuckDBWASMConnection as DuckDBWASMConnectionBase } from './duckdb_wasm_connection';
 export declare class DuckDBWASMConnection extends DuckDBWASMConnectionBase {
     getBundles(): DuckDBBundles;
-    createHash(sqlCommand: string): Promise<string>;
 }

package/dist/duckdb_wasm_connection_node.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBWASMConnection = void 0;
 const duckdb_wasm_connection_1 = require("./duckdb_wasm_connection");
-const malloy_1 = require("@malloydata/malloy");
 class DuckDBWASMConnection extends duckdb_wasm_connection_1.DuckDBWASMConnection {
     getBundles() {
         const resolvePath = require.resolve('@duckdb/duckdb-wasm');
@@ -47,9 +46,6 @@ class DuckDBWASMConnection extends duckdb_wasm_connection_1.DuckDBWASMConnection
             },
         };
     }
-    async createHash(sqlCommand) {
-        return (0, malloy_1.makeDigest)(sqlCommand);
-    }
 }
 exports.DuckDBWASMConnection = DuckDBWASMConnection;
 //# sourceMappingURL=duckdb_wasm_connection_node.js.map

package/dist/index.js

@@ -25,4 +25,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBConnection = void 0;
 var duckdb_connection_1 = require("./duckdb_connection");
 Object.defineProperty(exports, "DuckDBConnection", { enumerable: true, get: function () { return duckdb_connection_1.DuckDBConnection; } });
+const malloy_1 = require("@malloydata/malloy");
+const duckdb_connection_2 = require("./duckdb_connection");
+(0, malloy_1.registerConnectionType)('duckdb', {
+    factory: (config) => {
+        const options = { ...config };
+        // Map user-friendly "path" to the constructor's "databasePath"
+        if ('path' in options && !('databasePath' in options)) {
+            options['databasePath'] = options['path'];
+            delete options['path'];
+        }
+        return new duckdb_connection_2.DuckDBConnection(options);
+    },
+    properties: [
+        {
+            name: 'databasePath',
+            displayName: 'Database Path',
+            type: 'file',
+            optional: true,
+            default: ':memory:',
+            fileFilters: { DuckDB: ['db', 'duckdb', 'ddb'] },
+        },
+        {
+            name: 'workingDirectory',
+            displayName: 'Working Directory',
+            type: 'string',
+            optional: true,
+        },
+        {
+            name: 'motherDuckToken',
+            displayName: 'MotherDuck Token',
+            type: 'password',
+            optional: true,
+        },
+        {
+            name: 'additionalExtensions',
+            displayName: 'Additional Extensions',
+            type: 'string',
+            optional: true,
+        },
+        {
+            name: 'readOnly',
+            displayName: 'Read Only',
+            type: 'boolean',
+            optional: true,
+        },
+        {
+            name: 'setupSQL',
+            displayName: 'Setup SQL',
+            type: 'text',
+            optional: true,
+            description: 'SQL statements to run when the connection is established',
+        },
+    ],
+});
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-duckdb",
-  "version": "0.0.336",
+  "version": "0.0.338",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@duckdb/duckdb-wasm": "1.33.1-dev13.0",
     "@duckdb/node-api": "1.4.3-r.1",
-    "@malloydata/malloy": "0.0.336",
+    "@malloydata/malloy": "0.0.338",
     "@motherduck/wasm-client": "^0.6.6",
     "apache-arrow": "^17.0.0",
     "web-worker": "^1.3.0"