@narrative.io/data-collaboration-sdk-ts 2.101.0 → 2.101.1-beta.0

package/build/nql/SubstraitParser.js

@@ -0,0 +1,797 @@
+/*!
+Copyright 2023 Narrative I/O, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+NOTICE: THIS FILE HAS BEEN MODIFIED BY NARRATIVE I/O UNDER COMPLIANCE WITH THE APACHE 2.0 LICENCE FROM THE ORIGINAL WORK
+OF THE COMPANY Substrait (https://github.com/substrait-io/substrait-js).
+*/
+var AggregationInvocation;
+(function (AggregationInvocation) {
+    AggregationInvocation[AggregationInvocation["AGGREGATION_INVOCATION_UNSPECIFIED"] = 0] = "AGGREGATION_INVOCATION_UNSPECIFIED";
+    AggregationInvocation[AggregationInvocation["AGGREGATION_INVOCATION_ALL"] = 1] = "AGGREGATION_INVOCATION_ALL";
+    AggregationInvocation[AggregationInvocation["AGGREGATION_INVOCATION_DISTINCT"] = 2] = "AGGREGATION_INVOCATION_DISTINCT";
+})(AggregationInvocation || (AggregationInvocation = {}));
+var AggregationPhase;
+(function (AggregationPhase) {
+    AggregationPhase[AggregationPhase["AGGREGATION_PHASE_UNSPECIFIED"] = 0] = "AGGREGATION_PHASE_UNSPECIFIED";
+    AggregationPhase[AggregationPhase["AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE"] = 1] = "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE";
+    AggregationPhase[AggregationPhase["AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE"] = 2] = "AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE";
+    AggregationPhase[AggregationPhase["AGGREGATION_PHASE_INITIAL_TO_RESULT"] = 3] = "AGGREGATION_PHASE_INITIAL_TO_RESULT";
+    AggregationPhase[AggregationPhase["AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT"] = 4] = "AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT";
+})(AggregationPhase || (AggregationPhase = {}));
+var JoinType;
+(function (JoinType) {
+    JoinType[JoinType["JOIN_TYPE_UNSPECIFIED"] = 0] = "JOIN_TYPE_UNSPECIFIED";
+    JoinType[JoinType["JOIN_TYPE_INNER"] = 1] = "JOIN_TYPE_INNER";
+    JoinType[JoinType["JOIN_TYPE_OUTER"] = 2] = "JOIN_TYPE_OUTER";
+    JoinType[JoinType["JOIN_TYPE_LEFT"] = 3] = "JOIN_TYPE_LEFT";
+    JoinType[JoinType["JOIN_TYPE_RIGHT"] = 4] = "JOIN_TYPE_RIGHT";
+    JoinType[JoinType["JOIN_TYPE_SEMI"] = 5] = "JOIN_TYPE_SEMI";
+    JoinType[JoinType["JOIN_TYPE_ANTI"] = 6] = "JOIN_TYPE_ANTI";
+    JoinType[JoinType["JOIN_TYPE_SINGLE"] = 7] = "JOIN_TYPE_SINGLE";
+})(JoinType || (JoinType = {}));
+var SetOp;
+(function (SetOp) {
+    SetOp[SetOp["SET_OP_UNSPECIFIED"] = 0] = "SET_OP_UNSPECIFIED";
+    SetOp[SetOp["SET_OP_MINUS_PRIMARY"] = 1] = "SET_OP_MINUS_PRIMARY";
+    SetOp[SetOp["SET_OP_MINUS_MULTISET"] = 2] = "SET_OP_MINUS_MULTISET";
+    SetOp[SetOp["SET_OP_INTERSECTION_PRIMARY"] = 3] = "SET_OP_INTERSECTION_PRIMARY";
+    SetOp[SetOp["SET_OP_INTERSECTION_MULTISET"] = 4] = "SET_OP_INTERSECTION_MULTISET";
+    SetOp[SetOp["SET_OP_UNION_DISTINCT"] = 5] = "SET_OP_UNION_DISTINCT";
+    SetOp[SetOp["SET_OP_UNION_ALL"] = 6] = "SET_OP_UNION_ALL";
+})(SetOp || (SetOp = {}));
+var SortDirection;
+(function (SortDirection) {
+    SortDirection[SortDirection["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    SortDirection[SortDirection["ASCENDING_NULLS_FIRST"] = 1] = "ASCENDING_NULLS_FIRST";
+    SortDirection[SortDirection["ASCENDING_NULLS_LAST"] = 2] = "ASCENDING_NULLS_LAST";
+    SortDirection[SortDirection["DESCENDING_NULLS_FIRST"] = 3] = "DESCENDING_NULLS_FIRST";
+    SortDirection[SortDirection["DESCENDING_NULLS_LAST"] = 4] = "DESCENDING_NULLS_LAST";
+    SortDirection[SortDirection["CLUSTERED"] = 5] = "CLUSTERED";
+})(SortDirection || (SortDirection = {}));
+class SubstraitParser {
+    idCounters;
+    extSet;
+    fieldNames = [];
+    selectedFields = [];
+    filters = [];
+    logicalOperators = [];
+    /**
+     * Constructs a SubstraitParser
+     * @param {SubstraitPlan} plan the Substrait plan
+     */
+    constructor(plan) {
+        this.idCounters = new Map();
+        this.extSet = this.buildExtensionSet(plan);
+    }
+    /**
+     * Creates a map from anchor to function name
+     * @param {SubstraitPlan} plan the Substrait plan
+     * @return {Map<number, string>} the created mapping
+     */
+    buildExtensionSet(plan) {
+        const extSet = new Map();
+        for (const extensionDecl of plan.extensions) {
+            const func = extensionDecl.extensionFunction;
+            extSet.set(func.functionAnchor, func.name.split(":")[0].toLowerCase());
+        }
+        return extSet;
+    }
+    /**
+     * Geneate a unique id for the node
+     * @param {string} type The type of the node
+     * @return {string} A unique id
+     */
+    nextId(type) {
+        const value = this.idCounters.get(type) ?? 0;
+        this.idCounters.set(type, value + 1);
+        return `${type}_${value}`;
+    }
+    /**
+     * Create a schema field
+     *
+     * This is a special field with an empty name and an empty type string
+     * and uknown nullability
+     *
+     * @param {Field[]} fields the fields of the schema
+     * @return {Field} a schema field
+     */
+    makeSchemaField(fields) {
+        return {
+            name: "",
+            children: fields,
+            type: "",
+            nullability: "NULLABILITY_UNSPECIFIED",
+        };
+    }
+    /**
+     * Applies a Substrait emit to an output schema
+     * @param {Field} schema the original output schema
+     * @param {Object} emit a potential remapping of fields
+     * @return {Field} the remapped output schema
+     */
+    applyEmit(schema, emit) {
+        let outputFields = schema.children;
+        if (emit?.outputMapping != null) {
+            outputFields = emit.outputMapping.map((idx) => schema.children[idx]);
+        }
+        return this.makeSchemaField(outputFields);
+    }
+    /**
+     * Create a print node, generating a new id
+     *
+     * @param {string} type the node type
+     * @param {PrintNode[]} inputs the inputs to the node
+     * @param {SimpleProperty[]} props properties describing the node
+     * @param {Field} schema the output schema of the node
+     * @param {Object} emit the Substrait emit for the node
+     * @return {PrintNode} a print node
+     */
+    makePrintNode(type, inputs, props, schema, emit) {
+        const emitSchema = this.applyEmit(schema, emit);
+        return {
+            id: this.nextId(type),
+            type,
+            inputs,
+            props,
+            schema: emitSchema,
+        };
+    }
+    /**
+     * Recursive helper for structFieldToStr
+     * @param {*} field the Substrait field to convert
+     * @param {*} currentName the current name
+     * @param {Field} currentField the current input field
+     * @return {Field} a stringified represenstation
+     */
+    structFieldHelper(field, currentName, currentField) {
+        const fieldNum = field.field;
+        const fieldName = currentField.name !== "" ? currentField.name : `$${fieldNum}`;
+        const nextName = `${currentName}${fieldName}`;
+        if (field.child != null) {
+            return this.structFieldHelper(field.child, `${nextName}.`, currentField.children[fieldNum]);
+        }
+        return currentField.children[fieldNum];
+    }
+    /**
+     * Convert a struct field to a stringified representation
+     *
+     * Struct fields are usually intuitively written with names.
+     * For example, a.b.c.   However, fields in Substrait plans
+     * are not typically named.  So instead we represent them as
+     * $0, $1, $2, ... where $N means the field at index N.
+     *
+     * If the field does happen to be named we will use that.
+     *
+     * @param {StructItem} field a Substrait struct field
+     * @param {Field} exprIn the input to the expression
+     * @return {Field} a stringified representation
+     */
+    structFieldToField(field, exprIn) {
+        return this.structFieldHelper(field, "", exprIn);
+    }
+    /**
+     * Convert a direct reference to a stringified representation
+     * @param {Object} ref A Substrait direct reference
+     * @param {Object} exprIn the input to the expression
+     * @return {Field} a string representation
+     */
+    directReferenceToField(ref, exprIn) {
+        if (ref.structField != null) {
+            return this.structFieldToField(ref.structField, exprIn);
+        }
+        else {
+            throw new Error(`Unrecognized direct reference: ${JSON.stringify(ref)}`);
+        }
+    }
+    /**
+     * Convert a reference to a stringified representation
+     * @param {Object} ref A Substrait reference expression
+     * @param {Object} exprIn the input to the expression
+     * @return {Field} a string representation
+     */
+    referenceToField(ref, exprIn) {
+        if (ref.directReference != null) {
+            return this.directReferenceToField(ref.directReference, exprIn);
+        }
+        else {
+            throw new Error(`Unrecognized reference: ${JSON.stringify(ref)}`);
+        }
+    }
+    /**
+     * Convert a Substrait function argument to a string
+     * @param {Object} arg the argument to convert
+     * @param {Field} inp the input field
+     * @return {string} a string representation
+     */
+    functionArgumentToStr(arg, inp) {
+        if (arg.enum != null) {
+            if (arg.enum.specified == null) {
+                return "unspecified";
+            }
+            return arg.enum.specified;
+        }
+        else if (arg.type != null) {
+            return this.typeToField(arg.type).type;
+        }
+        else if (arg.value != null) {
+            return this.expressionToStr(arg.value, inp).name;
+        }
+        else {
+            throw new Error("A FunctionArgument did not have an enum/type/value");
+        }
+    }
+    /**
+     * Converts a Substrait function reference to a string
+     * @param {number} ref a Substrait function reference
+     * @return {string} a string version of the reference
+     */
+    functionRefToName(ref) {
+        return this.extSet.get(ref) ?? "unknown";
+    }
+    /**
+     * Convert arguments to a joined string
+     * @param {FunctionTyp} func A Substrait function call
+     * @param {Field} schema The input type
+     * @return {string} A string representation
+     */
+    argsToString(func, schema) {
+        const args = func.arguments.length > 0
+            ? func.arguments.map((arg) => this.functionArgumentToStr(arg, schema))
+            : [];
+        return args.join(",");
+    }
+    /**
+     * Convert a scalar function to a stringified representation
+     * @param {Object} func the function to convert
+     * @param {Field} schema the input type info
+     * @return {Field} a string version of the function
+     */
+    scalarFunctionToField(func, schema) {
+        const argsString = this.argsToString(func, schema);
+        const outputType = this.typeToField(func.outputType);
+        const functionName = this.functionRefToName(func.functionReference);
+        if (!["and", "or", "not", "cast"].includes(functionName)) {
+            const args = argsString.split(",");
+            if (args.length === 1) {
+                this.filters.push(`${args[0]} ${functionName} `);
+            }
+            else if (args.length === 2) {
+                this.filters.push(`${args[0]} ${functionName} ${args[1]}`);
+            }
+            else {
+                this.filters.push(`${functionName}(${args.join(", ")})`);
+            }
+        }
+        else {
+            this.logicalOperators.push(functionName);
+        }
+        const fieldName = `${functionName}(${argsString})`;
+        outputType.name = fieldName;
+        return outputType;
+    }
+    /**
+     * Converts a Substrait literal to a field
+     * @param {Object} lit the Substrait literal
+     * @return {Field} a field representation
+     */
+    literalToField(lit) {
+        const nullability = lit.nullable
+            ? "NULLABILITY_NULLABLE"
+            : "NULLABILITY_REQUIRED";
+        if (lit.bool != null) {
+            return {
+                name: String(lit.bool.value),
+                type: "boolean",
+                nullability,
+                children: [],
+            };
+        }
+        else if (lit.date != null) {
+            return {
+                name: new Date((lit.date?.value ?? 0) * 8.64e7).toISOString(),
+                type: "date",
+                nullability,
+                children: [],
+            };
+        }
+        else if (lit.decimal != null) {
+            return {
+                name: String(this.base64ToDecimal(lit.decimal.value ?? "", lit.decimal.precision, lit.decimal.scale)),
+                type: "decimal",
+                nullability,
+                children: [],
+            };
+        }
+        else if (lit.i32 != null) {
+            return {
+                name: lit.i32?.value?.toString() ?? "unspecified",
+                type: "i32",
+                nullability,
+                children: [],
+            };
+        }
+        else if (lit.intervalDayToSecond != null) {
+            const val = lit.intervalDayToSecond;
+            return {
+                name: `${val.days}d${val.seconds}s${val.microseconds}u`,
+                type: "interval_day",
+                nullability,
+                children: [],
+            };
+        }
+        else if (lit.fixedChar != null) {
+            const val = typeof lit.fixedChar === "string"
+                ? lit.fixedChar
+                : lit.fixedChar.value ?? "unspecified";
+            return {
+                name: `${val}`,
+                type: "interval_day",
+                nullability,
+                children: [],
+            };
+        }
+        else {
+            throw new Error(`Unrecognized literal: ${JSON.stringify(lit)}`);
+        }
+    }
+    /**
+     * Convert a cast expression to a stringified representation
+     * @param {Object} cast A Substrait cast expression
+     * @param {Field} schema The input schema
+     * @return {Field} A field representation
+     */
+    castToField(cast, schema) {
+        const input = this.expressionToStr(cast.input, schema);
+        const outputType = this.typeToField(cast.type);
+        let fb = "unspecified";
+        if (cast.failureBehavior === "FAILURE_BEHAVIOR_RETURN_NULL") {
+            fb = "or null";
+        }
+        else if (cast.failureBehavior === "THROW_EXCEPTION") {
+            fb = "or die";
+        }
+        const name = `cast(${input.name}, ${outputType.type}, ${fb})`;
+        outputType.name = name;
+        return outputType;
+    }
+    /**
+     * Convert an expression to a stringified representation
+     *
+     * The expression is returned as a field where the type
+     * of the field is the output type of the expression and the
+     * name of the field is a string representation of the expression
+     *
+     * @param {Object} expr A Substrait expression
+     * @param {Object} exprIn the input to the expression
+     * @return {Field} a string representation
+     */
+    expressionToStr(expr, exprIn) {
+        if (expr.selection != null) {
+            return this.referenceToField(expr.selection, exprIn);
+        }
+        else if (expr.scalarFunction != null) {
+            return this.scalarFunctionToField(expr.scalarFunction, exprIn);
+        }
+        else if (expr.literal != null) {
+            return this.literalToField(expr.literal);
+        }
+        else if (expr.cast != null) {
+            return this.castToField(expr.cast, exprIn);
+        }
+        else {
+            throw new Error(`Unrecognized expression: ${JSON.stringify(expr)}`);
+        }
+    }
+    /**
+     * Convert a project relation to a print node
+     * @param {Object} project A Substrait ProjectRel
+     * @return {PrintNode} a print node
+     */
+    projectToNode(project) {
+        const input = this.relToNode(project.input);
+        const expressions = project.expressions.map((val, idx) => {
+            return {
+                name: `expressions[${idx}]`,
+                field: this.expressionToStr(val, input.schema),
+            };
+        });
+        const outFields = expressions.map((expr) => expr.field);
+        const fields = input.schema.children.concat(outFields);
+        const schema = this.makeSchemaField(fields);
+        const props = expressions.map((expr) => ({
+            name: expr.name,
+            value: expr.field.name,
+        }));
+        const inputs = [this.relToNode(project.input)];
+        return this.makePrintNode("project", inputs, props, schema, project.common?.emit);
+    }
+    /**
+     * Convert a Substrait data type to an unnamed Field
+     *
+     * The field's name will be an empty string
+     *
+     * @param {Object} type a Substrait data type
+     * @return {Field} an unnamed field
+     */
+    typeToField(type) {
+        let typeStr = null;
+        let nullability = "NULLABILITY_UNSPECIFIED";
+        if (type.varchar != null) {
+            typeStr = `VARCHAR<${type.varchar.length}>`;
+            nullability = type.varchar.nullability;
+        }
+        else if (type.fixedChar != null) {
+            typeStr = `FIXEDCHAR<${type.fixedChar.length}>`;
+            nullability =
+                typeof type.fixedChar !== "string"
+                    ? type.fixedChar?.nullability
+                    : "NULLABILITY_REQUIRED";
+        }
+        else if (type.date != null) {
+            typeStr = "date";
+            nullability = type.date.nullability;
+        }
+        else if (type.decimal != null) {
+            typeStr = `DECIMAL<${type.decimal.precision},${type.decimal.scale}>`;
+            nullability = type.decimal.nullability ?? "NULLABILITY_UNSPECIFIED";
+        }
+        else if (type.i32 != null) {
+            typeStr = "i32";
+            nullability = type.i32.nullability;
+        }
+        else if (type.i64 != null) {
+            typeStr = "i64";
+            nullability = type.i64.nullability;
+        }
+        else if (type.bool != null) {
+            typeStr = "boolean";
+            nullability = type.bool.nullability;
+        }
+        else if (type.string != null) {
+            typeStr = "string";
+            nullability = type.string.nullability;
+        }
+        else if (type.fp64 != null) {
+            typeStr = "fp64";
+            nullability = type.fp64.nullability;
+        }
+        else if (type.timestampTz != null) {
+            typeStr = "timestampTz";
+            nullability = type.timestampTz.nullability;
+        }
+        else if (type.struct != null) {
+            typeStr = "struct";
+            nullability = type.struct.nullability;
+        }
+        else if (type.fixedBinary != null) {
+            typeStr = "fixedBinary";
+            nullability = type.fixedBinary.nullability;
+        }
+        else {
+            throw new Error(`Unrecognized type: ${JSON.stringify(type)}`);
+        }
+        return {
+            name: "",
+            type: typeStr,
+            nullability,
+            children: [],
+        };
+    }
+    /**
+     * Convert a named struct to an array of Field
+     * @param {NamedStruct} struct a Substrait named struct
+     * @return {Field[]} named fields
+     */
+    namedStructToSchema(struct) {
+        // const names = struct.names
+        // const types = this.flattenTypes(struct.struct)
+        // console.log('names', names.length)
+        // console.log('types', types.length)
+        // if (names.length !== types.length) {
+        //   throw new Error('Mismatched names and types')
+        // }
+        return {
+            name: "test",
+            type: "struct",
+            nullability: "NULLABILITY_UNSPECIFIED",
+            children: [],
+        };
+        // return this.makeSchemaField(outTypes)
+    }
+    // mapNames (input: NamedStruct, prefix: string = ''): string[] {
+    //   const output: string[] = []
+    //   for (let i = 0; i < input.names.length; i++) {
+    //     const name = input.names[i]
+    //     const type = input.struct.types[i]
+    //     if (type.struct != null) {
+    //       output.push(...this.mapNames({ name, types: type.struct.types }, `${prefix}${name}.`))
+    //     } else {
+    //       output.push(`${prefix}${name}`)
+    //     }
+    //   }
+    //   return output
+    // }
+    /**
+     * Extract the properties from a read relation
+     * @param {Object} read a Substrait read relation
+     * @return {SimpleProperty[]} properties for the relation
+     */
+    readTypeToProps(read) {
+        return [
+            { name: "namedTable.names", value: read.namedTable.names.join(".") },
+        ];
+    }
+    /**
+     * Convert a Substrait read relation to a print node
+     * @param {Object} read a Substrait read relation
+     * @return {PrintNode} a print node
+     */
+    readToNode(read) {
+        const schema = this.namedStructToSchema(read.baseSchema);
+        const props = this.readTypeToProps(read);
+        return this.makePrintNode("read", [], props, schema, read.common?.emit);
+    }
+    /**
+     * True if the object has a field with the given name
+     * @param {Object} obj the object to test
+     * @param {string} fieldName the field name to look for
+     * @return {boolean} the result of the test
+     */
+    hasValue(obj, fieldName) {
+        return fieldName in obj;
+    }
+    /**
+     * Convert a Substrait fetch relation to a print node
+     * @param {Object} fetch a Substrait fetch relation
+     * @return {PrintNode} a print node
+     */
+    fetchToNode(fetch) {
+        const input = this.relToNode(fetch.input);
+        const schema = input.schema;
+        const props = [];
+        if (this.hasValue(fetch, "offset")) {
+            props.push({ name: "offset", value: String(fetch.offset) });
+        }
+        if (this.hasValue(fetch, "count")) {
+            props.push({ name: "count", value: String(fetch.count) });
+        }
+        return this.makePrintNode("fetch", [input], props, schema, fetch.common.emit);
+    }
+    /**
+     * Convert a Substrait sort field to a property
+     * @param {Object} sortField a Substrait sort field
+     * @param {Field} schema the schema of the sort input
+     * @return {SimpleProperty} a property describing the sort
+     */
+    sortFieldToStr(sortField, schema) {
+        const exprStr = this.expressionToStr(sortField.expr, schema).name;
+        if (sortField.direction !== null) {
+            const dir = sortField.direction;
+            let sortDesc = "";
+            if (dir === SortDirection.ASCENDING_NULLS_FIRST) {
+                sortDesc = "ascending (nulls first)";
+            }
+            else if (dir === SortDirection.ASCENDING_NULLS_LAST) {
+                sortDesc = "ascending (nulls last)";
+            }
+            else if (dir === SortDirection.DESCENDING_NULLS_FIRST) {
+                sortDesc = "descending (nulls first)";
+            }
+            else if (dir === SortDirection.DESCENDING_NULLS_LAST) {
+                sortDesc = "descending (nulls last)";
+            }
+            else if (dir === SortDirection.CLUSTERED) {
+                sortDesc = "clustered";
+            }
+            else {
+                sortDesc = "unspecified";
+            }
+            return `${exprStr} | ${sortDesc}`;
+        }
+    }
+    /**
+     * Convert a Substrait sort relation to a print node
+     * @param {Object} sort a Substrait sort relation
+     * @return {PrintNode} a print node
+     */
+    sortToNode(sort) {
+        const input = this.relToNode(sort.input);
+        const schema = input.schema;
+        const props = sort.sorts.map((sort, idx) => {
+            return {
+                name: `sorts[${idx}]`,
+                value: this.sortFieldToStr(sort, schema) ?? "undefined",
+            };
+        });
+        return this.makePrintNode("sort", [input], props, schema, sort.common.emit);
+    }
+    /**
+     * Convert a Substrait aggregate function to a field
+     * @param {Object} func the Substrait aggregate function
+     * @param {Field} inp the input field
+     * @return {Field} a field representation of the function
+     */
+    aggregateFunctionToField(func, inp) {
+        // TODO (weston) sorts, phases, invocation
+        return this.scalarFunctionToField(func, inp);
+    }
+    /**
+     * Convert a Substrait aggregate relation to a print node
+     * @param {Object} agg a Substrait aggregate relation
+     * @return {PrintNode} a print node
+     */
+    aggToNode(agg) {
+        const input = this.relToNode(agg.input);
+        const props = [];
+        const fields = [];
+        agg.groupings.forEach((grouping, idx) => {
+            for (const groupingExpr of grouping.groupingExpressions) {
+                const groupingField = this.expressionToStr(groupingExpr, input.schema);
+                props.push({ name: `grouping[${idx}]`, value: groupingField.name });
+                fields.push(groupingField);
+            }
+        });
+        agg.measures.forEach((measure, idx) => {
+            const aggregate = this.aggregateFunctionToField(measure.measure, input.schema);
+            fields.push(aggregate);
+            const innerProps = [
+                {
+                    name: "measure",
+                    value: aggregate.name,
+                },
+            ];
+            innerProps.push({
+                name: "filter",
+                value: this.expressionToStr(measure.filter, input.schema).name,
+            });
+            props.push({
+                name: `measures[${idx}]`,
+                value: JSON.stringify(innerProps), // TODO Is this right?
+            });
+        });
+        const schema = this.makeSchemaField(fields);
+        return this.makePrintNode("aggregate", [input], props, schema, agg.common.emit);
+    }
+    /**
+     * Convert a Substrait filter relation to a print node
+     * @param {Object} filt a Substrait filter relation
+     * @return {PrintNode} a print node
+     */
+    filterToNode(filt) {
+        const input = this.relToNode(filt.input);
+        const props = [];
+        const schema = input.schema;
+        props.push({
+            name: "condition",
+            value: this.expressionToStr(filt.condition, schema).name,
+        });
+        const printNode = this.makePrintNode("filter", [input], props, schema, filt.common.emit);
+        return printNode;
+    }
+    /**
+     * Converts a Substrait join relation to a print node
+     * @param {Object} join a Substrait join relation
+     * @return {PrintNode} a print node
+     */
+    joinToNode(join) {
+        const left = this.relToNode(join.left);
+        const right = this.relToNode(join.right);
+        const props = [];
+        const schema = this.makeSchemaField(left.schema.children.concat(right.schema.children));
+        let joinType = "unspecified";
+        if (join.type !== null) {
+            joinType = JoinType[join.type];
+        }
+        props.push({ name: "type", value: joinType });
+        if (join.expression !== null) {
+            const exprStr = this.expressionToStr(join.expression, schema).name;
+            props.push({ name: "expression", value: exprStr });
+        }
+        return this.makePrintNode("join", [left, right], props, schema, join.common.emit);
+    }
+    /**
+     * Converts a Substrait relation to a print node
+     * @param {Object} rel the Substrait relation to convert
+     * @return {PrintNode} a print node
+     */
+    relToNode(rel) {
+        if (rel.project != null) {
+            return this.projectToNode(rel.project);
+        }
+        else if (rel.read != null) {
+            return this.readToNode(rel.read);
+        }
+        else if (rel.fetch != null) {
+            return this.fetchToNode(rel.fetch);
+        }
+        else if (rel.sort != null) {
+            return this.sortToNode(rel.sort);
+        }
+        else if (rel.aggregate != null) {
+            return this.aggToNode(rel.aggregate);
+        }
+        else if (rel.filter != null) {
+            return this.filterToNode(rel.filter);
+        }
+        else if (rel.join != null) {
+            return this.joinToNode(rel.join);
+        }
+        else {
+            throw new Error(`Unrecognized relation: ${JSON.stringify(rel)}`);
+        }
+    }
+    /**
+     * Converts a Substrait root relation to a print node
+     * @param {Object} rel the Substrait relation to convert
+     * @return {PrintNode} a print node
+     */
+    rootRelToNode(rel) {
+        const props = rel.names.map((val, idx) => ({
+            name: `name[${idx}]`,
+            value: val,
+        }));
+        this.selectedFields = this.selectedFields.concat(rel.names);
+        const inputs = [this.relToNode(rel.input)];
+        const schema = this.makeSchemaField([]);
+        return this.makePrintNode("sink", inputs, props, schema);
+    }
+    /**
+     * Converts a Substrait plan to a print node
+     * @param {Object} plan the Substrait plan to convert
+     * @return {PrintNode} a print node
+     */
+    planToNode(plan) {
+        const nodes = [];
+        for (const relation of plan.relations) {
+            if (relation.root != null) {
+                nodes.push(this.rootRelToNode(relation.root));
+            }
+            else {
+                throw new Error(`Unrecognized plan relation ${JSON.stringify(relation)}`);
+            }
+        }
+        const schema = this.makeSchemaField([]);
+        return this.makePrintNode("plan", nodes, [], schema);
+    }
+    parse(plan) {
+        this.selectedFields = [];
+        this.planToNode(plan);
+        return {
+            selection: this.selectedFields,
+            filters: this.deduplicate(this.filters),
+            logicalOperators: this.deduplicate(this.logicalOperators),
+        };
+    }
+    /**
+     * Converts a base64 string into a decimal number.
+     *
+     * @public
+     * @param {string} base64 - The base64 string to convert.
+     * @param {number} precision - The total number of digits in the output number.
+     * @param {number} scale - The number of digits after the decimal point in the output number.
+     * @throws {Error} Will throw an error if the conversion fails.
+     * @returns {number} The converted decimal number.
+     * @example
+     * // returns 123.45
+     * this.base64ToDecimal('MTIzNDU=', 5, 2);
+     */
+    base64ToDecimal(base64, precision, scale) {
+        // Decode base64 string to a Buffer
+        const buffer = Buffer.from(base64, "base64");
+        let value = BigInt(0);
+        for (let i = buffer.length - 1; i >= 0; i--) {
+            value = (value << BigInt(8)) + BigInt(buffer[i]);
+        }
+        return Number(value) / Math.pow(10, scale);
+    }
+    deduplicate(array) {
+        return Array.from(new Set(array));
+    }
+}
+export { SubstraitParser };