@narrative.io/data-collaboration-sdk-ts 2.50.0 → 2.52.0

package/build/nql/NqlBuilder.d.ts

@@ -1,14 +1,15 @@
 import type { NqlBudget, NqlPlaceholder } from "./Ast";
 import type { CreateMaterializedView, CreateMaterializedViewMetadata, Deduplication, Explain, Expression, Output, Raw, Select, Statement, Table } from "./AstParser";
+export type DatasetIdToNameMap = Record<number, string>;
 export type CompiledNql = string;
-export declare function compileStatement(n: Statement): CompiledNql;
-export declare function compileCreateMaterializedView(n: CreateMaterializedView): CompiledNql;
+export declare function compileStatement(n: Statement, dsMap?: DatasetIdToNameMap): CompiledNql;
+export declare function compileCreateMaterializedView(n: CreateMaterializedView, dsMap?: DatasetIdToNameMap): CompiledNql;
 export declare function compileCreateMaterializedViewMetadata(metadata?: CreateMaterializedViewMetadata): string;
-export declare function compileExplain(n: Explain): CompiledNql;
-export declare function compileSelect(q: Select): CompiledNql;
+export declare function compileExplain(n: Explain, dsMap?: DatasetIdToNameMap): CompiledNql;
+export declare function compileSelect(q: Select, dsMap?: DatasetIdToNameMap): CompiledNql;
 export declare function compileBudget(budget: NqlBudget): CompiledNql;
-export declare function compileDeduplication(d: Deduplication | Raw): CompiledNql;
-export declare function compileFrom(tables: Table[] | Raw): CompiledNql;
-export declare function compileOutput(n: Output): CompiledNql;
-export declare function compileExpression(n: Expression): CompiledNql;
+export declare function compileDeduplication(d: Deduplication | Raw, dsMap?: DatasetIdToNameMap): CompiledNql;
+export declare function compileFrom(tables: Table[] | Raw, dsMap?: DatasetIdToNameMap): CompiledNql;
+export declare function compileOutput(n: Output, dsMap?: DatasetIdToNameMap): CompiledNql;
+export declare function compileExpression(n: Expression, dsMap?: DatasetIdToNameMap): CompiledNql;
 export declare function compilePlaceholder(n: NqlPlaceholder): CompiledNql;

package/build/nql/NqlBuilder.js

@@ -1,16 +1,16 @@
 const quoteChar = '"';
