@malloydata/db-duckdb 0.0.222-dev241212001744 → 0.0.222-dev241212021944

package/dist/duckdb_common.d.ts

@@ -28,18 +28,6 @@ export declare abstract class DuckDBCommon extends BaseConnection implements Tes
     abstract runSQLStream(sql: string, options: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
     fetchSelectSchema(sqlRef: SQLSourceDef): Promise<SQLSourceDef | string>;
     estimateQueryCost(_: string): Promise<QueryRunStats>;
-    /**
-     * Split's a structs columns declaration into individual columns
-     * to be fed back into fillStructDefFromTypeMap(). Handles commas
-     * within nested STRUCT() declarations.
-     *
-     * (https://github.com/malloydata/malloy/issues/635)
-     *
-     * @param s struct's column declaration
-     * @return Array of column type declarations
-     */
-    private splitColumns;
-    private stringToTypeMap;
     fillStructDefFromTypeMap(structDef: StructDef, typeMap: {
         [name: string]: string;
     }): void;

package/dist/duckdb_common.js

@@ -91,104 +91,13 @@ class DuckDBCommon extends connection_1.BaseConnection {
     async estimateQueryCost(_) {
         return {};
     }
-    /**
-     * Split's a structs columns declaration into individual columns
-     * to be fed back into fillStructDefFromTypeMap(). Handles commas
-     * within nested STRUCT() declarations.
-     *
-     * (https://github.com/malloydata/malloy/issues/635)
-     *
-     * @param s struct's column declaration
-     * @return Array of column type declarations
-     */
-    splitColumns(s) {
-        const columns = [];
-        let parens = 0;
-        let column = '';
-        let eatSpaces = true;
-        for (let idx = 0; idx < s.length; idx++) {
-            const c = s.charAt(idx);
-            if (eatSpaces && c === ' ') {
-                // Eat space
-            }
-            else {
-                eatSpaces = false;
-                if (!parens && c === ',') {
-                    columns.push(column);
-                    column = '';
-                    eatSpaces = true;
-                }
-                else {
-                    column += c;
-                }
-                if (c === '(') {
-                    parens += 1;
-                }
-                else if (c === ')') {
-                    parens -= 1;
-                }
-            }
-        }
-        columns.push(column);
-        return columns;
-    }
-    stringToTypeMap(s) {
-        const ret = {};
-        const columns = this.splitColumns(s);
-        for (const c of columns) {
-            //const [name, type] = c.split(" ", 1);
-            const columnMatch = c.match(/^(?<name>[^\s]+) (?<type>.*)$/);
-            if (columnMatch && columnMatch.groups) {
-                ret[columnMatch.groups['name']] = columnMatch.groups['type'];
-            }
-            else {
-                throw new Error(`Badly form Structure definition ${s}`);
-            }
-        }
-        return ret;
-    }
     fillStructDefFromTypeMap(structDef, typeMap) {
         for (const fieldName in typeMap) {
-            let duckDBType = typeMap[fieldName];
             // Remove quotes from field name
             const name = unquoteName(fieldName);
-            let malloyType = this.dialect.sqlTypeToMalloyType(duckDBType);
-            const arrayMatch = duckDBType.match(/(?<duckDBType>.*)\[\]$/);
-            if (arrayMatch && arrayMatch.groups) {
-                duckDBType = arrayMatch.groups['duckDBType'];
-            }
-            const structMatch = duckDBType.match(/^STRUCT\((?<fields>.*)\)$/);
-            if (structMatch && structMatch.groups) {
-                const newTypeMap = this.stringToTypeMap(structMatch.groups['fields']);
-                let innerStructDef;
-                const structhead = { name, dialect: this.dialectName, fields: [] };
-                if (arrayMatch) {
-                    innerStructDef = {
-                        type: 'array',
-                        elementTypeDef: { type: 'record_element' },
-                        join: 'many',
-                        ...structhead,
-                    };
-                }
-                else {
-                    innerStructDef = {
-                        type: 'record',
-                        join: 'one',
-                        ...structhead,
-                    };
-                }
-                this.fillStructDefFromTypeMap(innerStructDef, newTypeMap);
-                structDef.fields.push(innerStructDef);
-            }
-            else {
-                if (arrayMatch) {
-                    malloyType = this.dialect.sqlTypeToMalloyType(duckDBType);
-                    structDef.fields.push((0, malloy_1.mkArrayDef)(malloyType, name, this.dialectName));
-                }
-                else {
-                    structDef.fields.push({ ...malloyType, name });
-                }
-            }
+            const dbType = typeMap[fieldName];
+            const malloyType = this.dialect.parseDuckDBType(dbType);
+            structDef.fields.push((0, malloy_1.mkFieldDef)(malloyType, name, 'duckdb'));
         }
     }
     async schemaFromQuery(infoQuery, structDef) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-duckdb",
-  "version": "0.0.222-dev241212001744",
+  "version": "0.0.222-dev241212021944",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@duckdb/duckdb-wasm": "1.29.0",
-    "@malloydata/malloy": "^0.0.222-dev241212001744",
+    "@malloydata/malloy": "^0.0.222-dev241212021944",
     "@motherduck/wasm-client": "^0.6.6",
     "apache-arrow": "^17.0.0",
     "duckdb": "1.1.1",