@narrative.io/data-collaboration-sdk-ts 0.0.107 → 0.0.109

package/build/nql/SubstraitParser.js

@@ -62,76 +62,76 @@ class SubstraitParser {
     filters = [];
     logicalOperators = [];
     /**
-       * Constructs a SubstraitParser
-       * @param {SubstraitPlan} plan the Substrait plan
-       */
+     * 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
-       */
+     * 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());
+            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
-       */
+     * 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
-       */
+     * 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: '',
+            name: "",
             children: fields,
-            type: '',
-            nullability: 'NULLABILITY_UNSPECIFIED'
+            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
-       */
+     * 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) {
+        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
-       */
+     * 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 {
@@ -139,19 +139,19 @@ class SubstraitParser {
             type,
             inputs,
             props,
-            schema: emitSchema
+            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
-       */
+     * 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 fieldName = currentField.name !== "" ? currentField.name : `$${fieldNum}`;
         const nextName = `${currentName}${fieldName}`;
         if (field.child != null) {
             return this.structFieldHelper(field.child, `${nextName}.`, currentField.children[fieldNum]);
@@ -159,28 +159,28 @@ class SubstraitParser {
         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
-       */
+     * 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);
+        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
-       */
+     * 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);
@@ -190,11 +190,11 @@ class SubstraitParser {
         }
     }
     /**
-       * 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
-       */
+     * 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);
@@ -204,15 +204,15 @@ class SubstraitParser {
         }
     }
     /**
-       * 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
-       */
+     * 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 "unspecified";
             }
             return arg.enum.specified;
         }
@@ -223,41 +223,41 @@ class SubstraitParser {
             return this.expressionToStr(arg.value, inp).name;
         }
         else {
-            throw new Error('A FunctionArgument did not have an enum/type/value');
+            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
-       */
+     * 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';
+        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
-       */
+     * 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(',');
+        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
-       */
+     * 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 (!["and", "or", "not", "cast"].includes(functionName)) {
+            const args = argsString.split(",");
             if (args.length === 1) {
                 this.filters.push(`${args[0]} ${functionName} `);
             }
@@ -265,7 +265,7 @@ class SubstraitParser {
                 this.filters.push(`${args[0]} ${functionName} ${args[1]}`);
             }
             else {
-                this.filters.push(`${functionName}(${args.join(', ')})`);
+                this.filters.push(`${functionName}(${args.join(", ")})`);
             }
         }
         else {
@@ -276,60 +276,64 @@ class SubstraitParser {
         return outputType;
     }
     /**
-       * Converts a Substrait literal to a field
-       * @param {Object} lit the Substrait literal
-       * @return {Field} a field representation
-       */
+     * 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';
+        const nullability = lit.nullable
+            ? "NULLABILITY_NULLABLE"
+            : "NULLABILITY_REQUIRED";
         if (lit.bool != null) {
             return {
                 name: String(lit.bool.value),
-                type: 'boolean',
+                type: "boolean",
                 nullability,
-                children: []
+                children: [],
             };
         }
         else if (lit.date != null) {
             return {
                 name: new Date((lit.date?.value ?? 0) * 8.64e7).toISOString(),
-                type: 'date',
+                type: "date",
                 nullability,
-                children: []
+                children: [],
             };
         }
         else if (lit.decimal != null) {
             return {
                 name: String(this.base64ToDecimal(lit.decimal.value, lit.decimal.precision, lit.decimal.scale)),
-                type: 'decimal',
+                type: "decimal",
                 nullability,
-                children: []
+                children: [],
             };
         }
         else if (lit.i32 != null) {
             return {
-                name: lit.i32?.value?.toString() ?? 'unspecified',
-                type: 'i32',
+                name: lit.i32?.value?.toString() ?? "unspecified",
+                type: "i32",
                 nullability,
-                children: []
+                children: [],
             };
         }
         else if (lit.intervalDayToSecond != null) {
             const val = lit.intervalDayToSecond;
             return {
                 name: `${val.days}d${val.seconds}s${val.microseconds}u`,
-                type: 'interval_day',
+                type: "interval_day",
                 nullability,
-                children: []
+                children: [],
             };
         }
         else if (lit.fixedChar != null) {
-            const val = typeof lit.fixedChar === 'string' ? lit.fixedChar : lit.fixedChar.value ?? 'unspecified';
+            const val = typeof lit.fixedChar === "string"
+                ? lit.fixedChar
+                : lit.fixedChar.value ?? "unspecified";
             return {
                 name: `${val}`,
-                type: 'interval_day',
+                type: "interval_day",
                 nullability,
-                children: []
+                children: [],
             };
         }
         else {
@@ -337,36 +341,36 @@ class SubstraitParser {
         }
     }
     /**
-       * 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
-       */
+     * 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';
+        let fb = "unspecified";
+        if (cast.failureBehavior === "FAILURE_BEHAVIOR_RETURN_NULL") {
+            fb = "or null";
         }
-        else if (cast.failureBehavior === 'THROW_EXCEPTION') {
-            fb = 'or die';
+        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
-       */
+     * 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);
@@ -385,16 +389,16 @@ class SubstraitParser {
         }
     }
     /**
-       * Convert a project relation to a print node
-       * @param {Object} project A Substrait ProjectRel
-       * @return {PrintNode} a print node
-       */
+     * 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)
+                field: this.expressionToStr(val, input.schema),
             };
         });
         const outFields = expressions.map((expr) => expr.field);