-export function compileStatement(n) {
+export function compileStatement(n, dsMap) {
     switch (n.type) {
         case "create_materialized_view":
-            return compileCreateMaterializedView(n);
+            return compileCreateMaterializedView(n, dsMap);
         case "explain":
-            return compileExplain(n);
+            return compileExplain(n, dsMap);
         default:
             return unreachable(n);
     }
 }
-export function compileCreateMaterializedView(n) {
-    return `CREATE MATERIALIZE VIEW ${quote(n.name)}${compileCreateMaterializedViewMetadata(n.metadata)} AS (${compileSelect(n.select)})`;
+export function compileCreateMaterializedView(n, dsMap) {
+    return `CREATE MATERIALIZE VIEW ${quote(n.name)}${compileCreateMaterializedViewMetadata(n.metadata)} AS (${compileSelect(n.select, dsMap)})`;
 }
 export function compileCreateMaterializedViewMetadata(metadata) {
     function compileDisplayName() {
@@ -70,17 +70,17 @@ export function compileCreateMaterializedViewMetadata(metadata) {
     }
     return ` ${compileDisplayName()}${compileDescription()}${compileTags()}${compileRefreshSchedule()}${compileExpire()}${compileWriteMode()}${compileExtendedStats()}${compilePartitionBy()}`;
 }
-export function compileExplain(n) {
-    return `EXPLAIN ${compileSelect(n.query)}`;
+export function compileExplain(n, dsMap) {
+    return `EXPLAIN ${compileSelect(n.query, dsMap)}`;
 }
-export function compileSelect(q) {
-    const columns = q.columns.map((e) => compileOutput(e));
+export function compileSelect(q, dsMap) {
+    const columns = q.columns.map((e) => compileOutput(e, dsMap));
     const select = `SELECT ${columns.join(", ")}`;
     const budget = q.budget !== null ? compileBudget(q.budget) : "";
-    const from = `FROM ${compileFrom(q.from)}`;
-    const where = q.where !== null ? `WHERE ${compileExpression(q.where)}` : "";
+    const from = `FROM ${compileFrom(q.from, dsMap)}`;
+    const where = q.where !== null ? `WHERE ${compileExpression(q.where, dsMap)}` : "";
     const qualify = q.deduplication !== null
-        ? `QUALIFY ${compileDeduplication(q.deduplication)}`
+        ? `QUALIFY ${compileDeduplication(q.deduplication, dsMap)}`
         : "";
     return `${select} ${from} ${where} ${qualify} ${budget}`;
 }
@@ -100,24 +100,30 @@ export function compileBudget(budget) {
     }
     return `LIMIT ${budget.amount.value} ${budget.amount.currency.toUpperCase()} ${period}`;
 }
-export function compileDeduplication(d) {
+export function compileDeduplication(d, dsMap) {
     if (d.type === "deduplication") {
-        const expressions = d.expressions.map(compileExpression).join(", ");
+        const expressions = d.expressions
+            .map((e) => compileExpression(e, dsMap))
+            .join(", ");
         return `ROW_NUMBER() OVER (PARTITION BY ${expressions} ORDER BY 0) = 1`;
     }
     return raw(d);
 }
-export function compileFrom(tables) {
+export function compileFrom(tables, dsMap) {
     if (isArray(tables)) {
-        return compileTableRefs(tables);
+        return compileTableRefs(tables, dsMap);
     }
     return compileRawRef(tables.nql, tables.as);
 }
-function compileTableRefs(tables) {
+function compileTableRefs(tables, dsMap) {
     function ref(table) {
         switch (table.type) {
-            case "dataset":
-                return aliased(`company_data.${quote(table.datasetId.toString())}`, table.as, false);
+            case "dataset": {
+                const datasetName = dsMap
+                    ? dsMap[table.datasetId]
+                    : table.datasetId.toString();
+                return aliased(`company_data.${quote(datasetName ? datasetName : table.datasetId.toString())}`, table.as, false);
+            }
             case "rosetta_stone":
                 return aliased("narrative.rosetta_stone", table.as, false);
             case "raw_table":
@@ -128,7 +134,7 @@ function compileTableRefs(tables) {
                 throw new Error("unreachable");
         }
     }
-    function compileTableRef(table) {
+    function compileTableRef(table, dsMap) {
         let stmt = "";
         // NB: by convention the first table in list will never have a join associated with it,
         // hence the leading ' ' below does what we want.
@@ -189,23 +195,23 @@ function compileTableRefs(tables) {
                 default:
                     unreachable(table.join.conditionType);
             }
-            stmt += ` ${compileExpression(table.join.condition)}`;
+            stmt += ` ${compileExpression(table.join.condition, dsMap)}`;
         }
         return stmt;
     }
     let nql = "";
     for (const table of tables) {
-        const stmt = compileTableRef(table);
+        const stmt = compileTableRef(table, dsMap);
         nql += stmt;
     }
     return nql;
 }
-export function compileOutput(n) {
+export function compileOutput(n, dsMap) {
     switch (n.type) {
         case "attribute_ref":
             return compileAttributeRef(n.column, n.as, false);
         case "dataset_column_ref":
-            return compileDatasetColumnRef(n.datasetId, n.column, n.as, false);
+            return compileDatasetColumnRef(n.datasetId, n.column, n.as, dsMap);
         case "lit":
             return compileLit(n.value, n.value_type, n.as, false);
         case "raw_ref":
@@ -217,40 +223,40 @@ export function compileOutput(n) {
     }
     throw new Error("unreachable");
 }
-export function compileExpression(n) {
+export function compileExpression(n, dsMap) {
     switch (n.type) {
         case "=":
-            return compileBinaryOperator("=", [n.left, n.right], n.as);
+            return compileBinaryOperator("=", [n.left, n.right], n.as, dsMap);
         case "<>":
-            return compileBinaryOperator("<>", [n.left, n.right], n.as);
+            return compileBinaryOperator("<>", [n.left, n.right], n.as, dsMap);
         case "<":
-            return compileBinaryOperator("<", [n.left, n.right], n.as);
+            return compileBinaryOperator("<", [n.left, n.right], n.as, dsMap);
         case "<=":
-            return compileBinaryOperator("<=", [n.left, n.right], n.as);
+            return compileBinaryOperator("<=", [n.left, n.right], n.as, dsMap);
         case ">":
-            return compileBinaryOperator(">", [n.left, n.right], n.as);
+            return compileBinaryOperator(">", [n.left, n.right], n.as, dsMap);
         case ">=":
-            return compileBinaryOperator(">=", [n.left, n.right], n.as);
+            return compileBinaryOperator(">=", [n.left, n.right], n.as, dsMap);
         case "and":
-            return compileBinaryOperator("AND", n.operands, n.as);
+            return compileBinaryOperator("AND", n.operands, n.as, dsMap);
         case "attribute_ref":
             return compileAttributeRef(n.column, n.as);
         case "between":
-            return compileBetween(n.operand, n.lower, n.upper, n.as);
+            return compileBetween(n.operand, n.lower, n.upper, n.as, dsMap);
         case "dataset_column_ref":
-            return compileDatasetColumnRef(n.datasetId, n.column, n.as);
+            return compileDatasetColumnRef(n.datasetId, n.column, n.as, dsMap);
         case "in":
-            return compileIn(n.expression, n.values, n.negated, n.as);
+            return compileIn(n.expression, n.values, n.negated, n.as, dsMap);
         case "is_null":
-            return compileIsNull(n.operand, n.negated, n.as);
+            return compileIsNull(n.operand, n.negated, n.as, dsMap);
         case "like":
-            return compileLike(n.value, n.pattern, n.negated, n.as);
+            return compileLike(n.value, n.pattern, n.negated, n.as, dsMap);
         case "lit":
             return compileLit(n.value, n.value_type, n.as);
         case "not":
-            return compileNot(n.operand, n.as);
+            return compileNot(n.operand, n.as, dsMap);
         case "or":
-            return compileBinaryOperator("OR", n.operands, n.as);
+            return compileBinaryOperator("OR", n.operands, n.as, dsMap);
         case "nql":
             return raw(n);
         case "raw_ref":
@@ -270,16 +276,16 @@ function compileAttributeRef(column, as, aliasParens) {
     }, "");
     return aliased(`narrative.rosetta_stone.${quotedSegments}`, as, aliasParens);
 }
-function compileBetween(operand, lower, upper, as) {
-    const operandNql = compileExpression(operand);
-    const lowerNql = compileExpression(lower);
-    const upperNql = compileExpression(upper);
+function compileBetween(operand, lower, upper, as, dsMap) {
+    const operandNql = compileExpression(operand, dsMap);
+    const lowerNql = compileExpression(lower, dsMap);
+    const upperNql = compileExpression(upper, dsMap);
     return aliased(`${operandNql} BETWEEN ${lowerNql} AND ${upperNql}`, as);
 }
-function compileBinaryOperator(op, operands, as) {
-    return aliased(`(${operands.map((e) => compileExpression(e)).join(` ${op} `)})`, as);
+function compileBinaryOperator(op, operands, as, dsMap) {
+    return aliased(`(${operands.map((e) => compileExpression(e, dsMap)).join(` ${op} `)})`, as);
 }
-function compileDatasetColumnRef(datasetId, column, as, aliasParen) {
+function compileDatasetColumnRef(datasetId, column, as, dsMap) {
     const formattedColumn = column
         .split(".")
         .reduce((acc, segment, index) => {
@@ -288,22 +294,23 @@ function compileDatasetColumnRef(datasetId, column, as, aliasParen) {
         }
         return `${acc}.${quote(segment)}`;
     }, "");
-    return aliased(`company_data.${quote(datasetId.toString())}.${formattedColumn}`, as, false);
+    const datasetName = dsMap ? dsMap[datasetId] : datasetId.toString();
+    return aliased(`company_data.${quote(datasetName ? datasetName : datasetId.toString())}.${formattedColumn}`, as, false);
 }
-function compileIn(expression, values, negated, as) {
+function compileIn(expression, values, negated, as, dsMap) {
     const op = !negated ? "IN" : "NOT IN";
     const compiledValues = isArray(values)
-        ? `(${values.map((e) => compileExpression(e)).join(", ")})`
+        ? `(${values.map((e) => compileExpression(e, dsMap)).join(", ")})`
         : raw(values);
-    return aliased(`${compileExpression(expression)} ${op} ${compiledValues}`, as);
+    return aliased(`${compileExpression(expression, dsMap)} ${op} ${compiledValues}`, as);
 }
-function compileIsNull(operand, negated, as) {
+function compileIsNull(operand, negated, as, dsMap) {
     const op = !negated ? "IS NULL" : "IS NOT NULL";
-    return compilePostfixUnaryOperator(op, operand, as);
+    return compilePostfixUnaryOperator(op, operand, as, dsMap);
 }
-function compileLike(value, pattern, negated, as) {
+function compileLike(value, pattern, negated, as, dsMap) {
     const op = !negated ? "LIKE" : "NOT LIKE";
-    return aliased(`${compileExpression(value)} ${op} ${str(pattern)}`, as);
+    return aliased(`${compileExpression(value, dsMap)} ${op} ${str(pattern)}`, as);
 }
 function compileLit(value, valueType, as, aliasParens) {
     let valueNql;
@@ -339,17 +346,17 @@ function compileLit(value, valueType, as, aliasParens) {
     }
     return aliased(valueNql, as, aliasParens);
 }
-function compileNot(operand, as) {
-    return aliased(`NOT ${compileExpression(operand)}`, as);
+function compileNot(operand, as, dsMap) {
+    return aliased(`NOT ${compileExpression(operand, dsMap)}`, as);
 }
-function compilePostfixUnaryOperator(op, operand, as) {
-    return aliased(`(${compileExpression(operand)}) ${op}`, as);
+function compilePostfixUnaryOperator(op, operand, as, dsMap) {
+    return aliased(`(${compileExpression(operand, dsMap)}) ${op}`, as);
 }
 function compileRawRef(nql, as) {
     return aliased(nql, as);
 }
-function compileUnaryMinus(operand, as) {
-    return aliased(`-(${compileExpression(operand)})`, as);
+function compileUnaryMinus(operand, as, dsMap) {
+    return aliased(`-(${compileExpression(operand, dsMap)})`, as);
 }
 export function compilePlaceholder(n) {
     switch (n.expectedType) {

package/build/queries/types.d.ts

@@ -1,9 +1,18 @@
 import type { CollaboratorsConfig } from "src/types";
 import type * as Parser from "../nql/AstParser";
+export interface CondensedNqlDatasetSource {
+    type: "dataset";
+    datasetName: string;
+}
+export interface CondensedNqlRosettaSource {
+    type: "rosetta_stone";
+}
+export type CondensedNqlSource = CondensedNqlDatasetSource | CondensedNqlRosettaSource;
 export interface NqlQueryAst {
     parsed: Parser.Select;
     compiled: string;
     placeholdersWithContext?: unknown[];
+    sources?: CondensedNqlSource[];
     ast_metadata: {
         node_type: "multiple";
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narrative.io/data-collaboration-sdk-ts",
-	"version": "2.50.0",
+	"version": "2.52.0",
 	"main": "build/index.js",
 	"repository": "github:narrative-io/data-collaboration-sdk-ts",
 	"source": "src/index.ts",