@narrative.io/data-collaboration-sdk-ts 2.3.0 → 2.5.0

package/build/nql/AstParser.d.ts

@@ -18,7 +18,7 @@ export interface Select {
     where: BooleanExpression | Raw | null;
 }
 export type Output = ColumnRef | Lit | Raw;
-export type Expression = ArithmeticExpression | BooleanExpression | ColumnRef | Lit | FunctionCall | StringExpression | UnaryMinus | Raw;
+export type Expression = BooleanExpression | ColumnRef | Lit | Raw;
 export interface Raw {
     type: "nql";
     as?: string;
@@ -29,10 +29,7 @@ export interface Deduplication {
     expressions: Expression[];
 }
 export type ColumnRef = AttributeRef | DatasetColumnRef | RawRef;
-export type ArithmeticExpression = BinaryArithmeticExpression | UnaryMinus;
-export type BinaryArithmeticExpression = Add | Divide | Multiply | Subtract;
 export type BooleanExpression = And | Between | Equals | NotEquals | Gt | Gte | In | IsNull | Like | Lt | Lte | Not | Or;
-export type StringExpression = Concat;
 export type Table = RosettaTable | DatasetTable | RawTable;
 export interface RosettaTable {
     type: "rosetta_stone";
@@ -80,37 +77,6 @@ export interface Lit {
     value_type: ast.NqlSimpleType;
     value: string | null;
 }
-export interface FunctionCall {
-    type: "function";
-    as?: string;
-    args: Expression[];
-    name: string;
-}
-export interface Add {
-    type: "+";
-    as?: string;
-    operands: Expression[];
-}
-export interface Divide {
-    type: "/";
-    as?: string;
-    operands: Expression[];
-}
-export interface Multiply {
-    type: "*";
-    as?: string;
-    operands: Expression[];
-}
-export interface Subtract {
-    type: "-";
-    as?: string;
-    operands: Expression[];
-}
-export interface UnaryMinus {
-    type: "unary_-";
-    as?: string;
-    operand: Expression;
-}
 export interface And {
     type: "and";
     as?: string;
@@ -190,12 +156,7 @@ export interface Like {
     value: Expression;
     pattern: string;
 }
-export interface Concat {
-    type: "||";
-    as?: string;
-    operands: Expression[];
-}
-export type Node = Select | Expression | Deduplication | Table | BooleanExpression | ArithmeticExpression | StringExpression | Join | AttributeRef | DatasetColumnRef | RawRef | Lit | FunctionCall | Add | Divide | Multiply | Subtract | UnaryMinus | And | Or | Not | Between | Equals | NotEquals | Lt | Lte | Gt | Gte | In | IsNull | Like | Concat | Raw;
+export type Node = Select | Expression | Deduplication | Table | BooleanExpression | Join | AttributeRef | DatasetColumnRef | RawRef | Lit | And | Or | Not | Between | Equals | NotEquals | Lt | Lte | Gt | Gte | In | IsNull | Like | Raw | ast.NqlBinaryOp;
 export declare function parseStatement(n: ast.NqlAst): Statement | Raw;
 export declare function parseCreateMaterializedView(n: ast.NqlCreateMaterializedView): CreateMaterializedView;
 export declare function parseExplain(n: ast.NqlExplain): Explain | Raw;

package/build/nql/AstParser.js

@@ -100,7 +100,7 @@ export function parseDeduplication(n) {
     return n.qualify !== null ? nqlOrFail(n.qualify) : null;
 }
 export function parseExpression(n) {
-    const parse = oneOf(parseArithmetic, parseBooleanExpression, parseColumnRef, parseFunctionCall, parseLit, parseStringExpression);
+    const parse = oneOf(parseBooleanExpression, parseColumnRef, parseLit, parseStringExpression);
     return parse(n);
 }
 export function parseOutput(n) {
@@ -160,99 +160,12 @@ function parseBooleanExpression(n) {
 function parseStringExpression(n) {
     switch (n.type) {
         case "binary_op": {
-            switch (n.name) {
-                case "||":
-                    return parseConcat(n);
-                default:
-                    return nqlOrFail(n);
-            }
-        }
-        default:
             return nqlOrFail(n);
-    }
-}
-function parseConcat(n) {
-    const operands = parseOperands(n, "||");
-    const concat = {
-        type: "||",
-        as: n.as,
-        operands,
-    };
-    return concat;
-}
-function parseArithmetic(n) {
-    switch (n.type) {
-        case "binary_op": {
-            switch (n.name) {
-                case "+":
-                    return parseAdd(n);
-                case "/":
-                    return parseDivide(n);
-                case "*":
-                    return parseMultiply(n);
-                case "-":
-                    return parseSubtract(n);
-                default:
-                    return nqlOrFail(n);
-            }
-        }
-        case "operator": {
-            switch (n.name) {
-                case "-":
-                    return parseUnaryMinus(n);
-                default:
-                    return nqlOrFail(n);
-            }
         }
         default:
             return nqlOrFail(n);
     }
 }
-function parseAdd(n) {
-    const operands = parseOperands(n, "+");
-    const add = {
-        type: "+",
-        as: n.as,
-        operands,
-    };
-    return add;
-}
-function parseDivide(n) {
-    const operands = parseOperands(n, "/");
-    const divide = {
-        type: "/",
-        as: n.as,
-        operands,
-    };
-    return divide;
-}
-function parseMultiply(n) {
-    const operands = parseOperands(n, "*");
-    const mult = {
-        type: "*",
-        as: n.as,
-        operands,
-    };
-    return mult;
-}
-function parseSubtract(n) {
-    const operands = parseOperands(n, "-");
-    const sub = {
-        type: "-",
-        as: n.as,
-        operands,
-    };
-    return sub;
-}
-function parseUnaryMinus(n) {
-    const operand = parseExpression(n.args[0]);
-    const minus = {
-        type: "unary_-",
-        as: n.as,
-        operand,
-    };
-    return minus;
-}
 function parseBetween(n) {
     const operand = parseExpression(n.args[0]);
     const lower = parseExpression(n.args[1]);
@@ -301,22 +214,6 @@ function parseColumnRef(n) {
             return nqlOrFail(n);
     }
 }
-function parseFunctionCall(n) {
-    switch (n.type) {
-        case "function": {
-            const args = n.args.map((arg) => parseExpression(arg));
-            const fn = {
-                type: "function",
-                as: n.as,
-                args,
-                name: n.name,
-            };
-            return fn;
-        }
-        default:
-            return nqlOrFail(n);
-    }
-}
 function parseLit(n) {
     switch (n.type) {
         case "literal": {

package/build/nql/AstTraverse.js

@@ -1,17 +1,8 @@
 function findTraversalTargets(node) {
     switch (node.type) {
-        case "function":
-            return node.args;
-        case "+":
-        case "/":
-        case "*":
-        case "-":
         case "and":
         case "or":
-        case "||":
             return node.operands;
-        case "unary_-":
-            return [node.operand];
         case "is_null":
             return [node.operand];
         case "like":

package/build/nql/NqlBuilder.js

@@ -166,16 +166,6 @@ export function compileExpression(n) {
             return compileBinaryOperator(">", [n.left, n.right], n.as);
         case ">=":
             return compileBinaryOperator(">=", [n.left, n.right], n.as);
-        case "+":
-            return compileBinaryOperator("+", n.operands, n.as);
-        case "/":
-            return compileBinaryOperator("/", n.operands, n.as);
-        case "*":
-            return compileBinaryOperator("*", n.operands, n.as);
-        case "-":
-            return compileBinaryOperator("-", n.operands, n.as);
-        case "||":
-            return compileBinaryOperator("||", n.operands, n.as);
         case "and":
             return compileBinaryOperator("AND", n.operands, n.as);
         case "attribute_ref":
@@ -184,8 +174,6 @@ export function compileExpression(n) {
             return compileBetween(n.operand, n.lower, n.upper, n.as);
         case "dataset_column_ref":
             return compileDatasetColumnRef(n.datasetId, n.column, n.as);
-        case "function":
-            return compileFunctionCall(n.name, n.args, n.as);
         case "in":
             return compileIn(n.expression, n.values, n.negated, n.as);
         case "is_null":
@@ -202,8 +190,6 @@ export function compileExpression(n) {
             return raw(n);
         case "raw_ref":
             return compileRawRef(n.nql, n.as);
-        case "unary_-":
-            return compileUnaryMinus(n.operand, n.as);
     }
     return unreachable(n);
 }
@@ -237,35 +223,6 @@ function compileDatasetColumnRef(datasetId, column, as, aliasParen) {
     }, "");
     return aliased(`company_data.${quote(datasetId.toString())}.${formattedColumn}`, as, false);
 }
-function compileFunctionCall(name, args, as) {
-    // Calling convenions for functions are all over the place:
-    //   - CAST is invoked as CAST($value AS $type)
-    //   - EXTRACT is invoked as EXTRACT($part FROM $value)
-    //   - etc., etc., with many exceptions
-    // We'll likely wanto types for all the functions we know how to support, or have every function
-    // described by the API, including providing a template for its calling convention. For now the
-    // below will get us a to a v1.
-    // Useful reference: https://calcite.apache.org/docs/reference.html#arithmetic-operators-and-functions
-    const argsNql = args.map((e) => compileExpression(e));
-    let callNql;
-    switch (name) {
-        case "CAST":
-            callNql = `CAST(${argsNql[0]} AS ${argsNql[1]})`;
-            break;
-        case "EXTRACT":
-            callNql = `EXTRACT(${argsNql[0]} FROM ${argsNql[1]})`;
-            break;
-        case "TRIM":
-            callNql = `TRIM(${argsNql[0]} ${argsNql[1]} FROM ${argsNql[2]})`;
-            break;
-        default: {
-            // hope for the best. definitely does not work in all cases.
-            callNql =
-                argsNql.length > 0 ? `${name}(${argsNql.join(", ")})` : `${name}`;
-        }
-    }
-    return aliased(callNql, as);
-}
 function compileIn(expression, values, negated, as) {
     const op = !negated ? "IN" : "NOT IN";
     const compiledValues = isArray(values)
@@ -342,7 +299,7 @@ function quote(s) {
     return `${quoteChar}${s.replace(quoteChar, `\\${quoteChar}`)}${quoteChar}`;
 }
 function raw(n) {
-    return aliased(n.nql, n.as);
+    return aliased(n.nql, n.as, true);
 }
 function isArray(ns) {
     return Array.isArray(ns);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narrative.io/data-collaboration-sdk-ts",
-	"version": "2.3.0",
+	"version": "2.5.0",
 	"main": "build/index.js",
 	"repository": "github:narrative-io/data-collaboration-sdk-ts",
 	"source": "src/index.ts",
@@ -29,7 +29,7 @@
 		"@types/jest": "29.5.12",
 		"babel-jest": "29.7.0",
 		"jest": "29.7.0",
-		"lefthook": "1.6.11",
+		"lefthook": "1.6.12",
 		"ts-jest": "29.1.2"
 	},
 	"dependencies": {