@@ -402,85 +406,88 @@ class SubstraitParser {
         const schema = this.makeSchemaField(fields);
         const props = expressions.map((expr) => ({
             name: expr.name,
-            value: expr.field.name
+            value: expr.field.name,
         }));
         const inputs = [this.relToNode(project.input)];
-        return this.makePrintNode('project', inputs, props, schema, project.common?.emit);
+        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
-       */
+     * 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';
+        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';
+            nullability =
+                typeof type.fixedChar !== "string"
+                    ? type.fixedChar?.nullability
+                    : "NULLABILITY_REQUIRED";
         }
         else if (type.date != null) {
-            typeStr = 'date';
+            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';
+            nullability = type.decimal.nullability ?? "NULLABILITY_UNSPECIFIED";
         }
         else if (type.i32 != null) {
-            typeStr = 'i32';
+            typeStr = "i32";
             nullability = type.i32.nullability;
         }
         else if (type.i64 != null) {
-            typeStr = 'i64';
+            typeStr = "i64";
             nullability = type.i64.nullability;
         }
         else if (type.bool != null) {
-            typeStr = 'boolean';
+            typeStr = "boolean";
             nullability = type.bool.nullability;
         }
         else if (type.string != null) {
-            typeStr = 'string';
+            typeStr = "string";
             nullability = type.string.nullability;
         }
         else if (type.fp64 != null) {
-            typeStr = 'fp64';
+            typeStr = "fp64";
             nullability = type.fp64.nullability;
         }
         else if (type.timestampTz != null) {
-            typeStr = 'timestampTz';
+            typeStr = "timestampTz";
             nullability = type.timestampTz.nullability;
         }
         else if (type.struct != null) {
-            typeStr = 'struct';
+            typeStr = "struct";
             nullability = type.struct.nullability;
         }
         else if (type.fixedBinary != null) {
-            typeStr = 'fixedBinary';
+            typeStr = "fixedBinary";
             nullability = type.fixedBinary.nullability;
         }
         else {
             throw new Error(`Unrecognized type: ${JSON.stringify(type)}`);
         }
         return {
-            name: '',
+            name: "",
             type: typeStr,
             nullability,
-            children: []
+            children: [],
         };
     }
     /**
-       * Convert a named struct to an array of Field
-       * @param {NamedStruct} struct a Substrait named struct
-       * @return {Field[]} named fields
-       */
+     * 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)
@@ -490,10 +497,10 @@ class SubstraitParser {
         //   throw new Error('Mismatched names and types')
         // }
         return {
-            name: 'test',
-            type: 'struct',
-            nullability: 'NULLABILITY_UNSPECIFIED',
-            children: []
+            name: "test",
+            type: "struct",
+            nullability: "NULLABILITY_UNSPECIFIED",
+            children: [],
         };
         // return this.makeSchemaField(outTypes)
     }
@@ -511,112 +518,114 @@ class SubstraitParser {
     //   return output
     // }
     /**
-       * Extract the properties from a read relation
-       * @param {Object} read a Substrait read relation
-       * @return {SimpleProperty[]} properties for the relation
-       */
+     * 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('.') }];
+        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
-       */
+     * 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);
+        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
-       */
+     * 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
-       */
+     * 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, "offset")) {
+            props.push({ name: "offset", value: String(fetch.offset) });
         }
