@malloydata/malloy 0.0.222-dev241212001744 → 0.0.222-dev241212154316

package/dist/dialect/duckdb/duckdb.d.ts

@@ -55,6 +55,7 @@ export declare class DuckDBDialect extends PostgresBase {
         [name: string]: DialectFunctionOverloadDef[];
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    parseDuckDBType(sqlType: string): AtomicTypeDef;
     sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;

package/dist/dialect/duckdb/duckdb.js

@@ -30,6 +30,7 @@ const dialect_1 = require("../dialect");
 const pg_impl_1 = require("../pg_impl");
 const dialect_functions_1 = require("./dialect_functions");
 const function_overrides_1 = require("./function_overrides");
+const tiny_parser_1 = require("../tiny_parser");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
 const duckDBToMalloyTypes = {
@@ -287,6 +288,20 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         }
         return malloyType.type;
     }
+    parseDuckDBType(sqlType) {
+        const parser = new DuckDBTypeParser(sqlType);
+        try {
+            return parser.typeDef();
+        }
+        catch (e) {
+            if (e instanceof tiny_parser_1.TinyParseError) {
+                return { type: 'sql native', rawType: sqlType };
+            }
+            else {
+                throw e;
+            }
+        }
+    }
     sqlTypeToMalloyType(sqlType) {
         var _a, _b, _c;
         // Remove decimal precision
@@ -350,4 +365,113 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     }
 }
 exports.DuckDBDialect = DuckDBDialect;
+class DuckDBTypeParser extends tiny_parser_1.TinyParser {
+    constructor(input) {
+        super(input, {
+            /* whitespace           */ space: /^\s+/,
+            /* single quoted string */ qsingle: /^'([^']|'')*'/,
+            /* double quoted string */ qdouble: /^"([^"]|"")*"/,
+            /* (n) size             */ size: /^\(\d+\)/,
+            /* (n1,n2) precision    */ precision: /^\(\d+,\d+\)/,
+            /* T[] -> array of T    */ arrayOf: /^\[]/,
+            /* other punctuation    */ char: /^[,:[\]()-]/,
+            /* unquoted word        */ id: /^\w+/,
+        });
+    }
+    unquoteName(token) {
+        if (token.type === 'qsingle') {
+            return token.text.replace("''", '');
+        }
+        else if (token.type === 'qdouble') {
+            return token.text.replace('""', '');
+        }
+        return token.text;
+    }
+    sqlID(token) {
+        return token.text.toUpperCase();
+    }
+    typeDef() {
+        const unknownStart = this.parseCursor;
+        const wantID = this.next('id');
+        const id = this.sqlID(wantID);
+        let baseType;
+        if (id === 'VARCHAR') {
+            if (this.peek().type === 'size') {
+                this.next();
+            }
+        }
+        if ((id === 'DECIMAL' || id === 'NUMERIC') &&
+            this.peek().type === 'precision') {
+            this.next();
+            baseType = { type: 'number', numberType: 'float' };
+        }
+        else if (id === 'TIMESTAMP') {
+            if (this.peek().text === 'WITH') {
+                this.nextText('WITH', 'TIME', 'ZONE');
+            }
+            baseType = { type: 'timestamp' };
+        }
+        else if (duckDBToMalloyTypes[id]) {
+            baseType = duckDBToMalloyTypes[id];
+        }
+        else if (id === 'STRUCT') {
+            this.next('(');
+            baseType = { type: 'record', fields: [] };
+            for (;;) {
+                const fieldName = this.next();
+                if (fieldName.type === 'qsingle' ||
+                    fieldName.type === 'qdouble' ||
+                    fieldName.type === 'id') {
+                    const fieldType = this.typeDef();
+                    baseType.fields.push((0, malloy_types_1.mkFieldDef)(fieldType, this.unquoteName(fieldName), 'duckdb'));
+                }
+                else {
+                    if (fieldName.type !== ')') {
+                        throw this.parseError('Expected identifier or ) to end STRUCT');
+                    }
+                    break;
+                }
+                if (this.peek().type === ',') {
+                    this.next();
+                }
+            }
+        }
+        else {
+            if (wantID.type === 'id') {
+                for (;;) {
+                    const next = this.peek();
+                    // Might be WEIRDTYP(a,b)[] ... stop at the []
+                    if (next.type === 'arrayOf' || next.type === 'eof') {
+                        break;
+                    }
+                    this.next();
+                }
+                baseType = {
+                    type: 'sql native',
+                    rawType: this.input.slice(unknownStart, this.parseCursor - unknownStart + 1),
+                };
+            }
+            else {
+                throw this.parseError('Could not understand type');
+            }
+        }
+        while (this.peek().type === 'arrayOf') {
+            this.next();
+            if (baseType.type === 'record') {
+                baseType = {
+                    type: 'array',
+                    elementTypeDef: { type: 'record_element' },
+                    fields: baseType.fields,
+                };
+            }
+            else {
+                baseType = {
+                    type: 'array',
+                    elementTypeDef: baseType,
+                };
+            }
+        }
+        return baseType;
+    }
+}
 //# sourceMappingURL=duckdb.js.map

package/dist/dialect/tiny_parser.d.ts

