@narrative.io/data-collaboration-sdk-ts 1.0.0 → 1.1.0

package/build/nql/SubstraitParser.js

@@ -1,785 +0,0 @@
-/*!
-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);
-        }
-        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);
-        }
-        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;
-        }
-        if (arg.type != null) {
-            return this.typeToField(arg.type).type;
-        }
-        if (arg.value != null) {
-            return this.expressionToStr(arg.value, inp).name;
-        }
-        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: [],
-            };
-        }
-        if (lit.date != null) {
-            return {
-                name: new Date((lit.date?.value ?? 0) * 8.64e7).toISOString(),
-                type: "date",
-                nullability,
-                children: [],
-            };
-        }
-        if (lit.decimal != null) {
-            return {
-                name: String(this.base64ToDecimal(lit.decimal.value ?? "", lit.decimal.precision, lit.decimal.scale)),
-                type: "decimal",
-                nullability,
-                children: [],
-            };
-        }
-        if (lit.i32 != null) {
-            return {
-                name: lit.i32?.value?.toString() ?? "unspecified",
-                type: "i32",
-                nullability,
-                children: [],
-            };
-        }
-        if (lit.intervalDayToSecond != null) {
-            const val = lit.intervalDayToSecond;
-            return {
-                name: `${val.days}d${val.seconds}s${val.microseconds}u`,
-                type: "interval_day",
-                nullability,
-                children: [],
-            };
-        }
-        if (lit.fixedChar != null) {
-            const val = typeof lit.fixedChar === "string"
-                ? lit.fixedChar
-                : lit.fixedChar.value ?? "unspecified";
-            return {
-                name: `${val}`,
-                type: "interval_day",
-                nullability,
-                children: [],
-            };
-        }
-        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);
-        }
-        if (expr.scalarFunction != null) {
-            return this.scalarFunctionToField(expr.scalarFunction, exprIn);
-        }
-        if (expr.literal != null) {
-            return this.literalToField(expr.literal);
-        }
-        if (expr.cast != null) {
-            return this.castToField(expr.cast, exprIn);
-        }
-        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 = [];
-        for (const [idx, grouping] of agg.groupings.entries()) {
-            for (const groupingExpr of grouping.groupingExpressions) {
-                const groupingField = this.expressionToStr(groupingExpr, input.schema);
-                props.push({ name: `grouping[${idx}]`, value: groupingField.name });
-                fields.push(groupingField);
-            }
-        }
-        for (const [idx, measure] of agg.measures.entries()) {
-            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);
-        }
-        if (rel.read != null) {
-            return this.readToNode(rel.read);
-        }
-        if (rel.fetch != null) {
-            return this.fetchToNode(rel.fetch);
-        }
-        if (rel.sort != null) {
-            return this.sortToNode(rel.sort);
-        }
-        if (rel.aggregate != null) {
-            return this.aggToNode(rel.aggregate);
-        }
-        if (rel.filter != null) {
-            return this.filterToNode(rel.filter);
-        }
-        if (rel.join != null) {
-            return this.joinToNode(rel.join);
-        }
-        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) / 10 ** scale;
-    }
-    deduplicate(array) {
-        return Array.from(new Set(array));
-    }
-}
-export { SubstraitParser };