-        if (this.hasValue(fetch, 'count')) {
-            props.push({ name: 'count', value: String(fetch.count) });
+        if (this.hasValue(fetch, "count")) {
+            props.push({ name: "count", value: String(fetch.count) });
         }
-        return this.makePrintNode('fetch', [input], props, schema, fetch.common.emit);
+        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
-       */
+     * 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 = '';
+            let sortDesc = "";
             if (dir === SortDirection.ASCENDING_NULLS_FIRST) {
-                sortDesc = 'ascending (nulls first)';
+                sortDesc = "ascending (nulls first)";
             }
             else if (dir === SortDirection.ASCENDING_NULLS_LAST) {
-                sortDesc = 'ascending (nulls last)';
+                sortDesc = "ascending (nulls last)";
             }
             else if (dir === SortDirection.DESCENDING_NULLS_FIRST) {
-                sortDesc = 'descending (nulls first)';
+                sortDesc = "descending (nulls first)";
             }
             else if (dir === SortDirection.DESCENDING_NULLS_LAST) {
-                sortDesc = 'descending (nulls last)';
+                sortDesc = "descending (nulls last)";
             }
             else if (dir === SortDirection.CLUSTERED) {
-                sortDesc = 'clustered';
+                sortDesc = "clustered";
             }
             else {
-                sortDesc = 'unspecified';
+                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
-       */
+     * 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'
+                value: this.sortFieldToStr(sort, schema) ?? "undefined",
             };
         });
-        return this.makePrintNode('sort', [input], props, schema, sort.common.emit);
+        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
-       */
+     * 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
-       */
+     * 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 = [];
@@ -633,64 +642,64 @@ class SubstraitParser {
             fields.push(aggregate);
             const innerProps = [
                 {
-                    name: 'measure',
-                    value: aggregate.name
-                }
+                    name: "measure",
+                    value: aggregate.name,
+                },
             ];
             innerProps.push({
-                name: 'filter',
-                value: this.expressionToStr(measure.filter, input.schema).name
+                name: "filter",
+                value: this.expressionToStr(measure.filter, input.schema).name,
             });
             props.push({
                 name: `measures[${idx}]`,
-                value: JSON.stringify(innerProps) // TODO Is this right?
+                value: JSON.stringify(innerProps), // TODO Is this right?
             });
         });
         const schema = this.makeSchemaField(fields);
-        return this.makePrintNode('aggregate', [input], props, schema, agg.common.emit);
+        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
-       */
+     * 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
+            name: "condition",
+            value: this.expressionToStr(filt.condition, schema).name,
         });
-        const printNode = this.makePrintNode('filter', [input], props, schema, filt.common.emit);
+        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
-       */
+     * 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';
+        let joinType = "unspecified";
         if (join.type !== null) {
             joinType = JoinType[join.type];
         }
-        props.push({ name: 'type', value: joinType });
+        props.push({ name: "type", value: joinType });
         if (join.expression !== null) {
             const exprStr = this.expressionToStr(join.expression, schema).name;
-            props.push({ name: 'expression', value: exprStr });
+            props.push({ name: "expression", value: exprStr });
         }
-        return this.makePrintNode('join', [left, right], props, schema, join.common.emit);
+        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
-       */
+     * 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);
@@ -718,25 +727,25 @@ class SubstraitParser {
         }
     }
     /**
-       * Converts a Substrait root relation to a print node
-       * @param {Object} rel the Substrait relation to convert
-       * @return {PrintNode} a print node
-       */
+     * 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
+            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);
+        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
-       */
+     * 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) {
@@ -748,7 +757,7 @@ class SubstraitParser {
             }
         }
         const schema = this.makeSchemaField([]);
-        return this.makePrintNode('plan', nodes, [], schema);
+        return this.makePrintNode("plan", nodes, [], schema);
     }
     parse(plan) {
         this.selectedFields = [];
@@ -756,7 +765,7 @@ class SubstraitParser {
         return {
             selection: this.selectedFields,
             filters: this.deduplicate(this.filters),
-            logicalOperators: this.deduplicate(this.logicalOperators)
+            logicalOperators: this.deduplicate(this.logicalOperators),
         };
     }
     /**
@@ -774,7 +783,7 @@ class SubstraitParser {
      */
     base64ToDecimal(base64, precision, scale) {
         // Decode base64 string to a Buffer
-        const buffer = Buffer.from(base64, 'base64');
+        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]);