@@ -9,10 +9,12 @@ export interface TinyToken {
  *
  * NOTE: All parse errors are exceptions.
  */
+export declare class TinyParseError extends Error {
+}
 export declare class TinyParser {
     readonly input: string;
     private tokens;
-    private parseCursor;
+    protected parseCursor: number;
     private lookAhead?;
     private tokenMap;
     /**
@@ -26,7 +28,7 @@ export declare class TinyParser {
      *   last characters stripped
      */
     constructor(input: string, tokenMap?: Record<string, RegExp>);
-    parseError(str: string): Error;
+    parseError(str: string): TinyParseError;
     peek(): TinyToken;
     private getNext;
     /**
@@ -36,6 +38,8 @@ export declare class TinyParser {
      * @returns The last token read
      */
     next(...types: string[]): TinyToken;
+    nextText(...texts: string[]): TinyToken;
     skipTo(type: string): void;
+    dump(): TinyToken[];
     private tokenize;
 }

package/dist/dialect/tiny_parser.js

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TinyParser = void 0;
+exports.TinyParser = exports.TinyParseError = void 0;
 /**
  * Simple framework for writing schema parsers. The parsers using this felt
  * better than the more ad-hoc code they replaced, and are smaller than
@@ -14,6 +14,9 @@ exports.TinyParser = void 0;
  *
  * NOTE: All parse errors are exceptions.
  */
+class TinyParseError extends Error {
+}
+exports.TinyParseError = TinyParseError;
 class TinyParser {
     /**
      * The token map is tested in order. Return TinyToken
@@ -28,19 +31,19 @@ class TinyParser {
     constructor(input, tokenMap) {
         this.input = input;
         this.parseCursor = 0;
-        this.tokens = this.tokenize(input);
         this.tokenMap = tokenMap !== null && tokenMap !== void 0 ? tokenMap : {
             space: /^\s+/,
             char: /^[,:[\]()-]/,
             id: /^\w+/,
             qstr: /^"\w+"/,
         };
+        this.tokens = this.tokenize(input);
     }
     parseError(str) {
         const errText = `INTERNAL ERROR parsing schema: ${str}\n` +
             `${this.input}\n` +
             `${' '.repeat(this.parseCursor)}^`;
-        return new Error(errText);
+        return new TinyParseError(errText);
     }
     peek() {
         if (this.lookAhead) {
@@ -80,7 +83,24 @@ class TinyParser {
         }
         if (next)
             return next;
-        throw this.parseError(`Expected ${expected}`);
+        throw this.parseError(`Expected token type '${expected}'`);
+    }
+    nextText(...texts) {
+        if (texts.length === 0)
+            return this.getNext();
+        let next = undefined;
+        let expected = texts[0];
+        for (const txt of texts) {
+            next = this.getNext();
+            expected = txt;
+            if (next.text !== txt) {
+                next = undefined;
+                break;
+            }
+        }
+        if (next)
+            return next;
+        throw this.parseError(`Expected '${expected}'`);
     }
     skipTo(type) {
         for (;;) {
@@ -93,6 +113,12 @@ class TinyParser {
             }
         }
     }
+    dump() {
+        const p = this.parseCursor;
+        const parts = [...this.tokenize(this.input)];
+        this.parseCursor = p;
+        return parts;
+    }
     *tokenize(src) {
         const tokenList = this.tokenMap;
         while (this.parseCursor < src.length) {
@@ -112,6 +138,7 @@ class TinyParser {
                             type: tokenType === 'char' ? tokenText : tokenType,
                             text: tokenText,
                         };
+                        break;
                     }
                 }
             }

package/dist/lang/test/composite-field-usage.spec.js

@@ -160,6 +160,30 @@ describe('composite sources', () => {
         run: foo(param is 2) -> { group_by: y }
       `).toTranslate();
         });
+        test('array.each is okay', () => {
+            expect(`
+        ##! experimental { composite_sources }
+        source: foo is compose(
+          a extend { dimension: x is 1 },
+          a extend { dimension: y is 2 }
+        ) extend {
+          dimension: arr is [1, 2, 3]
+        }
+        run: foo -> { group_by: y, arr.each }
+      `).toTranslate();
+        });
+        test('timevalue extract okay', () => {
+            expect(`
+        ##! experimental { composite_sources }
+        source: foo is compose(
+          a extend { dimension: x is 1 },
+          a extend { dimension: y is 2 }
+        ) extend {
+          dimension: time is now
+        }
+        run: foo -> { group_by: y, time.day }
+      `).toTranslate();
+        });
     });
 });
 //# sourceMappingURL=composite-field-usage.spec.js.map

package/dist/model/composite_source_utils.js

@@ -99,11 +99,15 @@ function _resolveCompositeSources(path, source, compositeFieldUsage, narrowedCom
                 error: { code: 'composite_source_not_defined', data: { path: newPath } },
             };
         }
-        if (!(0, malloy_types_1.isJoined)(join) || !(0, malloy_types_1.isSourceDef)(join)) {
+        if (!(0, malloy_types_1.isJoined)(join)) {
             return {
                 error: { code: 'composite_source_not_a_join', data: { path: newPath } },
             };
         }
+        else if (!(0, malloy_types_1.isSourceDef)(join)) {
+            // Non-source join, like an array, skip it (no need to resolve)
+            continue;
+        }
         const resolved = _resolveCompositeSources(newPath, join, joinedUsage, narrowedJoinedSources[joinName]);
         if ('error' in resolved) {
             return resolved;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.222-dev241212001744",
+  "version": "0.0.222-dev241212154316",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",