@itwin/ecsql-common 4.2.0-dev.10

package/lib/esm/ECSqlAst.js

@@ -0,0 +1,2384 @@
+import { asInstanceOf, isInstanceOf } from "@itwin/core-bentley";
+/**
+ * Id returned by native code
+ * @internal
+ */
+var NativeExpIds;
+(function (NativeExpIds) {
+    NativeExpIds["AllOrAny"] = "AllOrAnyExp";
+    NativeExpIds["Assignment"] = "AssignmentExp";
+    NativeExpIds["BetweenRangeValue"] = "BetweenRangeValueExp";
+    NativeExpIds["BinaryBoolean"] = "BinaryBooleanExp";
+    NativeExpIds["BinaryValue"] = "BinaryValueExp";
+    NativeExpIds["BooleanFactor"] = "BooleanFactorExp";
+    NativeExpIds["Cast"] = "CastExp";
+    NativeExpIds["ClassName"] = "ClassNameExp";
+    NativeExpIds["CommonTable"] = "CommonTableExp";
+    NativeExpIds["CommonTableBlock"] = "CommonTableBlockExp";
+    NativeExpIds["CommonTableBlockName"] = "CommonTableBlockNameExp";
+    NativeExpIds["CrossJoin"] = "CrossJoinExp";
+    NativeExpIds["DeleteStatement"] = "DeleteStatementExp";
+    NativeExpIds["DerivedProperty"] = "DerivedPropertyExp";
+    NativeExpIds["FunctionCall"] = "FunctionCallExp";
+    NativeExpIds["IIF"] = "IIFExp";
+    NativeExpIds["InsertStatement"] = "InsertStatementExp";
+    NativeExpIds["LikeRhsValue"] = "LikeRhsValueExp";
+    NativeExpIds["LimitOffset"] = "LimitOffsetExp";
+    NativeExpIds["LiteralValue"] = "LiteralValueExp";
+    NativeExpIds["MemberFunctionCall"] = "MemberFunctionCallExp";
+    NativeExpIds["NaturalJoin"] = "NaturalJoinExp";
+    NativeExpIds["Options"] = "OptionsExp";
+    NativeExpIds["OrderBySpec"] = "OrderBySpecExp";
+    NativeExpIds["Parameter"] = "ParameterExp";
+    NativeExpIds["PropertyName"] = "PropertyNameExp";
+    NativeExpIds["QualifiedJoin"] = "QualifiedJoinExp";
+    NativeExpIds["RowConstructor"] = "RowConstructor";
+    NativeExpIds["SearchCaseValue"] = "SearchCaseValueExp";
+    NativeExpIds["SelectStatement"] = "SelectStatementExp";
+    NativeExpIds["SingleSelectStatement"] = "SingleSelectStatementExp";
+    NativeExpIds["Subquery"] = "SubqueryExp";
+    NativeExpIds["SubqueryRef"] = "SubqueryRefExp";
+    NativeExpIds["SubqueryTest"] = "SubqueryTestExp";
+    NativeExpIds["TableValuedFunction"] = "TableValuedFunctionExp";
+    NativeExpIds["UnaryValue"] = "UnaryValueExp";
+    NativeExpIds["UpdateStatement"] = "UpdateStatementExp";
+    NativeExpIds["UsingRelationshipJoinExp"] = "UsingRelationshipJoinExp";
+})(NativeExpIds || (NativeExpIds = {}));
+/**
+ * Type of literal value.
+ * @alpha
+ */
+export var LiteralValueType;
+(function (LiteralValueType) {
+    LiteralValueType["Null"] = "NULL";
+    LiteralValueType["String"] = "STRING";
+    LiteralValueType["Date"] = "DATE";
+    LiteralValueType["Time"] = "TIME";
+    LiteralValueType["Timestamp"] = "TIMESTAMP";
+    LiteralValueType["Raw"] = "RAW";
+})(LiteralValueType || (LiteralValueType = {}));
+/**
+ * Qualified JOIN type @see [[QualifiedJoinExpr]]
+ * @alpha
+ */
+export var JoinType;
+(function (JoinType) {
+    JoinType["LeftOuter"] = "LEFT OUTER JOIN";
+    JoinType["RightOuter"] = "RIGHT OUTER JOIN";
+    JoinType["FullOuter"] = "FULL OUTER JOIN";
+    JoinType["Inner"] = "INNER JOIN";
+})(JoinType || (JoinType = {}));
+/**
+ * ECSql expr type supported @see [[Expr]]
+ * @alpha
+ */
+export var ExprType;
+(function (ExprType) {
+    ExprType["Literal"] = "Literal";
+    ExprType["Unary"] = "Unary";
+    ExprType["Parameter"] = "Parameter";
+    ExprType["Cast"] = "Cast";
+    ExprType["BinaryValue"] = "BinaryValue";
+    ExprType["SearchCase"] = "SearchCase";
+    ExprType["IIF"] = "IIF";
+    ExprType["FuncCall"] = "FuncCall";
+    ExprType["PropertyName"] = "PropertyName";
+    ExprType["Subquery"] = "Subquery";
+    ExprType["Between"] = "Between";
+    // Match = "Match",
+    ExprType["Like"] = "Like";
+    ExprType["In"] = "In";
+    ExprType["Not"] = "Not";
+    ExprType["IsOfType"] = "IsOfType";
+    ExprType["IsNull"] = "IsNull";
+    ExprType["BinaryBoolean"] = "BinaryBoolean";
+    ExprType["SubqueryTest"] = "SubqueryTest";
+    ExprType["UsingRelationshipJoin"] = "UsingRelationshipJoin";
+    ExprType["QualifiedJoin"] = "QualifiedJoin";
+    ExprType["SubqueryRef"] = "SubqueryRef";
+    ExprType["CteBlockRef"] = "CteBlockRef";
+    ExprType["ClassName"] = "ClassName";
+    ExprType["TableValuedFunc"] = "TableValuedFunc";
+    ExprType["DerivedProperty"] = "DerivedProperty";
+    ExprType["SetClause"] = "SetClause";
+    ExprType["Select"] = "Select";
+    ExprType["ECSqlOptionsClause"] = "ECSqlOptions";
+    ExprType["CteBlock"] = "CteBlock";
+    ExprType["MemberFuncCall"] = "MemberFuncCall";
+    ExprType["Cte"] = "Cte";
+    ExprType["UpdateStatement"] = "UpdateStatement";
+    ExprType["InsertStatement"] = "InsertStatement";
+    ExprType["DeleteStatement"] = "DeleteStatement";
+    ExprType["SelectStatement"] = "SelectStatement";
+    ExprType["SelectionClause"] = "SelectionClause";
+    ExprType["WhereClause"] = "WhereClause";
+    ExprType["GroupByClause"] = "GroupByClause";
+    ExprType["HavingClause"] = "HavingCluase";
+    ExprType["FromClause"] = "FromClause";
+    ExprType["OrderByClause"] = "OrderByClause";
+    ExprType["OrderBySpec"] = "OrderBySpec";
+    ExprType["LimitClause"] = "LimitClause";
+    ExprType["Assignment"] = "Assignment";
+})(ExprType || (ExprType = {}));
+/**
+ * Allow to create statement expression tree from a ecsql
+ *  @alpha
+ */
+export class ExprFactory {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async parseStatement(ecsql) {
+        return StatementExpr.deserialize(this.provider.parseECSql(ecsql));
+    }
+}
+/**
+ * Base class for all ECSql expressions.
+ *  @alpha
+ */
+export class Expr {
+    constructor(expType) {
+        this.expType = expType;
+    }
+    /**
+     * Find instances of expressions matching the type in sub tree.
+     * @param type a subclass of Expr
+     * @returns
+     */
+    findInstancesOf(type) {
+        const listOfT = [];
+        this.traverse((expr) => {
+            const inst = expr.asInstanceOf(type);
+            if (inst)
+                listOfT.push(inst);
+        });
+        return listOfT;
+    }
+    /**
+     * Allow to traverse the expression tree depth first
+     * @param callback this will be called for each expression traverse from first to last.
+     */
+    traverse(callback) {
+        const list = [this];
+        let parent;
+        while (list.length > 0) {
+            const current = list.pop();
+            if (current) {
+                const rc = callback(current, parent);
+                if (typeof rc === "boolean") {
+                    if (!rc)
+                        return;
+                }
+                parent = current;
+                list.push(...current.children.reverse());
+            }
+        }
+    }
+    /**
+     * Test if class instance is of certain type
+     * @param type A class that extends from Expr
+     * @returns true if instances matches the type else return false.
+     */
+    isInstanceOf(type) { return isInstanceOf(this, type); }
+    asInstanceOf(type) { return asInstanceOf(this, type); }
+    /**
+     * Convert expression tree to ECSQL.
+     * @param args args to ecsql writer.
+     * @returns ECSQL string
+     */
+    toECSql(args) {
+        if (args) {
+            const customWriter = new ECSqlWriter(args);
+            this.writeTo(customWriter);
+            return customWriter.toString();
+        }
+        const defaultWriter = new ECSqlWriter();
+        this.writeTo(defaultWriter);
+        return defaultWriter.toString();
+    }
+}
+/**
+ * Base class for all ECSQL Statements. Here are list of subclasses @see [[CteExpr]], @see [[SelectStatement]], @see [[InsertStatement]], @see [UpdateStatement]] and @see [[DeleteStatement]]
+ *  @alpha
+ */
+export class StatementExpr extends Expr {
+    static deserialize(node) {
+        if (node.id === NativeExpIds.CommonTable)
+            return CteExpr.deserialize(node);
+        if (node.id === NativeExpIds.InsertStatement)
+            return InsertStatementExpr.deserialize(node);
+        if (node.id === NativeExpIds.UpdateStatement)
+            return UpdateStatementExpr.deserialize(node);
+        if (node.id === NativeExpIds.DeleteStatement)
+            return DeleteStatementExpr.deserialize(node);
+        if (node.id === NativeExpIds.SelectStatement)
+            return SelectStatementExpr.deserialize(node);
+        throw new Error(`unknow node.id = ${node.id}`);
+    }
+}
+/**
+ * Base class for all computed expression like Value and Boolean.
+ * @alpha
+ */
+export class ComputedExpr extends Expr {
+    static deserialize(node) {
+        if (BooleanExpr.deserializableIds.includes(node.id)) {
+            return BooleanExpr.deserialize(node);
+        }
+        if (ValueExpr.deserializableIds.includes(node.id)) {
+            return ValueExpr.deserialize(node);
+        }
+        throw new Error(`unknow node.id = ${node.id}`);
+    }
+}
+/**
+ * Base class for a boolean expressions. It has following subclasses
+ * @see [[BooleanExpr]]
+ * @see [[ubqueryTestExpr]]
+ * @see [[BetweenExpr]]
+ * @see [[LikeExpr]]
+ * @see [[InExpr]]
+ * @see [[IsNullExpr]]
+ * @see [[IsOfTypeExpr]]
+ * @see [[NotExpr]]
+ * @see [[BinaryBooleanExpr]]
+ * @alpha
+ */
+class BooleanExpr extends ComputedExpr {
+    static deserialize(node) {
+        if (node.id === NativeExpIds.BinaryBoolean) {
+            const op = node.op;
+            // if (MatchExpr.parseOp(op)[0]) {
+            //   return MatchExpr.deserialize(node);
+            // }
+            if (BetweenExpr.parseOp(op)[0]) {
+                return BetweenExpr.deserialize(node);
+            }
+            if (LikeExpr.parseOp(op)[0]) {
+                return LikeExpr.deserialize(node);
+            }
+            if (InExpr.parseOp(op)[0]) {
+                return InExpr.deserialize(node);
+            }
+            if (IsNullExpr.parseOp(node)[0]) {
+                return IsNullExpr.deserialize(node);
+            }
+            if (IsOfTypeExpr.parseOp(node)[0]) {
+                return IsOfTypeExpr.deserialize(node);
+            }
+            return BinaryBooleanExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.BooleanFactor) {
+            return NotExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.SubqueryTest) {
+            return SubqueryTestExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.BooleanFactor) {
+            return NotExpr.deserialize(node);
+        }
+        throw new Error(`Unknown type of native value exp ${node.id}`);
+    }
+}
+BooleanExpr.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.BooleanFactor, NativeExpIds.SubqueryTest, NativeExpIds.AllOrAny, NativeExpIds.BooleanFactor];
+export { BooleanExpr };
+/**
+ * Base class for all value expressions. Following is list of subclasses.
+ * @see [[SubqueryExpr]]
+ * @see [[ValueExpr]]
+ * @see [[UnaryValueExpr]]
+ * @see [[FuncCallExpr]]
+ * @see [[CastExpr]]
+ * @see [[BinaryValueExpr]]
+ * @see [[SearchCaseExpr]]
+ * @see [[IIFExpr]]
+ * @see [[LiteralExpr]]
+ * @see [[PropertyNameExpr]]
+ * @alpha
+ */
+class ValueExpr extends ComputedExpr {
+    static deserialize(node) {
+        if (node.id === NativeExpIds.UnaryValue) {
+            return UnaryValueExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.PropertyName) {
+            return PropertyNameExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.Parameter) {
+            return ParameterExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.FunctionCall) {
+            return FuncCallExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.Cast) {
+            return CastExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.Subquery) {
+            return SubqueryExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.BinaryValue) {
+            return BinaryValueExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.SearchCaseValue) {
+            return SearchCaseExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.IIF) {
+            return IIFExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.LiteralValue) {
+            return LiteralExpr.deserialize(node);
+        }
+        throw new Error(`Unknown type of native value exp ${node.id}`);
+    }
+}
+ValueExpr.deserializableIds = [
+    NativeExpIds.LiteralValue,
+    NativeExpIds.Parameter,
+    NativeExpIds.FunctionCall,
+    NativeExpIds.Cast,
+    NativeExpIds.BinaryValue,
+    NativeExpIds.SearchCaseValue,
+    NativeExpIds.IIF,
+    NativeExpIds.UnaryValue,
+    NativeExpIds.PropertyName,
+    NativeExpIds.Subquery,
+];
+export { ValueExpr };
+/**
+ * Base class for expressions that can be used in FROM clause of a SELECT. Following list of this subclasses.
+ * @see [[ClassRefExpr]]
+ * @see [[ClassNameExpr]]
+ * @see [[SubqueryRefExpr]]
+ * @see [[UsingRelationshipJoinExpr]]
+ * @see [[QualifiedJoinExpr]]
+ * @see [[CteBlockRefExpr]]
+ * @see [[TableValuedFuncExpr]]
+ * @alpha
+ */
+class ClassRefExpr extends Expr {
+    static deserialize(node) {
+        if (node.id === NativeExpIds.ClassName) {
+            return ClassNameExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.SubqueryRef) {
+            return SubqueryRefExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.UsingRelationshipJoinExp) {
+            return UsingRelationshipJoinExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.QualifiedJoin) {
+            return QualifiedJoinExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.CommonTableBlockName) {
+            return CteBlockRefExpr.deserialize(node);
+        }
+        if (node.id === NativeExpIds.TableValuedFunction) {
+            return TableValuedFuncExpr.deserialize(node);
+        }
+        throw new Error(`Unknown type of native value exp ${node.id}`);
+    }
+}
+ClassRefExpr.deserializableIds = [
+    NativeExpIds.ClassName,
+    NativeExpIds.SubqueryRef,
+    NativeExpIds.UsingRelationshipJoinExp,
+    NativeExpIds.QualifiedJoin,
+    NativeExpIds.CommonTableBlockName,
+];
+export { ClassRefExpr };
+/**
+ * Write expression tree to string
+ * @alpha
+ */
+export class ECSqlWriter {
+    constructor(options = {
+        multiline: false,
+        spaceAfterComma: true,
+        spaceAroundBinOp: true,
+        eol: "\r\n",
+        keywordCasing: "UPPER",
+        indent: { size: 3, char: " " },
+    }) {
+        this.options = options;
+        this._tokens = [];
+        this._currentIndent = 0;
+        this._isNewLine = false;
+    }
+    indent() {
+        this._currentIndent++;
+    }
+    unindent() {
+        if (this._currentIndent > 0)
+            this._currentIndent--;
+    }
+    appendBinaryOp(val) {
+        if (this.options.spaceAroundBinOp)
+            return this.append(` ${val} `);
+        return this.append(val);
+    }
+    appendKeyword(val) {
+        if (this.options.keywordCasing === "UPPER")
+            return this.append(val);
+        return this.append(val.toLowerCase());
+    }
+    appendComma() {
+        this.append(",");
+        if (this.options.spaceAfterComma)
+            this.appendSpace();
+    }
+    appendQuoted(val) {
+        return this.append(`[${val}]`);
+    }
+    append(val) {
+        if (this._isNewLine) {
+            if (this._currentIndent > 0 && this.options.indent.size > 0 && this.options.indent.char.length === 1) {
+                this._tokens.push("".padEnd(this._currentIndent * this.options.indent.size, this.options.indent.char));
+            }
+            this._isNewLine = false;
+        }
+        this._tokens.push(val);
+        return this;
+    }
+    appendStringLiteral(val) {
+        return this.append(`'${val}'`);
+    }
+    appendLineOrSpace() {
+        if (this.options.multiline)
+            return this.appendLine();
+        return this.appendSpace();
+    }
+    appendSpace() {
+        return this.append(" ");
+    }
+    appendLine() {
+        if (this.options.multiline) {
+            this._isNewLine = true;
+            if (this._tokens.length > 0) {
+                this._tokens[this._tokens.length - 1] = this._tokens[this._tokens.length - 1].trimEnd();
+            }
+            this._tokens.push(this.options.eol);
+        }
+        return this;
+    }
+    clear() {
+        this._tokens = [];
+        return this;
+    }
+    squash() {
+        if (this._tokens.length > 1) {
+            this._tokens = [this.toString()];
+        }
+        return this;
+    }
+    toString() {
+        return this._tokens.join("");
+    }
+    appendExp(exp) {
+        exp.writeTo(this);
+        return this;
+    }
+}
+/**
+ * Use to describe selection clause terms in a SELECT statements @see [[SelectionClauseExpr]] @see [[SelectExpr]]
+ * @alpha
+ */
+class DerivedPropertyExpr extends Expr {
+    constructor(computedExpr, alias) {
+        super(DerivedPropertyExpr.type);
+        this.computedExpr = computedExpr;
+        this.alias = alias;
+    }
+    get children() {
+        return [this.computedExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.DerivedProperty) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.DerivedProperty'. ${JSON.stringify(node)}`);
+        }
+        return new DerivedPropertyExpr(ComputedExpr.deserialize(node.exp), node.alias ? node.alias : undefined);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.computedExpr);
+        if (this.alias) {
+            writer.appendSpace();
+            writer.appendQuoted(this.alias);
+        }
+    }
+}
+DerivedPropertyExpr.type = ExprType.DerivedProperty;
+export { DerivedPropertyExpr };
+/**
+ * Describes a ECSQL delete statement.
+ * @alpha
+ */
+class DeleteStatementExpr extends StatementExpr {
+    constructor(className, where, options) {
+        super(DeleteStatementExpr.type);
+        this.className = className;
+        this.where = where;
+        this.options = options;
+    }
+    get children() {
+        const exprs = [this.className];
+        if (this.where)
+            exprs.push(this.where);
+        if (this.options)
+            exprs.push(this.options);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.DeleteStatement) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.DeleteStatement'. ${JSON.stringify(node)}`);
+        }
+        const className = ClassNameExpr.deserialize(node.class);
+        const where = node.where ? WhereClauseExp.deserialize(node.where) : undefined;
+        const options = node.options ? ECSqlOptionsClauseExpr.deserialize(node.options) : undefined;
+        return new DeleteStatementExpr(className, where, options);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("DELETE");
+        writer.appendSpace();
+        writer.appendKeyword("FROM");
+        writer.appendSpace();
+        writer.appendExp(this.className);
+        if (this.where) {
+            writer.appendSpace();
+            writer.appendExp(this.where);
+        }
+        if (this.options) {
+            writer.appendSpace();
+            writer.appendExp(this.options);
+        }
+    }
+}
+DeleteStatementExpr.type = ExprType.DeleteStatement;
+export { DeleteStatementExpr };
+/**
+ * Describe a ECSQL Insert statement.
+ * @alpha
+ */
+class InsertStatementExpr extends StatementExpr {
+    constructor(className, values, propertyNames) {
+        super(InsertStatementExpr.type);
+        this.className = className;
+        this.values = values;
+        this.propertyNames = propertyNames;
+    }
+    get children() {
+        const exprs = [this.className];
+        exprs.push(...this.values);
+        if (this.propertyNames)
+            exprs.push(...this.propertyNames);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.InsertStatement) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.InsertStatement'. ${JSON.stringify(node)}`);
+        }
+        const className = ClassNameExpr.deserialize(node.class);
+        if (className.polymorphicInfo) {
+            // Patch as INSERT are always ONLY but parser have issue accepting ONLY.
+            if (className.polymorphicInfo.allOrAny === "ONLY") {
+                className.polymorphicInfo = undefined;
+            }
+        }
+        const values = Array.from(node.values.map((v) => ValueExpr.deserialize(v)));
+        const properties = node.properties ? Array.from(node.properties.map((v) => PropertyNameExpr.deserialize(v))) : undefined;
+        return new InsertStatementExpr(className, values, properties);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("INSERT");
+        writer.appendSpace();
+        writer.appendKeyword("INTO");
+        writer.appendSpace();
+        writer.appendExp(this.className);
+        writer.appendSpace();
+        if (this.propertyNames) {
+            writer.append("(");
+            this.propertyNames.forEach((v, i) => {
+                if (i > 0) {
+                    writer.appendComma();
+                }
+                writer.appendExp(v);
+            });
+            writer.append(")");
+        }
+        writer.appendSpace();
+        writer.appendKeyword("VALUES");
+        writer.append("(");
+        this.values.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+        writer.append(")");
+    }
+}
+InsertStatementExpr.type = ExprType.InsertStatement;
+export { InsertStatementExpr };
+/**
+ * Describes a JOIN clause e.g. <classNameExpr> JOIN <classNameExpr> ON <joinspec>
+ * @alpha
+ */
+class QualifiedJoinExpr extends ClassRefExpr {
+    constructor(joinType, from, to, spec) {
+        super(QualifiedJoinExpr.type);
+        this.joinType = joinType;
+        this.from = from;
+        this.to = to;
+        this.spec = spec;
+    }
+    get children() {
+        const exprs = [this.from, this.to];
+        if (this.spec instanceof BooleanExpr)
+            exprs.push(this.spec);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.QualifiedJoin) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.QualifiedJoin'. ${JSON.stringify(node)}`);
+        }
+        const type = node.type;
+        const from = ClassRefExpr.deserialize(node.from);
+        const to = ClassRefExpr.deserialize(node.to);
+        let spec;
+        if (Array.isArray(node.spec))
+            spec = node.spec;
+        else
+            spec = BooleanExpr.deserialize(node.spec);
+        return new QualifiedJoinExpr(type, from, to, spec);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.from);
+        writer.appendSpace();
+        if (this.joinType === JoinType.LeftOuter) {
+            writer.appendKeyword("LEFT").appendSpace();
+            writer.appendKeyword("OUTER").appendSpace();
+            writer.appendKeyword("JOIN").appendSpace();
+        }
+        else if (this.joinType === JoinType.RightOuter) {
+            writer.appendKeyword("RIGHT").appendSpace();
+            writer.appendKeyword("OUTER").appendSpace();
+            writer.appendKeyword("JOIN").appendSpace();
+        }
+        else if (this.joinType === JoinType.FullOuter) {
+            writer.appendKeyword("FULL").appendSpace();
+            writer.appendKeyword("OUTER").appendSpace();
+            writer.appendKeyword("JOIN").appendSpace();
+        }
+        else if (this.joinType === JoinType.Inner) {
+            writer.appendKeyword("INNER").appendSpace();
+            writer.appendKeyword("JOIN").appendSpace();
+        }
+        else {
+            throw new Error(`not supported join type ${this.joinType}`);
+        }
+        writer.appendExp(this.to);
+        if (this.spec) {
+            writer.appendSpace();
+            if (this.spec instanceof BooleanExpr) {
+                writer.appendKeyword("ON");
+                writer.appendSpace();
+                writer.appendExp(this.spec);
+            }
+            else if (this.spec instanceof Array) {
+                writer.appendKeyword("USING");
+                this.spec.forEach((v, i) => {
+                    if (i > 0) {
+                        writer.appendComma();
+                        writer.append(v);
+                    }
+                });
+            }
+            else {
+                throw new Error("unknow join spec");
+            }
+        }
+    }
+}
+QualifiedJoinExpr.type = ExprType.QualifiedJoin;
+export { QualifiedJoinExpr };
+/**
+ * Describe a JOIN USING clause.
+ * @alpha
+ */
+class UsingRelationshipJoinExpr extends ClassRefExpr {
+    constructor(fromClassName, toClassName, toRelClassName, direction) {
+        super(UsingRelationshipJoinExpr.type);
+        this.fromClassName = fromClassName;
+        this.toClassName = toClassName;
+        this.toRelClassName = toRelClassName;
+        this.direction = direction;
+    }
+    get children() {
+        return [this.fromClassName, this.toClassName, this.toRelClassName];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.UsingRelationshipJoinExp) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.UsingRelationshipJoinExp'. ${JSON.stringify(node)}`);
+        }
+        const from = ClassRefExpr.deserialize(node.from);
+        const to = ClassNameExpr.deserialize(node.to);
+        const usingRel = ClassNameExpr.deserialize(node.using);
+        const direction = node.direction ? node.direction : undefined;
+        return new UsingRelationshipJoinExpr(from, to, usingRel, direction);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.fromClassName);
+        writer.appendSpace();
+        writer.appendKeyword("JOIN");
+        writer.appendSpace();
+        writer.appendExp(this.toClassName);
+        writer.appendSpace();
+        writer.appendKeyword("USING");
+        writer.appendSpace();
+        writer.appendExp(this.toRelClassName);
+        if (this.direction) {
+            writer.appendSpace();
+            writer.appendKeyword(this.direction);
+        }
+    }
+}
+UsingRelationshipJoinExpr.type = ExprType.UsingRelationshipJoin;
+export { UsingRelationshipJoinExpr };
+/**
+ * Describe subquery result test e.g. EXISTS(<subquery>)
+ * @alpha
+ */
+class SubqueryTestExpr extends BooleanExpr {
+    constructor(op, query) {
+        super(SubqueryTestExpr.type);
+        this.op = op;
+        this.query = query;
+    }
+    get children() {
+        return [this.query];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.SubqueryTest) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.SubqueryTest'. ${JSON.stringify(node)}`);
+        }
+        const query = SubqueryExpr.deserialize(node.query);
+        const op = node.op;
+        return new SubqueryTestExpr(op, query);
+    }
+    writeTo(writer) {
+        writer.appendKeyword(this.op);
+        writer.appendExp(this.query);
+    }
+}
+SubqueryTestExpr.type = ExprType.SubqueryTest;
+export { SubqueryTestExpr };
+/**
+ * Describe a subquery when used in FROM clause.
+ * @alpha
+ */
+class SubqueryRefExpr extends ClassRefExpr {
+    constructor(query, polymorphicInfo, alias) {
+        super(SubqueryRefExpr.type);
+        this.query = query;
+        this.polymorphicInfo = polymorphicInfo;
+        this.alias = alias;
+    }
+    get children() {
+        return [this.query];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.SubqueryRef) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.SubqueryRef'. ${JSON.stringify(node)}`);
+        }
+        const query = SubqueryExpr.deserialize(node.query);
+        const polymorphicInfo = node.polymorphicInfo ? node.polymorphicInfo : undefined;
+        const alias = node.alias ? node.alias : undefined;
+        return new SubqueryRefExpr(query, polymorphicInfo, alias);
+    }
+    writeTo(writer) {
+        if (this.polymorphicInfo) {
+            if (this.polymorphicInfo.disqualify) {
+                writer.append(this.polymorphicInfo.disqualify);
+            }
+            writer.appendKeyword(this.polymorphicInfo.allOrAny);
+            writer.appendSpace();
+        }
+        writer.appendExp(this.query);
+        if (this.alias) {
+            writer.appendSpace();
+            writer.appendQuoted(this.alias);
+        }
+    }
+}
+SubqueryRefExpr.type = ExprType.SubqueryRef;
+export { SubqueryRefExpr };
+/**
+ * Describe a optionally compound SELECT statement.
+ * @alpha
+ */
+class SelectStatementExpr extends StatementExpr {
+    constructor(singleSelect, nextSelect) {
+        super(SelectStatementExpr.type);
+        this.singleSelect = singleSelect;
+        this.nextSelect = nextSelect;
+    }
+    get children() {
+        const exprs = [this.singleSelect];
+        if (this.nextSelect)
+            exprs.push(this.nextSelect.select);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.SelectStatement) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.SelectStatement'. ${JSON.stringify(node)}`);
+        }
+        const singleSelect = SelectExpr.deserialize(node.select);
+        let nextSelect;
+        if (node.nextBlock) {
+            nextSelect = {
+                op: node.nextBlock.combineOp,
+                select: SelectStatementExpr.deserialize(node.nextBlock.select),
+            };
+        }
+        return new SelectStatementExpr(singleSelect, nextSelect);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.singleSelect);
+        if (this.nextSelect) {
+            writer.appendSpace();
+            if (this.nextSelect.op === "UNION ALL") {
+                writer.appendKeyword("UNION");
+                writer.appendSpace();
+                writer.appendKeyword("ALL");
+            }
+            else {
+                writer.append(this.nextSelect.op);
+            }
+            writer.appendSpace();
+            writer.appendExp(this.nextSelect.select);
+        }
+    }
+}
+SelectStatementExpr.type = ExprType.SelectStatement;
+export { SelectStatementExpr };
+/**
+ * Describe selection in a SELECT query
+ * @alpha
+ */
+class SelectionClauseExpr extends Expr {
+    constructor(derivedPropertyList) {
+        super(SelectionClauseExpr.type);
+        this.derivedPropertyList = derivedPropertyList;
+    }
+    get children() {
+        return [...this.derivedPropertyList];
+    }
+    static deserialize(node) {
+        if (!Array.isArray(node)) {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode[] ${JSON.stringify(node)}`);
+        }
+        return new SelectionClauseExpr(Array.from(node.map((v) => DerivedPropertyExpr.deserialize(v))));
+    }
+    writeTo(writer) {
+        this.derivedPropertyList.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+    }
+}
+SelectionClauseExpr.type = ExprType.SelectionClause;
+export { SelectionClauseExpr };
+/**
+ * Describe a GROUP BY clause in a SELECT statement.
+ * @alpha
+ */
+class GroupByClauseExpr extends Expr {
+    constructor(exprList) {
+        super(GroupByClauseExpr.type);
+        this.exprList = exprList;
+    }
+    get children() {
+        return [...this.exprList];
+    }
+    static deserialize(node) {
+        if (!Array.isArray(node)) {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode[] ${JSON.stringify(node)}`);
+        }
+        return new GroupByClauseExpr(Array.from(node.map((v) => ValueExpr.deserialize(v))));
+    }
+    writeTo(writer) {
+        writer.appendKeyword("GROUP");
+        writer.appendSpace();
+        writer.appendKeyword("BY");
+        writer.appendSpace();
+        this.exprList.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+    }
+}
+GroupByClauseExpr.type = ExprType.GroupByClause;
+export { GroupByClauseExpr };
+/**
+ * Describe a HAVING clause in a SELECT statement.
+ * @alpha
+ */
+class HavingClauseExpr extends Expr {
+    constructor(filterExpr) {
+        super(HavingClauseExpr.type);
+        this.filterExpr = filterExpr;
+    }
+    get children() {
+        return [this.filterExpr];
+    }
+    static deserialize(node) {
+        if (typeof node !== "object") {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode ${JSON.stringify(node)}`);
+        }
+        return new HavingClauseExpr(BooleanExpr.deserialize(node));
+    }
+    writeTo(writer) {
+        writer.appendKeyword("HAVING");
+        writer.appendSpace();
+        writer.appendExp(this.filterExpr);
+    }
+}
+HavingClauseExpr.type = ExprType.HavingClause;
+export { HavingClauseExpr };
+/**
+ * Describe a FROM clause in a SELECT statement.
+ * @alpha
+ */
+class FromClauseExpr extends Expr {
+    constructor(classRefs) {
+        super(FromClauseExpr.type);
+        this.classRefs = classRefs;
+    }
+    get children() {
+        return [...this.classRefs];
+    }
+    static deserialize(node) {
+        if (!Array.isArray(node)) {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode[] ${JSON.stringify(node)}`);
+        }
+        return new FromClauseExpr(Array.from(node.map((v) => ClassRefExpr.deserialize(v))));
+    }
+    writeTo(writer) {
+        writer.appendKeyword("FROM");
+        writer.appendSpace();
+        this.classRefs.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+    }
+}
+FromClauseExpr.type = ExprType.FromClause;
+export { FromClauseExpr };
+/**
+ * Describe a WHERE clause in a SELECT, UPDATE and DELETE statement.
+ * @alpha
+ */
+class WhereClauseExp extends Expr {
+    constructor(filterExpr) {
+        super(WhereClauseExp.type);
+        this.filterExpr = filterExpr;
+    }
+    get children() {
+        return [this.filterExpr];
+    }
+    static deserialize(node) {
+        if (typeof node !== "object") {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode ${JSON.stringify(node)}`);
+        }
+        return new WhereClauseExp(BooleanExpr.deserialize(node));
+    }
+    writeTo(writer) {
+        writer.appendKeyword("WHERE");
+        writer.appendSpace();
+        writer.appendExp(this.filterExpr);
+    }
+}
+WhereClauseExp.type = ExprType.WhereClause;
+export { WhereClauseExp };
+/**
+ * Describe a single sorted term in a ORDER BY clause of a SELECT statement.
+ * @alpha
+ */
+class OrderBySpecExpr extends Expr {
+    constructor(term, sortDirection, nulls) {
+        super(OrderBySpecExpr.type);
+        this.term = term;
+        this.sortDirection = sortDirection;
+        this.nulls = nulls;
+    }
+    get children() {
+        return [this.term];
+    }
+    static deserialize(node) {
+        if (typeof node !== "object") {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode ${JSON.stringify(node)}`);
+        }
+        return new OrderBySpecExpr(ValueExpr.deserialize(node.exp), node.direction ? node.direction : undefined);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.term);
+        if (this.sortDirection) {
+            writer.appendSpace();
+            writer.appendKeyword(this.sortDirection);
+        }
+        if (this.nulls) {
+            writer.appendSpace();
+            writer.appendKeyword("NULLS");
+            writer.appendSpace();
+            writer.appendKeyword(this.nulls);
+        }
+    }
+}
+OrderBySpecExpr.type = ExprType.OrderBySpec;
+export { OrderBySpecExpr };
+/**
+ * Describe a ORDER BY clause in a SELECT statement.
+ * @alpha
+ */
+class OrderByClauseExpr extends Expr {
+    constructor(terms) {
+        super(OrderByClauseExpr.type);
+        this.terms = terms;
+    }
+    get children() {
+        return [...this.terms.map((v) => v.term)];
+    }
+    static deserialize(node) {
+        if (!Array.isArray(node)) {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode[] ${JSON.stringify(node)}`);
+        }
+        return new OrderByClauseExpr(Array.from(node.map((v) => OrderBySpecExpr.deserialize(v))));
+    }
+    writeTo(writer) {
+        writer.appendKeyword("ORDER");
+        writer.appendSpace();
+        writer.appendKeyword("BY");
+        writer.appendSpace();
+        this.terms.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+    }
+}
+OrderByClauseExpr.type = ExprType.OrderByClause;
+export { OrderByClauseExpr };
+/**
+ * Describe a LIMIT clause in a SELECT statement.
+ * @alpha
+ */
+class LimitClauseExpr extends Expr {
+    constructor(limit, offset) {
+        super(LimitClauseExpr.type);
+        this.limit = limit;
+        this.offset = offset;
+    }
+    get children() {
+        const exprs = [this.limit];
+        if (this.offset)
+            exprs.push(this.offset);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (typeof node !== "object") {
+            throw new Error(`Expect node to be array of NativeECSqlParseNode ${JSON.stringify(node)}`);
+        }
+        return new LimitClauseExpr(ValueExpr.deserialize(node.exp), node.offset ? ValueExpr.deserialize(node.offset) : undefined);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("LIMIT");
+        writer.appendSpace();
+        writer.appendExp(this.limit);
+        if (this.offset) {
+            writer.appendSpace();
+            writer.appendKeyword("OFFSET");
+            writer.appendSpace();
+            writer.appendExp(this.offset);
+        }
+    }
+}
+LimitClauseExpr.type = ExprType.LimitClause;
+export { LimitClauseExpr };
+/**
+ * Describe a single select statement.
+ * @alpha
+ */
+class SelectExpr extends Expr {
+    constructor(selection, rowQuantifier, from, where, groupBy, having, orderBy, limit, options) {
+        super(SelectExpr.type);
+        this.selection = selection;
+        this.rowQuantifier = rowQuantifier;
+        this.from = from;
+        this.where = where;
+        this.groupBy = groupBy;
+        this.having = having;
+        this.orderBy = orderBy;
+        this.limit = limit;
+        this.options = options;
+    }
+    get children() {
+        const exprs = [this.selection];
+        if (this.from)
+            exprs.push(this.from);
+        if (this.where)
+            exprs.push(this.where);
+        if (this.groupBy)
+            exprs.push(this.groupBy);
+        if (this.having)
+            exprs.push(this.having);
+        if (this.orderBy)
+            exprs.push(this.orderBy);
+        if (this.limit)
+            exprs.push(this.limit);
+        if (this.options)
+            exprs.push(this.options);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.SingleSelectStatement && node.id !== NativeExpIds.RowConstructor) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.SingleSelectStatement/RowConstructor'. ${JSON.stringify(node)}`);
+        }
+        if (node.id === NativeExpIds.RowConstructor) {
+            const values = SelectionClauseExpr.deserialize(node.values);
+            return new SelectExpr(values);
+        }
+        const selection = SelectionClauseExpr.deserialize(node.selection);
+        const from = node.from ? FromClauseExpr.deserialize(node.from) : undefined;
+        const where = node.where ? WhereClauseExp.deserialize(node.where) : undefined;
+        const groupBy = node.groupBy ? GroupByClauseExpr.deserialize(node.groupBy) : undefined;
+        const having = node.having ? HavingClauseExpr.deserialize(node.having) : undefined;
+        const orderBy = node.orderBy ? OrderByClauseExpr.deserialize(node.orderBy) : undefined;
+        const options = node.options ? ECSqlOptionsClauseExpr.deserialize(node.options) : undefined;
+        const limitSpec = node.limit ? LimitClauseExpr.deserialize(node.limit) : undefined;
+        const rowQuantifier = node.selectionType ? node.selectionType : undefined;
+        return new SelectExpr(selection, rowQuantifier, from, where, groupBy, having, orderBy, limitSpec, options);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("SELECT");
+        writer.appendSpace();
+        if (this.rowQuantifier) {
+            writer.appendKeyword(this.rowQuantifier);
+            writer.appendSpace();
+        }
+        writer.appendExp(this.selection);
+        if (this.from) {
+            writer.appendSpace();
+            writer.appendExp(this.from);
+        }
+        if (this.where) {
+            writer.appendSpace();
+            writer.appendExp(this.where);
+        }
+        if (this.groupBy) {
+            writer.appendSpace();
+            writer.appendExp(this.groupBy);
+        }
+        if (this.having) {
+            writer.appendSpace();
+            writer.appendExp(this.having);
+        }
+        if (this.orderBy) {
+            writer.appendSpace();
+            writer.appendExp(this.orderBy);
+        }
+        if (this.limit) {
+            writer.appendSpace();
+            writer.appendExp(this.limit);
+        }
+        if (this.options) {
+            writer.appendSpace();
+            writer.appendExp(this.options);
+        }
+    }
+}
+SelectExpr.type = ExprType.Select;
+export { SelectExpr };
+/**
+ * Describe a subquery when used as value. This kind of query expect to return one column and one one value.
+ * @alpha
+ */
+class SubqueryExpr extends ValueExpr {
+    constructor(query) {
+        super(SubqueryExpr.type);
+        this.query = query;
+    }
+    get children() {
+        return [this.query];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.Subquery) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.Subquery'. ${JSON.stringify(node)}`);
+        }
+        return new SubqueryExpr(SelectStatementExpr.deserialize(node.query));
+    }
+    writeTo(writer) {
+        writer.append("(");
+        writer.appendExp(this.query);
+        writer.append(")");
+    }
+}
+SubqueryExpr.type = ExprType.Subquery;
+export { SubqueryExpr };
+/**
+ * Describe a binary boolean expression in ECSQL.
+ * @alpha
+ */
+class BinaryBooleanExpr extends BooleanExpr {
+    constructor(op, lhsExpr, rhsExpr, not) {
+        super(BinaryBooleanExpr.type);
+        this.op = op;
+        this.lhsExpr = lhsExpr;
+        this.rhsExpr = rhsExpr;
+        this.not = not;
+    }
+    get children() {
+        return [this.lhsExpr, this.rhsExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryBoolean'. ${JSON.stringify(node)}`);
+        }
+        const op = node.op;
+        return new BinaryBooleanExpr(op, ComputedExpr.deserialize(node.lhs), ComputedExpr.deserialize(node.rhs));
+    }
+    writeTo(writer) {
+        writer.append("(");
+        writer.appendExp(this.lhsExpr);
+        writer.appendBinaryOp(this.op);
+        writer.appendExp(this.rhsExpr);
+        writer.append(")");
+    }
+}
+BinaryBooleanExpr.type = ExprType.BinaryBoolean;
+export { BinaryBooleanExpr };
+/**
+ * Describe a <expr> IS NULL boolean expression
+ * @alpha
+ */
+class IsNullExpr extends BooleanExpr {
+    constructor(operandExpr, not) {
+        super(IsNullExpr.type);
+        this.operandExpr = operandExpr;
+        this.not = not;
+    }
+    get children() {
+        return [this.operandExpr];
+    }
+    static parseOp(node) {
+        const op = node.op;
+        const isLiteral = node.rhs.op === NativeExpIds.LiteralValue;
+        if (!isLiteral) {
+            return [false, false];
+        }
+        const isNull = LiteralExpr.deserialize(node.rhs).rawValue === "NULL";
+        return [op.startsWith("IS"), isNull];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryBoolean'. ${JSON.stringify(node)}`);
+        }
+        const [isNullExp, isNull] = this.parseOp(node);
+        if (!isNullExp) {
+            throw new Error(`Parse node has 'node.op !== IS NULL'. ${JSON.stringify(node)}`);
+        }
+        const exp = ValueExpr.deserialize(node.lhs);
+        return new IsNullExpr(exp, isNull ? "NOT" : undefined);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.operandExpr);
+        writer.appendSpace();
+        writer.appendKeyword("IS");
+        writer.appendSpace();
+        if (this.not) {
+            writer.appendKeyword("NOT");
+            writer.appendSpace();
+        }
+        writer.appendKeyword("NULL");
+    }
+}
+IsNullExpr.type = ExprType.IsNull;
+export { IsNullExpr };
+/**
+ * Describe a <expr> IS (type1[, type2]) in ECSQL.
+ * @alpha
+ */
+class IsOfTypeExpr extends BooleanExpr {
+    constructor(lhsExpr, typeNames, not) {
+        super(IsOfTypeExpr.type);
+        this.lhsExpr = lhsExpr;
+        this.typeNames = typeNames;
+        this.not = not;
+    }
+    get children() {
+        return [this.lhsExpr, ...this.typeNames];
+    }
+    static parseOp(node) {
+        const op = node.op;
+        return [op.startsWith("IS") && Array.isArray(node.rhs), op.endsWith("NOT")];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryBoolean'. ${JSON.stringify(node)}`);
+        }
+        const [isTypeOf, isNull] = this.parseOp(node);
+        if (!isTypeOf) {
+            throw new Error(`Parse node has 'node.op !== IS (type....)'. ${JSON.stringify(node)}`);
+        }
+        const exp = ValueExpr.deserialize(node.lhs);
+        const classNames = Array.from(node.rhs.map((v) => ClassNameExpr.deserialize(v)));
+        return new IsOfTypeExpr(exp, classNames, isNull ? "NOT" : undefined);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.lhsExpr);
+        writer.appendSpace();
+        writer.appendKeyword("IS");
+        writer.appendSpace();
+        if (this.not) {
+            writer.appendKeyword("NOT");
+            writer.appendSpace();
+        }
+        writer.append("(");
+        this.typeNames.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+        writer.append(")");
+    }
+}
+IsOfTypeExpr.type = ExprType.IsOfType;
+export { IsOfTypeExpr };
+/**
+ * Describe a NOT <expr>  boolean expression
+ * @alpha
+ */
+class NotExpr extends BooleanExpr {
+    constructor(operandExpr) {
+        super(NotExpr.type);
+        this.operandExpr = operandExpr;
+    }
+    get children() {
+        return [this.operandExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BooleanFactor) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BooleanFactor'. ${JSON.stringify(node)}`);
+        }
+        const exp = ComputedExpr.deserialize(node.exp);
+        return new NotExpr(exp);
+    }
+    writeTo(writer) {
+        writer.append("(");
+        writer.appendKeyword("NOT");
+        writer.appendSpace();
+        writer.appendExp(this.operandExpr);
+        writer.append(")");
+    }
+}
+NotExpr.type = ExprType.Not;
+export { NotExpr };
+/**
+ * Describe a <expr> IN subquery|(val1[,val2...]) boolean expression
+ * @alpha
+ */
+class InExpr extends BooleanExpr {
+    constructor(lhsExpr, rhsExpr, not) {
+        super(InExpr.type);
+        this.lhsExpr = lhsExpr;
+        this.rhsExpr = rhsExpr;
+        this.not = not;
+    }
+    get children() {
+        const exprs = [this.lhsExpr];
+        if (this.rhsExpr instanceof SubqueryExpr)
+            exprs.push(this.rhsExpr);
+        else {
+            exprs.push(...this.rhsExpr);
+        }
+        return exprs;
+    }
+    static parseOp(op) {
+        return [op.endsWith("IN"), op.startsWith("NOT ")];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryBoolean'. ${JSON.stringify(node)}`);
+        }
+        const [isIn, isNull] = this.parseOp(node.op);
+        if (!isIn) {
+            throw new Error(`Parse node has 'node.op !== IN'. ${JSON.stringify(node)}`);
+        }
+        const lhs = ValueExpr.deserialize(node.lhs);
+        if (Array.isArray(node.rhs))
+            return new InExpr(lhs, Array.from(node.rhs.map((v) => ValueExpr.deserialize(v))), isNull ? "NOT" : undefined);
+        else if (node.rhs.id === NativeExpIds.Subquery)
+            return new InExpr(lhs, SubqueryExpr.deserialize(node.rhs), isNull ? "NOT" : undefined);
+        else
+            throw new Error(`unknown IN rhs ${node.rhs.id}`);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.lhsExpr);
+        writer.appendSpace();
+        if (this.not) {
+            writer.appendKeyword("NOT");
+            writer.appendSpace();
+        }
+        writer.appendKeyword("IN");
+        writer.appendSpace();
+        if (this.rhsExpr instanceof SubqueryExpr) {
+            writer.appendExp(this.rhsExpr);
+        }
+        else if (Array.isArray(this.rhsExpr)) {
+            writer.append("(");
+            this.rhsExpr.forEach((v, i) => {
+                if (i > 0) {
+                    writer.appendComma();
+                }
+                writer.appendExp(v);
+            });
+            writer.append(")");
+        }
+        else {
+            throw new Error("unknown expression on rhs of IN expr.");
+        }
+    }
+}
+InExpr.type = ExprType.In;
+export { InExpr };
+/**
+ * Describe a <expr> LIKE <expr> [ESCAPE <expr>] boolean expression
+ * @alpha
+ */
+class LikeExpr extends BooleanExpr {
+    constructor(lhsExpr, patternExpr, escapeExpr, not) {
+        super(LikeExpr.type);
+        this.lhsExpr = lhsExpr;
+        this.patternExpr = patternExpr;
+        this.escapeExpr = escapeExpr;
+        this.not = not;
+    }
+    get children() {
+        const exprs = [this.lhsExpr, this.patternExpr];
+        if (this.escapeExpr)
+            exprs.push(this.escapeExpr);
+        return exprs;
+    }
+    static parseOp(op) {
+        return [op.endsWith("LIKE"), op.startsWith("NOT ")];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryBoolean'. ${JSON.stringify(node)}`);
+        }
+        const [isLike, isNull] = this.parseOp(node.op);
+        if (!isLike) {
+            throw new Error(`Parse node has 'node.op !== LIKE'. ${JSON.stringify(node)}`);
+        }
+        const lhs = ValueExpr.deserialize(node.lhs);
+        const pattren = ValueExpr.deserialize(node.rhs.pattren);
+        const escape = node.rhs.escape ? ValueExpr.deserialize(node.rhs.escape) : undefined;
+        return new LikeExpr(lhs, pattren, escape, isNull ? "NOT" : undefined);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.lhsExpr);
+        writer.appendSpace();
+        if (this.not) {
+            writer.appendKeyword("NOT");
+            writer.appendSpace();
+        }
+        writer.appendKeyword("LIKE");
+        writer.appendSpace();
+        writer.appendExp(this.patternExpr);
+        if (this.escapeExpr) {
+            writer.appendSpace();
+            writer.appendKeyword("ESCAPE");
+            writer.appendSpace();
+            writer.appendExp(this.escapeExpr);
+        }
+    }
+}
+LikeExpr.type = ExprType.Like;
+export { LikeExpr };
+/**
+ * Describe a <expr> BETWEEN <expr> AND <expr> boolean expression
+ * @alpha
+ */
+class BetweenExpr extends BooleanExpr {
+    constructor(lhsExpr, lowerBoundExpr, upperBoundExpr, not) {
+        super(BetweenExpr.type);
+        this.lhsExpr = lhsExpr;
+        this.lowerBoundExpr = lowerBoundExpr;
+        this.upperBoundExpr = upperBoundExpr;
+        this.not = not;
+    }
+    get children() {
+        return [this.lhsExpr, this.lowerBoundExpr, this.upperBoundExpr];
+    }
+    static parseOp(op) {
+        return [op.endsWith(" BETWEEN"), op.startsWith("NOT ")];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryBoolean'. ${JSON.stringify(node)}`);
+        }
+        const [isBetween, isNull] = this.parseOp(node.op);
+        if (!isBetween) {
+            throw new Error(`Parse node has 'node.op !== BETWEEN'. ${JSON.stringify(node)}`);
+        }
+        const rhs = node.rhs;
+        return new BetweenExpr(ValueExpr.deserialize(node.lhs), ValueExpr.deserialize(rhs.lbound), ValueExpr.deserialize(rhs.ubound), isNull ? "NOT" : undefined);
+    }
+    writeTo(writer) {
+        writer.appendExp(this.lhsExpr);
+        writer.appendSpace();
+        if (this.not) {
+            writer.appendKeyword("NOT");
+            writer.appendSpace();
+        }
+        writer.appendKeyword("BETWEEN");
+        writer.appendSpace();
+        writer.appendExp(this.lowerBoundExpr);
+        writer.appendSpace();
+        writer.appendKeyword("AND");
+        writer.appendSpace();
+        writer.appendExp(this.upperBoundExpr);
+    }
+}
+BetweenExpr.type = ExprType.Between;
+export { BetweenExpr };
+/**
+ * Describe a common table expression base query statement
+ * @alpha
+ */
+class CteExpr extends StatementExpr {
+    constructor(cteBlocks, query, recursive) {
+        super(CteExpr.type);
+        this.cteBlocks = cteBlocks;
+        this.query = query;
+        this.recursive = recursive;
+    }
+    get children() {
+        return [...this.cteBlocks, this.query];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.CommonTable) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.CommonTable'. ${JSON.stringify(node)}`);
+        }
+        const blocks = Array.from(node.blocks.map((v) => CteBlockExpr.deserialize(v)));
+        return new CteExpr(blocks, SelectStatementExpr.deserialize(node.select), node.recursive === true ? "RECURSIVE" : undefined);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("WITH");
+        writer.appendSpace();
+        if (this.recursive) {
+            writer.appendKeyword(this.recursive);
+            writer.appendSpace();
+        }
+        this.cteBlocks.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+        writer.appendSpace();
+        writer.appendExp(this.query);
+    }
+}
+CteExpr.type = ExprType.Cte;
+export { CteExpr };
+/**
+ * Describe a single block of CTE that can be reference in FROM clause of a SELECT
+ * @alpha
+ */
+class CteBlockExpr extends Expr {
+    constructor(name, query, props) {
+        super(CteBlockExpr.type);
+        this.name = name;
+        this.query = query;
+        this.props = props;
+    }
+    get children() {
+        return [this.query];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.CommonTableBlock) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.CommonTableBlock'. ${JSON.stringify(node)}`);
+        }
+        return new CteBlockExpr(node.name, SelectStatementExpr.deserialize(node.asQuery), node.args);
+    }
+    writeTo(writer) {
+        writer.appendQuoted(this.name);
+        writer.append("(");
+        this.props.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendQuoted(v);
+        });
+        writer.append(")");
+        writer.appendSpace();
+        writer.appendKeyword("AS");
+        writer.appendSpace();
+        writer.append("(");
+        writer.appendLine();
+        writer.indent();
+        writer.appendExp(this.query);
+        writer.unindent();
+        writer.appendLine();
+        writer.append(")");
+    }
+}
+CteBlockExpr.type = ExprType.CteBlock;
+export { CteBlockExpr };
+/**
+ * Describe a name reference to a CTE block.
+ * @alpha
+ */
+class CteBlockRefExpr extends ClassRefExpr {
+    constructor(name, alias) {
+        super(CteBlockRefExpr.type);
+        this.name = name;
+        this.alias = alias;
+    }
+    get children() {
+        return [];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.CommonTableBlockName) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.CommonTableBlockName'. ${JSON.stringify(node)}`);
+        }
+        return new CteBlockRefExpr(node.name, node.alias ? node.alias : undefined);
+    }
+    writeTo(writer) {
+        writer.appendQuoted(this.name);
+        if (this.alias) {
+            writer.appendQuoted(this.alias);
+        }
+    }
+}
+CteBlockRefExpr.type = ExprType.CteBlockRef;
+export { CteBlockRefExpr };
+/**
+ * Describe a table value function expression in ECSQL that appear in FROM clause of query.
+ * @alpha
+ */
+class TableValuedFuncExpr extends ClassRefExpr {
+    constructor(schemaName, memberFunc, alias) {
+        super(TableValuedFuncExpr.type);
+        this.schemaName = schemaName;
+        this.memberFunc = memberFunc;
+        this.alias = alias;
+    }
+    get children() {
+        return [this.memberFunc];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.TableValuedFunction) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.TableValuedFunction'. ${JSON.stringify(node)}`);
+        }
+        return new TableValuedFuncExpr(node.schema, MemberFuncCallExpr.deserialize(node.func), node.alias);
+    }
+    writeTo(writer) {
+        writer.appendQuoted(this.schemaName);
+        writer.append(".");
+        writer.appendExp(this.memberFunc);
+        if (this.alias) {
+            writer.appendSpace();
+            writer.appendQuoted(this.alias);
+        }
+    }
+}
+TableValuedFuncExpr.type = ExprType.TableValuedFunc;
+export { TableValuedFuncExpr };
+/**
+ * Describe a class name reference in ECSQL that appear in FROM clause of a SELECT.
+ * @alpha
+ */
+class ClassNameExpr extends ClassRefExpr {
+    constructor(schemaNameOrAlias, className, tablespace, alias, polymorphicInfo, memberFunc) {
+        super(ClassNameExpr.type);
+        this.schemaNameOrAlias = schemaNameOrAlias;
+        this.className = className;
+        this.tablespace = tablespace;
+        this.alias = alias;
+        this.polymorphicInfo = polymorphicInfo;
+        this.memberFunc = memberFunc;
+    }
+    get children() {
+        return [];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.ClassName) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.ClassName'. ${JSON.stringify(node)}`);
+        }
+        const className = node.className;
+        const tablespace = node.tableSpace ? node.tableSpace : undefined;
+        const schemaName = node.schemaName;
+        const alias = node.alias ? node.alias : undefined;
+        const polymorphicInfo = node.polymorphicInfo ? { disqualify: node.polymorphicInfo.disqualify, allOrAny: node.polymorphicInfo.scope } : undefined;
+        const memberFunc = node.func ? MemberFuncCallExpr.deserialize(node.func) : undefined;
+        return new ClassNameExpr(schemaName, className, tablespace, alias, polymorphicInfo, memberFunc);
+    }
+    writeTo(writer) {
+        if (this.polymorphicInfo) {
+            if (this.polymorphicInfo.disqualify) {
+                writer.append(this.polymorphicInfo.disqualify);
+            }
+            writer.appendKeyword(this.polymorphicInfo.allOrAny);
+            writer.appendSpace();
+        }
+        if (this.tablespace) {
+            writer.append("[").append(this.tablespace).append("]");
+            writer.append(".");
+        }
+        writer.append("[").append(this.schemaNameOrAlias).append("]");
+        writer.append(".");
+        writer.append("[").append(this.className).append("]");
+        if (this.memberFunc) {
+            writer.append(".");
+            writer.appendExp(this.memberFunc);
+        }
+        if (this.alias) {
+            writer.appendSpace();
+            writer.appendQuoted(this.alias);
+        }
+    }
+    static fromECSql(ecsql) {
+        const regex = /\s*((\+)?\s*(ALL|ONLY)\s+)?(\[?(\w+)\]?[\.:])?\[?(\w+)\]?[\.:]\[?(\w+)\]?(\s+(AS)?(\s+(\w+)))?/i;
+        const match = ecsql.match(regex);
+        if (!match) {
+            throw new Error("ECSQL className must follow syntax: [+][ALL|ONLY] [tablespace.][.|:][schemaOrAlias]][.|:][className] [AS] [alias");
+        }
+        const plus = match.at(2);
+        const allOrOnlyStr = match.at(3);
+        const tablespace = match.at(5);
+        const schemaOrAlias = match.at(6);
+        const className = match.at(7);
+        const alias = match.at(11);
+        if (!schemaOrAlias || !className)
+            throw new Error("ECSQL className must follow syntax: [+][ALL|ONLY] [tablespace.][.|:][schemaOrAlias]][.|:][className] [AS] [alias");
+        let polyInfo;
+        if (allOrOnlyStr) {
+            const allOrAny = allOrOnlyStr.toUpperCase();
+            polyInfo = { disqualify: plus, allOrAny };
+        }
+        return new ClassNameExpr(schemaOrAlias, className, tablespace, alias, polyInfo);
+    }
+}
+ClassNameExpr.type = ExprType.ClassName;
+export { ClassNameExpr };
+/**
+ * Describe a UPDATE statement in ECSQL.
+ * @alpha
+ */
+class UpdateStatementExpr extends StatementExpr {
+    constructor(className, assignement, where, options) {
+        super(UpdateStatementExpr.type);
+        this.className = className;
+        this.assignement = assignement;
+        this.where = where;
+        this.options = options;
+    }
+    get children() {
+        const exprs = [this.className, this.assignement];
+        if (this.where)
+            exprs.push(this.where);
+        if (this.options)
+            exprs.push(this.options);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.UpdateStatement) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.UpdateStatement'. ${JSON.stringify(node)}`);
+        }
+        const className = ClassNameExpr.deserialize(node.className);
+        const assignment = SetClauseExpr.deserialize(node.assignment);
+        const where = node.where ? WhereClauseExp.deserialize(node.where) : undefined;
+        const options = node.options ? ECSqlOptionsClauseExpr.deserialize(node.options) : undefined;
+        return new UpdateStatementExpr(className, assignment, where, options);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("UPDATE");
+        writer.appendSpace();
+        writer.appendExp(this.className);
+        writer.appendSpace();
+        writer.appendExp(this.assignement);
+        if (this.where) {
+            writer.appendSpace();
+            writer.appendExp(this.where);
+        }
+        if (this.options) {
+            writer.appendSpace();
+            writer.appendExp(this.options);
+        }
+    }
+}
+UpdateStatementExpr.type = ExprType.UpdateStatement;
+export { UpdateStatementExpr };
+/**
+ * Describe ECSQL option clause.
+ * @alpha
+ */
+class ECSqlOptionsClauseExpr extends Expr {
+    constructor(options) {
+        super(ECSqlOptionsClauseExpr.type);
+        this.options = options;
+    }
+    get children() {
+        return [];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.Options) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.Options'. ${JSON.stringify(node)}`);
+        }
+        return new ECSqlOptionsClauseExpr(node.options);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("ECSQLOPTIONS");
+        writer.appendSpace();
+        this.options.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendSpace();
+            }
+            writer.append(v.name);
+            if (v.value) {
+                writer.appendBinaryOp("=");
+                writer.append(v.value);
+            }
+        });
+    }
+}
+ECSqlOptionsClauseExpr.type = ExprType.ECSqlOptionsClause;
+export { ECSqlOptionsClauseExpr };
+/**
+ * A single property value assignment for update clause
+ * @alpha
+ */
+class AssignmentExpr extends Expr {
+    constructor(propertyName, valueExpr) {
+        super(SetClauseExpr.type);
+        this.propertyName = propertyName;
+        this.valueExpr = valueExpr;
+    }
+    get children() {
+        return [this.propertyName, this.valueExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.Assignment) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.Assignment'. ${JSON.stringify(node)}`);
+        }
+        return new AssignmentExpr(PropertyNameExpr.deserialize(node.propertyName), ValueExpr.deserialize(node.value));
+    }
+    writeTo(writer) {
+        writer.appendExp(this.propertyName);
+        writer.appendBinaryOp("=");
+        writer.appendExp(this.valueExpr);
+    }
+}
+AssignmentExpr.type = ExprType.Assignment;
+export { AssignmentExpr };
+/**
+ * Describe a set clause in a UPDATE statement
+ * @alpha
+ */
+class SetClauseExpr extends Expr {
+    constructor(assignments) {
+        super(SetClauseExpr.type);
+        this.assignments = assignments;
+    }
+    get children() {
+        return [...this.assignments];
+    }
+    static deserialize(node) {
+        if (!Array.isArray(node)) {
+            throw new Error(`AssignmentClause expect array of NativeECSqlParseNode. ${JSON.stringify(node)}`);
+        }
+        const setClause = node;
+        const assignments = [];
+        setClause.forEach((v) => {
+            assignments.push(AssignmentExpr.deserialize(v));
+        });
+        return new SetClauseExpr(assignments);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("SET");
+        writer.appendSpace();
+        this.assignments.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+    }
+}
+SetClauseExpr.type = ExprType.SetClause;
+export { SetClauseExpr };
+/**
+ * Describe a strong typed IIF function in ECSQL
+ * @alpha
+ */
+class IIFExpr extends ValueExpr {
+    constructor(whenExpr, thenExpr, elseExpr) {
+        super(IIFExpr.type);
+        this.whenExpr = whenExpr;
+        this.thenExpr = thenExpr;
+        this.elseExpr = elseExpr;
+    }
+    get children() {
+        return [this.whenExpr, this.thenExpr, this.elseExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.IIF) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.IIF'. ${JSON.stringify(node)}`);
+        }
+        return new IIFExpr(BooleanExpr.deserialize(node.when), ValueExpr.deserialize(node.then), ValueExpr.deserialize(node.else));
+    }
+    writeTo(writer) {
+        writer.appendKeyword("IIF");
+        writer.append("(");
+        writer.appendExp(this.whenExpr);
+        writer.appendComma();
+        writer.appendExp(this.thenExpr);
+        writer.appendComma();
+        writer.appendExp(this.elseExpr);
+        writer.append(")");
+    }
+}
+IIFExpr.type = ExprType.IIF;
+export { IIFExpr };
+/**
+ * Describe a CASE-WHEN-THEN expression in ECSQL
+ * @alpha
+ */
+class SearchCaseExpr extends ValueExpr {
+    constructor(whenThenList, elseExpr) {
+        super(SearchCaseExpr.type);
+        this.whenThenList = whenThenList;
+        this.elseExpr = elseExpr;
+    }
+    get children() {
+        const exprs = [];
+        this.whenThenList.forEach((v) => {
+            exprs.push(v.whenExpr, v.thenExpr);
+        });
+        if (this.elseExpr)
+            exprs.push(this.elseExpr);
+        return exprs;
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.SearchCaseValue) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.SearchCaseValue'. ${JSON.stringify(node)}`);
+        }
+        const whenThenList = [];
+        for (const whenThenProps of node.whenThenList) {
+            whenThenList.push({
+                whenExpr: BooleanExpr.deserialize(whenThenProps.when),
+                thenExpr: ValueExpr.deserialize(whenThenProps.then),
+            });
+        }
+        const elseExp = node.elseExp ? ValueExpr.deserialize(node.elseExp) : undefined;
+        return new SearchCaseExpr(whenThenList, elseExp);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("CASE");
+        this.whenThenList.forEach((v) => {
+            writer.appendSpace();
+            writer.appendKeyword("WHEN");
+            writer.appendSpace();
+            writer.appendExp(v.whenExpr);
+            writer.appendSpace();
+            writer.appendKeyword("THEN");
+            writer.appendSpace();
+            writer.appendExp(v.thenExpr);
+        });
+        if (this.elseExpr) {
+            writer.appendSpace();
+            writer.appendKeyword("ELSE");
+            writer.appendSpace();
+            writer.appendExp(this.elseExpr);
+        }
+        writer.appendSpace();
+        writer.appendKeyword("END");
+    }
+}
+SearchCaseExpr.type = ExprType.SearchCase;
+export { SearchCaseExpr };
+/**
+ * Describe a binary value expression
+ * @alpha
+ */
+class BinaryValueExpr extends ValueExpr {
+    constructor(op, lhsExpr, rhsExpr) {
+        super(BinaryValueExpr.type);
+        this.op = op;
+        this.lhsExpr = lhsExpr;
+        this.rhsExpr = rhsExpr;
+    }
+    get children() {
+        return [this.lhsExpr, this.rhsExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.BinaryValue && node.id !== NativeExpIds.BinaryBoolean) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.BinaryValue' . ${JSON.stringify(node)}`);
+        }
+        return new BinaryValueExpr(node.op, ValueExpr.deserialize(node.lhs), ValueExpr.deserialize(node.rhs));
+    }
+    writeTo(writer) {
+        writer.append("(");
+        writer.appendExp(this.lhsExpr);
+        writer.appendBinaryOp(this.op);
+        writer.appendExp(this.rhsExpr);
+        writer.append(")");
+    }
+}
+BinaryValueExpr.type = ExprType.BinaryValue;
+export { BinaryValueExpr };
+/**
+ * Cast a expression into a target time e.g. CAST(<expr> AS STRING)
+ * @alpha
+ */
+class CastExpr extends ValueExpr {
+    constructor(valueExpr, targetType) {
+        super(CastExpr.type);
+        this.valueExpr = valueExpr;
+        this.targetType = targetType;
+    }
+    get children() {
+        return [this.valueExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.Cast) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.CastExp'. ${JSON.stringify(node)}`);
+        }
+        return new CastExpr(ValueExpr.deserialize(node.exp), node.as);
+    }
+    writeTo(writer) {
+        writer.appendKeyword("CAST");
+        writer.append("(");
+        writer.appendExp(this.valueExpr);
+        writer.appendSpace();
+        writer.appendKeyword("AS");
+        writer.appendSpace();
+        writer.append(this.targetType);
+        writer.append(")");
+    }
+}
+CastExpr.type = ExprType.Cast;
+export { CastExpr };
+/**
+ * Represent a member function called w.r.t a ClassNameExpr
+ * @alpha
+ */
+class MemberFuncCallExpr extends Expr {
+    constructor(functionName, args) {
+        super(MemberFuncCallExpr.type);
+        this.functionName = functionName;
+        this.args = args;
+    }
+    get children() {
+        return [...this.args];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.MemberFunctionCall) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.MemberFunctionCall'. ${JSON.stringify(node)}`);
+        }
+        const args = Array.from(node.args.map((v) => ValueExpr.deserialize(v)));
+        return new MemberFuncCallExpr(node.name, args);
+    }
+    writeTo(writer) {
+        writer.appendQuoted(this.functionName);
+        writer.append("(");
+        this.args.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+        writer.append(")");
+    }
+}
+MemberFuncCallExpr.type = ExprType.MemberFuncCall;
+export { MemberFuncCallExpr };
+/**
+ * Represent a function call in ecsql
+ * @alpha
+ */
+class FuncCallExpr extends ValueExpr {
+    constructor(functionName, args, allOrDistinct) {
+        super(FuncCallExpr.type);
+        this.functionName = functionName;
+        this.args = args;
+        this.allOrDistinct = allOrDistinct;
+    }
+    get children() {
+        return [...this.args];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.FunctionCall) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.FunctionCall'. ${JSON.stringify(node)}`);
+        }
+        const args = Array.from(node.args.map((v) => ValueExpr.deserialize(v)));
+        const rowQuantifier = node.quantifier ? node.quantifier : undefined;
+        return new FuncCallExpr(node.name, args, rowQuantifier);
+    }
+    writeTo(writer) {
+        writer.append(this.functionName);
+        writer.append("(");
+        if (this.allOrDistinct) {
+            writer.appendKeyword(this.allOrDistinct);
+            writer.appendSpace();
+        }
+        this.args.forEach((v, i) => {
+            if (i > 0) {
+                writer.appendComma();
+            }
+            writer.appendExp(v);
+        });
+        writer.append(")");
+    }
+    static makeAbs(arg) {
+        return new FuncCallExpr("ABS", [arg]);
+    }
+    static makeLower(arg) {
+        return new FuncCallExpr("LOWER", [arg]);
+    }
+    static makeUpper(arg) {
+        return new FuncCallExpr("UPPER", [arg]);
+    }
+    static makeLTrim(arg0, arg1) {
+        return new FuncCallExpr("LTRIM", arg1 ? [arg0, arg1] : [arg0]);
+    }
+    static makeRTrim(arg0, arg1) {
+        return new FuncCallExpr("RTRIM", arg1 ? [arg0, arg1] : [arg0]);
+    }
+    static makeLHex(arg) {
+        return new FuncCallExpr("HEX", [arg]);
+    }
+    static makeLIfNull(arg0, arg1) {
+        return new FuncCallExpr("IFNULL", [arg0, arg1]);
+    }
+    static makeInstr(arg0, arg1) {
+        return new FuncCallExpr("INSTR", [arg0, arg1]);
+    }
+    static makeLength(arg0) {
+        return new FuncCallExpr("LENGTH", [arg0]);
+    }
+    static makeLike(arg0, arg1, arg2) {
+        return new FuncCallExpr("LIKE", arg2 ? [arg0, arg1, arg2] : [arg0, arg1]);
+    }
+    static makeLikelihood(arg0, arg1) {
+        return new FuncCallExpr("LIKELIHOOD", [arg0, arg1]);
+    }
+    static makeMax(arg, ...optionalArgs) {
+        return new FuncCallExpr("MAX", [arg, ...optionalArgs]);
+    }
+    static makeMin(arg, ...optionalArgs) {
+        return new FuncCallExpr("MIN", [arg, ...optionalArgs]);
+    }
+    static makePrintf(arg, ...optionalArgs) {
+        return new FuncCallExpr("PRINTF", [arg, ...optionalArgs]);
+    }
+    static makeRandom() {
+        return new FuncCallExpr("RANDOM", []);
+    }
+    static makeQuote(arg) {
+        return new FuncCallExpr("QUOTE", [arg]);
+    }
+    static makeRandomBlob(arg) {
+        return new FuncCallExpr("RANDOMBLOB", [arg]);
+    }
+    static makeReplace(arg0, arg1, arg2) {
+        return new FuncCallExpr("REPLACE", [arg0, arg1, arg2]);
+    }
+    static makeRound(arg0, arg1) {
+        return new FuncCallExpr("ROUND", arg1 ? [arg0, arg1] : [arg0]);
+    }
+    static makeSign(arg0) {
+        return new FuncCallExpr("SIGN", [arg0]);
+    }
+    static makeUnhex(arg0) {
+        return new FuncCallExpr("UNHEX", [arg0]);
+    }
+    static makeSoundex(arg0) {
+        return new FuncCallExpr("SOUNDEX", [arg0]);
+    }
+    static makeTrim(arg0, arg1) {
+        return new FuncCallExpr("TRIM", arg1 ? [arg0, arg1] : [arg0]);
+    }
+    static makeTypeOf(arg0) {
+        return new FuncCallExpr("TYPEOF", [arg0]);
+    }
+    static makeZeroBlob(arg0) {
+        return new FuncCallExpr("ZEROBLOB", [arg0]);
+    }
+    static makeUnlikely(arg0) {
+        return new FuncCallExpr("UNLIKELY", [arg0]);
+    }
+    static makeSubstring(arg0, arg1, arg2) {
+        return new FuncCallExpr("SUBSTR", [arg0, arg1, arg2]);
+    }
+    static makeStrToGuid(arg0) {
+        return new FuncCallExpr("STRTOGUID", [arg0]);
+    }
+    static makeGuidToStr(arg0) {
+        return new FuncCallExpr("GUIDTOSTR", [arg0]);
+    }
+    static makeIdToHex(arg0) {
+        return new FuncCallExpr("IDTOHEX", [arg0]);
+    }
+    static makeHexToId(arg0) {
+        return new FuncCallExpr("HEXTOID", [arg0]);
+    }
+    static makeEcClassName(arg0, fmt = "s:c") {
+        return new FuncCallExpr("EC_CLASSNAME", [arg0, new LiteralExpr(LiteralValueType.String, fmt)]);
+    }
+    static makeEcClassId(arg0) {
+        return new FuncCallExpr("EC_CLASSId", [arg0]);
+    }
+    static makeInstanceOf(arg0, arg1) {
+        return new FuncCallExpr("EC_INSTANCEOF", [arg0, arg1]);
+    }
+}
+FuncCallExpr.type = ExprType.FuncCall;
+export { FuncCallExpr };
+/**
+ * Represent positional or named parameter
+ * @alpha
+ */
+class ParameterExpr extends ValueExpr {
+    constructor(name) {
+        super(ParameterExpr.type);
+        this.name = name;
+    }
+    get children() {
+        return [];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.Parameter) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.Parameter'. ${JSON.stringify(node)}`);
+        }
+        return new ParameterExpr(node.name);
+    }
+    writeTo(writer) {
+        if (this.name && this.name !== "")
+            writer.append(`:${this.name}`);
+        else
+            writer.append(`?`);
+    }
+}
+ParameterExpr.type = ExprType.Parameter;
+export { ParameterExpr };
+/**
+ * Unary value with operator e.g. [+|-|~]<number>
+ * @alpha
+ */
+class UnaryValueExpr extends ValueExpr {
+    constructor(op, valueExpr) {
+        super(UnaryValueExpr.type);
+        this.op = op;
+        this.valueExpr = valueExpr;
+    }
+    get children() {
+        return [this.valueExpr];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.UnaryValue && node.id !== NativeExpIds.BooleanFactor) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.UnaryValue  && node.id !== NativeExpIds.BooleanFactor'. ${JSON.stringify(node)}`);
+        }
+        if (node.op !== "+" && node.op !== "-" && node.op !== "~") {
+            throw new Error(`Unrecognized operator in .node.op'. Must me on of UnaryOp. ${JSON.stringify(node)}`);
+        }
+        return new UnaryValueExpr(node.op, ValueExpr.deserialize(node.exp));
+    }
+    writeTo(writer) {
+        writer.append(this.op);
+        writer.appendExp(this.valueExpr);
+    }
+}
+UnaryValueExpr.type = ExprType.Unary;
+export { UnaryValueExpr };
+/**
+ * Represent constant literal like string, data, time, timestamp, number or null
+ * @alpha
+ */
+class LiteralExpr extends ValueExpr {
+    constructor(valueType, rawValue) {
+        super(LiteralExpr.type);
+        this.valueType = valueType;
+        this.rawValue = rawValue;
+    }
+    get children() {
+        return [];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.LiteralValue) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.LiteralValue'. ${JSON.stringify(node)}`);
+        }
+        return new LiteralExpr(node.kind, node.value);
+    }
+    writeTo(writer) {
+        if (this.valueType === LiteralValueType.String)
+            writer.appendStringLiteral(this.rawValue);
+        else if (this.valueType === LiteralValueType.Date)
+            writer.appendKeyword("DATE").appendSpace().appendStringLiteral(this.rawValue);
+        else if (this.valueType === LiteralValueType.Time)
+            writer.appendKeyword("TIME").appendSpace().appendStringLiteral(this.rawValue);
+        else if (this.valueType === LiteralValueType.Timestamp)
+            writer.appendKeyword("TIMESTAMP").appendSpace().appendStringLiteral(this.rawValue);
+        else if (this.valueType === LiteralValueType.Null)
+            writer.appendKeyword("NULL");
+        else
+            writer.append(this.rawValue);
+    }
+    static makeRaw(val) { return new LiteralExpr(LiteralValueType.Raw, val); }
+    static makeString(val) { return new LiteralExpr(LiteralValueType.String, val); }
+    static makeNumber(val) { return new LiteralExpr(LiteralValueType.Raw, val.toString()); }
+    static makeDate(val) { return new LiteralExpr(LiteralValueType.Date, val.toDateString()); }
+    static makeTime(val) { return new LiteralExpr(LiteralValueType.String, val.toTimeString()); }
+    static makeTimestamp(val) { return new LiteralExpr(LiteralValueType.String, val.toTimeString()); }
+    static makeNull() { return new LiteralExpr(LiteralValueType.Null, ""); }
+}
+LiteralExpr.type = ExprType.Literal;
+export { LiteralExpr };
+/**
+ * Represent property name identifier
+ * @alpha
+ */
+class PropertyNameExpr extends ValueExpr {
+    constructor(propertyPath) {
+        super(PropertyNameExpr.type);
+        this.propertyPath = propertyPath;
+    }
+    get children() {
+        return [];
+    }
+    static deserialize(node) {
+        if (node.id !== NativeExpIds.PropertyName) {
+            throw new Error(`Parse node is 'node.id !== NativeExpIds.PropertyNameExp'. ${JSON.stringify(node)}`);
+        }
+        return new PropertyNameExpr(node.path);
+    }
+    writeTo(writer) {
+        // donot quote $
+        const str = this.propertyPath.split("->");
+        if (str.length === 2) {
+            writer.append(str[0].split(".").map((v) => v.startsWith("[") || v === "$" ? v : `[${v}]`).join("."));
+            writer.append("->");
+        }
+        writer.append(str[str.length - 1].split(".").map((v) => v.startsWith("[") || v === "$" ? v : `[${v}]`).join("."));
+    }
+}
+PropertyNameExpr.type = ExprType.PropertyName;
+export { PropertyNameExpr };
+//# sourceMappingURL=ECSqlAst.js.map