@malloydata/malloy 0.0.304 → 0.0.306

package/dist/model/sql_block.js

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileSQLInterpolation = compileSQLInterpolation;
 exports.sqlKey = sqlKey;
-const malloy_query_1 = require("./malloy_query");
+const query_model_1 = require("./query_model");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 function compileSQLInterpolation(select, connection, partialModel) {
@@ -42,7 +42,7 @@ function compileSQLInterpolation(select, connection, partialModel) {
                 if (!partialModel) {
                     throw new Error('Internal error: Partial model missing when compiling SQL block');
                 }
-                queryModel = new malloy_query_1.QueryModel(partialModel);
+                queryModel = (0, query_model_1.makeQueryModel)(partialModel);
             }
             const compiledSql = queryModel.compileQuery(segment, {
                 defaultRowLimit: undefined,

package/dist/model/stage_writer.d.ts

@@ -0,0 +1,25 @@
+import type { Dialect } from '../dialect';
+import type { QueryToMaterialize, StructDef, Query } from './malloy_types';
+export declare class StageWriter {
+    parent: StageWriter | undefined;
+    withs: string[];
+    udfs: string[];
+    pdts: string[];
+    dependenciesToMaterialize: Record<string, QueryToMaterialize>;
+    stagePrefix: string;
+    useCTE: boolean;
+    constructor(useCTE: boolean | undefined, parent: StageWriter | undefined);
+    getName(id: number): string;
+    root(): StageWriter;
+    addStage(sql: string): string;
+    addUDF(stageWriter: StageWriter, dialect: Dialect, structDef: StructDef): string;
+    addMaterializedQuery(fieldName: string, query: Query, materializatedTablePrefix?: string): string;
+    addPDT(baseName: string, dialect: Dialect): string;
+    combineStages(includeLastStage: boolean): {
+        sql: string;
+        lastStageName: string | undefined;
+    };
+    /** emit the SQL for all the stages.  */
+    generateSQLStages(): string;
+    generateCoorelatedSubQuery(dialect: Dialect, structDef: StructDef): string;
+}

package/dist/model/stage_writer.js

@@ -0,0 +1,120 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageWriter = void 0;
+const utils_1 = require("./materialization/utils");
+const utils_2 = require("./utils");
+class StageWriter {
+    constructor(useCTE = true, parent) {
+        this.parent = parent;
+        this.withs = [];
+        this.udfs = [];
+        this.pdts = [];
+        this.dependenciesToMaterialize = {};
+        this.stagePrefix = '__stage';
+        this.useCTE = useCTE;
+    }
+    getName(id) {
+        return `${this.stagePrefix}${id}`;
+    }
+    root() {
+        if (this.parent === undefined) {
+            return this;
+        }
+        else {
+            return this.parent.root();
+        }
+    }
+    addStage(sql) {
+        if (this.useCTE) {
+            this.withs.push(sql);
+            return this.getName(this.withs.length - 1);
+        }
+        else {
+            this.withs[0] = sql;
+            return (0, utils_2.indent)(`\n(${sql})\n`);
+        }
+    }
+    addUDF(stageWriter, dialect, structDef) {
+        var _a;
+        // eslint-disable-next-line prefer-const
+        let { sql, lastStageName } = stageWriter.combineStages(true);
+        if (lastStageName === undefined) {
+            throw new Error('Internal Error: no stage to combine');
+        }
+        sql += dialect.sqlCreateFunctionCombineLastStage(lastStageName, (0, utils_2.getDialectFieldList)(structDef), (_a = structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.orderBy);
+        const id = `${dialect.udfPrefix}${this.root().udfs.length}`;
+        sql = dialect.sqlCreateFunction(id, sql);
+        this.root().udfs.push(sql);
+        return id;
+    }
+    addMaterializedQuery(fieldName, query, materializatedTablePrefix) {
+        var _a;
+        const name = query.name;
+        if (!name) {
+            throw new Error(`Source ${fieldName} on a unnamed query that is tagged as materialize, only named queries can be materialized.`);
+        }
+        const path = (_a = query.location) === null || _a === void 0 ? void 0 : _a.url;
+        if (!path) {
+            throw new Error(`Trying to materialize query ${name}, but its path is not set.`);
+        }
+        // Creating an object that should uniquely identify a query within a Malloy model repo.
+        const queryMaterializationSpec = (0, utils_1.buildQueryMaterializationSpec)(path, name, materializatedTablePrefix);
+        this.root().dependenciesToMaterialize[queryMaterializationSpec.id] =
+            queryMaterializationSpec;
+        return queryMaterializationSpec.id;
+    }
+    addPDT(baseName, dialect) {
+        const sql = this.combineStages(false).sql + this.withs[this.withs.length - 1];
+        const name = baseName + (0, utils_2.generateHash)(sql);
+        const tableName = `scratch.${name}`;
+        this.root().pdts.push(dialect.sqlCreateTableAsSelect(tableName, sql));
+        return tableName;
+    }
+    // combine all the stages except the last one into a WITH statement
+    //  return SQL and the last stage name
+    combineStages(includeLastStage) {
+        if (!this.useCTE) {
+            return { sql: this.withs[0], lastStageName: this.withs[0] };
+        }
+        let lastStageName = this.getName(0);
+        let prefix = 'WITH ';
+        let w = '';
+        for (let i = 0; i < this.withs.length - (includeLastStage ? 0 : 1); i++) {
+            const sql = this.withs[i];
+            lastStageName = this.getName(i);
+            if (sql === undefined) {
+                throw new Error(`Expected sql WITH to be present for stage ${lastStageName}.`);
+            }
+            w += `${prefix}${lastStageName} AS (\n${(0, utils_2.indent)(sql)})\n`;
+            prefix = ', ';
+        }
+        return { sql: w, lastStageName };
+    }
+    /** emit the SQL for all the stages.  */
+    generateSQLStages() {
+        const lastStageNum = this.withs.length - 1;
+        if (lastStageNum < 0) {
+            throw new Error('No SQL generated');
+        }
+        const udfs = this.udfs.join('\n');
+        const pdts = this.pdts.join('\n');
+        const sql = this.combineStages(false).sql;
+        return udfs + pdts + sql + this.withs[lastStageNum];
+    }
+    generateCoorelatedSubQuery(dialect, structDef) {
+        var _a, _b;
+        if (!this.useCTE) {
+            return dialect.sqlCreateFunctionCombineLastStage(`(${this.withs[0]})`, (0, utils_2.getDialectFieldList)(structDef), (_a = structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.orderBy);
+        }
+        else {
+            return (this.combineStages(true).sql +
+                dialect.sqlCreateFunctionCombineLastStage(this.getName(this.withs.length - 1), (0, utils_2.getDialectFieldList)(structDef), (_b = structDef.resultMetadata) === null || _b === void 0 ? void 0 : _b.orderBy));
+        }
+    }
+}
+exports.StageWriter = StageWriter;
+//# sourceMappingURL=stage_writer.js.map

package/dist/model/utils.d.ts

@@ -1,4 +1,5 @@
-import type { Expr, GenericSQLExpr } from './malloy_types';
+import type { Expr, GenericSQLExpr, StructDef } from './malloy_types';
+import type { DialectFieldList } from '../dialect';
 /** simple indent function */
 export declare function indent(s: string): string;
 /**
@@ -32,3 +33,19 @@ export type SQLExprElement = string | Expr;
  * expression node.
  */
 export declare function composeSQLExpr(from: SQLExprElement[]): GenericSQLExpr;
+export declare function getDialectFieldList(structDef: StructDef): DialectFieldList;
+/**
+ * A little extra paranoia to save us from fields which contain the special
+ * characters used to build the grouping key.
+ */
+export declare function pathToKey(node: string, fields: string[]): string;
+export declare function groupingKey(node: string, fields: string[]): string;
+export declare function caseGroup(groupSets: number[], s: string): string;
+export declare class GenerateState {
+    whereSQL?: string;
+    applyValue?: string;
+    totalGroupSet: number;
+    withWhere(s?: string): GenerateState;
+    withApply(s: string): GenerateState;
+    withTotal(groupSet: number): GenerateState;
+}

package/dist/model/utils.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AndChain = void 0;
+exports.GenerateState = exports.AndChain = void 0;
 exports.indent = indent;
 exports.generateSQLStringLiteral = generateSQLStringLiteral;
 exports.generateHash = generateHash;
@@ -32,6 +32,10 @@ exports.exprKids = exprKids;
 exports.exprWalk = exprWalk;
 exports.exprMap = exprMap;
 exports.composeSQLExpr = composeSQLExpr;
+exports.getDialectFieldList = getDialectFieldList;
+exports.pathToKey = pathToKey;
+exports.groupingKey = groupingKey;
+exports.caseGroup = caseGroup;
 const uuid_1 = require("uuid");
 const malloy_types_1 = require("./malloy_types");
 /** simple indent function */
@@ -195,4 +199,65 @@ function composeSQLExpr(from) {
     }
     return ret;
 }
+function getDialectFieldList(structDef) {
+    const dialectFieldList = [];
+    for (const f of structDef.fields.filter(malloy_types_1.fieldIsIntrinsic)) {
+        dialectFieldList.push({
+            typeDef: f,
+            sqlExpression: (0, malloy_types_1.getIdentifier)(f),
+            rawName: (0, malloy_types_1.getIdentifier)(f),
+            sqlOutputName: (0, malloy_types_1.getIdentifier)(f),
+        });
+    }
+    return dialectFieldList;
+}
+/**
+ * A little extra paranoia to save us from fields which contain the special
+ * characters used to build the grouping key.
+ */
+function pathToKey(node, fields) {
+    return node + `/${fields.map(f => `${f.length}:${f}`).join(',')}`;
+}
+function groupingKey(node, fields) {
+    const sortedFields = [...fields].sort();
+    return pathToKey(node, sortedFields);
+}
+function caseGroup(groupSets, s) {
+    if (groupSets.length === 0) {
+        return s;
+    }
+    else {
+        const exp = groupSets.length === 1
+            ? `=${groupSets[0]}`
+            : ` IN (${groupSets.join(',')})`;
+        return `CASE WHEN group_set${exp} THEN\n  ${s}\n  END`;
+    }
+}
+class GenerateState {
+    constructor() {
+        this.totalGroupSet = -1;
+    }
+    withWhere(s) {
+        const newState = new GenerateState();
+        newState.whereSQL = s;
+        newState.applyValue = this.applyValue;
+        newState.totalGroupSet = this.totalGroupSet;
+        return newState;
+    }
+    withApply(s) {
+        const newState = new GenerateState();
+        newState.whereSQL = this.whereSQL;
+        newState.applyValue = s;
+        newState.totalGroupSet = this.totalGroupSet;
+        return newState;
+    }
+    withTotal(groupSet) {
+        const newState = new GenerateState();
+        newState.whereSQL = this.whereSQL;
+        newState.applyValue = this.applyValue;
+        newState.totalGroupSet = groupSet;
+        return newState;
+    }
+}
+exports.GenerateState = GenerateState;
 //# sourceMappingURL=utils.js.map

package/dist/to_stable.js

@@ -48,7 +48,6 @@ exports.writeMalloyObjectToTag = writeMalloyObjectToTag;
 exports.extractMalloyObjectFromTag = extractMalloyObjectFromTag;
 const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
 const model_1 = require("./model");
-const malloy_query_1 = require("./model/malloy_query");
 const annotation_1 = require("./annotation");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 function sourceDefToSourceInfo(sourceDef) {
@@ -100,7 +99,7 @@ function modelDefToModelInfo(modelDef) {
             });
         }
         else if (entry.type === 'query') {
-            const outputStruct = (0, malloy_query_1.getResultStructDefForQuery)(modelDef, entry);
+            const outputStruct = (0, model_1.getResultStructDefForQuery)(modelDef, entry);
             const annotations = getAnnotationsFromField(entry);
             const resultMetadataAnnotation = outputStruct.resultMetadata
                 ? getResultStructMetadataAnnotation(outputStruct, outputStruct.resultMetadata)
@@ -121,7 +120,7 @@ function modelDefToModelInfo(modelDef) {
         }
     }
     for (const query of modelDef.queryList) {
-        const outputStruct = (0, malloy_query_1.getResultStructDefForQuery)(modelDef, query);
+        const outputStruct = (0, model_1.getResultStructDefForQuery)(modelDef, query);
         const annotations = getAnnotationsFromField(query);
         const resultMetadataAnnotation = outputStruct.resultMetadata
             ? getResultStructMetadataAnnotation(outputStruct, outputStruct.resultMetadata)
@@ -188,7 +187,7 @@ function convertFieldInfos(source, fields) {
         }));
         const annotations = rawAnnotations.length > 0 ? rawAnnotations : undefined;
         if ((0, model_1.isTurtle)(field)) {
-            const outputStruct = (0, malloy_query_1.getResultStructDefForView)(source, field);
+            const outputStruct = (0, model_1.getResultStructDefForView)(source, field);
             const resultMetadataAnnotation = outputStruct.resultMetadata
                 ? getResultStructMetadataAnnotation(outputStruct, outputStruct.resultMetadata)
                 : undefined;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.304";
+export declare const MALLOY_VERSION = "0.0.306";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.304';
+exports.MALLOY_VERSION = '0.0.306';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.304",
+  "version": "0.0.306",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.304",
-    "@malloydata/malloy-interfaces": "0.0.304",
-    "@malloydata/malloy-tag": "0.0.304",
+    "@malloydata/malloy-filter": "0.0.306",
+    "@malloydata/malloy-interfaces": "0.0.306",
+    "@malloydata/malloy-tag": "0.0.306",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",