@pgsql/transform 17.1.0

package/esm/index.js

@@ -0,0 +1,1309 @@
+export function transformPG13ToPG17(node) {
+    if ('ParseResult' in node) {
+        return { ParseResult: transformParseResult(node.ParseResult) };
+    }
+    if ('ScanResult' in node) {
+        return { ScanResult: transformScanResult(node.ScanResult) };
+    }
+    if ('Integer' in node) {
+        return { Integer: node.Integer };
+    }
+    if ('Float' in node) {
+        return { Float: node.Float };
+    }
+    if ('Boolean' in node) {
+        return { Boolean: node.Boolean };
+    }
+    if ('String' in node) {
+        return { String: node.String };
+    }
+    if ('BitString' in node) {
+        return { BitString: node.BitString };
+    }
+    if ('List' in node) {
+        return { List: transformList(node.List) };
+    }
+    if ('OidList' in node) {
+        return { OidList: transformOidList(node.OidList) };
+    }
+    if ('IntList' in node) {
+        return { IntList: transformIntList(node.IntList) };
+    }
+    if ('A_Const' in node) {
+        return { A_Const: transformA_Const(node.A_Const) };
+    }
+    if ('Alias' in node) {
+        return { Alias: transformAlias(node.Alias) };
+    }
+    if ('RangeVar' in node) {
+        return { RangeVar: transformRangeVar(node.RangeVar) };
+    }
+    if ('TableFunc' in node) {
+        return { TableFunc: transformTableFunc(node.TableFunc) };
+    }
+    if ('IntoClause' in node) {
+        return { IntoClause: transformIntoClause(node.IntoClause) };
+    }
+    if ('Var' in node) {
+        return { Var: transformVar(node.Var) };
+    }
+    if ('Param' in node) {
+        return { Param: transformParam(node.Param) };
+    }
+    if ('Aggref' in node) {
+        return { Aggref: transformAggref(node.Aggref) };
+    }
+    if ('GroupingFunc' in node) {
+        return { GroupingFunc: transformGroupingFunc(node.GroupingFunc) };
+    }
+    if ('WindowFunc' in node) {
+        return { WindowFunc: transformWindowFunc(node.WindowFunc) };
+    }
+    if ('SubscriptingRef' in node) {
+        return { SubscriptingRef: transformSubscriptingRef(node.SubscriptingRef) };
+    }
+    if ('FuncExpr' in node) {
+        return { FuncExpr: transformFuncExpr(node.FuncExpr) };
+    }
+    if ('NamedArgExpr' in node) {
+        return { NamedArgExpr: transformNamedArgExpr(node.NamedArgExpr) };
+    }
+    if ('OpExpr' in node) {
+        return { OpExpr: transformOpExpr(node.OpExpr) };
+    }
+    if ('DistinctExpr' in node) {
+        return { DistinctExpr: transformDistinctExpr(node.DistinctExpr) };
+    }
+    if ('NullIfExpr' in node) {
+        return { NullIfExpr: transformNullIfExpr(node.NullIfExpr) };
+    }
+    if ('ScalarArrayOpExpr' in node) {
+        return { ScalarArrayOpExpr: transformScalarArrayOpExpr(node.ScalarArrayOpExpr) };
+    }
+    if ('BoolExpr' in node) {
+        return { BoolExpr: transformBoolExpr(node.BoolExpr) };
+    }
+    if ('SubLink' in node) {
+        return { SubLink: transformSubLink(node.SubLink) };
+    }
+    if ('SubPlan' in node) {
+        return { SubPlan: transformSubPlan(node.SubPlan) };
+    }
+    if ('AlternativeSubPlan' in node) {
+        return { AlternativeSubPlan: transformAlternativeSubPlan(node.AlternativeSubPlan) };
+    }
+    if ('FieldSelect' in node) {
+        return { FieldSelect: transformFieldSelect(node.FieldSelect) };
+    }
+    if ('FieldStore' in node) {
+        return { FieldStore: transformFieldStore(node.FieldStore) };
+    }
+    if ('RelabelType' in node) {
+        return { RelabelType: transformRelabelType(node.RelabelType) };
+    }
+    if ('CoerceViaIO' in node) {
+        return { CoerceViaIO: transformCoerceViaIO(node.CoerceViaIO) };
+    }
+    if ('ArrayCoerceExpr' in node) {
+        return { ArrayCoerceExpr: transformArrayCoerceExpr(node.ArrayCoerceExpr) };
+    }
+    if ('ConvertRowtypeExpr' in node) {
+        return { ConvertRowtypeExpr: transformConvertRowtypeExpr(node.ConvertRowtypeExpr) };
+    }
+    if ('CollateExpr' in node) {
+        return { CollateExpr: transformCollateExpr(node.CollateExpr) };
+    }
+    if ('CaseExpr' in node) {
+        return { CaseExpr: transformCaseExpr(node.CaseExpr) };
+    }
+    if ('CaseWhen' in node) {
+        return { CaseWhen: transformCaseWhen(node.CaseWhen) };
+    }
+    if ('CaseTestExpr' in node) {
+        return { CaseTestExpr: transformCaseTestExpr(node.CaseTestExpr) };
+    }
+    if ('ArrayExpr' in node) {
+        return { ArrayExpr: transformArrayExpr(node.ArrayExpr) };
+    }
+    if ('RowExpr' in node) {
+        return { RowExpr: transformRowExpr(node.RowExpr) };
+    }
+    if ('RowCompareExpr' in node) {
+        return { RowCompareExpr: transformRowCompareExpr(node.RowCompareExpr) };
+    }
+    if ('CoalesceExpr' in node) {
+        return { CoalesceExpr: transformCoalesceExpr(node.CoalesceExpr) };
+    }
+    if ('MinMaxExpr' in node) {
+        return { MinMaxExpr: transformMinMaxExpr(node.MinMaxExpr) };
+    }
+    if ('SQLValueFunction' in node) {
+        return { SQLValueFunction: transformSQLValueFunction(node.SQLValueFunction) };
+    }
+    if ('XmlExpr' in node) {
+        return { XmlExpr: transformXmlExpr(node.XmlExpr) };
+    }
+    if ('JsonFormat' in node) {
+        return { JsonFormat: transformJsonFormat(node.JsonFormat) };
+    }
+    if ('JsonReturning' in node) {
+        return { JsonReturning: transformJsonReturning(node.JsonReturning) };
+    }
+    if ('JsonValueExpr' in node) {
+        return { JsonValueExpr: transformJsonValueExpr(node.JsonValueExpr) };
+    }
+    if ('JsonConstructorExpr' in node) {
+        return { JsonConstructorExpr: transformJsonConstructorExpr(node.JsonConstructorExpr) };
+    }
+    if ('JsonIsPredicate' in node) {
+        return { JsonIsPredicate: transformJsonIsPredicate(node.JsonIsPredicate) };
+    }
+    if ('NullTest' in node) {
+        return { NullTest: transformNullTest(node.NullTest) };
+    }
+    if ('BooleanTest' in node) {
+        return { BooleanTest: transformBooleanTest(node.BooleanTest) };
+    }
+    if ('CoerceToDomain' in node) {
+        return { CoerceToDomain: transformCoerceToDomain(node.CoerceToDomain) };
+    }
+    if ('CoerceToDomainValue' in node) {
+        return { CoerceToDomainValue: transformCoerceToDomainValue(node.CoerceToDomainValue) };
+    }
+    if ('SetToDefault' in node) {
+        return { SetToDefault: transformSetToDefault(node.SetToDefault) };
+    }
+    if ('CurrentOfExpr' in node) {
+        return { CurrentOfExpr: transformCurrentOfExpr(node.CurrentOfExpr) };
+    }
+    if ('NextValueExpr' in node) {
+        return { NextValueExpr: transformNextValueExpr(node.NextValueExpr) };
+    }
+    if ('InferenceElem' in node) {
+        return { InferenceElem: transformInferenceElem(node.InferenceElem) };
+    }
+    if ('TargetEntry' in node) {
+        return { TargetEntry: transformTargetEntry(node.TargetEntry) };
+    }
+    if ('RangeTblRef' in node) {
+        return { RangeTblRef: transformRangeTblRef(node.RangeTblRef) };
+    }
+    if ('JoinExpr' in node) {
+        return { JoinExpr: transformJoinExpr(node.JoinExpr) };
+    }
+    if ('FromExpr' in node) {
+        return { FromExpr: transformFromExpr(node.FromExpr) };
+    }
+    if ('OnConflictExpr' in node) {
+        return { OnConflictExpr: transformOnConflictExpr(node.OnConflictExpr) };
+    }
+    if ('Query' in node) {
+        return { Query: transformQuery(node.Query) };
+    }
+    if ('TypeName' in node) {
+        return { TypeName: transformTypeName(node.TypeName) };
+    }
+    if ('ColumnRef' in node) {
+        return { ColumnRef: transformColumnRef(node.ColumnRef) };
+    }
+    if ('ParamRef' in node) {
+        return { ParamRef: transformParamRef(node.ParamRef) };
+    }
+    if ('A_Expr' in node) {
+        return { A_Expr: transformA_Expr(node.A_Expr) };
+    }
+    if ('TypeCast' in node) {
+        return { TypeCast: transformTypeCast(node.TypeCast) };
+    }
+    if ('CollateClause' in node) {
+        return { CollateClause: transformCollateClause(node.CollateClause) };
+    }
+    if ('RoleSpec' in node) {
+        return { RoleSpec: transformRoleSpec(node.RoleSpec) };
+    }
+    if ('FuncCall' in node) {
+        return { FuncCall: transformFuncCall(node.FuncCall) };
+    }
+    if ('A_Star' in node) {
+        return { A_Star: node.A_Star };
+    }
+    if ('A_Indices' in node) {
+        return { A_Indices: transformA_Indices(node.A_Indices) };
+    }
+    if ('A_Indirection' in node) {
+        return { A_Indirection: transformA_Indirection(node.A_Indirection) };
+    }
+    if ('A_ArrayExpr' in node) {
+        return { A_ArrayExpr: transformA_ArrayExpr(node.A_ArrayExpr) };
+    }
+    if ('ResTarget' in node) {
+        return { ResTarget: transformResTarget(node.ResTarget) };
+    }
+    if ('MultiAssignRef' in node) {
+        return { MultiAssignRef: transformMultiAssignRef(node.MultiAssignRef) };
+    }
+    if ('SortBy' in node) {
+        return { SortBy: transformSortBy(node.SortBy) };
+    }
+    if ('WindowDef' in node) {
+        return { WindowDef: transformWindowDef(node.WindowDef) };
+    }
+    if ('RangeSubselect' in node) {
+        return { RangeSubselect: transformRangeSubselect(node.RangeSubselect) };
+    }
+    if ('RangeFunction' in node) {
+        return { RangeFunction: transformRangeFunction(node.RangeFunction) };
+    }
+    if ('RangeTableFunc' in node) {
+        return { RangeTableFunc: transformRangeTableFunc(node.RangeTableFunc) };
+    }
+    if ('RangeTableFuncCol' in node) {
+        return { RangeTableFuncCol: transformRangeTableFuncCol(node.RangeTableFuncCol) };
+    }
+    if ('RangeTableSample' in node) {
+        return { RangeTableSample: transformRangeTableSample(node.RangeTableSample) };
+    }
+    if ('ColumnDef' in node) {
+        return { ColumnDef: transformColumnDef(node.ColumnDef) };
+    }
+    if ('TableLikeClause' in node) {
+        return { TableLikeClause: transformTableLikeClause(node.TableLikeClause) };
+    }
+    if ('IndexElem' in node) {
+        return { IndexElem: transformIndexElem(node.IndexElem) };
+    }
+    if ('DefElem' in node) {
+        return { DefElem: transformDefElem(node.DefElem) };
+    }
+    if ('LockingClause' in node) {
+        return { LockingClause: transformLockingClause(node.LockingClause) };
+    }
+    if ('XmlSerialize' in node) {
+        return { XmlSerialize: transformXmlSerialize(node.XmlSerialize) };
+    }
+    if ('PartitionElem' in node) {
+        return { PartitionElem: transformPartitionElem(node.PartitionElem) };
+    }
+    if ('PartitionSpec' in node) {
+        return { PartitionSpec: transformPartitionSpec(node.PartitionSpec) };
+    }
+    if ('PartitionBoundSpec' in node) {
+        return { PartitionBoundSpec: transformPartitionBoundSpec(node.PartitionBoundSpec) };
+    }
+    if ('PartitionRangeDatum' in node) {
+        return { PartitionRangeDatum: transformPartitionRangeDatum(node.PartitionRangeDatum) };
+    }
+    if ('PartitionCmd' in node) {
+        return { PartitionCmd: transformPartitionCmd(node.PartitionCmd) };
+    }
+    if ('RangeTblEntry' in node) {
+        return { RangeTblEntry: transformRangeTblEntry(node.RangeTblEntry) };
+    }
+    if ('WindowFuncRunCondition' in node) {
+        return node;
+    }
+    if ('MergeSupportFunc' in node) {
+        return node;
+    }
+    if ('JsonBehavior' in node) {
+        return node;
+    }
+    if ('JsonExpr' in node) {
+        return node;
+    }
+    if ('JsonTablePath' in node) {
+        return node;
+    }
+    if ('JsonTablePathScan' in node) {
+        return node;
+    }
+    if ('JsonTableSiblingJoin' in node) {
+        return node;
+    }
+    if ('MergeAction' in node) {
+        return { MergeAction: transformMergeAction(node.MergeAction) };
+    }
+    throw new Error(`Unknown node type: ${JSON.stringify(node)}`);
+}
+function transformNodeArray(nodes) {
+    return nodes?.map(node => transformPG13ToPG17(node));
+}
+function transformOptionalNode(node) {
+    return node ? transformPG13ToPG17(node) : undefined;
+}
+function transformParseResult(result) {
+    return {
+        version: result.version,
+        stmts: result.stmts?.map(stmt => transformRawStmt(stmt))
+    };
+}
+function transformScanResult(result) {
+    return {
+        version: result.version,
+        tokens: result.tokens
+    };
+}
+function transformList(list) {
+    return {
+        items: transformNodeArray(list.items)
+    };
+}
+function transformA_Const(aConst) {
+    return {
+        ival: aConst.ival,
+        fval: aConst.fval,
+        boolval: aConst.boolval,
+        sval: aConst.sval,
+        bsval: aConst.bsval,
+        isnull: aConst.isnull,
+        location: aConst.location
+    };
+}
+function transformAlias(alias) {
+    return {
+        aliasname: alias.aliasname,
+        colnames: transformNodeArray(alias.colnames)
+    };
+}
+function transformRangeVar(rangeVar) {
+    return {
+        catalogname: rangeVar.catalogname,
+        schemaname: rangeVar.schemaname,
+        relname: rangeVar.relname,
+        inh: rangeVar.inh,
+        relpersistence: rangeVar.relpersistence,
+        alias: rangeVar.alias ? transformAlias(rangeVar.alias) : undefined,
+        location: rangeVar.location
+    };
+}
+function transformTableFunc(tableFunc) {
+    return {
+        functype: undefined,
+        ns_uris: transformNodeArray(tableFunc.ns_uris),
+        ns_names: transformNodeArray(tableFunc.ns_names),
+        docexpr: transformOptionalNode(tableFunc.docexpr),
+        rowexpr: transformOptionalNode(tableFunc.rowexpr),
+        colnames: transformNodeArray(tableFunc.colnames),
+        coltypes: transformNodeArray(tableFunc.coltypes),
+        coltypmods: transformNodeArray(tableFunc.coltypmods),
+        colcollations: transformNodeArray(tableFunc.colcollations),
+        colexprs: transformNodeArray(tableFunc.colexprs),
+        coldefexprs: transformNodeArray(tableFunc.coldefexprs),
+        colvalexprs: undefined,
+        passingvalexprs: undefined,
+        notnulls: tableFunc.notnulls,
+        plan: undefined,
+        ordinalitycol: tableFunc.ordinalitycol,
+        location: tableFunc.location
+    };
+}
+function transformIntoClause(intoClause) {
+    return {
+        rel: intoClause.rel ? transformRangeVar(intoClause.rel) : undefined,
+        colNames: transformNodeArray(intoClause.colNames),
+        accessMethod: intoClause.accessMethod,
+        options: transformNodeArray(intoClause.options),
+        onCommit: intoClause.onCommit,
+        tableSpaceName: intoClause.tableSpaceName,
+        viewQuery: transformOptionalNode(intoClause.viewQuery),
+        skipData: intoClause.skipData
+    };
+}
+function transformVar(varNode) {
+    return {
+        xpr: transformOptionalNode(varNode.xpr),
+        varno: varNode.varno,
+        varattno: varNode.varattno,
+        vartype: varNode.vartype,
+        vartypmod: varNode.vartypmod,
+        varcollid: varNode.varcollid,
+        varlevelsup: varNode.varlevelsup,
+        location: varNode.location
+    };
+}
+function transformParam(param) {
+    return {
+        xpr: transformOptionalNode(param.xpr),
+        paramkind: param.paramkind,
+        paramid: param.paramid,
+        paramtype: param.paramtype,
+        paramtypmod: param.paramtypmod,
+        paramcollid: param.paramcollid,
+        location: param.location
+    };
+}
+function transformAggref(aggref) {
+    return {
+        xpr: transformOptionalNode(aggref.xpr),
+        aggfnoid: aggref.aggfnoid,
+        aggtype: aggref.aggtype,
+        aggcollid: aggref.aggcollid,
+        inputcollid: aggref.inputcollid,
+        aggdirectargs: transformNodeArray(aggref.aggdirectargs),
+        args: transformNodeArray(aggref.args),
+        aggorder: transformNodeArray(aggref.aggorder),
+        aggdistinct: transformNodeArray(aggref.aggdistinct),
+        aggfilter: transformOptionalNode(aggref.aggfilter),
+        aggstar: aggref.aggstar,
+        aggvariadic: aggref.aggvariadic,
+        aggkind: aggref.aggkind,
+        agglevelsup: aggref.agglevelsup,
+        aggsplit: aggref.aggsplit,
+        aggno: aggref.aggno,
+        aggtransno: aggref.aggtransno,
+        location: aggref.location
+    };
+}
+function transformGroupingFunc(groupingFunc) {
+    return {
+        xpr: transformOptionalNode(groupingFunc.xpr),
+        args: transformNodeArray(groupingFunc.args),
+        refs: transformNodeArray(groupingFunc.refs),
+        agglevelsup: groupingFunc.agglevelsup,
+        location: groupingFunc.location
+    };
+}
+function transformWindowFunc(windowFunc) {
+    return {
+        xpr: transformOptionalNode(windowFunc.xpr),
+        winfnoid: windowFunc.winfnoid,
+        wintype: windowFunc.wintype,
+        wincollid: windowFunc.wincollid,
+        inputcollid: windowFunc.inputcollid,
+        args: transformNodeArray(windowFunc.args),
+        aggfilter: transformOptionalNode(windowFunc.aggfilter),
+        winref: windowFunc.winref,
+        winstar: windowFunc.winstar,
+        winagg: windowFunc.winagg,
+        location: windowFunc.location
+    };
+}
+function transformSubscriptingRef(subscriptingRef) {
+    return {
+        xpr: transformOptionalNode(subscriptingRef.xpr),
+        refcontainertype: subscriptingRef.refcontainertype,
+        refelemtype: subscriptingRef.refelemtype,
+        refrestype: subscriptingRef.refrestype,
+        reftypmod: subscriptingRef.reftypmod,
+        refcollid: subscriptingRef.refcollid,
+        refupperindexpr: transformNodeArray(subscriptingRef.refupperindexpr),
+        reflowerindexpr: transformNodeArray(subscriptingRef.reflowerindexpr),
+        refexpr: transformOptionalNode(subscriptingRef.refexpr),
+        refassgnexpr: transformOptionalNode(subscriptingRef.refassgnexpr)
+    };
+}
+function transformFuncExpr(funcExpr) {
+    return {
+        xpr: transformOptionalNode(funcExpr.xpr),
+        funcid: funcExpr.funcid,
+        funcresulttype: funcExpr.funcresulttype,
+        funcretset: funcExpr.funcretset,
+        funcvariadic: funcExpr.funcvariadic,
+        funcformat: funcExpr.funcformat,
+        funccollid: funcExpr.funccollid,
+        inputcollid: funcExpr.inputcollid,
+        args: transformNodeArray(funcExpr.args),
+        location: funcExpr.location
+    };
+}
+function transformNamedArgExpr(namedArgExpr) {
+    return {
+        xpr: transformOptionalNode(namedArgExpr.xpr),
+        arg: transformOptionalNode(namedArgExpr.arg),
+        name: namedArgExpr.name,
+        argnumber: namedArgExpr.argnumber,
+        location: namedArgExpr.location
+    };
+}
+function transformOpExpr(opExpr) {
+    return {
+        xpr: transformOptionalNode(opExpr.xpr),
+        opno: opExpr.opno,
+        opresulttype: opExpr.opresulttype,
+        opretset: opExpr.opretset,
+        opcollid: opExpr.opcollid,
+        inputcollid: opExpr.inputcollid,
+        args: transformNodeArray(opExpr.args),
+        location: opExpr.location
+    };
+}
+function transformDistinctExpr(distinctExpr) {
+    return {
+        xpr: transformOptionalNode(distinctExpr.xpr),
+        opno: distinctExpr.opno,
+        opresulttype: distinctExpr.opresulttype,
+        opretset: distinctExpr.opretset,
+        opcollid: distinctExpr.opcollid,
+        inputcollid: distinctExpr.inputcollid,
+        args: transformNodeArray(distinctExpr.args),
+        location: distinctExpr.location
+    };
+}
+function transformNullIfExpr(nullIfExpr) {
+    return {
+        xpr: transformOptionalNode(nullIfExpr.xpr),
+        opno: nullIfExpr.opno,
+        opresulttype: nullIfExpr.opresulttype,
+        opretset: nullIfExpr.opretset,
+        opcollid: nullIfExpr.opcollid,
+        inputcollid: nullIfExpr.inputcollid,
+        args: transformNodeArray(nullIfExpr.args),
+        location: nullIfExpr.location
+    };
+}
+function transformScalarArrayOpExpr(scalarArrayOpExpr) {
+    return {
+        xpr: transformOptionalNode(scalarArrayOpExpr.xpr),
+        opno: scalarArrayOpExpr.opno,
+        useOr: scalarArrayOpExpr.useOr,
+        inputcollid: scalarArrayOpExpr.inputcollid,
+        args: transformNodeArray(scalarArrayOpExpr.args),
+        location: scalarArrayOpExpr.location
+    };
+}
+function transformBoolExpr(boolExpr) {
+    return {
+        xpr: transformOptionalNode(boolExpr.xpr),
+        boolop: boolExpr.boolop,
+        args: transformNodeArray(boolExpr.args),
+        location: boolExpr.location
+    };
+}
+function transformSubLink(subLink) {
+    return {
+        xpr: transformOptionalNode(subLink.xpr),
+        subLinkType: subLink.subLinkType,
+        subLinkId: subLink.subLinkId,
+        testexpr: transformOptionalNode(subLink.testexpr),
+        operName: transformNodeArray(subLink.operName),
+        subselect: transformOptionalNode(subLink.subselect),
+        location: subLink.location
+    };
+}
+function transformSubPlan(subPlan) {
+    return {
+        xpr: transformOptionalNode(subPlan.xpr),
+        subLinkType: subPlan.subLinkType,
+        testexpr: transformOptionalNode(subPlan.testexpr),
+        plan_id: subPlan.plan_id,
+        plan_name: subPlan.plan_name,
+        firstColType: subPlan.firstColType,
+        firstColTypmod: subPlan.firstColTypmod,
+        firstColCollation: subPlan.firstColCollation,
+        useHashTable: subPlan.useHashTable,
+        unknownEqFalse: subPlan.unknownEqFalse,
+        parallel_safe: subPlan.parallel_safe,
+        args: transformNodeArray(subPlan.args),
+        startup_cost: subPlan.startup_cost,
+        per_call_cost: subPlan.per_call_cost
+    };
+}
+function transformAlternativeSubPlan(altSubPlan) {
+    return {
+        xpr: transformOptionalNode(altSubPlan.xpr),
+        subplans: transformNodeArray(altSubPlan.subplans)
+    };
+}
+function transformFieldSelect(fieldSelect) {
+    return {
+        xpr: transformOptionalNode(fieldSelect.xpr),
+        arg: transformOptionalNode(fieldSelect.arg),
+        fieldnum: fieldSelect.fieldnum,
+        resulttype: fieldSelect.resulttype,
+        resulttypmod: fieldSelect.resulttypmod,
+        resultcollid: fieldSelect.resultcollid
+    };
+}
+function transformFieldStore(fieldStore) {
+    return {
+        xpr: transformOptionalNode(fieldStore.xpr),
+        arg: transformOptionalNode(fieldStore.arg),
+        newvals: transformNodeArray(fieldStore.newvals),
+        resulttype: fieldStore.resulttype
+    };
+}
+function transformRelabelType(relabelType) {
+    return {
+        xpr: transformOptionalNode(relabelType.xpr),
+        arg: transformOptionalNode(relabelType.arg),
+        resulttype: relabelType.resulttype,
+        resulttypmod: relabelType.resulttypmod,
+        resultcollid: relabelType.resultcollid,
+        relabelformat: relabelType.relabelformat,
+        location: relabelType.location
+    };
+}
+function transformCoerceViaIO(coerceViaIO) {
+    return {
+        xpr: transformOptionalNode(coerceViaIO.xpr),
+        arg: transformOptionalNode(coerceViaIO.arg),
+        resulttype: coerceViaIO.resulttype,
+        resultcollid: coerceViaIO.resultcollid,
+        coerceformat: coerceViaIO.coerceformat,
+        location: coerceViaIO.location
+    };
+}
+function transformArrayCoerceExpr(arrayCoerceExpr) {
+    return {
+        xpr: transformOptionalNode(arrayCoerceExpr.xpr),
+        arg: transformOptionalNode(arrayCoerceExpr.arg),
+        elemexpr: transformOptionalNode(arrayCoerceExpr.elemexpr),
+        resulttype: arrayCoerceExpr.resulttype,
+        resulttypmod: arrayCoerceExpr.resulttypmod,
+        resultcollid: arrayCoerceExpr.resultcollid,
+        coerceformat: arrayCoerceExpr.coerceformat,
+        location: arrayCoerceExpr.location
+    };
+}
+function transformConvertRowtypeExpr(convertRowtypeExpr) {
+    return {
+        xpr: transformOptionalNode(convertRowtypeExpr.xpr),
+        arg: transformOptionalNode(convertRowtypeExpr.arg),
+        resulttype: convertRowtypeExpr.resulttype,
+        convertformat: convertRowtypeExpr.convertformat,
+        location: convertRowtypeExpr.location
+    };
+}
+function transformCollateExpr(collateExpr) {
+    return {
+        xpr: transformOptionalNode(collateExpr.xpr),
+        arg: transformOptionalNode(collateExpr.arg),
+        collOid: collateExpr.collOid,
+        location: collateExpr.location
+    };
+}
+function transformCaseExpr(caseExpr) {
+    return {
+        xpr: transformOptionalNode(caseExpr.xpr),
+        casetype: caseExpr.casetype,
+        casecollid: caseExpr.casecollid,
+        arg: transformOptionalNode(caseExpr.arg),
+        args: transformNodeArray(caseExpr.args),
+        defresult: transformOptionalNode(caseExpr.defresult),
+        location: caseExpr.location
+    };
+}
+function transformCaseWhen(caseWhen) {
+    return {
+        xpr: transformOptionalNode(caseWhen.xpr),
+        expr: transformOptionalNode(caseWhen.expr),
+        result: transformOptionalNode(caseWhen.result),
+        location: caseWhen.location
+    };
+}
+function transformCaseTestExpr(caseTestExpr) {
+    return {
+        xpr: transformOptionalNode(caseTestExpr.xpr),
+        typeId: caseTestExpr.typeId,
+        typeMod: caseTestExpr.typeMod,
+        collation: caseTestExpr.collation
+    };
+}
+function transformArrayExpr(arrayExpr) {
+    return {
+        xpr: transformOptionalNode(arrayExpr.xpr),
+        array_typeid: arrayExpr.array_typeid,
+        array_collid: arrayExpr.array_collid,
+        element_typeid: arrayExpr.element_typeid,
+        elements: transformNodeArray(arrayExpr.elements),
+        multidims: arrayExpr.multidims,
+        location: arrayExpr.location
+    };
+}
+function transformRowExpr(rowExpr) {
+    return {
+        xpr: transformOptionalNode(rowExpr.xpr),
+        args: transformNodeArray(rowExpr.args),
+        row_typeid: rowExpr.row_typeid,
+        row_format: rowExpr.row_format,
+        colnames: transformNodeArray(rowExpr.colnames),
+        location: rowExpr.location
+    };
+}
+function transformRowCompareExpr(rowCompareExpr) {
+    return {
+        xpr: transformOptionalNode(rowCompareExpr.xpr),
+        rctype: rowCompareExpr.rctype,
+        largs: transformNodeArray(rowCompareExpr.largs),
+        rargs: transformNodeArray(rowCompareExpr.rargs)
+    };
+}
+function transformCoalesceExpr(coalesceExpr) {
+    return {
+        xpr: transformOptionalNode(coalesceExpr.xpr),
+        coalescetype: coalesceExpr.coalescetype,
+        coalescecollid: coalesceExpr.coalescecollid,
+        args: transformNodeArray(coalesceExpr.args),
+        location: coalesceExpr.location
+    };
+}
+function transformMinMaxExpr(minMaxExpr) {
+    return {
+        xpr: transformOptionalNode(minMaxExpr.xpr),
+        minmaxtype: minMaxExpr.minmaxtype,
+        minmaxcollid: minMaxExpr.minmaxcollid,
+        inputcollid: minMaxExpr.inputcollid,
+        op: minMaxExpr.op,
+        args: transformNodeArray(minMaxExpr.args),
+        location: minMaxExpr.location
+    };
+}
+function transformSQLValueFunction(sqlValueFunction) {
+    return {
+        xpr: transformOptionalNode(sqlValueFunction.xpr),
+        op: sqlValueFunction.op,
+        type: sqlValueFunction.type,
+        typmod: sqlValueFunction.typmod,
+        location: sqlValueFunction.location
+    };
+}
+function transformXmlExpr(xmlExpr) {
+    return {
+        xpr: transformOptionalNode(xmlExpr.xpr),
+        op: xmlExpr.op,
+        name: xmlExpr.name,
+        named_args: transformNodeArray(xmlExpr.named_args),
+        arg_names: transformNodeArray(xmlExpr.arg_names),
+        args: transformNodeArray(xmlExpr.args),
+        xmloption: xmlExpr.xmloption,
+        type: xmlExpr.type,
+        typmod: xmlExpr.typmod,
+        location: xmlExpr.location
+    };
+}
+function transformJsonFormat(jsonFormat) {
+    return {
+        format_type: jsonFormat.format_type,
+        encoding: jsonFormat.encoding,
+        location: jsonFormat.location
+    };
+}
+function transformJsonReturning(jsonReturning) {
+    return {
+        format: jsonReturning.format ? transformJsonFormat(jsonReturning.format) : undefined,
+        typid: jsonReturning.typid,
+        typmod: jsonReturning.typmod
+    };
+}
+function transformJsonValueExpr(jsonValueExpr) {
+    return {
+        raw_expr: transformOptionalNode(jsonValueExpr.raw_expr),
+        formatted_expr: transformOptionalNode(jsonValueExpr.formatted_expr),
+        format: jsonValueExpr.format ? transformJsonFormat(jsonValueExpr.format) : undefined
+    };
+}
+function transformJsonConstructorExpr(jsonConstructorExpr) {
+    return {
+        xpr: transformOptionalNode(jsonConstructorExpr.xpr),
+        type: jsonConstructorExpr.type,
+        args: transformNodeArray(jsonConstructorExpr.args),
+        func: transformOptionalNode(jsonConstructorExpr.func),
+        coercion: transformOptionalNode(jsonConstructorExpr.coercion),
+        returning: jsonConstructorExpr.returning ? transformJsonReturning(jsonConstructorExpr.returning) : undefined,
+        absent_on_null: jsonConstructorExpr.absent_on_null,
+        location: jsonConstructorExpr.location
+    };
+}
+function transformJsonIsPredicate(jsonIsPredicate) {
+    return {
+        expr: transformOptionalNode(jsonIsPredicate.expr),
+        format: jsonIsPredicate.format ? transformJsonFormat(jsonIsPredicate.format) : undefined,
+        item_type: jsonIsPredicate.item_type,
+        location: jsonIsPredicate.location
+    };
+}
+function transformNullTest(nullTest) {
+    return {
+        xpr: transformOptionalNode(nullTest.xpr),
+        arg: transformOptionalNode(nullTest.arg),
+        nulltesttype: nullTest.nulltesttype,
+        argisrow: nullTest.argisrow,
+        location: nullTest.location
+    };
+}
+function transformBooleanTest(booleanTest) {
+    return {
+        xpr: transformOptionalNode(booleanTest.xpr),
+        arg: transformOptionalNode(booleanTest.arg),
+        booltesttype: booleanTest.booltesttype,
+        location: booleanTest.location
+    };
+}
+function transformCoerceToDomain(coerceToDomain) {
+    return {
+        xpr: transformOptionalNode(coerceToDomain.xpr),
+        arg: transformOptionalNode(coerceToDomain.arg),
+        resulttype: coerceToDomain.resulttype,
+        resulttypmod: coerceToDomain.resulttypmod,
+        resultcollid: coerceToDomain.resultcollid,
+        coercionformat: coerceToDomain.coercionformat,
+        location: coerceToDomain.location
+    };
+}
+function transformCoerceToDomainValue(coerceToDomainValue) {
+    return {
+        xpr: transformOptionalNode(coerceToDomainValue.xpr),
+        typeId: coerceToDomainValue.typeId,
+        typeMod: coerceToDomainValue.typeMod,
+        collation: coerceToDomainValue.collation,
+        location: coerceToDomainValue.location
+    };
+}
+function transformSetToDefault(setToDefault) {
+    return {
+        xpr: transformOptionalNode(setToDefault.xpr),
+        typeId: setToDefault.typeId,
+        typeMod: setToDefault.typeMod,
+        collation: setToDefault.collation,
+        location: setToDefault.location
+    };
+}
+function transformCurrentOfExpr(currentOfExpr) {
+    return {
+        xpr: transformOptionalNode(currentOfExpr.xpr),
+        cvarno: currentOfExpr.cvarno,
+        cursor_name: currentOfExpr.cursor_name,
+        cursor_param: currentOfExpr.cursor_param
+    };
+}
+function transformNextValueExpr(nextValueExpr) {
+    return {
+        xpr: transformOptionalNode(nextValueExpr.xpr),
+        seqid: nextValueExpr.seqid,
+        typeId: nextValueExpr.typeId
+    };
+}
+function transformInferenceElem(inferenceElem) {
+    return {
+        xpr: transformOptionalNode(inferenceElem.xpr),
+        expr: transformOptionalNode(inferenceElem.expr),
+        infercollid: inferenceElem.infercollid,
+        inferopclass: inferenceElem.inferopclass
+    };
+}
+function transformTargetEntry(targetEntry) {
+    return {
+        xpr: transformOptionalNode(targetEntry.xpr),
+        expr: transformOptionalNode(targetEntry.expr),
+        resno: targetEntry.resno,
+        resname: targetEntry.resname,
+        ressortgroupref: targetEntry.ressortgroupref,
+        resorigtbl: targetEntry.resorigtbl,
+        resorigcol: targetEntry.resorigcol,
+        resjunk: targetEntry.resjunk
+    };
+}
+function transformRangeTblRef(rangeTblRef) {
+    return {
+        rtindex: rangeTblRef.rtindex
+    };
+}
+function transformJoinExpr(joinExpr) {
+    return {
+        jointype: joinExpr.jointype,
+        isNatural: joinExpr.isNatural,
+        larg: transformOptionalNode(joinExpr.larg),
+        rarg: transformOptionalNode(joinExpr.rarg),
+        usingClause: transformNodeArray(joinExpr.usingClause),
+        join_using_alias: joinExpr.join_using_alias ? transformAlias(joinExpr.join_using_alias) : undefined,
+        quals: transformOptionalNode(joinExpr.quals),
+        alias: joinExpr.alias ? transformAlias(joinExpr.alias) : undefined,
+        rtindex: joinExpr.rtindex
+    };
+}
+function transformFromExpr(fromExpr) {
+    return {
+        fromlist: transformNodeArray(fromExpr.fromlist),
+        quals: transformOptionalNode(fromExpr.quals)
+    };
+}
+function transformOnConflictExpr(onConflictExpr) {
+    return {
+        action: onConflictExpr.action,
+        arbiterElems: transformNodeArray(onConflictExpr.arbiterElems),
+        arbiterWhere: transformOptionalNode(onConflictExpr.arbiterWhere),
+        constraint: onConflictExpr.constraint,
+        onConflictSet: transformNodeArray(onConflictExpr.onConflictSet),
+        onConflictWhere: transformOptionalNode(onConflictExpr.onConflictWhere),
+        exclRelIndex: onConflictExpr.exclRelIndex,
+        exclRelTlist: transformNodeArray(onConflictExpr.exclRelTlist)
+    };
+}
+function transformQuery(query) {
+    return {
+        commandType: query.commandType,
+        querySource: query.querySource,
+        canSetTag: query.canSetTag,
+        utilityStmt: transformOptionalNode(query.utilityStmt),
+        resultRelation: query.resultRelation,
+        hasAggs: query.hasAggs,
+        hasWindowFuncs: query.hasWindowFuncs,
+        hasTargetSRFs: query.hasTargetSRFs,
+        hasSubLinks: query.hasSubLinks,
+        hasDistinctOn: query.hasDistinctOn,
+        hasRecursive: query.hasRecursive,
+        hasModifyingCTE: query.hasModifyingCTE,
+        hasForUpdate: query.hasForUpdate,
+        hasRowSecurity: query.hasRowSecurity,
+        isReturn: query.isReturn,
+        cteList: transformNodeArray(query.cteList),
+        rtable: transformNodeArray(query.rtable),
+        jointree: query.jointree ? transformFromExpr(query.jointree) : undefined,
+        mergeActionList: transformNodeArray(query.mergeActionList),
+        targetList: transformNodeArray(query.targetList),
+        override: query.override,
+        onConflict: query.onConflict ? transformOnConflictExpr(query.onConflict) : undefined,
+        returningList: transformNodeArray(query.returningList),
+        groupClause: transformNodeArray(query.groupClause),
+        groupingSets: transformNodeArray(query.groupingSets),
+        havingQual: transformOptionalNode(query.havingQual),
+        windowClause: transformNodeArray(query.windowClause),
+        distinctClause: transformNodeArray(query.distinctClause),
+        sortClause: transformNodeArray(query.sortClause),
+        limitOffset: transformOptionalNode(query.limitOffset),
+        limitCount: transformOptionalNode(query.limitCount),
+        limitOption: query.limitOption,
+        rowMarks: transformNodeArray(query.rowMarks),
+        setOperations: transformOptionalNode(query.setOperations),
+        withCheckOptions: transformNodeArray(query.withCheckOptions),
+        stmt_location: query.stmt_location,
+        stmt_len: query.stmt_len
+    };
+}
+function transformTypeName(typeName) {
+    return {
+        names: transformNodeArray(typeName.names),
+        typeOid: typeName.typeOid,
+        setof: typeName.setof,
+        pct_type: typeName.pct_type,
+        typmods: transformNodeArray(typeName.typmods),
+        typemod: typeName.typemod,
+        arrayBounds: transformNodeArray(typeName.arrayBounds),
+        location: typeName.location
+    };
+}
+function transformColumnRef(columnRef) {
+    return {
+        fields: transformNodeArray(columnRef.fields),
+        location: columnRef.location
+    };
+}
+function transformParamRef(paramRef) {
+    return {
+        number: paramRef.number,
+        location: paramRef.location
+    };
+}
+function transformA_Expr(aExpr) {
+    return {
+        kind: aExpr.kind,
+        name: transformNodeArray(aExpr.name),
+        lexpr: transformOptionalNode(aExpr.lexpr),
+        rexpr: transformOptionalNode(aExpr.rexpr),
+        location: aExpr.location
+    };
+}
+function transformTypeCast(typeCast) {
+    return {
+        arg: transformOptionalNode(typeCast.arg),
+        typeName: typeCast.typeName ? transformTypeName(typeCast.typeName) : undefined,
+        location: typeCast.location
+    };
+}
+function transformCollateClause(collateClause) {
+    return {
+        arg: transformOptionalNode(collateClause.arg),
+        collname: transformNodeArray(collateClause.collname),
+        location: collateClause.location
+    };
+}
+function transformRoleSpec(roleSpec) {
+    return {
+        roletype: roleSpec.roletype,
+        rolename: roleSpec.rolename,
+        location: roleSpec.location
+    };
+}
+function transformFuncCall(funcCall) {
+    return {
+        funcname: transformNodeArray(funcCall.funcname),
+        args: transformNodeArray(funcCall.args),
+        agg_order: transformNodeArray(funcCall.agg_order),
+        agg_filter: transformOptionalNode(funcCall.agg_filter),
+        over: funcCall.over ? transformWindowDef(funcCall.over) : undefined,
+        agg_within_group: funcCall.agg_within_group,
+        agg_star: funcCall.agg_star,
+        agg_distinct: funcCall.agg_distinct,
+        func_variadic: funcCall.func_variadic,
+        funcformat: funcCall.funcformat,
+        location: funcCall.location
+    };
+}
+function transformA_Indices(aIndices) {
+    return {
+        is_slice: aIndices.is_slice,
+        lidx: transformOptionalNode(aIndices.lidx),
+        uidx: transformOptionalNode(aIndices.uidx)
+    };
+}
+function transformA_Indirection(aIndirection) {
+    return {
+        arg: transformOptionalNode(aIndirection.arg),
+        indirection: transformNodeArray(aIndirection.indirection)
+    };
+}
+function transformA_ArrayExpr(aArrayExpr) {
+    return {
+        elements: transformNodeArray(aArrayExpr.elements),
+        location: aArrayExpr.location
+    };
+}
+function transformResTarget(resTarget) {
+    return {
+        name: resTarget.name,
+        indirection: transformNodeArray(resTarget.indirection),
+        val: transformOptionalNode(resTarget.val),
+        location: resTarget.location
+    };
+}
+function transformMultiAssignRef(multiAssignRef) {
+    return {
+        source: transformOptionalNode(multiAssignRef.source),
+        colno: multiAssignRef.colno,
+        ncolumns: multiAssignRef.ncolumns
+    };
+}
+function transformSortBy(sortBy) {
+    return {
+        node: transformOptionalNode(sortBy.node),
+        sortby_dir: sortBy.sortby_dir,
+        sortby_nulls: sortBy.sortby_nulls,
+        useOp: transformNodeArray(sortBy.useOp),
+        location: sortBy.location
+    };
+}
+function transformWindowDef(windowDef) {
+    return {
+        name: windowDef.name,
+        refname: windowDef.refname,
+        partitionClause: transformNodeArray(windowDef.partitionClause),
+        orderClause: transformNodeArray(windowDef.orderClause),
+        frameOptions: windowDef.frameOptions,
+        startOffset: transformOptionalNode(windowDef.startOffset),
+        endOffset: transformOptionalNode(windowDef.endOffset),
+        location: windowDef.location
+    };
+}
+function transformRangeSubselect(rangeSubselect) {
+    return {
+        lateral: rangeSubselect.lateral,
+        subquery: transformOptionalNode(rangeSubselect.subquery),
+        alias: rangeSubselect.alias ? transformAlias(rangeSubselect.alias) : undefined
+    };
+}
+function transformRangeFunction(rangeFunction) {
+    return {
+        lateral: rangeFunction.lateral,
+        ordinality: rangeFunction.ordinality,
+        is_rowsfrom: rangeFunction.is_rowsfrom,
+        functions: transformNodeArray(rangeFunction.functions),
+        alias: rangeFunction.alias ? transformAlias(rangeFunction.alias) : undefined,
+        coldeflist: transformNodeArray(rangeFunction.coldeflist)
+    };
+}
+function transformRangeTableFunc(rangeTableFunc) {
+    return {
+        lateral: rangeTableFunc.lateral,
+        docexpr: transformOptionalNode(rangeTableFunc.docexpr),
+        rowexpr: transformOptionalNode(rangeTableFunc.rowexpr),
+        namespaces: transformNodeArray(rangeTableFunc.namespaces),
+        columns: transformNodeArray(rangeTableFunc.columns),
+        alias: rangeTableFunc.alias ? transformAlias(rangeTableFunc.alias) : undefined,
+        location: rangeTableFunc.location
+    };
+}
+function transformRangeTableFuncCol(rangeTableFuncCol) {
+    return {
+        colname: rangeTableFuncCol.colname,
+        typeName: rangeTableFuncCol.typeName ? transformTypeName(rangeTableFuncCol.typeName) : undefined,
+        for_ordinality: rangeTableFuncCol.for_ordinality,
+        is_not_null: rangeTableFuncCol.is_not_null,
+        colexpr: transformOptionalNode(rangeTableFuncCol.colexpr),
+        coldefexpr: transformOptionalNode(rangeTableFuncCol.coldefexpr),
+        location: rangeTableFuncCol.location
+    };
+}
+function transformRangeTableSample(rangeTableSample) {
+    return {
+        relation: transformOptionalNode(rangeTableSample.relation),
+        method: transformNodeArray(rangeTableSample.method),
+        args: transformNodeArray(rangeTableSample.args),
+        repeatable: transformOptionalNode(rangeTableSample.repeatable),
+        location: rangeTableSample.location
+    };
+}
+function transformColumnDef(columnDef) {
+    return {
+        colname: columnDef.colname,
+        typeName: columnDef.typeName ? transformTypeName(columnDef.typeName) : undefined,
+        compression: columnDef.compression,
+        inhcount: columnDef.inhcount,
+        is_local: columnDef.is_local,
+        is_not_null: columnDef.is_not_null,
+        is_from_type: columnDef.is_from_type,
+        storage: columnDef.storage,
+        raw_default: transformOptionalNode(columnDef.raw_default),
+        cooked_default: transformOptionalNode(columnDef.cooked_default),
+        identity: columnDef.identity,
+        identitySequence: columnDef.identitySequence ? transformRangeVar(columnDef.identitySequence) : undefined,
+        generated: columnDef.generated,
+        collClause: columnDef.collClause ? transformCollateClause(columnDef.collClause) : undefined,
+        collOid: columnDef.collOid,
+        constraints: transformNodeArray(columnDef.constraints),
+        fdwoptions: transformNodeArray(columnDef.fdwoptions),
+        location: columnDef.location
+    };
+}
+function transformTableLikeClause(tableLikeClause) {
+    return {
+        relation: tableLikeClause.relation ? transformRangeVar(tableLikeClause.relation) : undefined,
+        options: tableLikeClause.options,
+        relationOid: tableLikeClause.relationOid
+    };
+}
+function transformIndexElem(indexElem) {
+    return {
+        name: indexElem.name,
+        expr: transformOptionalNode(indexElem.expr),
+        indexcolname: indexElem.indexcolname,
+        collation: transformNodeArray(indexElem.collation),
+        opclass: transformNodeArray(indexElem.opclass),
+        opclassopts: transformNodeArray(indexElem.opclassopts),
+        ordering: indexElem.ordering,
+        nulls_ordering: indexElem.nulls_ordering
+    };
+}
+function transformDefElem(defElem) {
+    return {
+        defnamespace: defElem.defnamespace,
+        defname: defElem.defname,
+        arg: transformOptionalNode(defElem.arg),
+        defaction: defElem.defaction,
+        location: defElem.location
+    };
+}
+function transformLockingClause(lockingClause) {
+    return {
+        lockedRels: transformNodeArray(lockingClause.lockedRels),
+        strength: lockingClause.strength,
+        waitPolicy: lockingClause.waitPolicy
+    };
+}
+function transformXmlSerialize(xmlSerialize) {
+    return {
+        xmloption: xmlSerialize.xmloption,
+        expr: transformOptionalNode(xmlSerialize.expr),
+        typeName: xmlSerialize.typeName ? transformTypeName(xmlSerialize.typeName) : undefined,
+        indent: xmlSerialize.indent,
+        location: xmlSerialize.location
+    };
+}
+function transformPartitionElem(partitionElem) {
+    return {
+        name: partitionElem.name,
+        expr: transformOptionalNode(partitionElem.expr),
+        collation: transformNodeArray(partitionElem.collation),
+        opclass: transformNodeArray(partitionElem.opclass),
+        location: partitionElem.location
+    };
+}
+function transformPartitionSpec(partitionSpec) {
+    return {
+        strategy: partitionSpec.strategy,
+        partParams: transformNodeArray(partitionSpec.partParams),
+        location: partitionSpec.location
+    };
+}
+function transformPartitionBoundSpec(partitionBoundSpec) {
+    return {
+        strategy: partitionBoundSpec.strategy,
+        is_default: partitionBoundSpec.is_default,
+        modulus: partitionBoundSpec.modulus,
+        remainder: partitionBoundSpec.remainder,
+        listdatums: transformNodeArray(partitionBoundSpec.listdatums),
+        lowerdatums: transformNodeArray(partitionBoundSpec.lowerdatums),
+        upperdatums: transformNodeArray(partitionBoundSpec.upperdatums),
+        location: partitionBoundSpec.location
+    };
+}
+function transformPartitionRangeDatum(partitionRangeDatum) {
+    return {
+        kind: partitionRangeDatum.kind,
+        value: transformOptionalNode(partitionRangeDatum.value),
+        location: partitionRangeDatum.location
+    };
+}
+function transformPartitionCmd(partitionCmd) {
+    return {
+        name: partitionCmd.name ? transformRangeVar(partitionCmd.name) : undefined,
+        bound: partitionCmd.bound ? transformPartitionBoundSpec(partitionCmd.bound) : undefined,
+        concurrent: partitionCmd.concurrent
+    };
+}
+function transformRangeTblEntry(rangeTblEntry) {
+    return {
+        alias: rangeTblEntry.alias ? transformAlias(rangeTblEntry.alias) : undefined,
+        eref: rangeTblEntry.eref ? transformAlias(rangeTblEntry.eref) : undefined,
+        rtekind: rangeTblEntry.rtekind,
+        relid: rangeTblEntry.relid,
+        inh: rangeTblEntry.inh,
+        relkind: rangeTblEntry.relkind,
+        rellockmode: rangeTblEntry.rellockmode,
+        perminfoindex: rangeTblEntry.perminfoindex,
+        tablesample: rangeTblEntry.tablesample ? transformTableSampleClause(rangeTblEntry.tablesample) : undefined,
+        subquery: rangeTblEntry.subquery ? transformQuery(rangeTblEntry.subquery) : undefined,
+        security_barrier: rangeTblEntry.security_barrier,
+        jointype: rangeTblEntry.jointype,
+        joinmergedcols: rangeTblEntry.joinmergedcols,
+        joinaliasvars: transformNodeArray(rangeTblEntry.joinaliasvars),
+        join_using_alias: rangeTblEntry.join_using_alias ? transformAlias(rangeTblEntry.join_using_alias) : undefined,
+        functions: transformNodeArray(rangeTblEntry.functions),
+        funcordinality: rangeTblEntry.funcordinality,
+        tablefunc: rangeTblEntry.tablefunc ? transformTableFunc(rangeTblEntry.tablefunc) : undefined,
+        values_lists: transformNodeArray(rangeTblEntry.values_lists),
+        ctename: rangeTblEntry.ctename,
+        ctelevelsup: rangeTblEntry.ctelevelsup,
+        self_reference: rangeTblEntry.self_reference,
+        enrname: rangeTblEntry.enrname,
+        enrtuples: rangeTblEntry.enrtuples,
+        lateral: rangeTblEntry.lateral,
+        inFromCl: rangeTblEntry.inFromCl,
+        securityQuals: transformNodeArray(rangeTblEntry.securityQuals)
+    };
+}
+function transformOidList(oidList) {
+    return oidList;
+}
+function transformIntList(intList) {
+    return intList;
+}
+function transformRawStmt(rawStmt) {
+    return {
+        stmt: transformOptionalNode(rawStmt.stmt),
+        stmt_location: rawStmt.stmt_location,
+        stmt_len: rawStmt.stmt_len
+    };
+}
+function transformMergeAction(mergeAction) {
+    return {
+        commandType: mergeAction.commandType,
+        override: mergeAction.override,
+        qual: transformOptionalNode(mergeAction.qual),
+        targetList: transformNodeArray(mergeAction.targetList)
+    };
+}
+function transformTableSampleClause(tableSampleClause) {
+    return tableSampleClause;
+}
+export * as PG13Types from './13/types';
+export * as PG17Types from './17/types';