From c8b483325992309237542f1bc8115f8b3d8ec495 Mon Sep 17 00:00:00 2001 From: Dan Lynch Date: Mon, 23 Jun 2025 11:29:59 -0700 Subject: [PATCH] meta setup --- .../__tests__/__snapshots__/meta.test.ts.snap | 1233 ++ packages/proto-parser/__tests__/meta.test.ts | 371 +- packages/proto-parser/test-utils/meta/asts.ts | 2490 ++++ .../proto-parser/test-utils/meta/index.ts | 8 + .../test-utils/meta/runtime-schema.ts | 11427 ++++++++++++++++ .../proto-parser/test-utils/meta/wrapped.ts | 3574 +++++ .../proto-parser/test-utils/utils/asts.ts | 2838 ---- .../proto-parser/test-utils/utils/wrapped.ts | 2324 ---- 8 files changed, 19082 insertions(+), 5183 deletions(-) create mode 100644 packages/proto-parser/test-utils/meta/asts.ts create mode 100644 packages/proto-parser/test-utils/meta/index.ts create mode 100644 packages/proto-parser/test-utils/meta/runtime-schema.ts create mode 100644 packages/proto-parser/test-utils/meta/wrapped.ts delete mode 100644 packages/proto-parser/test-utils/utils/asts.ts delete mode 100644 packages/proto-parser/test-utils/utils/wrapped.ts diff --git a/packages/proto-parser/__tests__/__snapshots__/meta.test.ts.snap b/packages/proto-parser/__tests__/__snapshots__/meta.test.ts.snap index 3da8e032..fd6edf13 100644 --- a/packages/proto-parser/__tests__/__snapshots__/meta.test.ts.snap +++ b/packages/proto-parser/__tests__/__snapshots__/meta.test.ts.snap @@ -49,3 +49,1236 @@ exports[`AST to AST to create AST — meta 🤯 2`] = ` op: "SETOP_NONE" })" `; + +exports[`Complex AST — Advanced SQL with CTEs, Window Functions, Joins, and Subqueries 1`] = ` +{ + "SelectStmt": { + "fromClause": [ + { + "JoinExpr": { + "jointype": "JOIN_INNER", + "larg": { + "RangeVar": { + "alias": { + "aliasname": "c", + }, + "inh": true, + "relname": "customers", + "relpersistence": "p", + }, + }, + "quals": { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "c", + }, + }, + { + "String": { + "sval": "id", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": "=", + }, + }, + ], + "rexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "customer_id", + }, + }, + ], + }, + }, + }, + }, + "rarg": { + "RangeVar": { + "alias": { + "aliasname": "cr", + }, + "inh": true, + "relname": "customer_rankings", + "relpersistence": "p", + }, + }, + }, + }, + ], + "limitCount": { + "A_Const": { + "ival": { + "ival": 50, + }, + }, + }, + "limitOption": "LIMIT_OPTION_COUNT", + "op": "SETOP_NONE", + "sortClause": [ + { + "SortBy": { + "node": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "sales_rank", + }, + }, + ], + }, + }, + "sortby_dir": "SORTBY_ASC", + "sortby_nulls": "SORTBY_NULLS_DEFAULT", + }, + }, + ], + "targetList": [ + { + "ResTarget": { + "name": "customer_name", + "val": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "c", + }, + }, + { + "String": { + "sval": "name", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "total_sales", + "val": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "total_sales", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "sales_rank", + "val": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "sales_rank", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "customer_tier", + "val": { + "CaseExpr": { + "args": [ + { + "CaseWhen": { + "expr": { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "sales_rank", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": "<=", + }, + }, + ], + "rexpr": { + "A_Const": { + "ival": { + "ival": 10, + }, + }, + }, + }, + }, + "result": { + "A_Const": { + "sval": { + "sval": "Premium", + }, + }, + }, + }, + }, + { + "CaseWhen": { + "expr": { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "sales_rank", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": "<=", + }, + }, + ], + "rexpr": { + "A_Const": { + "ival": { + "ival": 50, + }, + }, + }, + }, + }, + "result": { + "A_Const": { + "sval": { + "sval": "Gold", + }, + }, + }, + }, + }, + { + "CaseWhen": { + "expr": { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "sales_rank", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": "<=", + }, + }, + ], + "rexpr": { + "A_Const": { + "ival": { + "ival": 100, + }, + }, + }, + }, + }, + "result": { + "A_Const": { + "sval": { + "sval": "Silver", + }, + }, + }, + }, + }, + ], + "defresult": { + "A_Const": { + "sval": { + "sval": "Bronze", + }, + }, + }, + }, + }, + }, + }, + { + "ResTarget": { + "name": "recent_order_count", + "val": { + "SubLink": { + "subLinkType": "EXPR_SUBLINK", + "subselect": { + "SelectStmt": { + "fromClause": [ + { + "RangeVar": { + "alias": { + "aliasname": "o2", + }, + "inh": true, + "relname": "orders", + "relpersistence": "p", + }, + }, + ], + "limitOption": "LIMIT_OPTION_DEFAULT", + "op": "SETOP_NONE", + "targetList": [ + { + "ResTarget": { + "val": { + "FuncCall": { + "args": [ + { + "A_Star": {}, + }, + ], + "funcname": [ + { + "String": { + "sval": "count", + }, + }, + ], + }, + }, + }, + }, + ], + "whereClause": { + "BoolExpr": { + "args": [ + { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "o2", + }, + }, + { + "String": { + "sval": "customer_id", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": "=", + }, + }, + ], + "rexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "c", + }, + }, + { + "String": { + "sval": "id", + }, + }, + ], + }, + }, + }, + }, + { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "o2", + }, + }, + { + "String": { + "sval": "order_date", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": ">=", + }, + }, + ], + "rexpr": { + "FuncCall": { + "args": [], + "funcname": [ + { + "String": { + "sval": "current_date", + }, + }, + ], + }, + }, + }, + }, + ], + "boolop": "AND_EXPR", + }, + }, + }, + }, + }, + }, + }, + }, + ], + "whereClause": { + "BoolExpr": { + "args": [ + { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "cr", + }, + }, + { + "String": { + "sval": "total_sales", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": ">", + }, + }, + ], + "rexpr": { + "A_Const": { + "ival": { + "ival": 1000, + }, + }, + }, + }, + }, + { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "c", + }, + }, + { + "String": { + "sval": "status", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": "IS NOT", + }, + }, + ], + "rexpr": { + "A_Const": { + "sval": { + "sval": "inactive", + }, + }, + }, + }, + }, + ], + "boolop": "AND_EXPR", + }, + }, + "withClause": { + "ctes": [ + { + "CommonTableExpr": { + "ctename": "sales_summary", + "ctequery": { + "SelectStmt": { + "fromClause": [ + { + "RangeVar": { + "inh": true, + "relname": "orders", + "relpersistence": "p", + }, + }, + ], + "groupClause": [ + { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "customer_id", + }, + }, + ], + }, + }, + ], + "limitOption": "LIMIT_OPTION_DEFAULT", + "op": "SETOP_NONE", + "targetList": [ + { + "ResTarget": { + "name": "customer_id", + "val": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "customer_id", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "total_sales", + "val": { + "FuncCall": { + "args": [ + { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "amount", + }, + }, + ], + }, + }, + ], + "funcname": [ + { + "String": { + "sval": "sum", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "avg_order_value", + "val": { + "FuncCall": { + "args": [ + { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "amount", + }, + }, + ], + }, + }, + ], + "funcname": [ + { + "String": { + "sval": "avg", + }, + }, + ], + }, + }, + }, + }, + ], + "whereClause": { + "A_Expr": { + "kind": "AEXPR_OP", + "lexpr": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "order_date", + }, + }, + ], + }, + }, + "name": [ + { + "String": { + "sval": ">=", + }, + }, + ], + "rexpr": { + "A_Const": { + "sval": { + "sval": "2023-01-01", + }, + }, + }, + }, + }, + }, + }, + }, + }, + { + "CommonTableExpr": { + "ctename": "customer_rankings", + "ctequery": { + "SelectStmt": { + "fromClause": [ + { + "RangeVar": { + "inh": true, + "relname": "sales_summary", + "relpersistence": "p", + }, + }, + ], + "limitOption": "LIMIT_OPTION_DEFAULT", + "op": "SETOP_NONE", + "targetList": [ + { + "ResTarget": { + "name": "customer_id", + "val": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "customer_id", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "total_sales", + "val": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "total_sales", + }, + }, + ], + }, + }, + }, + }, + { + "ResTarget": { + "name": "sales_rank", + "val": { + "WindowFunc": { + "args": [], + "winagg": false, + "winfnoid": 3133, + "winref": 1, + "winstar": false, + "wintype": 20, + }, + }, + }, + }, + { + "ResTarget": { + "name": "sales_percentile", + "val": { + "WindowFunc": { + "args": [], + "winagg": false, + "winfnoid": 3974, + "winref": 2, + "winstar": false, + "wintype": 701, + }, + }, + }, + }, + ], + "windowClause": [ + { + "WindowDef": { + "name": "sales_window", + "orderClause": [ + { + "SortBy": { + "node": { + "ColumnRef": { + "fields": [ + { + "String": { + "sval": "total_sales", + }, + }, + ], + }, + }, + "sortby_dir": "SORTBY_DESC", + "sortby_nulls": "SORTBY_NULLS_DEFAULT", + }, + }, + ], + }, + }, + ], + }, + }, + }, + }, + ], + "recursive": false, + }, + }, +} +`; + +exports[`Complex AST — Advanced SQL with CTEs, Window Functions, Joins, and Subqueries 2`] = ` +"ast.selectStmt({ + targetList: [ast.resTarget({ + name: "customer_name", + val: ast.columnRef({ + fields: [ast.string({ + sval: "c" + }), ast.string({ + sval: "name" + })] + }) + }), ast.resTarget({ + name: "total_sales", + val: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "total_sales" + })] + }) + }), ast.resTarget({ + name: "sales_rank", + val: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "sales_rank" + })] + }) + }), ast.resTarget({ + name: "customer_tier", + val: ast.caseExpr({ + args: [ast.caseWhen({ + expr: ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: "<=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "sales_rank" + })] + }), + rexpr: ast.aConst({ + ival: ast.ival({}) + }) + }), + result: ast.aConst({ + sval: ast.sval({ + 0: "P", + 1: "r", + 2: "e", + 3: "m", + 4: "i", + 5: "u", + 6: "m" + }) + }) + }), ast.caseWhen({ + expr: ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: "<=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "sales_rank" + })] + }), + rexpr: ast.aConst({ + ival: ast.ival({}) + }) + }), + result: ast.aConst({ + sval: ast.sval({ + 0: "G", + 1: "o", + 2: "l", + 3: "d" + }) + }) + }), ast.caseWhen({ + expr: ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: "<=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "sales_rank" + })] + }), + rexpr: ast.aConst({ + ival: ast.ival({}) + }) + }), + result: ast.aConst({ + sval: ast.sval({ + 0: "S", + 1: "i", + 2: "l", + 3: "v", + 4: "e", + 5: "r" + }) + }) + })], + defresult: ast.aConst({ + sval: ast.sval({ + 0: "B", + 1: "r", + 2: "o", + 3: "n", + 4: "z", + 5: "e" + }) + }) + }) + }), ast.resTarget({ + name: "recent_order_count", + val: ast.subLink({ + subLinkType: "EXPR_SUBLINK", + subselect: ast.selectStmt({ + targetList: [ast.resTarget({ + val: ast.funcCall({ + funcname: [ast.string({ + sval: "count" + })], + args: [ast.aStar({})] + }) + })], + fromClause: [ast.rangeVar({ + relname: "orders", + inh: true, + relpersistence: "p", + alias: ast.aliasname({ + 0: "o", + 1: "2" + }) + })], + whereClause: ast.boolExpr({ + boolop: "AND_EXPR", + args: [ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: "=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "o2" + }), ast.string({ + sval: "customer_id" + })] + }), + rexpr: ast.columnRef({ + fields: [ast.string({ + sval: "c" + }), ast.string({ + sval: "id" + })] + }) + }), ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: ">=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "o2" + }), ast.string({ + sval: "order_date" + })] + }), + rexpr: ast.funcCall({ + funcname: [ast.string({ + sval: "current_date" + })], + args: [] + }) + })] + }), + limitOption: "LIMIT_OPTION_DEFAULT", + op: "SETOP_NONE" + }) + }) + })], + fromClause: [ast.joinExpr({ + jointype: "JOIN_INNER", + larg: ast.rangeVar({ + relname: "customers", + inh: true, + relpersistence: "p", + alias: ast.aliasname({ + 0: "c" + }) + }), + rarg: ast.rangeVar({ + relname: "customer_rankings", + inh: true, + relpersistence: "p", + alias: ast.aliasname({ + 0: "c", + 1: "r" + }) + }), + quals: ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: "=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "c" + }), ast.string({ + sval: "id" + })] + }), + rexpr: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "customer_id" + })] + }) + }) + })], + whereClause: ast.boolExpr({ + boolop: "AND_EXPR", + args: [ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: ">" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "total_sales" + })] + }), + rexpr: ast.aConst({ + ival: ast.ival({}) + }) + }), ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: "IS NOT" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "c" + }), ast.string({ + sval: "status" + })] + }), + rexpr: ast.aConst({ + sval: ast.sval({ + 0: "i", + 1: "n", + 2: "a", + 3: "c", + 4: "t", + 5: "i", + 6: "v", + 7: "e" + }) + }) + })] + }), + sortClause: [ast.sortBy({ + node: ast.columnRef({ + fields: [ast.string({ + sval: "cr" + }), ast.string({ + sval: "sales_rank" + })] + }), + sortby_dir: "SORTBY_ASC", + sortby_nulls: "SORTBY_NULLS_DEFAULT" + })], + limitCount: ast.aConst({ + ival: ast.ival({}) + }), + limitOption: "LIMIT_OPTION_COUNT", + withClause: ast.ctes({ + 0: ast.commonTableExpr({ + ctename: "sales_summary", + ctequery: ast.selectStmt({ + targetList: [ast.resTarget({ + name: "customer_id", + val: ast.columnRef({ + fields: [ast.string({ + sval: "customer_id" + })] + }) + }), ast.resTarget({ + name: "total_sales", + val: ast.funcCall({ + funcname: [ast.string({ + sval: "sum" + })], + args: [ast.columnRef({ + fields: [ast.string({ + sval: "amount" + })] + })] + }) + }), ast.resTarget({ + name: "avg_order_value", + val: ast.funcCall({ + funcname: [ast.string({ + sval: "avg" + })], + args: [ast.columnRef({ + fields: [ast.string({ + sval: "amount" + })] + })] + }) + })], + fromClause: [ast.rangeVar({ + relname: "orders", + inh: true, + relpersistence: "p" + })], + whereClause: ast.aExpr({ + kind: "AEXPR_OP", + name: [ast.string({ + sval: ">=" + })], + lexpr: ast.columnRef({ + fields: [ast.string({ + sval: "order_date" + })] + }), + rexpr: ast.aConst({ + sval: ast.sval({ + 0: "2", + 1: "0", + 2: "2", + 3: "3", + 4: "-", + 5: "0", + 6: "1", + 7: "-", + 8: "0", + 9: "1" + }) + }) + }), + groupClause: [ast.columnRef({ + fields: [ast.string({ + sval: "customer_id" + })] + })], + limitOption: "LIMIT_OPTION_DEFAULT", + op: "SETOP_NONE" + }) + }), + 1: ast.commonTableExpr({ + ctename: "customer_rankings", + ctequery: ast.selectStmt({ + targetList: [ast.resTarget({ + name: "customer_id", + val: ast.columnRef({ + fields: [ast.string({ + sval: "customer_id" + })] + }) + }), ast.resTarget({ + name: "total_sales", + val: ast.columnRef({ + fields: [ast.string({ + sval: "total_sales" + })] + }) + }), ast.resTarget({ + name: "sales_rank", + val: ast.windowFunc({ + winfnoid: 3133, + wintype: 20, + args: [], + winref: 1, + winstar: false, + winagg: false + }) + }), ast.resTarget({ + name: "sales_percentile", + val: ast.windowFunc({ + winfnoid: 3974, + wintype: 701, + args: [], + winref: 2, + winstar: false, + winagg: false + }) + })], + fromClause: [ast.rangeVar({ + relname: "sales_summary", + inh: true, + relpersistence: "p" + })], + windowClause: [ast.windowDef({ + name: "sales_window", + orderClause: [ast.sortBy({ + node: ast.columnRef({ + fields: [ast.string({ + sval: "total_sales" + })] + }), + sortby_dir: "SORTBY_DESC", + sortby_nulls: "SORTBY_NULLS_DEFAULT" + })] + })], + limitOption: "LIMIT_OPTION_DEFAULT", + op: "SETOP_NONE" + }) + }) + }), + op: "SETOP_NONE" +})" +`; diff --git a/packages/proto-parser/__tests__/meta.test.ts b/packages/proto-parser/__tests__/meta.test.ts index e016aa44..29a3cd9c 100644 --- a/packages/proto-parser/__tests__/meta.test.ts +++ b/packages/proto-parser/__tests__/meta.test.ts @@ -1,18 +1,19 @@ -import ast from '../test-utils/utils/asts'; +import * as t from '../test-utils/meta'; +import { SelectStmt } from '@pgsql/types'; import { generateTsAstCodeFromPgAst } from '../src/utils' import generate from '@babel/generator'; it('AST to AST to create AST — meta 🤯', () => { - const selectStmt = ast.selectStmt({ + const selectStmt = t.nodes.selectStmt({ targetList: [ - ast.resTarget({ - val: ast.columnRef({ - fields: [ast.aStar()] + t.nodes.resTarget({ + val: t.nodes.columnRef({ + fields: [t.nodes.aStar()] }) }) ], fromClause: [ - ast.rangeVar({ + t.nodes.rangeVar({ relname: 'some_amazing_table', inh: true, relpersistence: 'p' @@ -26,20 +27,348 @@ it('AST to AST to create AST — meta 🤯', () => { const astForAst = generateTsAstCodeFromPgAst(selectStmt); expect(generate(astForAst).code).toMatchSnapshot(); - expect(generate(astForAst).code).toEqual( -`ast.selectStmt({ - targetList: [ast.resTarget({ - val: ast.columnRef({ - fields: [ast.aStar({})] - }) - })], - fromClause: [ast.rangeVar({ - relname: "some_amazing_table", - inh: true, - relpersistence: "p" - })], - limitOption: "LIMIT_OPTION_DEFAULT", - op: "SETOP_NONE" -})`); +}); +it('Complex AST — Advanced SQL with CTEs, Window Functions, Joins, and Subqueries', () => { + const complexSelectStmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({ + // WITH clause for CTEs + withClause: t.ast.withClause({ + ctes: [ + // First CTE: Sales summary + t.nodes.commonTableExpr({ + ctename: 'sales_summary', + ctequery: t.nodes.selectStmt({ + targetList: [ + t.nodes.resTarget({ + name: 'customer_id', + val: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'customer_id' })] + }) + }), + t.nodes.resTarget({ + name: 'total_sales', + val: t.nodes.funcCall({ + funcname: [t.nodes.string({ sval: 'sum' })], + args: [ + t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'amount' })] + }) + ] + }) + }), + t.nodes.resTarget({ + name: 'avg_order_value', + val: t.nodes.funcCall({ + funcname: [t.nodes.string({ sval: 'avg' })], + args: [ + t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'amount' })] + }) + ] + }) + }) + ], + fromClause: [ + t.nodes.rangeVar({ + relname: 'orders', + inh: true, + relpersistence: 'p' + }) + ], + whereClause: t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '>=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'order_date' })] + }), + rexpr: t.nodes.aConst({ + sval: t.ast.string({ sval: '2023-01-01' }) + }) + }), + groupClause: [ + t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'customer_id' })] + }) + ], + limitOption: 'LIMIT_OPTION_DEFAULT', + op: 'SETOP_NONE' + }) + }), + t.nodes.commonTableExpr({ + ctename: 'customer_rankings', + ctequery: t.nodes.selectStmt({ + targetList: [ + t.nodes.resTarget({ + name: 'customer_id', + val: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'customer_id' })] + }) + }), + t.nodes.resTarget({ + name: 'total_sales', + val: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'total_sales' })] + }) + }), + t.nodes.resTarget({ + name: 'sales_rank', + val: t.nodes.windowFunc({ + winfnoid: 3133, // ROW_NUMBER function OID + wintype: 20, // INT8 type + args: [], + winref: 1, + winstar: false, + winagg: false + }) + }), + t.nodes.resTarget({ + name: 'sales_percentile', + val: t.nodes.windowFunc({ + winfnoid: 3974, // PERCENT_RANK function OID + wintype: 701, // FLOAT8 type + args: [], + winref: 2, + winstar: false, + winagg: false + }) + }) + ], + fromClause: [ + t.nodes.rangeVar({ + relname: 'sales_summary', + inh: true, + relpersistence: 'p' + }) + ], + windowClause: [ + t.nodes.windowDef({ + name: 'sales_window', + orderClause: [ + t.nodes.sortBy({ + node: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'total_sales' })] + }), + sortby_dir: 'SORTBY_DESC', + sortby_nulls: 'SORTBY_NULLS_DEFAULT' + }) + ] + }) + ], + limitOption: 'LIMIT_OPTION_DEFAULT', + op: 'SETOP_NONE' + }) + }) + ], + recursive: false + }), + + // Main SELECT target list with complex expressions + targetList: [ + t.nodes.resTarget({ + name: 'customer_name', + val: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'c' }), t.nodes.string({ sval: 'name' })] + }) + }), + t.nodes.resTarget({ + name: 'total_sales', + val: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'total_sales' })] + }) + }), + t.nodes.resTarget({ + name: 'sales_rank', + val: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'sales_rank' })] + }) + }), + t.nodes.resTarget({ + name: 'customer_tier', + val: t.nodes.caseExpr({ + args: [ + t.nodes.caseWhen({ + expr: t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '<=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'sales_rank' })] + }), + rexpr: t.nodes.aConst({ + ival: t.ast.integer({ ival: 10 }) + }) + }), + result: t.nodes.aConst({ + sval: t.ast.string({ sval: 'Premium' }) + }) + }), + t.nodes.caseWhen({ + expr: t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '<=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'sales_rank' })] + }), + rexpr: t.nodes.aConst({ + ival: t.ast.integer({ ival: 50 }) + }) + }), + result: t.nodes.aConst({ + sval: t.ast.string({ sval: 'Gold' }) + }) + }), + t.nodes.caseWhen({ + expr: t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '<=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'sales_rank' })] + }), + rexpr: t.nodes.aConst({ + ival: t.ast.integer({ ival: 100 }) + }) + }), + result: t.nodes.aConst({ + sval: t.ast.string({ sval: 'Silver' }) + }) + }) + ], + defresult: t.nodes.aConst({ + sval: t.ast.string({ sval: 'Bronze' }) + }) + }) + }), + t.nodes.resTarget({ + name: 'recent_order_count', + val: t.nodes.subLink({ + subLinkType: 'EXPR_SUBLINK', + subselect: t.nodes.selectStmt({ + targetList: [ + t.nodes.resTarget({ + val: t.nodes.funcCall({ + funcname: [t.nodes.string({ sval: 'count' })], + args: [t.nodes.aStar()] + }) + }) + ], + fromClause: [ + t.nodes.rangeVar({ + relname: 'orders', + alias: t.ast.alias({ aliasname: 'o2' }), + inh: true, + relpersistence: 'p' + }) + ], + whereClause: t.nodes.boolExpr({ + boolop: 'AND_EXPR', + args: [ + t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'o2' }), t.nodes.string({ sval: 'customer_id' })] + }), + rexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'c' }), t.nodes.string({ sval: 'id' })] + }) + }), + t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '>=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'o2' }), t.nodes.string({ sval: 'order_date' })] + }), + rexpr: t.nodes.funcCall({ + funcname: [t.nodes.string({ sval: 'current_date' })], + args: [] + }) + }) + ] + }), + limitOption: 'LIMIT_OPTION_DEFAULT', + op: 'SETOP_NONE' + }) + }) + }) + ], + + // Complex FROM clause with joins + fromClause: [ + t.nodes.joinExpr({ + jointype: 'JOIN_INNER', + larg: t.nodes.rangeVar({ + relname: 'customers', + alias: t.ast.alias({ aliasname: 'c' }), + inh: true, + relpersistence: 'p' + }), + rarg: t.nodes.rangeVar({ + relname: 'customer_rankings', + alias: t.ast.alias({ aliasname: 'cr' }), + inh: true, + relpersistence: 'p' + }), + quals: t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '=' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'c' }), t.nodes.string({ sval: 'id' })] + }), + rexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'customer_id' })] + }) + }) + }) + ], + + // WHERE clause with complex conditions + whereClause: t.nodes.boolExpr({ + boolop: 'AND_EXPR', + args: [ + t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: '>' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'total_sales' })] + }), + rexpr: t.nodes.aConst({ + ival: t.ast.integer({ ival: 1000 }) + }) + }), + t.nodes.aExpr({ + kind: 'AEXPR_OP', + name: [t.nodes.string({ sval: 'IS NOT' })], + lexpr: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'c' }), t.nodes.string({ sval: 'status' })] + }), + rexpr: t.nodes.aConst({ + sval: t.ast.string({ sval: 'inactive' }) + }) + }) + ] + }), + + // ORDER BY clause + sortClause: [ + t.nodes.sortBy({ + node: t.nodes.columnRef({ + fields: [t.nodes.string({ sval: 'cr' }), t.nodes.string({ sval: 'sales_rank' })] + }), + sortby_dir: 'SORTBY_ASC', + sortby_nulls: 'SORTBY_NULLS_DEFAULT' + }) + ], + + // LIMIT clause + limitCount: t.nodes.aConst({ + ival: t.ast.integer({ ival: 50 }) + }), + + limitOption: 'LIMIT_OPTION_COUNT', + op: 'SETOP_NONE' + }); + + expect(complexSelectStmt).toMatchSnapshot(); + + const astForComplexAst = generateTsAstCodeFromPgAst(complexSelectStmt); + expect(generate(astForComplexAst).code).toMatchSnapshot(); }); \ No newline at end of file diff --git a/packages/proto-parser/test-utils/meta/asts.ts b/packages/proto-parser/test-utils/meta/asts.ts new file mode 100644 index 00000000..73f94fa5 --- /dev/null +++ b/packages/proto-parser/test-utils/meta/asts.ts @@ -0,0 +1,2490 @@ +/** +* This file was automatically generated by pg-proto-parser@1.29.0. +* DO NOT MODIFY IT BY HAND. Instead, modify the source proto file, +* and run the pg-proto-parser generate command to regenerate this file. +*/ +import _o from "nested-obj"; +import { ParseResult, ScanResult, Integer, Float, Boolean, String, BitString, List, OidList, IntList, A_Const, Alias, RangeVar, TableFunc, IntoClause, Var, Param, Aggref, GroupingFunc, WindowFunc, WindowFuncRunCondition, MergeSupportFunc, SubscriptingRef, FuncExpr, NamedArgExpr, OpExpr, DistinctExpr, NullIfExpr, ScalarArrayOpExpr, BoolExpr, SubLink, SubPlan, AlternativeSubPlan, FieldSelect, FieldStore, RelabelType, CoerceViaIO, ArrayCoerceExpr, ConvertRowtypeExpr, CollateExpr, CaseExpr, CaseWhen, CaseTestExpr, ArrayExpr, RowExpr, RowCompareExpr, CoalesceExpr, MinMaxExpr, SQLValueFunction, XmlExpr, JsonFormat, JsonReturning, JsonValueExpr, JsonConstructorExpr, JsonIsPredicate, JsonBehavior, JsonExpr, JsonTablePath, JsonTablePathScan, JsonTableSiblingJoin, NullTest, BooleanTest, MergeAction, CoerceToDomain, CoerceToDomainValue, SetToDefault, CurrentOfExpr, NextValueExpr, InferenceElem, TargetEntry, RangeTblRef, JoinExpr, FromExpr, OnConflictExpr, Query, TypeName, ColumnRef, ParamRef, A_Expr, TypeCast, CollateClause, RoleSpec, FuncCall, A_Star, A_Indices, A_Indirection, A_ArrayExpr, ResTarget, MultiAssignRef, SortBy, WindowDef, RangeSubselect, RangeFunction, RangeTableFunc, RangeTableFuncCol, RangeTableSample, ColumnDef, TableLikeClause, IndexElem, DefElem, LockingClause, XmlSerialize, PartitionElem, PartitionSpec, PartitionBoundSpec, PartitionRangeDatum, SinglePartitionSpec, PartitionCmd, RangeTblEntry, RTEPermissionInfo, RangeTblFunction, TableSampleClause, WithCheckOption, SortGroupClause, GroupingSet, WindowClause, RowMarkClause, WithClause, InferClause, OnConflictClause, CTESearchClause, CTECycleClause, CommonTableExpr, MergeWhenClause, TriggerTransition, JsonOutput, JsonArgument, JsonFuncExpr, JsonTablePathSpec, JsonTable, JsonTableColumn, JsonKeyValue, JsonParseExpr, JsonScalarExpr, JsonSerializeExpr, JsonObjectConstructor, JsonArrayConstructor, JsonArrayQueryConstructor, JsonAggConstructor, JsonObjectAgg, JsonArrayAgg, RawStmt, InsertStmt, DeleteStmt, UpdateStmt, MergeStmt, SelectStmt, SetOperationStmt, ReturnStmt, PLAssignStmt, CreateSchemaStmt, AlterTableStmt, ReplicaIdentityStmt, AlterTableCmd, AlterCollationStmt, AlterDomainStmt, GrantStmt, ObjectWithArgs, AccessPriv, GrantRoleStmt, AlterDefaultPrivilegesStmt, CopyStmt, VariableSetStmt, VariableShowStmt, CreateStmt, Constraint, CreateTableSpaceStmt, DropTableSpaceStmt, AlterTableSpaceOptionsStmt, AlterTableMoveAllStmt, CreateExtensionStmt, AlterExtensionStmt, AlterExtensionContentsStmt, CreateFdwStmt, AlterFdwStmt, CreateForeignServerStmt, AlterForeignServerStmt, CreateForeignTableStmt, CreateUserMappingStmt, AlterUserMappingStmt, DropUserMappingStmt, ImportForeignSchemaStmt, CreatePolicyStmt, AlterPolicyStmt, CreateAmStmt, CreateTrigStmt, CreateEventTrigStmt, AlterEventTrigStmt, CreatePLangStmt, CreateRoleStmt, AlterRoleStmt, AlterRoleSetStmt, DropRoleStmt, CreateSeqStmt, AlterSeqStmt, DefineStmt, CreateDomainStmt, CreateOpClassStmt, CreateOpClassItem, CreateOpFamilyStmt, AlterOpFamilyStmt, DropStmt, TruncateStmt, CommentStmt, SecLabelStmt, DeclareCursorStmt, ClosePortalStmt, FetchStmt, IndexStmt, CreateStatsStmt, StatsElem, AlterStatsStmt, CreateFunctionStmt, FunctionParameter, AlterFunctionStmt, DoStmt, InlineCodeBlock, CallStmt, CallContext, RenameStmt, AlterObjectDependsStmt, AlterObjectSchemaStmt, AlterOwnerStmt, AlterOperatorStmt, AlterTypeStmt, RuleStmt, NotifyStmt, ListenStmt, UnlistenStmt, TransactionStmt, CompositeTypeStmt, CreateEnumStmt, CreateRangeStmt, AlterEnumStmt, ViewStmt, LoadStmt, CreatedbStmt, AlterDatabaseStmt, AlterDatabaseRefreshCollStmt, AlterDatabaseSetStmt, DropdbStmt, AlterSystemStmt, ClusterStmt, VacuumStmt, VacuumRelation, ExplainStmt, CreateTableAsStmt, RefreshMatViewStmt, CheckPointStmt, DiscardStmt, LockStmt, ConstraintsSetStmt, ReindexStmt, CreateConversionStmt, CreateCastStmt, CreateTransformStmt, PrepareStmt, ExecuteStmt, DeallocateStmt, DropOwnedStmt, ReassignOwnedStmt, AlterTSDictionaryStmt, AlterTSConfigurationStmt, PublicationTable, PublicationObjSpec, CreatePublicationStmt, AlterPublicationStmt, CreateSubscriptionStmt, AlterSubscriptionStmt, DropSubscriptionStmt, ScanToken } from "@pgsql/types"; +export default { + parseResult(_p?: ParseResult): ParseResult { + const _j = {} as ParseResult; + _o.set(_j, "version", _p?.version); + _o.set(_j, "stmts", _p?.stmts); + return _j; + }, + scanResult(_p?: ScanResult): ScanResult { + const _j = {} as ScanResult; + _o.set(_j, "version", _p?.version); + _o.set(_j, "tokens", _p?.tokens); + return _j; + }, + integer(_p?: Integer): Integer { + const _j = {} as Integer; + _o.set(_j, "ival", _p?.ival); + return _j; + }, + float(_p?: Float): Float { + const _j = {} as Float; + _o.set(_j, "fval", _p?.fval); + return _j; + }, + boolean(_p?: Boolean): Boolean { + const _j = {} as Boolean; + _o.set(_j, "boolval", _p?.boolval); + return _j; + }, + string(_p?: String): String { + const _j = {} as String; + _o.set(_j, "sval", _p?.sval); + return _j; + }, + bitString(_p?: BitString): BitString { + const _j = {} as BitString; + _o.set(_j, "bsval", _p?.bsval); + return _j; + }, + list(_p?: List): List { + const _j = {} as List; + _o.set(_j, "items", _p?.items); + return _j; + }, + oidList(_p?: OidList): OidList { + const _j = {} as OidList; + _o.set(_j, "items", _p?.items); + return _j; + }, + intList(_p?: IntList): IntList { + const _j = {} as IntList; + _o.set(_j, "items", _p?.items); + return _j; + }, + aConst(_p?: A_Const): A_Const { + const _j = {} as A_Const; + _o.set(_j, "ival", _p?.ival); + _o.set(_j, "fval", _p?.fval); + _o.set(_j, "boolval", _p?.boolval); + _o.set(_j, "sval", _p?.sval); + _o.set(_j, "bsval", _p?.bsval); + _o.set(_j, "isnull", _p?.isnull); + _o.set(_j, "location", _p?.location); + return _j; + }, + alias(_p?: Alias): Alias { + const _j = {} as Alias; + _o.set(_j, "aliasname", _p?.aliasname); + _o.set(_j, "colnames", _p?.colnames); + return _j; + }, + rangeVar(_p?: RangeVar): RangeVar { + const _j = {} as RangeVar; + _o.set(_j, "catalogname", _p?.catalogname); + _o.set(_j, "schemaname", _p?.schemaname); + _o.set(_j, "relname", _p?.relname); + _o.set(_j, "inh", _p?.inh); + _o.set(_j, "relpersistence", _p?.relpersistence); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "location", _p?.location); + return _j; + }, + tableFunc(_p?: TableFunc): TableFunc { + const _j = {} as TableFunc; + _o.set(_j, "functype", _p?.functype); + _o.set(_j, "ns_uris", _p?.ns_uris); + _o.set(_j, "ns_names", _p?.ns_names); + _o.set(_j, "docexpr", _p?.docexpr); + _o.set(_j, "rowexpr", _p?.rowexpr); + _o.set(_j, "colnames", _p?.colnames); + _o.set(_j, "coltypes", _p?.coltypes); + _o.set(_j, "coltypmods", _p?.coltypmods); + _o.set(_j, "colcollations", _p?.colcollations); + _o.set(_j, "colexprs", _p?.colexprs); + _o.set(_j, "coldefexprs", _p?.coldefexprs); + _o.set(_j, "colvalexprs", _p?.colvalexprs); + _o.set(_j, "passingvalexprs", _p?.passingvalexprs); + _o.set(_j, "notnulls", _p?.notnulls); + _o.set(_j, "plan", _p?.plan); + _o.set(_j, "ordinalitycol", _p?.ordinalitycol); + _o.set(_j, "location", _p?.location); + return _j; + }, + intoClause(_p?: IntoClause): IntoClause { + const _j = {} as IntoClause; + _o.set(_j, "rel", _p?.rel); + _o.set(_j, "colNames", _p?.colNames); + _o.set(_j, "accessMethod", _p?.accessMethod); + _o.set(_j, "options", _p?.options); + _o.set(_j, "onCommit", _p?.onCommit); + _o.set(_j, "tableSpaceName", _p?.tableSpaceName); + _o.set(_j, "viewQuery", _p?.viewQuery); + _o.set(_j, "skipData", _p?.skipData); + return _j; + }, + var(_p?: Var): Var { + const _j = {} as Var; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "varno", _p?.varno); + _o.set(_j, "varattno", _p?.varattno); + _o.set(_j, "vartype", _p?.vartype); + _o.set(_j, "vartypmod", _p?.vartypmod); + _o.set(_j, "varcollid", _p?.varcollid); + _o.set(_j, "varnullingrels", _p?.varnullingrels); + _o.set(_j, "varlevelsup", _p?.varlevelsup); + _o.set(_j, "location", _p?.location); + return _j; + }, + param(_p?: Param): Param { + const _j = {} as Param; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "paramkind", _p?.paramkind); + _o.set(_j, "paramid", _p?.paramid); + _o.set(_j, "paramtype", _p?.paramtype); + _o.set(_j, "paramtypmod", _p?.paramtypmod); + _o.set(_j, "paramcollid", _p?.paramcollid); + _o.set(_j, "location", _p?.location); + return _j; + }, + aggref(_p?: Aggref): Aggref { + const _j = {} as Aggref; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "aggfnoid", _p?.aggfnoid); + _o.set(_j, "aggtype", _p?.aggtype); + _o.set(_j, "aggcollid", _p?.aggcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "aggargtypes", _p?.aggargtypes); + _o.set(_j, "aggdirectargs", _p?.aggdirectargs); + _o.set(_j, "args", _p?.args); + _o.set(_j, "aggorder", _p?.aggorder); + _o.set(_j, "aggdistinct", _p?.aggdistinct); + _o.set(_j, "aggfilter", _p?.aggfilter); + _o.set(_j, "aggstar", _p?.aggstar); + _o.set(_j, "aggvariadic", _p?.aggvariadic); + _o.set(_j, "aggkind", _p?.aggkind); + _o.set(_j, "agglevelsup", _p?.agglevelsup); + _o.set(_j, "aggsplit", _p?.aggsplit); + _o.set(_j, "aggno", _p?.aggno); + _o.set(_j, "aggtransno", _p?.aggtransno); + _o.set(_j, "location", _p?.location); + return _j; + }, + groupingFunc(_p?: GroupingFunc): GroupingFunc { + const _j = {} as GroupingFunc; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "args", _p?.args); + _o.set(_j, "refs", _p?.refs); + _o.set(_j, "agglevelsup", _p?.agglevelsup); + _o.set(_j, "location", _p?.location); + return _j; + }, + windowFunc(_p?: WindowFunc): WindowFunc { + const _j = {} as WindowFunc; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "winfnoid", _p?.winfnoid); + _o.set(_j, "wintype", _p?.wintype); + _o.set(_j, "wincollid", _p?.wincollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "aggfilter", _p?.aggfilter); + _o.set(_j, "runCondition", _p?.runCondition); + _o.set(_j, "winref", _p?.winref); + _o.set(_j, "winstar", _p?.winstar); + _o.set(_j, "winagg", _p?.winagg); + _o.set(_j, "location", _p?.location); + return _j; + }, + windowFuncRunCondition(_p?: WindowFuncRunCondition): WindowFuncRunCondition { + const _j = {} as WindowFuncRunCondition; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "wfunc_left", _p?.wfunc_left); + _o.set(_j, "arg", _p?.arg); + return _j; + }, + mergeSupportFunc(_p?: MergeSupportFunc): MergeSupportFunc { + const _j = {} as MergeSupportFunc; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "msftype", _p?.msftype); + _o.set(_j, "msfcollid", _p?.msfcollid); + _o.set(_j, "location", _p?.location); + return _j; + }, + subscriptingRef(_p?: SubscriptingRef): SubscriptingRef { + const _j = {} as SubscriptingRef; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "refcontainertype", _p?.refcontainertype); + _o.set(_j, "refelemtype", _p?.refelemtype); + _o.set(_j, "refrestype", _p?.refrestype); + _o.set(_j, "reftypmod", _p?.reftypmod); + _o.set(_j, "refcollid", _p?.refcollid); + _o.set(_j, "refupperindexpr", _p?.refupperindexpr); + _o.set(_j, "reflowerindexpr", _p?.reflowerindexpr); + _o.set(_j, "refexpr", _p?.refexpr); + _o.set(_j, "refassgnexpr", _p?.refassgnexpr); + return _j; + }, + funcExpr(_p?: FuncExpr): FuncExpr { + const _j = {} as FuncExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "funcid", _p?.funcid); + _o.set(_j, "funcresulttype", _p?.funcresulttype); + _o.set(_j, "funcretset", _p?.funcretset); + _o.set(_j, "funcvariadic", _p?.funcvariadic); + _o.set(_j, "funcformat", _p?.funcformat); + _o.set(_j, "funccollid", _p?.funccollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + namedArgExpr(_p?: NamedArgExpr): NamedArgExpr { + const _j = {} as NamedArgExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "name", _p?.name); + _o.set(_j, "argnumber", _p?.argnumber); + _o.set(_j, "location", _p?.location); + return _j; + }, + opExpr(_p?: OpExpr): OpExpr { + const _j = {} as OpExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "opresulttype", _p?.opresulttype); + _o.set(_j, "opretset", _p?.opretset); + _o.set(_j, "opcollid", _p?.opcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + distinctExpr(_p?: DistinctExpr): DistinctExpr { + const _j = {} as DistinctExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "opresulttype", _p?.opresulttype); + _o.set(_j, "opretset", _p?.opretset); + _o.set(_j, "opcollid", _p?.opcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + nullIfExpr(_p?: NullIfExpr): NullIfExpr { + const _j = {} as NullIfExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "opresulttype", _p?.opresulttype); + _o.set(_j, "opretset", _p?.opretset); + _o.set(_j, "opcollid", _p?.opcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + scalarArrayOpExpr(_p?: ScalarArrayOpExpr): ScalarArrayOpExpr { + const _j = {} as ScalarArrayOpExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "useOr", _p?.useOr); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + boolExpr(_p?: BoolExpr): BoolExpr { + const _j = {} as BoolExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "boolop", _p?.boolop); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + subLink(_p?: SubLink): SubLink { + const _j = {} as SubLink; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "subLinkType", _p?.subLinkType); + _o.set(_j, "subLinkId", _p?.subLinkId); + _o.set(_j, "testexpr", _p?.testexpr); + _o.set(_j, "operName", _p?.operName); + _o.set(_j, "subselect", _p?.subselect); + _o.set(_j, "location", _p?.location); + return _j; + }, + subPlan(_p?: SubPlan): SubPlan { + const _j = {} as SubPlan; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "subLinkType", _p?.subLinkType); + _o.set(_j, "testexpr", _p?.testexpr); + _o.set(_j, "paramIds", _p?.paramIds); + _o.set(_j, "plan_id", _p?.plan_id); + _o.set(_j, "plan_name", _p?.plan_name); + _o.set(_j, "firstColType", _p?.firstColType); + _o.set(_j, "firstColTypmod", _p?.firstColTypmod); + _o.set(_j, "firstColCollation", _p?.firstColCollation); + _o.set(_j, "useHashTable", _p?.useHashTable); + _o.set(_j, "unknownEqFalse", _p?.unknownEqFalse); + _o.set(_j, "parallel_safe", _p?.parallel_safe); + _o.set(_j, "setParam", _p?.setParam); + _o.set(_j, "parParam", _p?.parParam); + _o.set(_j, "args", _p?.args); + _o.set(_j, "startup_cost", _p?.startup_cost); + _o.set(_j, "per_call_cost", _p?.per_call_cost); + return _j; + }, + alternativeSubPlan(_p?: AlternativeSubPlan): AlternativeSubPlan { + const _j = {} as AlternativeSubPlan; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "subplans", _p?.subplans); + return _j; + }, + fieldSelect(_p?: FieldSelect): FieldSelect { + const _j = {} as FieldSelect; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "fieldnum", _p?.fieldnum); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + return _j; + }, + fieldStore(_p?: FieldStore): FieldStore { + const _j = {} as FieldStore; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "newvals", _p?.newvals); + _o.set(_j, "fieldnums", _p?.fieldnums); + _o.set(_j, "resulttype", _p?.resulttype); + return _j; + }, + relabelType(_p?: RelabelType): RelabelType { + const _j = {} as RelabelType; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "relabelformat", _p?.relabelformat); + _o.set(_j, "location", _p?.location); + return _j; + }, + coerceViaio(_p?: CoerceViaIO): CoerceViaIO { + const _j = {} as CoerceViaIO; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "coerceformat", _p?.coerceformat); + _o.set(_j, "location", _p?.location); + return _j; + }, + arrayCoerceExpr(_p?: ArrayCoerceExpr): ArrayCoerceExpr { + const _j = {} as ArrayCoerceExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "elemexpr", _p?.elemexpr); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "coerceformat", _p?.coerceformat); + _o.set(_j, "location", _p?.location); + return _j; + }, + convertRowtypeExpr(_p?: ConvertRowtypeExpr): ConvertRowtypeExpr { + const _j = {} as ConvertRowtypeExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "convertformat", _p?.convertformat); + _o.set(_j, "location", _p?.location); + return _j; + }, + collateExpr(_p?: CollateExpr): CollateExpr { + const _j = {} as CollateExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "collOid", _p?.collOid); + _o.set(_j, "location", _p?.location); + return _j; + }, + caseExpr(_p?: CaseExpr): CaseExpr { + const _j = {} as CaseExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "casetype", _p?.casetype); + _o.set(_j, "casecollid", _p?.casecollid); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "args", _p?.args); + _o.set(_j, "defresult", _p?.defresult); + _o.set(_j, "location", _p?.location); + return _j; + }, + caseWhen(_p?: CaseWhen): CaseWhen { + const _j = {} as CaseWhen; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "result", _p?.result); + _o.set(_j, "location", _p?.location); + return _j; + }, + caseTestExpr(_p?: CaseTestExpr): CaseTestExpr { + const _j = {} as CaseTestExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "typeId", _p?.typeId); + _o.set(_j, "typeMod", _p?.typeMod); + _o.set(_j, "collation", _p?.collation); + return _j; + }, + arrayExpr(_p?: ArrayExpr): ArrayExpr { + const _j = {} as ArrayExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "array_typeid", _p?.array_typeid); + _o.set(_j, "array_collid", _p?.array_collid); + _o.set(_j, "element_typeid", _p?.element_typeid); + _o.set(_j, "elements", _p?.elements); + _o.set(_j, "multidims", _p?.multidims); + _o.set(_j, "location", _p?.location); + return _j; + }, + rowExpr(_p?: RowExpr): RowExpr { + const _j = {} as RowExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "args", _p?.args); + _o.set(_j, "row_typeid", _p?.row_typeid); + _o.set(_j, "row_format", _p?.row_format); + _o.set(_j, "colnames", _p?.colnames); + _o.set(_j, "location", _p?.location); + return _j; + }, + rowCompareExpr(_p?: RowCompareExpr): RowCompareExpr { + const _j = {} as RowCompareExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "rctype", _p?.rctype); + _o.set(_j, "opnos", _p?.opnos); + _o.set(_j, "opfamilies", _p?.opfamilies); + _o.set(_j, "inputcollids", _p?.inputcollids); + _o.set(_j, "largs", _p?.largs); + _o.set(_j, "rargs", _p?.rargs); + return _j; + }, + coalesceExpr(_p?: CoalesceExpr): CoalesceExpr { + const _j = {} as CoalesceExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "coalescetype", _p?.coalescetype); + _o.set(_j, "coalescecollid", _p?.coalescecollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + minMaxExpr(_p?: MinMaxExpr): MinMaxExpr { + const _j = {} as MinMaxExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "minmaxtype", _p?.minmaxtype); + _o.set(_j, "minmaxcollid", _p?.minmaxcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "op", _p?.op); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return _j; + }, + sqlValueFunction(_p?: SQLValueFunction): SQLValueFunction { + const _j = {} as SQLValueFunction; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "op", _p?.op); + _o.set(_j, "type", _p?.type); + _o.set(_j, "typmod", _p?.typmod); + _o.set(_j, "location", _p?.location); + return _j; + }, + xmlExpr(_p?: XmlExpr): XmlExpr { + const _j = {} as XmlExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "op", _p?.op); + _o.set(_j, "name", _p?.name); + _o.set(_j, "named_args", _p?.named_args); + _o.set(_j, "arg_names", _p?.arg_names); + _o.set(_j, "args", _p?.args); + _o.set(_j, "xmloption", _p?.xmloption); + _o.set(_j, "indent", _p?.indent); + _o.set(_j, "type", _p?.type); + _o.set(_j, "typmod", _p?.typmod); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonFormat(_p?: JsonFormat): JsonFormat { + const _j = {} as JsonFormat; + _o.set(_j, "format_type", _p?.format_type); + _o.set(_j, "encoding", _p?.encoding); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonReturning(_p?: JsonReturning): JsonReturning { + const _j = {} as JsonReturning; + _o.set(_j, "format", _p?.format); + _o.set(_j, "typid", _p?.typid); + _o.set(_j, "typmod", _p?.typmod); + return _j; + }, + jsonValueExpr(_p?: JsonValueExpr): JsonValueExpr { + const _j = {} as JsonValueExpr; + _o.set(_j, "raw_expr", _p?.raw_expr); + _o.set(_j, "formatted_expr", _p?.formatted_expr); + _o.set(_j, "format", _p?.format); + return _j; + }, + jsonConstructorExpr(_p?: JsonConstructorExpr): JsonConstructorExpr { + const _j = {} as JsonConstructorExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "type", _p?.type); + _o.set(_j, "args", _p?.args); + _o.set(_j, "func", _p?.func); + _o.set(_j, "coercion", _p?.coercion); + _o.set(_j, "returning", _p?.returning); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "unique", _p?.unique); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonIsPredicate(_p?: JsonIsPredicate): JsonIsPredicate { + const _j = {} as JsonIsPredicate; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "format", _p?.format); + _o.set(_j, "item_type", _p?.item_type); + _o.set(_j, "unique_keys", _p?.unique_keys); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonBehavior(_p?: JsonBehavior): JsonBehavior { + const _j = {} as JsonBehavior; + _o.set(_j, "btype", _p?.btype); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "coerce", _p?.coerce); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonExpr(_p?: JsonExpr): JsonExpr { + const _j = {} as JsonExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "op", _p?.op); + _o.set(_j, "column_name", _p?.column_name); + _o.set(_j, "formatted_expr", _p?.formatted_expr); + _o.set(_j, "format", _p?.format); + _o.set(_j, "path_spec", _p?.path_spec); + _o.set(_j, "returning", _p?.returning); + _o.set(_j, "passing_names", _p?.passing_names); + _o.set(_j, "passing_values", _p?.passing_values); + _o.set(_j, "on_empty", _p?.on_empty); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "use_io_coercion", _p?.use_io_coercion); + _o.set(_j, "use_json_coercion", _p?.use_json_coercion); + _o.set(_j, "wrapper", _p?.wrapper); + _o.set(_j, "omit_quotes", _p?.omit_quotes); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonTablePath(_p?: JsonTablePath): JsonTablePath { + const _j = {} as JsonTablePath; + _o.set(_j, "name", _p?.name); + return _j; + }, + jsonTablePathScan(_p?: JsonTablePathScan): JsonTablePathScan { + const _j = {} as JsonTablePathScan; + _o.set(_j, "plan", _p?.plan); + _o.set(_j, "path", _p?.path); + _o.set(_j, "errorOnError", _p?.errorOnError); + _o.set(_j, "child", _p?.child); + _o.set(_j, "colMin", _p?.colMin); + _o.set(_j, "colMax", _p?.colMax); + return _j; + }, + jsonTableSiblingJoin(_p?: JsonTableSiblingJoin): JsonTableSiblingJoin { + const _j = {} as JsonTableSiblingJoin; + _o.set(_j, "plan", _p?.plan); + _o.set(_j, "lplan", _p?.lplan); + _o.set(_j, "rplan", _p?.rplan); + return _j; + }, + nullTest(_p?: NullTest): NullTest { + const _j = {} as NullTest; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "nulltesttype", _p?.nulltesttype); + _o.set(_j, "argisrow", _p?.argisrow); + _o.set(_j, "location", _p?.location); + return _j; + }, + booleanTest(_p?: BooleanTest): BooleanTest { + const _j = {} as BooleanTest; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "booltesttype", _p?.booltesttype); + _o.set(_j, "location", _p?.location); + return _j; + }, + mergeAction(_p?: MergeAction): MergeAction { + const _j = {} as MergeAction; + _o.set(_j, "matchKind", _p?.matchKind); + _o.set(_j, "commandType", _p?.commandType); + _o.set(_j, "override", _p?.override); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "updateColnos", _p?.updateColnos); + return _j; + }, + coerceToDomain(_p?: CoerceToDomain): CoerceToDomain { + const _j = {} as CoerceToDomain; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "coercionformat", _p?.coercionformat); + _o.set(_j, "location", _p?.location); + return _j; + }, + coerceToDomainValue(_p?: CoerceToDomainValue): CoerceToDomainValue { + const _j = {} as CoerceToDomainValue; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "typeId", _p?.typeId); + _o.set(_j, "typeMod", _p?.typeMod); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "location", _p?.location); + return _j; + }, + setToDefault(_p?: SetToDefault): SetToDefault { + const _j = {} as SetToDefault; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "typeId", _p?.typeId); + _o.set(_j, "typeMod", _p?.typeMod); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "location", _p?.location); + return _j; + }, + currentOfExpr(_p?: CurrentOfExpr): CurrentOfExpr { + const _j = {} as CurrentOfExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "cvarno", _p?.cvarno); + _o.set(_j, "cursor_name", _p?.cursor_name); + _o.set(_j, "cursor_param", _p?.cursor_param); + return _j; + }, + nextValueExpr(_p?: NextValueExpr): NextValueExpr { + const _j = {} as NextValueExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "seqid", _p?.seqid); + _o.set(_j, "typeId", _p?.typeId); + return _j; + }, + inferenceElem(_p?: InferenceElem): InferenceElem { + const _j = {} as InferenceElem; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "infercollid", _p?.infercollid); + _o.set(_j, "inferopclass", _p?.inferopclass); + return _j; + }, + targetEntry(_p?: TargetEntry): TargetEntry { + const _j = {} as TargetEntry; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "resno", _p?.resno); + _o.set(_j, "resname", _p?.resname); + _o.set(_j, "ressortgroupref", _p?.ressortgroupref); + _o.set(_j, "resorigtbl", _p?.resorigtbl); + _o.set(_j, "resorigcol", _p?.resorigcol); + _o.set(_j, "resjunk", _p?.resjunk); + return _j; + }, + rangeTblRef(_p?: RangeTblRef): RangeTblRef { + const _j = {} as RangeTblRef; + _o.set(_j, "rtindex", _p?.rtindex); + return _j; + }, + joinExpr(_p?: JoinExpr): JoinExpr { + const _j = {} as JoinExpr; + _o.set(_j, "jointype", _p?.jointype); + _o.set(_j, "isNatural", _p?.isNatural); + _o.set(_j, "larg", _p?.larg); + _o.set(_j, "rarg", _p?.rarg); + _o.set(_j, "usingClause", _p?.usingClause); + _o.set(_j, "join_using_alias", _p?.join_using_alias); + _o.set(_j, "quals", _p?.quals); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "rtindex", _p?.rtindex); + return _j; + }, + fromExpr(_p?: FromExpr): FromExpr { + const _j = {} as FromExpr; + _o.set(_j, "fromlist", _p?.fromlist); + _o.set(_j, "quals", _p?.quals); + return _j; + }, + onConflictExpr(_p?: OnConflictExpr): OnConflictExpr { + const _j = {} as OnConflictExpr; + _o.set(_j, "action", _p?.action); + _o.set(_j, "arbiterElems", _p?.arbiterElems); + _o.set(_j, "arbiterWhere", _p?.arbiterWhere); + _o.set(_j, "constraint", _p?.constraint); + _o.set(_j, "onConflictSet", _p?.onConflictSet); + _o.set(_j, "onConflictWhere", _p?.onConflictWhere); + _o.set(_j, "exclRelIndex", _p?.exclRelIndex); + _o.set(_j, "exclRelTlist", _p?.exclRelTlist); + return _j; + }, + query(_p?: Query): Query { + const _j = {} as Query; + _o.set(_j, "commandType", _p?.commandType); + _o.set(_j, "querySource", _p?.querySource); + _o.set(_j, "canSetTag", _p?.canSetTag); + _o.set(_j, "utilityStmt", _p?.utilityStmt); + _o.set(_j, "resultRelation", _p?.resultRelation); + _o.set(_j, "hasAggs", _p?.hasAggs); + _o.set(_j, "hasWindowFuncs", _p?.hasWindowFuncs); + _o.set(_j, "hasTargetSRFs", _p?.hasTargetSRFs); + _o.set(_j, "hasSubLinks", _p?.hasSubLinks); + _o.set(_j, "hasDistinctOn", _p?.hasDistinctOn); + _o.set(_j, "hasRecursive", _p?.hasRecursive); + _o.set(_j, "hasModifyingCTE", _p?.hasModifyingCTE); + _o.set(_j, "hasForUpdate", _p?.hasForUpdate); + _o.set(_j, "hasRowSecurity", _p?.hasRowSecurity); + _o.set(_j, "isReturn", _p?.isReturn); + _o.set(_j, "cteList", _p?.cteList); + _o.set(_j, "rtable", _p?.rtable); + _o.set(_j, "rteperminfos", _p?.rteperminfos); + _o.set(_j, "jointree", _p?.jointree); + _o.set(_j, "mergeActionList", _p?.mergeActionList); + _o.set(_j, "mergeTargetRelation", _p?.mergeTargetRelation); + _o.set(_j, "mergeJoinCondition", _p?.mergeJoinCondition); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "override", _p?.override); + _o.set(_j, "onConflict", _p?.onConflict); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "groupClause", _p?.groupClause); + _o.set(_j, "groupDistinct", _p?.groupDistinct); + _o.set(_j, "groupingSets", _p?.groupingSets); + _o.set(_j, "havingQual", _p?.havingQual); + _o.set(_j, "windowClause", _p?.windowClause); + _o.set(_j, "distinctClause", _p?.distinctClause); + _o.set(_j, "sortClause", _p?.sortClause); + _o.set(_j, "limitOffset", _p?.limitOffset); + _o.set(_j, "limitCount", _p?.limitCount); + _o.set(_j, "limitOption", _p?.limitOption); + _o.set(_j, "rowMarks", _p?.rowMarks); + _o.set(_j, "setOperations", _p?.setOperations); + _o.set(_j, "constraintDeps", _p?.constraintDeps); + _o.set(_j, "withCheckOptions", _p?.withCheckOptions); + _o.set(_j, "stmt_location", _p?.stmt_location); + _o.set(_j, "stmt_len", _p?.stmt_len); + return _j; + }, + typeName(_p?: TypeName): TypeName { + const _j = {} as TypeName; + _o.set(_j, "names", _p?.names); + _o.set(_j, "typeOid", _p?.typeOid); + _o.set(_j, "setof", _p?.setof); + _o.set(_j, "pct_type", _p?.pct_type); + _o.set(_j, "typmods", _p?.typmods); + _o.set(_j, "typemod", _p?.typemod); + _o.set(_j, "arrayBounds", _p?.arrayBounds); + _o.set(_j, "location", _p?.location); + return _j; + }, + columnRef(_p?: ColumnRef): ColumnRef { + const _j = {} as ColumnRef; + _o.set(_j, "fields", _p?.fields); + _o.set(_j, "location", _p?.location); + return _j; + }, + paramRef(_p?: ParamRef): ParamRef { + const _j = {} as ParamRef; + _o.set(_j, "number", _p?.number); + _o.set(_j, "location", _p?.location); + return _j; + }, + aExpr(_p?: A_Expr): A_Expr { + const _j = {} as A_Expr; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "name", _p?.name); + _o.set(_j, "lexpr", _p?.lexpr); + _o.set(_j, "rexpr", _p?.rexpr); + _o.set(_j, "location", _p?.location); + return _j; + }, + typeCast(_p?: TypeCast): TypeCast { + const _j = {} as TypeCast; + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "location", _p?.location); + return _j; + }, + collateClause(_p?: CollateClause): CollateClause { + const _j = {} as CollateClause; + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "collname", _p?.collname); + _o.set(_j, "location", _p?.location); + return _j; + }, + roleSpec(_p?: RoleSpec): RoleSpec { + const _j = {} as RoleSpec; + _o.set(_j, "roletype", _p?.roletype); + _o.set(_j, "rolename", _p?.rolename); + _o.set(_j, "location", _p?.location); + return _j; + }, + funcCall(_p?: FuncCall): FuncCall { + const _j = {} as FuncCall; + _o.set(_j, "funcname", _p?.funcname); + _o.set(_j, "args", _p?.args); + _o.set(_j, "agg_order", _p?.agg_order); + _o.set(_j, "agg_filter", _p?.agg_filter); + _o.set(_j, "over", _p?.over); + _o.set(_j, "agg_within_group", _p?.agg_within_group); + _o.set(_j, "agg_star", _p?.agg_star); + _o.set(_j, "agg_distinct", _p?.agg_distinct); + _o.set(_j, "func_variadic", _p?.func_variadic); + _o.set(_j, "funcformat", _p?.funcformat); + _o.set(_j, "location", _p?.location); + return _j; + }, + aStar(_p?: A_Star): A_Star { + const _j = {} as A_Star; + return _j; + }, + aIndices(_p?: A_Indices): A_Indices { + const _j = {} as A_Indices; + _o.set(_j, "is_slice", _p?.is_slice); + _o.set(_j, "lidx", _p?.lidx); + _o.set(_j, "uidx", _p?.uidx); + return _j; + }, + aIndirection(_p?: A_Indirection): A_Indirection { + const _j = {} as A_Indirection; + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "indirection", _p?.indirection); + return _j; + }, + aArrayExpr(_p?: A_ArrayExpr): A_ArrayExpr { + const _j = {} as A_ArrayExpr; + _o.set(_j, "elements", _p?.elements); + _o.set(_j, "location", _p?.location); + return _j; + }, + resTarget(_p?: ResTarget): ResTarget { + const _j = {} as ResTarget; + _o.set(_j, "name", _p?.name); + _o.set(_j, "indirection", _p?.indirection); + _o.set(_j, "val", _p?.val); + _o.set(_j, "location", _p?.location); + return _j; + }, + multiAssignRef(_p?: MultiAssignRef): MultiAssignRef { + const _j = {} as MultiAssignRef; + _o.set(_j, "source", _p?.source); + _o.set(_j, "colno", _p?.colno); + _o.set(_j, "ncolumns", _p?.ncolumns); + return _j; + }, + sortBy(_p?: SortBy): SortBy { + const _j = {} as SortBy; + _o.set(_j, "node", _p?.node); + _o.set(_j, "sortby_dir", _p?.sortby_dir); + _o.set(_j, "sortby_nulls", _p?.sortby_nulls); + _o.set(_j, "useOp", _p?.useOp); + _o.set(_j, "location", _p?.location); + return _j; + }, + windowDef(_p?: WindowDef): WindowDef { + const _j = {} as WindowDef; + _o.set(_j, "name", _p?.name); + _o.set(_j, "refname", _p?.refname); + _o.set(_j, "partitionClause", _p?.partitionClause); + _o.set(_j, "orderClause", _p?.orderClause); + _o.set(_j, "frameOptions", _p?.frameOptions); + _o.set(_j, "startOffset", _p?.startOffset); + _o.set(_j, "endOffset", _p?.endOffset); + _o.set(_j, "location", _p?.location); + return _j; + }, + rangeSubselect(_p?: RangeSubselect): RangeSubselect { + const _j = {} as RangeSubselect; + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "subquery", _p?.subquery); + _o.set(_j, "alias", _p?.alias); + return _j; + }, + rangeFunction(_p?: RangeFunction): RangeFunction { + const _j = {} as RangeFunction; + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "ordinality", _p?.ordinality); + _o.set(_j, "is_rowsfrom", _p?.is_rowsfrom); + _o.set(_j, "functions", _p?.functions); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "coldeflist", _p?.coldeflist); + return _j; + }, + rangeTableFunc(_p?: RangeTableFunc): RangeTableFunc { + const _j = {} as RangeTableFunc; + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "docexpr", _p?.docexpr); + _o.set(_j, "rowexpr", _p?.rowexpr); + _o.set(_j, "namespaces", _p?.namespaces); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "location", _p?.location); + return _j; + }, + rangeTableFuncCol(_p?: RangeTableFuncCol): RangeTableFuncCol { + const _j = {} as RangeTableFuncCol; + _o.set(_j, "colname", _p?.colname); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "for_ordinality", _p?.for_ordinality); + _o.set(_j, "is_not_null", _p?.is_not_null); + _o.set(_j, "colexpr", _p?.colexpr); + _o.set(_j, "coldefexpr", _p?.coldefexpr); + _o.set(_j, "location", _p?.location); + return _j; + }, + rangeTableSample(_p?: RangeTableSample): RangeTableSample { + const _j = {} as RangeTableSample; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "method", _p?.method); + _o.set(_j, "args", _p?.args); + _o.set(_j, "repeatable", _p?.repeatable); + _o.set(_j, "location", _p?.location); + return _j; + }, + columnDef(_p?: ColumnDef): ColumnDef { + const _j = {} as ColumnDef; + _o.set(_j, "colname", _p?.colname); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "compression", _p?.compression); + _o.set(_j, "inhcount", _p?.inhcount); + _o.set(_j, "is_local", _p?.is_local); + _o.set(_j, "is_not_null", _p?.is_not_null); + _o.set(_j, "is_from_type", _p?.is_from_type); + _o.set(_j, "storage", _p?.storage); + _o.set(_j, "storage_name", _p?.storage_name); + _o.set(_j, "raw_default", _p?.raw_default); + _o.set(_j, "cooked_default", _p?.cooked_default); + _o.set(_j, "identity", _p?.identity); + _o.set(_j, "identitySequence", _p?.identitySequence); + _o.set(_j, "generated", _p?.generated); + _o.set(_j, "collClause", _p?.collClause); + _o.set(_j, "collOid", _p?.collOid); + _o.set(_j, "constraints", _p?.constraints); + _o.set(_j, "fdwoptions", _p?.fdwoptions); + _o.set(_j, "location", _p?.location); + return _j; + }, + tableLikeClause(_p?: TableLikeClause): TableLikeClause { + const _j = {} as TableLikeClause; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "options", _p?.options); + _o.set(_j, "relationOid", _p?.relationOid); + return _j; + }, + indexElem(_p?: IndexElem): IndexElem { + const _j = {} as IndexElem; + _o.set(_j, "name", _p?.name); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "indexcolname", _p?.indexcolname); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "opclass", _p?.opclass); + _o.set(_j, "opclassopts", _p?.opclassopts); + _o.set(_j, "ordering", _p?.ordering); + _o.set(_j, "nulls_ordering", _p?.nulls_ordering); + return _j; + }, + defElem(_p?: DefElem): DefElem { + const _j = {} as DefElem; + _o.set(_j, "defnamespace", _p?.defnamespace); + _o.set(_j, "defname", _p?.defname); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "defaction", _p?.defaction); + _o.set(_j, "location", _p?.location); + return _j; + }, + lockingClause(_p?: LockingClause): LockingClause { + const _j = {} as LockingClause; + _o.set(_j, "lockedRels", _p?.lockedRels); + _o.set(_j, "strength", _p?.strength); + _o.set(_j, "waitPolicy", _p?.waitPolicy); + return _j; + }, + xmlSerialize(_p?: XmlSerialize): XmlSerialize { + const _j = {} as XmlSerialize; + _o.set(_j, "xmloption", _p?.xmloption); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "indent", _p?.indent); + _o.set(_j, "location", _p?.location); + return _j; + }, + partitionElem(_p?: PartitionElem): PartitionElem { + const _j = {} as PartitionElem; + _o.set(_j, "name", _p?.name); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "opclass", _p?.opclass); + _o.set(_j, "location", _p?.location); + return _j; + }, + partitionSpec(_p?: PartitionSpec): PartitionSpec { + const _j = {} as PartitionSpec; + _o.set(_j, "strategy", _p?.strategy); + _o.set(_j, "partParams", _p?.partParams); + _o.set(_j, "location", _p?.location); + return _j; + }, + partitionBoundSpec(_p?: PartitionBoundSpec): PartitionBoundSpec { + const _j = {} as PartitionBoundSpec; + _o.set(_j, "strategy", _p?.strategy); + _o.set(_j, "is_default", _p?.is_default); + _o.set(_j, "modulus", _p?.modulus); + _o.set(_j, "remainder", _p?.remainder); + _o.set(_j, "listdatums", _p?.listdatums); + _o.set(_j, "lowerdatums", _p?.lowerdatums); + _o.set(_j, "upperdatums", _p?.upperdatums); + _o.set(_j, "location", _p?.location); + return _j; + }, + partitionRangeDatum(_p?: PartitionRangeDatum): PartitionRangeDatum { + const _j = {} as PartitionRangeDatum; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "value", _p?.value); + _o.set(_j, "location", _p?.location); + return _j; + }, + singlePartitionSpec(_p?: SinglePartitionSpec): SinglePartitionSpec { + const _j = {} as SinglePartitionSpec; + return _j; + }, + partitionCmd(_p?: PartitionCmd): PartitionCmd { + const _j = {} as PartitionCmd; + _o.set(_j, "name", _p?.name); + _o.set(_j, "bound", _p?.bound); + _o.set(_j, "concurrent", _p?.concurrent); + return _j; + }, + rangeTblEntry(_p?: RangeTblEntry): RangeTblEntry { + const _j = {} as RangeTblEntry; + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "eref", _p?.eref); + _o.set(_j, "rtekind", _p?.rtekind); + _o.set(_j, "relid", _p?.relid); + _o.set(_j, "inh", _p?.inh); + _o.set(_j, "relkind", _p?.relkind); + _o.set(_j, "rellockmode", _p?.rellockmode); + _o.set(_j, "perminfoindex", _p?.perminfoindex); + _o.set(_j, "tablesample", _p?.tablesample); + _o.set(_j, "subquery", _p?.subquery); + _o.set(_j, "security_barrier", _p?.security_barrier); + _o.set(_j, "jointype", _p?.jointype); + _o.set(_j, "joinmergedcols", _p?.joinmergedcols); + _o.set(_j, "joinaliasvars", _p?.joinaliasvars); + _o.set(_j, "joinleftcols", _p?.joinleftcols); + _o.set(_j, "joinrightcols", _p?.joinrightcols); + _o.set(_j, "join_using_alias", _p?.join_using_alias); + _o.set(_j, "functions", _p?.functions); + _o.set(_j, "funcordinality", _p?.funcordinality); + _o.set(_j, "tablefunc", _p?.tablefunc); + _o.set(_j, "values_lists", _p?.values_lists); + _o.set(_j, "ctename", _p?.ctename); + _o.set(_j, "ctelevelsup", _p?.ctelevelsup); + _o.set(_j, "self_reference", _p?.self_reference); + _o.set(_j, "coltypes", _p?.coltypes); + _o.set(_j, "coltypmods", _p?.coltypmods); + _o.set(_j, "colcollations", _p?.colcollations); + _o.set(_j, "enrname", _p?.enrname); + _o.set(_j, "enrtuples", _p?.enrtuples); + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "inFromCl", _p?.inFromCl); + _o.set(_j, "securityQuals", _p?.securityQuals); + return _j; + }, + rtePermissionInfo(_p?: RTEPermissionInfo): RTEPermissionInfo { + const _j = {} as RTEPermissionInfo; + _o.set(_j, "relid", _p?.relid); + _o.set(_j, "inh", _p?.inh); + _o.set(_j, "requiredPerms", _p?.requiredPerms); + _o.set(_j, "checkAsUser", _p?.checkAsUser); + _o.set(_j, "selectedCols", _p?.selectedCols); + _o.set(_j, "insertedCols", _p?.insertedCols); + _o.set(_j, "updatedCols", _p?.updatedCols); + return _j; + }, + rangeTblFunction(_p?: RangeTblFunction): RangeTblFunction { + const _j = {} as RangeTblFunction; + _o.set(_j, "funcexpr", _p?.funcexpr); + _o.set(_j, "funccolcount", _p?.funccolcount); + _o.set(_j, "funccolnames", _p?.funccolnames); + _o.set(_j, "funccoltypes", _p?.funccoltypes); + _o.set(_j, "funccoltypmods", _p?.funccoltypmods); + _o.set(_j, "funccolcollations", _p?.funccolcollations); + _o.set(_j, "funcparams", _p?.funcparams); + return _j; + }, + tableSampleClause(_p?: TableSampleClause): TableSampleClause { + const _j = {} as TableSampleClause; + _o.set(_j, "tsmhandler", _p?.tsmhandler); + _o.set(_j, "args", _p?.args); + _o.set(_j, "repeatable", _p?.repeatable); + return _j; + }, + withCheckOption(_p?: WithCheckOption): WithCheckOption { + const _j = {} as WithCheckOption; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "relname", _p?.relname); + _o.set(_j, "polname", _p?.polname); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "cascaded", _p?.cascaded); + return _j; + }, + sortGroupClause(_p?: SortGroupClause): SortGroupClause { + const _j = {} as SortGroupClause; + _o.set(_j, "tleSortGroupRef", _p?.tleSortGroupRef); + _o.set(_j, "eqop", _p?.eqop); + _o.set(_j, "sortop", _p?.sortop); + _o.set(_j, "nulls_first", _p?.nulls_first); + _o.set(_j, "hashable", _p?.hashable); + return _j; + }, + groupingSet(_p?: GroupingSet): GroupingSet { + const _j = {} as GroupingSet; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "content", _p?.content); + _o.set(_j, "location", _p?.location); + return _j; + }, + windowClause(_p?: WindowClause): WindowClause { + const _j = {} as WindowClause; + _o.set(_j, "name", _p?.name); + _o.set(_j, "refname", _p?.refname); + _o.set(_j, "partitionClause", _p?.partitionClause); + _o.set(_j, "orderClause", _p?.orderClause); + _o.set(_j, "frameOptions", _p?.frameOptions); + _o.set(_j, "startOffset", _p?.startOffset); + _o.set(_j, "endOffset", _p?.endOffset); + _o.set(_j, "startInRangeFunc", _p?.startInRangeFunc); + _o.set(_j, "endInRangeFunc", _p?.endInRangeFunc); + _o.set(_j, "inRangeColl", _p?.inRangeColl); + _o.set(_j, "inRangeAsc", _p?.inRangeAsc); + _o.set(_j, "inRangeNullsFirst", _p?.inRangeNullsFirst); + _o.set(_j, "winref", _p?.winref); + _o.set(_j, "copiedOrder", _p?.copiedOrder); + return _j; + }, + rowMarkClause(_p?: RowMarkClause): RowMarkClause { + const _j = {} as RowMarkClause; + _o.set(_j, "rti", _p?.rti); + _o.set(_j, "strength", _p?.strength); + _o.set(_j, "waitPolicy", _p?.waitPolicy); + _o.set(_j, "pushedDown", _p?.pushedDown); + return _j; + }, + withClause(_p?: WithClause): WithClause { + const _j = {} as WithClause; + _o.set(_j, "ctes", _p?.ctes); + _o.set(_j, "recursive", _p?.recursive); + _o.set(_j, "location", _p?.location); + return _j; + }, + inferClause(_p?: InferClause): InferClause { + const _j = {} as InferClause; + _o.set(_j, "indexElems", _p?.indexElems); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "conname", _p?.conname); + _o.set(_j, "location", _p?.location); + return _j; + }, + onConflictClause(_p?: OnConflictClause): OnConflictClause { + const _j = {} as OnConflictClause; + _o.set(_j, "action", _p?.action); + _o.set(_j, "infer", _p?.infer); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "location", _p?.location); + return _j; + }, + cteSearchClause(_p?: CTESearchClause): CTESearchClause { + const _j = {} as CTESearchClause; + _o.set(_j, "search_col_list", _p?.search_col_list); + _o.set(_j, "search_breadth_first", _p?.search_breadth_first); + _o.set(_j, "search_seq_column", _p?.search_seq_column); + _o.set(_j, "location", _p?.location); + return _j; + }, + cteCycleClause(_p?: CTECycleClause): CTECycleClause { + const _j = {} as CTECycleClause; + _o.set(_j, "cycle_col_list", _p?.cycle_col_list); + _o.set(_j, "cycle_mark_column", _p?.cycle_mark_column); + _o.set(_j, "cycle_mark_value", _p?.cycle_mark_value); + _o.set(_j, "cycle_mark_default", _p?.cycle_mark_default); + _o.set(_j, "cycle_path_column", _p?.cycle_path_column); + _o.set(_j, "location", _p?.location); + _o.set(_j, "cycle_mark_type", _p?.cycle_mark_type); + _o.set(_j, "cycle_mark_typmod", _p?.cycle_mark_typmod); + _o.set(_j, "cycle_mark_collation", _p?.cycle_mark_collation); + _o.set(_j, "cycle_mark_neop", _p?.cycle_mark_neop); + return _j; + }, + commonTableExpr(_p?: CommonTableExpr): CommonTableExpr { + const _j = {} as CommonTableExpr; + _o.set(_j, "ctename", _p?.ctename); + _o.set(_j, "aliascolnames", _p?.aliascolnames); + _o.set(_j, "ctematerialized", _p?.ctematerialized); + _o.set(_j, "ctequery", _p?.ctequery); + _o.set(_j, "search_clause", _p?.search_clause); + _o.set(_j, "cycle_clause", _p?.cycle_clause); + _o.set(_j, "location", _p?.location); + _o.set(_j, "cterecursive", _p?.cterecursive); + _o.set(_j, "cterefcount", _p?.cterefcount); + _o.set(_j, "ctecolnames", _p?.ctecolnames); + _o.set(_j, "ctecoltypes", _p?.ctecoltypes); + _o.set(_j, "ctecoltypmods", _p?.ctecoltypmods); + _o.set(_j, "ctecolcollations", _p?.ctecolcollations); + return _j; + }, + mergeWhenClause(_p?: MergeWhenClause): MergeWhenClause { + const _j = {} as MergeWhenClause; + _o.set(_j, "matchKind", _p?.matchKind); + _o.set(_j, "commandType", _p?.commandType); + _o.set(_j, "override", _p?.override); + _o.set(_j, "condition", _p?.condition); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "values", _p?.values); + return _j; + }, + triggerTransition(_p?: TriggerTransition): TriggerTransition { + const _j = {} as TriggerTransition; + _o.set(_j, "name", _p?.name); + _o.set(_j, "isNew", _p?.isNew); + _o.set(_j, "isTable", _p?.isTable); + return _j; + }, + jsonOutput(_p?: JsonOutput): JsonOutput { + const _j = {} as JsonOutput; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "returning", _p?.returning); + return _j; + }, + jsonArgument(_p?: JsonArgument): JsonArgument { + const _j = {} as JsonArgument; + _o.set(_j, "val", _p?.val); + _o.set(_j, "name", _p?.name); + return _j; + }, + jsonFuncExpr(_p?: JsonFuncExpr): JsonFuncExpr { + const _j = {} as JsonFuncExpr; + _o.set(_j, "op", _p?.op); + _o.set(_j, "column_name", _p?.column_name); + _o.set(_j, "context_item", _p?.context_item); + _o.set(_j, "pathspec", _p?.pathspec); + _o.set(_j, "passing", _p?.passing); + _o.set(_j, "output", _p?.output); + _o.set(_j, "on_empty", _p?.on_empty); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "wrapper", _p?.wrapper); + _o.set(_j, "quotes", _p?.quotes); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonTablePathSpec(_p?: JsonTablePathSpec): JsonTablePathSpec { + const _j = {} as JsonTablePathSpec; + _o.set(_j, "string", _p?.string); + _o.set(_j, "name", _p?.name); + _o.set(_j, "name_location", _p?.name_location); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonTable(_p?: JsonTable): JsonTable { + const _j = {} as JsonTable; + _o.set(_j, "context_item", _p?.context_item); + _o.set(_j, "pathspec", _p?.pathspec); + _o.set(_j, "passing", _p?.passing); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonTableColumn(_p?: JsonTableColumn): JsonTableColumn { + const _j = {} as JsonTableColumn; + _o.set(_j, "coltype", _p?.coltype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "pathspec", _p?.pathspec); + _o.set(_j, "format", _p?.format); + _o.set(_j, "wrapper", _p?.wrapper); + _o.set(_j, "quotes", _p?.quotes); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "on_empty", _p?.on_empty); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonKeyValue(_p?: JsonKeyValue): JsonKeyValue { + const _j = {} as JsonKeyValue; + _o.set(_j, "key", _p?.key); + _o.set(_j, "value", _p?.value); + return _j; + }, + jsonParseExpr(_p?: JsonParseExpr): JsonParseExpr { + const _j = {} as JsonParseExpr; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "output", _p?.output); + _o.set(_j, "unique_keys", _p?.unique_keys); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonScalarExpr(_p?: JsonScalarExpr): JsonScalarExpr { + const _j = {} as JsonScalarExpr; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "output", _p?.output); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonSerializeExpr(_p?: JsonSerializeExpr): JsonSerializeExpr { + const _j = {} as JsonSerializeExpr; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "output", _p?.output); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonObjectConstructor(_p?: JsonObjectConstructor): JsonObjectConstructor { + const _j = {} as JsonObjectConstructor; + _o.set(_j, "exprs", _p?.exprs); + _o.set(_j, "output", _p?.output); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "unique", _p?.unique); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonArrayConstructor(_p?: JsonArrayConstructor): JsonArrayConstructor { + const _j = {} as JsonArrayConstructor; + _o.set(_j, "exprs", _p?.exprs); + _o.set(_j, "output", _p?.output); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonArrayQueryConstructor(_p?: JsonArrayQueryConstructor): JsonArrayQueryConstructor { + const _j = {} as JsonArrayQueryConstructor; + _o.set(_j, "query", _p?.query); + _o.set(_j, "output", _p?.output); + _o.set(_j, "format", _p?.format); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonAggConstructor(_p?: JsonAggConstructor): JsonAggConstructor { + const _j = {} as JsonAggConstructor; + _o.set(_j, "output", _p?.output); + _o.set(_j, "agg_filter", _p?.agg_filter); + _o.set(_j, "agg_order", _p?.agg_order); + _o.set(_j, "over", _p?.over); + _o.set(_j, "location", _p?.location); + return _j; + }, + jsonObjectAgg(_p?: JsonObjectAgg): JsonObjectAgg { + const _j = {} as JsonObjectAgg; + _o.set(_j, "constructor", _p?.constructor); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "unique", _p?.unique); + return _j; + }, + jsonArrayAgg(_p?: JsonArrayAgg): JsonArrayAgg { + const _j = {} as JsonArrayAgg; + _o.set(_j, "constructor", _p?.constructor); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + return _j; + }, + rawStmt(_p?: RawStmt): RawStmt { + const _j = {} as RawStmt; + _o.set(_j, "stmt", _p?.stmt); + _o.set(_j, "stmt_location", _p?.stmt_location); + _o.set(_j, "stmt_len", _p?.stmt_len); + return _j; + }, + insertStmt(_p?: InsertStmt): InsertStmt { + const _j = {} as InsertStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "cols", _p?.cols); + _o.set(_j, "selectStmt", _p?.selectStmt); + _o.set(_j, "onConflictClause", _p?.onConflictClause); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + _o.set(_j, "override", _p?.override); + return _j; + }, + deleteStmt(_p?: DeleteStmt): DeleteStmt { + const _j = {} as DeleteStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "usingClause", _p?.usingClause); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + return _j; + }, + updateStmt(_p?: UpdateStmt): UpdateStmt { + const _j = {} as UpdateStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "fromClause", _p?.fromClause); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + return _j; + }, + mergeStmt(_p?: MergeStmt): MergeStmt { + const _j = {} as MergeStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "sourceRelation", _p?.sourceRelation); + _o.set(_j, "joinCondition", _p?.joinCondition); + _o.set(_j, "mergeWhenClauses", _p?.mergeWhenClauses); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + return _j; + }, + selectStmt(_p?: SelectStmt): SelectStmt { + const _j = {} as SelectStmt; + _o.set(_j, "distinctClause", _p?.distinctClause); + _o.set(_j, "intoClause", _p?.intoClause); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "fromClause", _p?.fromClause); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "groupClause", _p?.groupClause); + _o.set(_j, "groupDistinct", _p?.groupDistinct); + _o.set(_j, "havingClause", _p?.havingClause); + _o.set(_j, "windowClause", _p?.windowClause); + _o.set(_j, "valuesLists", _p?.valuesLists); + _o.set(_j, "sortClause", _p?.sortClause); + _o.set(_j, "limitOffset", _p?.limitOffset); + _o.set(_j, "limitCount", _p?.limitCount); + _o.set(_j, "limitOption", _p?.limitOption); + _o.set(_j, "lockingClause", _p?.lockingClause); + _o.set(_j, "withClause", _p?.withClause); + _o.set(_j, "op", _p?.op); + _o.set(_j, "all", _p?.all); + _o.set(_j, "larg", _p?.larg); + _o.set(_j, "rarg", _p?.rarg); + return _j; + }, + setOperationStmt(_p?: SetOperationStmt): SetOperationStmt { + const _j = {} as SetOperationStmt; + _o.set(_j, "op", _p?.op); + _o.set(_j, "all", _p?.all); + _o.set(_j, "larg", _p?.larg); + _o.set(_j, "rarg", _p?.rarg); + _o.set(_j, "colTypes", _p?.colTypes); + _o.set(_j, "colTypmods", _p?.colTypmods); + _o.set(_j, "colCollations", _p?.colCollations); + _o.set(_j, "groupClauses", _p?.groupClauses); + return _j; + }, + returnStmt(_p?: ReturnStmt): ReturnStmt { + const _j = {} as ReturnStmt; + _o.set(_j, "returnval", _p?.returnval); + return _j; + }, + plAssignStmt(_p?: PLAssignStmt): PLAssignStmt { + const _j = {} as PLAssignStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "indirection", _p?.indirection); + _o.set(_j, "nnames", _p?.nnames); + _o.set(_j, "val", _p?.val); + _o.set(_j, "location", _p?.location); + return _j; + }, + createSchemaStmt(_p?: CreateSchemaStmt): CreateSchemaStmt { + const _j = {} as CreateSchemaStmt; + _o.set(_j, "schemaname", _p?.schemaname); + _o.set(_j, "authrole", _p?.authrole); + _o.set(_j, "schemaElts", _p?.schemaElts); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return _j; + }, + alterTableStmt(_p?: AlterTableStmt): AlterTableStmt { + const _j = {} as AlterTableStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "cmds", _p?.cmds); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + replicaIdentityStmt(_p?: ReplicaIdentityStmt): ReplicaIdentityStmt { + const _j = {} as ReplicaIdentityStmt; + _o.set(_j, "identity_type", _p?.identity_type); + _o.set(_j, "name", _p?.name); + return _j; + }, + alterTableCmd(_p?: AlterTableCmd): AlterTableCmd { + const _j = {} as AlterTableCmd; + _o.set(_j, "subtype", _p?.subtype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "num", _p?.num); + _o.set(_j, "newowner", _p?.newowner); + _o.set(_j, "def", _p?.def); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "recurse", _p?.recurse); + return _j; + }, + alterCollationStmt(_p?: AlterCollationStmt): AlterCollationStmt { + const _j = {} as AlterCollationStmt; + _o.set(_j, "collname", _p?.collname); + return _j; + }, + alterDomainStmt(_p?: AlterDomainStmt): AlterDomainStmt { + const _j = {} as AlterDomainStmt; + _o.set(_j, "subtype", _p?.subtype); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "name", _p?.name); + _o.set(_j, "def", _p?.def); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + grantStmt(_p?: GrantStmt): GrantStmt { + const _j = {} as GrantStmt; + _o.set(_j, "is_grant", _p?.is_grant); + _o.set(_j, "targtype", _p?.targtype); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "objects", _p?.objects); + _o.set(_j, "privileges", _p?.privileges); + _o.set(_j, "grantees", _p?.grantees); + _o.set(_j, "grant_option", _p?.grant_option); + _o.set(_j, "grantor", _p?.grantor); + _o.set(_j, "behavior", _p?.behavior); + return _j; + }, + objectWithArgs(_p?: ObjectWithArgs): ObjectWithArgs { + const _j = {} as ObjectWithArgs; + _o.set(_j, "objname", _p?.objname); + _o.set(_j, "objargs", _p?.objargs); + _o.set(_j, "objfuncargs", _p?.objfuncargs); + _o.set(_j, "args_unspecified", _p?.args_unspecified); + return _j; + }, + accessPriv(_p?: AccessPriv): AccessPriv { + const _j = {} as AccessPriv; + _o.set(_j, "priv_name", _p?.priv_name); + _o.set(_j, "cols", _p?.cols); + return _j; + }, + grantRoleStmt(_p?: GrantRoleStmt): GrantRoleStmt { + const _j = {} as GrantRoleStmt; + _o.set(_j, "granted_roles", _p?.granted_roles); + _o.set(_j, "grantee_roles", _p?.grantee_roles); + _o.set(_j, "is_grant", _p?.is_grant); + _o.set(_j, "opt", _p?.opt); + _o.set(_j, "grantor", _p?.grantor); + _o.set(_j, "behavior", _p?.behavior); + return _j; + }, + alterDefaultPrivilegesStmt(_p?: AlterDefaultPrivilegesStmt): AlterDefaultPrivilegesStmt { + const _j = {} as AlterDefaultPrivilegesStmt; + _o.set(_j, "options", _p?.options); + _o.set(_j, "action", _p?.action); + return _j; + }, + copyStmt(_p?: CopyStmt): CopyStmt { + const _j = {} as CopyStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "query", _p?.query); + _o.set(_j, "attlist", _p?.attlist); + _o.set(_j, "is_from", _p?.is_from); + _o.set(_j, "is_program", _p?.is_program); + _o.set(_j, "filename", _p?.filename); + _o.set(_j, "options", _p?.options); + _o.set(_j, "whereClause", _p?.whereClause); + return _j; + }, + variableSetStmt(_p?: VariableSetStmt): VariableSetStmt { + const _j = {} as VariableSetStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "name", _p?.name); + _o.set(_j, "args", _p?.args); + _o.set(_j, "is_local", _p?.is_local); + return _j; + }, + variableShowStmt(_p?: VariableShowStmt): VariableShowStmt { + const _j = {} as VariableShowStmt; + _o.set(_j, "name", _p?.name); + return _j; + }, + createStmt(_p?: CreateStmt): CreateStmt { + const _j = {} as CreateStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "tableElts", _p?.tableElts); + _o.set(_j, "inhRelations", _p?.inhRelations); + _o.set(_j, "partbound", _p?.partbound); + _o.set(_j, "partspec", _p?.partspec); + _o.set(_j, "ofTypename", _p?.ofTypename); + _o.set(_j, "constraints", _p?.constraints); + _o.set(_j, "options", _p?.options); + _o.set(_j, "oncommit", _p?.oncommit); + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "accessMethod", _p?.accessMethod); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return _j; + }, + constraint(_p?: Constraint): Constraint { + const _j = {} as Constraint; + _o.set(_j, "contype", _p?.contype); + _o.set(_j, "conname", _p?.conname); + _o.set(_j, "deferrable", _p?.deferrable); + _o.set(_j, "initdeferred", _p?.initdeferred); + _o.set(_j, "skip_validation", _p?.skip_validation); + _o.set(_j, "initially_valid", _p?.initially_valid); + _o.set(_j, "is_no_inherit", _p?.is_no_inherit); + _o.set(_j, "raw_expr", _p?.raw_expr); + _o.set(_j, "cooked_expr", _p?.cooked_expr); + _o.set(_j, "generated_when", _p?.generated_when); + _o.set(_j, "inhcount", _p?.inhcount); + _o.set(_j, "nulls_not_distinct", _p?.nulls_not_distinct); + _o.set(_j, "keys", _p?.keys); + _o.set(_j, "including", _p?.including); + _o.set(_j, "exclusions", _p?.exclusions); + _o.set(_j, "options", _p?.options); + _o.set(_j, "indexname", _p?.indexname); + _o.set(_j, "indexspace", _p?.indexspace); + _o.set(_j, "reset_default_tblspc", _p?.reset_default_tblspc); + _o.set(_j, "access_method", _p?.access_method); + _o.set(_j, "where_clause", _p?.where_clause); + _o.set(_j, "pktable", _p?.pktable); + _o.set(_j, "fk_attrs", _p?.fk_attrs); + _o.set(_j, "pk_attrs", _p?.pk_attrs); + _o.set(_j, "fk_matchtype", _p?.fk_matchtype); + _o.set(_j, "fk_upd_action", _p?.fk_upd_action); + _o.set(_j, "fk_del_action", _p?.fk_del_action); + _o.set(_j, "fk_del_set_cols", _p?.fk_del_set_cols); + _o.set(_j, "old_conpfeqop", _p?.old_conpfeqop); + _o.set(_j, "old_pktable_oid", _p?.old_pktable_oid); + _o.set(_j, "location", _p?.location); + return _j; + }, + createTableSpaceStmt(_p?: CreateTableSpaceStmt): CreateTableSpaceStmt { + const _j = {} as CreateTableSpaceStmt; + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "owner", _p?.owner); + _o.set(_j, "location", _p?.location); + _o.set(_j, "options", _p?.options); + return _j; + }, + dropTableSpaceStmt(_p?: DropTableSpaceStmt): DropTableSpaceStmt { + const _j = {} as DropTableSpaceStmt; + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + alterTableSpaceOptionsStmt(_p?: AlterTableSpaceOptionsStmt): AlterTableSpaceOptionsStmt { + const _j = {} as AlterTableSpaceOptionsStmt; + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "options", _p?.options); + _o.set(_j, "isReset", _p?.isReset); + return _j; + }, + alterTableMoveAllStmt(_p?: AlterTableMoveAllStmt): AlterTableMoveAllStmt { + const _j = {} as AlterTableMoveAllStmt; + _o.set(_j, "orig_tablespacename", _p?.orig_tablespacename); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "new_tablespacename", _p?.new_tablespacename); + _o.set(_j, "nowait", _p?.nowait); + return _j; + }, + createExtensionStmt(_p?: CreateExtensionStmt): CreateExtensionStmt { + const _j = {} as CreateExtensionStmt; + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterExtensionStmt(_p?: AlterExtensionStmt): AlterExtensionStmt { + const _j = {} as AlterExtensionStmt; + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterExtensionContentsStmt(_p?: AlterExtensionContentsStmt): AlterExtensionContentsStmt { + const _j = {} as AlterExtensionContentsStmt; + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "action", _p?.action); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "object", _p?.object); + return _j; + }, + createFdwStmt(_p?: CreateFdwStmt): CreateFdwStmt { + const _j = {} as CreateFdwStmt; + _o.set(_j, "fdwname", _p?.fdwname); + _o.set(_j, "func_options", _p?.func_options); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterFdwStmt(_p?: AlterFdwStmt): AlterFdwStmt { + const _j = {} as AlterFdwStmt; + _o.set(_j, "fdwname", _p?.fdwname); + _o.set(_j, "func_options", _p?.func_options); + _o.set(_j, "options", _p?.options); + return _j; + }, + createForeignServerStmt(_p?: CreateForeignServerStmt): CreateForeignServerStmt { + const _j = {} as CreateForeignServerStmt; + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "servertype", _p?.servertype); + _o.set(_j, "version", _p?.version); + _o.set(_j, "fdwname", _p?.fdwname); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterForeignServerStmt(_p?: AlterForeignServerStmt): AlterForeignServerStmt { + const _j = {} as AlterForeignServerStmt; + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "version", _p?.version); + _o.set(_j, "options", _p?.options); + _o.set(_j, "has_version", _p?.has_version); + return _j; + }, + createForeignTableStmt(_p?: CreateForeignTableStmt): CreateForeignTableStmt { + const _j = {} as CreateForeignTableStmt; + _o.set(_j, "base", _p?.base); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "options", _p?.options); + return _j; + }, + createUserMappingStmt(_p?: CreateUserMappingStmt): CreateUserMappingStmt { + const _j = {} as CreateUserMappingStmt; + _o.set(_j, "user", _p?.user); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterUserMappingStmt(_p?: AlterUserMappingStmt): AlterUserMappingStmt { + const _j = {} as AlterUserMappingStmt; + _o.set(_j, "user", _p?.user); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "options", _p?.options); + return _j; + }, + dropUserMappingStmt(_p?: DropUserMappingStmt): DropUserMappingStmt { + const _j = {} as DropUserMappingStmt; + _o.set(_j, "user", _p?.user); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + importForeignSchemaStmt(_p?: ImportForeignSchemaStmt): ImportForeignSchemaStmt { + const _j = {} as ImportForeignSchemaStmt; + _o.set(_j, "server_name", _p?.server_name); + _o.set(_j, "remote_schema", _p?.remote_schema); + _o.set(_j, "local_schema", _p?.local_schema); + _o.set(_j, "list_type", _p?.list_type); + _o.set(_j, "table_list", _p?.table_list); + _o.set(_j, "options", _p?.options); + return _j; + }, + createPolicyStmt(_p?: CreatePolicyStmt): CreatePolicyStmt { + const _j = {} as CreatePolicyStmt; + _o.set(_j, "policy_name", _p?.policy_name); + _o.set(_j, "table", _p?.table); + _o.set(_j, "cmd_name", _p?.cmd_name); + _o.set(_j, "permissive", _p?.permissive); + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "with_check", _p?.with_check); + return _j; + }, + alterPolicyStmt(_p?: AlterPolicyStmt): AlterPolicyStmt { + const _j = {} as AlterPolicyStmt; + _o.set(_j, "policy_name", _p?.policy_name); + _o.set(_j, "table", _p?.table); + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "with_check", _p?.with_check); + return _j; + }, + createAmStmt(_p?: CreateAmStmt): CreateAmStmt { + const _j = {} as CreateAmStmt; + _o.set(_j, "amname", _p?.amname); + _o.set(_j, "handler_name", _p?.handler_name); + _o.set(_j, "amtype", _p?.amtype); + return _j; + }, + createTrigStmt(_p?: CreateTrigStmt): CreateTrigStmt { + const _j = {} as CreateTrigStmt; + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "isconstraint", _p?.isconstraint); + _o.set(_j, "trigname", _p?.trigname); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "funcname", _p?.funcname); + _o.set(_j, "args", _p?.args); + _o.set(_j, "row", _p?.row); + _o.set(_j, "timing", _p?.timing); + _o.set(_j, "events", _p?.events); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "whenClause", _p?.whenClause); + _o.set(_j, "transitionRels", _p?.transitionRels); + _o.set(_j, "deferrable", _p?.deferrable); + _o.set(_j, "initdeferred", _p?.initdeferred); + _o.set(_j, "constrrel", _p?.constrrel); + return _j; + }, + createEventTrigStmt(_p?: CreateEventTrigStmt): CreateEventTrigStmt { + const _j = {} as CreateEventTrigStmt; + _o.set(_j, "trigname", _p?.trigname); + _o.set(_j, "eventname", _p?.eventname); + _o.set(_j, "whenclause", _p?.whenclause); + _o.set(_j, "funcname", _p?.funcname); + return _j; + }, + alterEventTrigStmt(_p?: AlterEventTrigStmt): AlterEventTrigStmt { + const _j = {} as AlterEventTrigStmt; + _o.set(_j, "trigname", _p?.trigname); + _o.set(_j, "tgenabled", _p?.tgenabled); + return _j; + }, + createpLangStmt(_p?: CreatePLangStmt): CreatePLangStmt { + const _j = {} as CreatePLangStmt; + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "plname", _p?.plname); + _o.set(_j, "plhandler", _p?.plhandler); + _o.set(_j, "plinline", _p?.plinline); + _o.set(_j, "plvalidator", _p?.plvalidator); + _o.set(_j, "pltrusted", _p?.pltrusted); + return _j; + }, + createRoleStmt(_p?: CreateRoleStmt): CreateRoleStmt { + const _j = {} as CreateRoleStmt; + _o.set(_j, "stmt_type", _p?.stmt_type); + _o.set(_j, "role", _p?.role); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterRoleStmt(_p?: AlterRoleStmt): AlterRoleStmt { + const _j = {} as AlterRoleStmt; + _o.set(_j, "role", _p?.role); + _o.set(_j, "options", _p?.options); + _o.set(_j, "action", _p?.action); + return _j; + }, + alterRoleSetStmt(_p?: AlterRoleSetStmt): AlterRoleSetStmt { + const _j = {} as AlterRoleSetStmt; + _o.set(_j, "role", _p?.role); + _o.set(_j, "database", _p?.database); + _o.set(_j, "setstmt", _p?.setstmt); + return _j; + }, + dropRoleStmt(_p?: DropRoleStmt): DropRoleStmt { + const _j = {} as DropRoleStmt; + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + createSeqStmt(_p?: CreateSeqStmt): CreateSeqStmt { + const _j = {} as CreateSeqStmt; + _o.set(_j, "sequence", _p?.sequence); + _o.set(_j, "options", _p?.options); + _o.set(_j, "ownerId", _p?.ownerId); + _o.set(_j, "for_identity", _p?.for_identity); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return _j; + }, + alterSeqStmt(_p?: AlterSeqStmt): AlterSeqStmt { + const _j = {} as AlterSeqStmt; + _o.set(_j, "sequence", _p?.sequence); + _o.set(_j, "options", _p?.options); + _o.set(_j, "for_identity", _p?.for_identity); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + defineStmt(_p?: DefineStmt): DefineStmt { + const _j = {} as DefineStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "oldstyle", _p?.oldstyle); + _o.set(_j, "defnames", _p?.defnames); + _o.set(_j, "args", _p?.args); + _o.set(_j, "definition", _p?.definition); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "replace", _p?.replace); + return _j; + }, + createDomainStmt(_p?: CreateDomainStmt): CreateDomainStmt { + const _j = {} as CreateDomainStmt; + _o.set(_j, "domainname", _p?.domainname); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "collClause", _p?.collClause); + _o.set(_j, "constraints", _p?.constraints); + return _j; + }, + createOpClassStmt(_p?: CreateOpClassStmt): CreateOpClassStmt { + const _j = {} as CreateOpClassStmt; + _o.set(_j, "opclassname", _p?.opclassname); + _o.set(_j, "opfamilyname", _p?.opfamilyname); + _o.set(_j, "amname", _p?.amname); + _o.set(_j, "datatype", _p?.datatype); + _o.set(_j, "items", _p?.items); + _o.set(_j, "isDefault", _p?.isDefault); + return _j; + }, + createOpClassItem(_p?: CreateOpClassItem): CreateOpClassItem { + const _j = {} as CreateOpClassItem; + _o.set(_j, "itemtype", _p?.itemtype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "number", _p?.number); + _o.set(_j, "order_family", _p?.order_family); + _o.set(_j, "class_args", _p?.class_args); + _o.set(_j, "storedtype", _p?.storedtype); + return _j; + }, + createOpFamilyStmt(_p?: CreateOpFamilyStmt): CreateOpFamilyStmt { + const _j = {} as CreateOpFamilyStmt; + _o.set(_j, "opfamilyname", _p?.opfamilyname); + _o.set(_j, "amname", _p?.amname); + return _j; + }, + alterOpFamilyStmt(_p?: AlterOpFamilyStmt): AlterOpFamilyStmt { + const _j = {} as AlterOpFamilyStmt; + _o.set(_j, "opfamilyname", _p?.opfamilyname); + _o.set(_j, "amname", _p?.amname); + _o.set(_j, "isDrop", _p?.isDrop); + _o.set(_j, "items", _p?.items); + return _j; + }, + dropStmt(_p?: DropStmt): DropStmt { + const _j = {} as DropStmt; + _o.set(_j, "objects", _p?.objects); + _o.set(_j, "removeType", _p?.removeType); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "concurrent", _p?.concurrent); + return _j; + }, + truncateStmt(_p?: TruncateStmt): TruncateStmt { + const _j = {} as TruncateStmt; + _o.set(_j, "relations", _p?.relations); + _o.set(_j, "restart_seqs", _p?.restart_seqs); + _o.set(_j, "behavior", _p?.behavior); + return _j; + }, + commentStmt(_p?: CommentStmt): CommentStmt { + const _j = {} as CommentStmt; + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "object", _p?.object); + _o.set(_j, "comment", _p?.comment); + return _j; + }, + secLabelStmt(_p?: SecLabelStmt): SecLabelStmt { + const _j = {} as SecLabelStmt; + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "object", _p?.object); + _o.set(_j, "provider", _p?.provider); + _o.set(_j, "label", _p?.label); + return _j; + }, + declareCursorStmt(_p?: DeclareCursorStmt): DeclareCursorStmt { + const _j = {} as DeclareCursorStmt; + _o.set(_j, "portalname", _p?.portalname); + _o.set(_j, "options", _p?.options); + _o.set(_j, "query", _p?.query); + return _j; + }, + closePortalStmt(_p?: ClosePortalStmt): ClosePortalStmt { + const _j = {} as ClosePortalStmt; + _o.set(_j, "portalname", _p?.portalname); + return _j; + }, + fetchStmt(_p?: FetchStmt): FetchStmt { + const _j = {} as FetchStmt; + _o.set(_j, "direction", _p?.direction); + _o.set(_j, "howMany", _p?.howMany); + _o.set(_j, "portalname", _p?.portalname); + _o.set(_j, "ismove", _p?.ismove); + return _j; + }, + indexStmt(_p?: IndexStmt): IndexStmt { + const _j = {} as IndexStmt; + _o.set(_j, "idxname", _p?.idxname); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "accessMethod", _p?.accessMethod); + _o.set(_j, "tableSpace", _p?.tableSpace); + _o.set(_j, "indexParams", _p?.indexParams); + _o.set(_j, "indexIncludingParams", _p?.indexIncludingParams); + _o.set(_j, "options", _p?.options); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "excludeOpNames", _p?.excludeOpNames); + _o.set(_j, "idxcomment", _p?.idxcomment); + _o.set(_j, "indexOid", _p?.indexOid); + _o.set(_j, "oldNumber", _p?.oldNumber); + _o.set(_j, "oldCreateSubid", _p?.oldCreateSubid); + _o.set(_j, "oldFirstRelfilelocatorSubid", _p?.oldFirstRelfilelocatorSubid); + _o.set(_j, "unique", _p?.unique); + _o.set(_j, "nulls_not_distinct", _p?.nulls_not_distinct); + _o.set(_j, "primary", _p?.primary); + _o.set(_j, "isconstraint", _p?.isconstraint); + _o.set(_j, "deferrable", _p?.deferrable); + _o.set(_j, "initdeferred", _p?.initdeferred); + _o.set(_j, "transformed", _p?.transformed); + _o.set(_j, "concurrent", _p?.concurrent); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "reset_default_tblspc", _p?.reset_default_tblspc); + return _j; + }, + createStatsStmt(_p?: CreateStatsStmt): CreateStatsStmt { + const _j = {} as CreateStatsStmt; + _o.set(_j, "defnames", _p?.defnames); + _o.set(_j, "stat_types", _p?.stat_types); + _o.set(_j, "exprs", _p?.exprs); + _o.set(_j, "relations", _p?.relations); + _o.set(_j, "stxcomment", _p?.stxcomment); + _o.set(_j, "transformed", _p?.transformed); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return _j; + }, + statsElem(_p?: StatsElem): StatsElem { + const _j = {} as StatsElem; + _o.set(_j, "name", _p?.name); + _o.set(_j, "expr", _p?.expr); + return _j; + }, + alterStatsStmt(_p?: AlterStatsStmt): AlterStatsStmt { + const _j = {} as AlterStatsStmt; + _o.set(_j, "defnames", _p?.defnames); + _o.set(_j, "stxstattarget", _p?.stxstattarget); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + createFunctionStmt(_p?: CreateFunctionStmt): CreateFunctionStmt { + const _j = {} as CreateFunctionStmt; + _o.set(_j, "is_procedure", _p?.is_procedure); + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "funcname", _p?.funcname); + _o.set(_j, "parameters", _p?.parameters); + _o.set(_j, "returnType", _p?.returnType); + _o.set(_j, "options", _p?.options); + _o.set(_j, "sql_body", _p?.sql_body); + return _j; + }, + functionParameter(_p?: FunctionParameter): FunctionParameter { + const _j = {} as FunctionParameter; + _o.set(_j, "name", _p?.name); + _o.set(_j, "argType", _p?.argType); + _o.set(_j, "mode", _p?.mode); + _o.set(_j, "defexpr", _p?.defexpr); + return _j; + }, + alterFunctionStmt(_p?: AlterFunctionStmt): AlterFunctionStmt { + const _j = {} as AlterFunctionStmt; + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "func", _p?.func); + _o.set(_j, "actions", _p?.actions); + return _j; + }, + doStmt(_p?: DoStmt): DoStmt { + const _j = {} as DoStmt; + _o.set(_j, "args", _p?.args); + return _j; + }, + inlineCodeBlock(_p?: InlineCodeBlock): InlineCodeBlock { + const _j = {} as InlineCodeBlock; + _o.set(_j, "source_text", _p?.source_text); + _o.set(_j, "langOid", _p?.langOid); + _o.set(_j, "langIsTrusted", _p?.langIsTrusted); + _o.set(_j, "atomic", _p?.atomic); + return _j; + }, + callStmt(_p?: CallStmt): CallStmt { + const _j = {} as CallStmt; + _o.set(_j, "funccall", _p?.funccall); + _o.set(_j, "funcexpr", _p?.funcexpr); + _o.set(_j, "outargs", _p?.outargs); + return _j; + }, + callContext(_p?: CallContext): CallContext { + const _j = {} as CallContext; + _o.set(_j, "atomic", _p?.atomic); + return _j; + }, + renameStmt(_p?: RenameStmt): RenameStmt { + const _j = {} as RenameStmt; + _o.set(_j, "renameType", _p?.renameType); + _o.set(_j, "relationType", _p?.relationType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "newname", _p?.newname); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + alterObjectDependsStmt(_p?: AlterObjectDependsStmt): AlterObjectDependsStmt { + const _j = {} as AlterObjectDependsStmt; + _o.set(_j, "objectType", _p?.objectType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "remove", _p?.remove); + return _j; + }, + alterObjectSchemaStmt(_p?: AlterObjectSchemaStmt): AlterObjectSchemaStmt { + const _j = {} as AlterObjectSchemaStmt; + _o.set(_j, "objectType", _p?.objectType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "newschema", _p?.newschema); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + alterOwnerStmt(_p?: AlterOwnerStmt): AlterOwnerStmt { + const _j = {} as AlterOwnerStmt; + _o.set(_j, "objectType", _p?.objectType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "newowner", _p?.newowner); + return _j; + }, + alterOperatorStmt(_p?: AlterOperatorStmt): AlterOperatorStmt { + const _j = {} as AlterOperatorStmt; + _o.set(_j, "opername", _p?.opername); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterTypeStmt(_p?: AlterTypeStmt): AlterTypeStmt { + const _j = {} as AlterTypeStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "options", _p?.options); + return _j; + }, + ruleStmt(_p?: RuleStmt): RuleStmt { + const _j = {} as RuleStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "rulename", _p?.rulename); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "event", _p?.event); + _o.set(_j, "instead", _p?.instead); + _o.set(_j, "actions", _p?.actions); + _o.set(_j, "replace", _p?.replace); + return _j; + }, + notifyStmt(_p?: NotifyStmt): NotifyStmt { + const _j = {} as NotifyStmt; + _o.set(_j, "conditionname", _p?.conditionname); + _o.set(_j, "payload", _p?.payload); + return _j; + }, + listenStmt(_p?: ListenStmt): ListenStmt { + const _j = {} as ListenStmt; + _o.set(_j, "conditionname", _p?.conditionname); + return _j; + }, + unlistenStmt(_p?: UnlistenStmt): UnlistenStmt { + const _j = {} as UnlistenStmt; + _o.set(_j, "conditionname", _p?.conditionname); + return _j; + }, + transactionStmt(_p?: TransactionStmt): TransactionStmt { + const _j = {} as TransactionStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "options", _p?.options); + _o.set(_j, "savepoint_name", _p?.savepoint_name); + _o.set(_j, "gid", _p?.gid); + _o.set(_j, "chain", _p?.chain); + _o.set(_j, "location", _p?.location); + return _j; + }, + compositeTypeStmt(_p?: CompositeTypeStmt): CompositeTypeStmt { + const _j = {} as CompositeTypeStmt; + _o.set(_j, "typevar", _p?.typevar); + _o.set(_j, "coldeflist", _p?.coldeflist); + return _j; + }, + createEnumStmt(_p?: CreateEnumStmt): CreateEnumStmt { + const _j = {} as CreateEnumStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "vals", _p?.vals); + return _j; + }, + createRangeStmt(_p?: CreateRangeStmt): CreateRangeStmt { + const _j = {} as CreateRangeStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "params", _p?.params); + return _j; + }, + alterEnumStmt(_p?: AlterEnumStmt): AlterEnumStmt { + const _j = {} as AlterEnumStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "oldVal", _p?.oldVal); + _o.set(_j, "newVal", _p?.newVal); + _o.set(_j, "newValNeighbor", _p?.newValNeighbor); + _o.set(_j, "newValIsAfter", _p?.newValIsAfter); + _o.set(_j, "skipIfNewValExists", _p?.skipIfNewValExists); + return _j; + }, + viewStmt(_p?: ViewStmt): ViewStmt { + const _j = {} as ViewStmt; + _o.set(_j, "view", _p?.view); + _o.set(_j, "aliases", _p?.aliases); + _o.set(_j, "query", _p?.query); + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "options", _p?.options); + _o.set(_j, "withCheckOption", _p?.withCheckOption); + return _j; + }, + loadStmt(_p?: LoadStmt): LoadStmt { + const _j = {} as LoadStmt; + _o.set(_j, "filename", _p?.filename); + return _j; + }, + createdbStmt(_p?: CreatedbStmt): CreatedbStmt { + const _j = {} as CreatedbStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterDatabaseStmt(_p?: AlterDatabaseStmt): AlterDatabaseStmt { + const _j = {} as AlterDatabaseStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterDatabaseRefreshCollStmt(_p?: AlterDatabaseRefreshCollStmt): AlterDatabaseRefreshCollStmt { + const _j = {} as AlterDatabaseRefreshCollStmt; + _o.set(_j, "dbname", _p?.dbname); + return _j; + }, + alterDatabaseSetStmt(_p?: AlterDatabaseSetStmt): AlterDatabaseSetStmt { + const _j = {} as AlterDatabaseSetStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "setstmt", _p?.setstmt); + return _j; + }, + dropdbStmt(_p?: DropdbStmt): DropdbStmt { + const _j = {} as DropdbStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterSystemStmt(_p?: AlterSystemStmt): AlterSystemStmt { + const _j = {} as AlterSystemStmt; + _o.set(_j, "setstmt", _p?.setstmt); + return _j; + }, + clusterStmt(_p?: ClusterStmt): ClusterStmt { + const _j = {} as ClusterStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "indexname", _p?.indexname); + _o.set(_j, "params", _p?.params); + return _j; + }, + vacuumStmt(_p?: VacuumStmt): VacuumStmt { + const _j = {} as VacuumStmt; + _o.set(_j, "options", _p?.options); + _o.set(_j, "rels", _p?.rels); + _o.set(_j, "is_vacuumcmd", _p?.is_vacuumcmd); + return _j; + }, + vacuumRelation(_p?: VacuumRelation): VacuumRelation { + const _j = {} as VacuumRelation; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "oid", _p?.oid); + _o.set(_j, "va_cols", _p?.va_cols); + return _j; + }, + explainStmt(_p?: ExplainStmt): ExplainStmt { + const _j = {} as ExplainStmt; + _o.set(_j, "query", _p?.query); + _o.set(_j, "options", _p?.options); + return _j; + }, + createTableAsStmt(_p?: CreateTableAsStmt): CreateTableAsStmt { + const _j = {} as CreateTableAsStmt; + _o.set(_j, "query", _p?.query); + _o.set(_j, "into", _p?.into); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "is_select_into", _p?.is_select_into); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return _j; + }, + refreshMatViewStmt(_p?: RefreshMatViewStmt): RefreshMatViewStmt { + const _j = {} as RefreshMatViewStmt; + _o.set(_j, "concurrent", _p?.concurrent); + _o.set(_j, "skipData", _p?.skipData); + _o.set(_j, "relation", _p?.relation); + return _j; + }, + checkPointStmt(_p?: CheckPointStmt): CheckPointStmt { + const _j = {} as CheckPointStmt; + return _j; + }, + discardStmt(_p?: DiscardStmt): DiscardStmt { + const _j = {} as DiscardStmt; + _o.set(_j, "target", _p?.target); + return _j; + }, + lockStmt(_p?: LockStmt): LockStmt { + const _j = {} as LockStmt; + _o.set(_j, "relations", _p?.relations); + _o.set(_j, "mode", _p?.mode); + _o.set(_j, "nowait", _p?.nowait); + return _j; + }, + constraintsSetStmt(_p?: ConstraintsSetStmt): ConstraintsSetStmt { + const _j = {} as ConstraintsSetStmt; + _o.set(_j, "constraints", _p?.constraints); + _o.set(_j, "deferred", _p?.deferred); + return _j; + }, + reindexStmt(_p?: ReindexStmt): ReindexStmt { + const _j = {} as ReindexStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "name", _p?.name); + _o.set(_j, "params", _p?.params); + return _j; + }, + createConversionStmt(_p?: CreateConversionStmt): CreateConversionStmt { + const _j = {} as CreateConversionStmt; + _o.set(_j, "conversion_name", _p?.conversion_name); + _o.set(_j, "for_encoding_name", _p?.for_encoding_name); + _o.set(_j, "to_encoding_name", _p?.to_encoding_name); + _o.set(_j, "func_name", _p?.func_name); + _o.set(_j, "def", _p?.def); + return _j; + }, + createCastStmt(_p?: CreateCastStmt): CreateCastStmt { + const _j = {} as CreateCastStmt; + _o.set(_j, "sourcetype", _p?.sourcetype); + _o.set(_j, "targettype", _p?.targettype); + _o.set(_j, "func", _p?.func); + _o.set(_j, "context", _p?.context); + _o.set(_j, "inout", _p?.inout); + return _j; + }, + createTransformStmt(_p?: CreateTransformStmt): CreateTransformStmt { + const _j = {} as CreateTransformStmt; + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "type_name", _p?.type_name); + _o.set(_j, "lang", _p?.lang); + _o.set(_j, "fromsql", _p?.fromsql); + _o.set(_j, "tosql", _p?.tosql); + return _j; + }, + prepareStmt(_p?: PrepareStmt): PrepareStmt { + const _j = {} as PrepareStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "argtypes", _p?.argtypes); + _o.set(_j, "query", _p?.query); + return _j; + }, + executeStmt(_p?: ExecuteStmt): ExecuteStmt { + const _j = {} as ExecuteStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "params", _p?.params); + return _j; + }, + deallocateStmt(_p?: DeallocateStmt): DeallocateStmt { + const _j = {} as DeallocateStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "isall", _p?.isall); + _o.set(_j, "location", _p?.location); + return _j; + }, + dropOwnedStmt(_p?: DropOwnedStmt): DropOwnedStmt { + const _j = {} as DropOwnedStmt; + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "behavior", _p?.behavior); + return _j; + }, + reassignOwnedStmt(_p?: ReassignOwnedStmt): ReassignOwnedStmt { + const _j = {} as ReassignOwnedStmt; + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "newrole", _p?.newrole); + return _j; + }, + altertsDictionaryStmt(_p?: AlterTSDictionaryStmt): AlterTSDictionaryStmt { + const _j = {} as AlterTSDictionaryStmt; + _o.set(_j, "dictname", _p?.dictname); + _o.set(_j, "options", _p?.options); + return _j; + }, + altertsConfigurationStmt(_p?: AlterTSConfigurationStmt): AlterTSConfigurationStmt { + const _j = {} as AlterTSConfigurationStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "cfgname", _p?.cfgname); + _o.set(_j, "tokentype", _p?.tokentype); + _o.set(_j, "dicts", _p?.dicts); + _o.set(_j, "override", _p?.override); + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "missing_ok", _p?.missing_ok); + return _j; + }, + publicationTable(_p?: PublicationTable): PublicationTable { + const _j = {} as PublicationTable; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "columns", _p?.columns); + return _j; + }, + publicationObjSpec(_p?: PublicationObjSpec): PublicationObjSpec { + const _j = {} as PublicationObjSpec; + _o.set(_j, "pubobjtype", _p?.pubobjtype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "pubtable", _p?.pubtable); + _o.set(_j, "location", _p?.location); + return _j; + }, + createPublicationStmt(_p?: CreatePublicationStmt): CreatePublicationStmt { + const _j = {} as CreatePublicationStmt; + _o.set(_j, "pubname", _p?.pubname); + _o.set(_j, "options", _p?.options); + _o.set(_j, "pubobjects", _p?.pubobjects); + _o.set(_j, "for_all_tables", _p?.for_all_tables); + return _j; + }, + alterPublicationStmt(_p?: AlterPublicationStmt): AlterPublicationStmt { + const _j = {} as AlterPublicationStmt; + _o.set(_j, "pubname", _p?.pubname); + _o.set(_j, "options", _p?.options); + _o.set(_j, "pubobjects", _p?.pubobjects); + _o.set(_j, "for_all_tables", _p?.for_all_tables); + _o.set(_j, "action", _p?.action); + return _j; + }, + createSubscriptionStmt(_p?: CreateSubscriptionStmt): CreateSubscriptionStmt { + const _j = {} as CreateSubscriptionStmt; + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "conninfo", _p?.conninfo); + _o.set(_j, "publication", _p?.publication); + _o.set(_j, "options", _p?.options); + return _j; + }, + alterSubscriptionStmt(_p?: AlterSubscriptionStmt): AlterSubscriptionStmt { + const _j = {} as AlterSubscriptionStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "conninfo", _p?.conninfo); + _o.set(_j, "publication", _p?.publication); + _o.set(_j, "options", _p?.options); + return _j; + }, + dropSubscriptionStmt(_p?: DropSubscriptionStmt): DropSubscriptionStmt { + const _j = {} as DropSubscriptionStmt; + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "behavior", _p?.behavior); + return _j; + }, + scanToken(_p?: ScanToken): ScanToken { + const _j = {} as ScanToken; + _o.set(_j, "start", _p?.start); + _o.set(_j, "end", _p?.end); + _o.set(_j, "token", _p?.token); + _o.set(_j, "keywordKind", _p?.keywordKind); + return _j; + } +}; \ No newline at end of file diff --git a/packages/proto-parser/test-utils/meta/index.ts b/packages/proto-parser/test-utils/meta/index.ts new file mode 100644 index 00000000..379197c3 --- /dev/null +++ b/packages/proto-parser/test-utils/meta/index.ts @@ -0,0 +1,8 @@ +import ast from './asts'; +import nodes from './wrapped'; +export { nodes }; +export { ast }; +export default { + nodes, + ast +} \ No newline at end of file diff --git a/packages/proto-parser/test-utils/meta/runtime-schema.ts b/packages/proto-parser/test-utils/meta/runtime-schema.ts new file mode 100644 index 00000000..957e8588 --- /dev/null +++ b/packages/proto-parser/test-utils/meta/runtime-schema.ts @@ -0,0 +1,11427 @@ +/** +* This file was automatically generated by pg-proto-parser@1.29.0. +* DO NOT MODIFY IT BY HAND. Instead, modify the source proto file, +* and run the pg-proto-parser generate command to regenerate this file. +*/ +export interface FieldSpec { + name: string; + type: string; + isNode: boolean; + isArray: boolean; + optional: boolean; +} +export interface NodeSpec { + name: string; + isNode: boolean; + fields: FieldSpec[]; +} +export const runtimeSchema: NodeSpec[] = [ + { + name: 'A_ArrayExpr', + isNode: true, + fields: [ + { + name: 'elements', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'A_Const', + isNode: true, + fields: [ + { + name: 'boolval', + type: 'Boolean', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'bsval', + type: 'BitString', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'fval', + type: 'Float', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'isnull', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ival', + type: 'Integer', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'sval', + type: 'String', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'A_Expr', + isNode: true, + fields: [ + { + name: 'kind', + type: 'A_Expr_Kind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'lexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'A_Indices', + isNode: true, + fields: [ + { + name: 'is_slice', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'lidx', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'uidx', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'A_Indirection', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'indirection', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'A_Star', + isNode: true, + fields: [ + + ] + }, + { + name: 'AccessPriv', + isNode: true, + fields: [ + { + name: 'cols', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'priv_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'Aggref', + isNode: true, + fields: [ + { + name: 'aggargtypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'aggcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggdirectargs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'aggdistinct', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'aggfilter', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'aggfnoid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggkind', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'agglevelsup', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggno', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggorder', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'aggsplit', + type: 'AggSplit', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggstar', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggtransno', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggtype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'aggvariadic', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'Alias', + isNode: true, + fields: [ + { + name: 'aliasname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'colnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterCollationStmt', + isNode: true, + fields: [ + { + name: 'collname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterDatabaseRefreshCollStmt', + isNode: true, + fields: [ + { + name: 'dbname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterDatabaseSetStmt', + isNode: true, + fields: [ + { + name: 'dbname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'setstmt', + type: 'VariableSetStmt', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterDatabaseStmt', + isNode: true, + fields: [ + { + name: 'dbname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterDefaultPrivilegesStmt', + isNode: true, + fields: [ + { + name: 'action', + type: 'GrantStmt', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterDomainStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'def', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subtype', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterEnumStmt', + isNode: true, + fields: [ + { + name: 'newVal', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'newValIsAfter', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'newValNeighbor', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'oldVal', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'skipIfNewValExists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterEventTrigStmt', + isNode: true, + fields: [ + { + name: 'tgenabled', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'trigname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterExtensionContentsStmt', + isNode: true, + fields: [ + { + name: 'action', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'extname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterExtensionStmt', + isNode: true, + fields: [ + { + name: 'extname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterFdwStmt', + isNode: true, + fields: [ + { + name: 'fdwname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'func_options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterForeignServerStmt', + isNode: true, + fields: [ + { + name: 'has_version', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'servername', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'version', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterFunctionStmt', + isNode: true, + fields: [ + { + name: 'actions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'func', + type: 'ObjectWithArgs', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlternativeSubPlan', + isNode: true, + fields: [ + { + name: 'subplans', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterObjectDependsStmt', + isNode: true, + fields: [ + { + name: 'extname', + type: 'String', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objectType', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'remove', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterObjectSchemaStmt', + isNode: true, + fields: [ + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'newschema', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objectType', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterOperatorStmt', + isNode: true, + fields: [ + { + name: 'opername', + type: 'ObjectWithArgs', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterOpFamilyStmt', + isNode: true, + fields: [ + { + name: 'amname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'isDrop', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'items', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'opfamilyname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterOwnerStmt', + isNode: true, + fields: [ + { + name: 'newowner', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objectType', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterPolicyStmt', + isNode: true, + fields: [ + { + name: 'policy_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'qual', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'table', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'with_check', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterPublicationStmt', + isNode: true, + fields: [ + { + name: 'action', + type: 'AlterPublicationAction', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'for_all_tables', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pubname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'pubobjects', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterRoleSetStmt', + isNode: true, + fields: [ + { + name: 'database', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'role', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'setstmt', + type: 'VariableSetStmt', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterRoleStmt', + isNode: true, + fields: [ + { + name: 'action', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'role', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterSeqStmt', + isNode: true, + fields: [ + { + name: 'for_identity', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'sequence', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterStatsStmt', + isNode: true, + fields: [ + { + name: 'defnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'stxstattarget', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterSubscriptionStmt', + isNode: true, + fields: [ + { + name: 'conninfo', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'kind', + type: 'AlterSubscriptionType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'publication', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'subname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterSystemStmt', + isNode: true, + fields: [ + { + name: 'setstmt', + type: 'VariableSetStmt', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterTableCmd', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'def', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'newowner', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'num', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'recurse', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subtype', + type: 'AlterTableType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterTableMoveAllStmt', + isNode: true, + fields: [ + { + name: 'new_tablespacename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nowait', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'orig_tablespacename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterTableSpaceOptionsStmt', + isNode: true, + fields: [ + { + name: 'isReset', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'tablespacename', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterTableStmt', + isNode: true, + fields: [ + { + name: 'cmds', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'AlterTSConfigurationStmt', + isNode: true, + fields: [ + { + name: 'cfgname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'dicts', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'kind', + type: 'AlterTSConfigType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'override', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'tokentype', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterTSDictionaryStmt', + isNode: true, + fields: [ + { + name: 'dictname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterTypeStmt', + isNode: true, + fields: [ + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'typeName', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'AlterUserMappingStmt', + isNode: true, + fields: [ + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'servername', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'user', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ArrayCoerceExpr', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'coerceformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'elemexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resultcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ArrayExpr', + isNode: true, + fields: [ + { + name: 'array_collid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'array_typeid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'element_typeid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'elements', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'multidims', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'BitString', + isNode: true, + fields: [ + { + name: 'bsval', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'Boolean', + isNode: true, + fields: [ + { + name: 'boolval', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'BooleanTest', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'booltesttype', + type: 'BoolTestType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'BoolExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'boolop', + type: 'BoolExprType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CallContext', + isNode: true, + fields: [ + { + name: 'atomic', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CallStmt', + isNode: true, + fields: [ + { + name: 'funccall', + type: 'FuncCall', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'funcexpr', + type: 'FuncExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'outargs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CaseExpr', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'casecollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'casetype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'defresult', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CaseTestExpr', + isNode: true, + fields: [ + { + name: 'collation', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeId', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeMod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CaseWhen', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'result', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CheckPointStmt', + isNode: true, + fields: [ + + ] + }, + { + name: 'ClosePortalStmt', + isNode: true, + fields: [ + { + name: 'portalname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ClusterStmt', + isNode: true, + fields: [ + { + name: 'indexname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'params', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CoalesceExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coalescecollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'coalescetype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CoerceToDomain', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'coercionformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resultcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CoerceToDomainValue', + isNode: true, + fields: [ + { + name: 'collation', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeId', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeMod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CoerceViaIO', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'coerceformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resultcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CollateClause', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'collname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CollateExpr', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'collOid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ColumnDef', + isNode: true, + fields: [ + { + name: 'collClause', + type: 'CollateClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'collOid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'colname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'compression', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'constraints', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'cooked_default', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'fdwoptions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'generated', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'identity', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'identitySequence', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'inhcount', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_from_type', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_local', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_not_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'raw_default', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'storage', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'storage_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ColumnRef', + isNode: true, + fields: [ + { + name: 'fields', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CommentStmt', + isNode: true, + fields: [ + { + name: 'comment', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CommonTableExpr', + isNode: true, + fields: [ + { + name: 'aliascolnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ctecolcollations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ctecolnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ctecoltypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ctecoltypmods', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ctematerialized', + type: 'CTEMaterialize', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ctename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ctequery', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'cterecursive', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cterefcount', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cycle_clause', + type: 'CTECycleClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'search_clause', + type: 'CTESearchClause', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CompositeTypeStmt', + isNode: true, + fields: [ + { + name: 'coldeflist', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'typevar', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'Constraint', + isNode: true, + fields: [ + { + name: 'access_method', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'conname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'contype', + type: 'ConstrType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cooked_expr', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'deferrable', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'exclusions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'fk_attrs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'fk_del_action', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'fk_del_set_cols', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'fk_matchtype', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'fk_upd_action', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'generated_when', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'including', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'indexname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'indexspace', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inhcount', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'initdeferred', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'initially_valid', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_no_inherit', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'keys', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nulls_not_distinct', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'old_conpfeqop', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'old_pktable_oid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pk_attrs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pktable', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'raw_expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'reset_default_tblspc', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'skip_validation', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'where_clause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ConstraintsSetStmt', + isNode: true, + fields: [ + { + name: 'constraints', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'deferred', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ConvertRowtypeExpr', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'convertformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CopyStmt', + isNode: true, + fields: [ + { + name: 'attlist', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'filename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_from', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_program', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateAmStmt', + isNode: true, + fields: [ + { + name: 'amname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'amtype', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'handler_name', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateCastStmt', + isNode: true, + fields: [ + { + name: 'context', + type: 'CoercionContext', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'func', + type: 'ObjectWithArgs', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'inout', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'sourcetype', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'targettype', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateConversionStmt', + isNode: true, + fields: [ + { + name: 'conversion_name', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'def', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'for_encoding_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'func_name', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'to_encoding_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreatedbStmt', + isNode: true, + fields: [ + { + name: 'dbname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateDomainStmt', + isNode: true, + fields: [ + { + name: 'collClause', + type: 'CollateClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'constraints', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'domainname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateEnumStmt', + isNode: true, + fields: [ + { + name: 'typeName', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'vals', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateEventTrigStmt', + isNode: true, + fields: [ + { + name: 'eventname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'trigname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'whenclause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateExtensionStmt', + isNode: true, + fields: [ + { + name: 'extname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateFdwStmt', + isNode: true, + fields: [ + { + name: 'fdwname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'func_options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateForeignServerStmt', + isNode: true, + fields: [ + { + name: 'fdwname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'servername', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'servertype', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'version', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateForeignTableStmt', + isNode: true, + fields: [ + { + name: 'base', + type: 'CreateStmt', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'servername', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateFunctionStmt', + isNode: true, + fields: [ + { + name: 'funcname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'is_procedure', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'parameters', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'returnType', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'sql_body', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateOpClassItem', + isNode: true, + fields: [ + { + name: 'class_args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'itemtype', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'ObjectWithArgs', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'number', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'order_family', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'storedtype', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateOpClassStmt', + isNode: true, + fields: [ + { + name: 'amname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'datatype', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'isDefault', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'items', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'opclassname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'opfamilyname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateOpFamilyStmt', + isNode: true, + fields: [ + { + name: 'amname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opfamilyname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreatePLangStmt', + isNode: true, + fields: [ + { + name: 'plhandler', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'plinline', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'plname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'pltrusted', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'plvalidator', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreatePolicyStmt', + isNode: true, + fields: [ + { + name: 'cmd_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'permissive', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'policy_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'qual', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'table', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'with_check', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreatePublicationStmt', + isNode: true, + fields: [ + { + name: 'for_all_tables', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pubname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'pubobjects', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateRangeStmt', + isNode: true, + fields: [ + { + name: 'params', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'typeName', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'CreateRoleStmt', + isNode: true, + fields: [ + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'role', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'stmt_type', + type: 'RoleStmtType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateSchemaStmt', + isNode: true, + fields: [ + { + name: 'authrole', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'schemaElts', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'schemaname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateSeqStmt', + isNode: true, + fields: [ + { + name: 'for_identity', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ownerId', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'sequence', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateStatsStmt', + isNode: true, + fields: [ + { + name: 'defnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'exprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'stat_types', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'stxcomment', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'transformed', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateStmt', + isNode: true, + fields: [ + { + name: 'accessMethod', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'constraints', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inhRelations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ofTypename', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'oncommit', + type: 'OnCommitAction', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'partbound', + type: 'PartitionBoundSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'partspec', + type: 'PartitionSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'tableElts', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'tablespacename', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateSubscriptionStmt', + isNode: true, + fields: [ + { + name: 'conninfo', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'publication', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'subname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateTableAsStmt', + isNode: true, + fields: [ + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'into', + type: 'IntoClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'is_select_into', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateTableSpaceStmt', + isNode: true, + fields: [ + { + name: 'location', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'owner', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'tablespacename', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateTransformStmt', + isNode: true, + fields: [ + { + name: 'fromsql', + type: 'ObjectWithArgs', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'lang', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'tosql', + type: 'ObjectWithArgs', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'type_name', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateTrigStmt', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'columns', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'constrrel', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'deferrable', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'events', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'initdeferred', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'isconstraint', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'row', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'timing', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'transitionRels', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'trigname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'whenClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CreateUserMappingStmt', + isNode: true, + fields: [ + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'servername', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'user', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'CTECycleClause', + isNode: true, + fields: [ + { + name: 'cycle_col_list', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'cycle_mark_collation', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cycle_mark_column', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cycle_mark_default', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'cycle_mark_neop', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cycle_mark_type', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cycle_mark_typmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cycle_mark_value', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'cycle_path_column', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CTESearchClause', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'search_breadth_first', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'search_col_list', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'search_seq_column', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'CurrentOfExpr', + isNode: true, + fields: [ + { + name: 'cursor_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cursor_param', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'cvarno', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'DeallocateStmt', + isNode: true, + fields: [ + { + name: 'isall', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DeclareCursorStmt', + isNode: true, + fields: [ + { + name: 'options', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'portalname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'DefElem', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'defaction', + type: 'DefElemAction', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'defname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'defnamespace', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DefineStmt', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'definition', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'defnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'kind', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'oldstyle', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DeleteStmt', + isNode: true, + fields: [ + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'returningList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'usingClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'withClause', + type: 'WithClause', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'DiscardStmt', + isNode: true, + fields: [ + { + name: 'target', + type: 'DiscardMode', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DistinctExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opno', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opresulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opretset', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'DoStmt', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'DropdbStmt', + isNode: true, + fields: [ + { + name: 'dbname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'DropOwnedStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'DropRoleStmt', + isNode: true, + fields: [ + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'DropStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'concurrent', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'objects', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'removeType', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DropSubscriptionStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DropTableSpaceStmt', + isNode: true, + fields: [ + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'tablespacename', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'DropUserMappingStmt', + isNode: true, + fields: [ + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'servername', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'user', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ExecuteStmt', + isNode: true, + fields: [ + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'params', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'ExplainStmt', + isNode: true, + fields: [ + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'FetchStmt', + isNode: true, + fields: [ + { + name: 'direction', + type: 'FetchDirection', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'howMany', + type: 'int64', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ismove', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'portalname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'FieldSelect', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'fieldnum', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resultcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'FieldStore', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'fieldnums', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'newvals', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'Float', + isNode: true, + fields: [ + { + name: 'fval', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'FromExpr', + isNode: true, + fields: [ + { + name: 'fromlist', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'quals', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'FuncCall', + isNode: true, + fields: [ + { + name: 'agg_distinct', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'agg_filter', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'agg_order', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'agg_star', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'agg_within_group', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'func_variadic', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'over', + type: 'WindowDef', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'FuncExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'funccollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcresulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcretset', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funcvariadic', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'FunctionParameter', + isNode: true, + fields: [ + { + name: 'argType', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'defexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'mode', + type: 'FunctionParameterMode', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'GrantRoleStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'granted_roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'grantee_roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'grantor', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'is_grant', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opt', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'GrantStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'grant_option', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'grantees', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'grantor', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'is_grant', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'objects', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'privileges', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'targtype', + type: 'GrantTargetType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'GroupingFunc', + isNode: true, + fields: [ + { + name: 'agglevelsup', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'refs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'GroupingSet', + isNode: true, + fields: [ + { + name: 'content', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'kind', + type: 'GroupingSetKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ImportForeignSchemaStmt', + isNode: true, + fields: [ + { + name: 'list_type', + type: 'ImportForeignSchemaType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'local_schema', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'remote_schema', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'server_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'table_list', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'IndexElem', + isNode: true, + fields: [ + { + name: 'collation', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'indexcolname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nulls_ordering', + type: 'SortByNulls', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opclass', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'opclassopts', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ordering', + type: 'SortByDir', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'IndexStmt', + isNode: true, + fields: [ + { + name: 'accessMethod', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'concurrent', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'deferrable', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'excludeOpNames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'idxcomment', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'idxname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'if_not_exists', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'indexIncludingParams', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'indexOid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'indexParams', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'initdeferred', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'isconstraint', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nulls_not_distinct', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'oldCreateSubid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'oldFirstRelfilelocatorSubid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'oldNumber', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'primary', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'reset_default_tblspc', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'tableSpace', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'transformed', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'unique', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'InferClause', + isNode: true, + fields: [ + { + name: 'conname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'indexElems', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'InferenceElem', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'infercollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inferopclass', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'InlineCodeBlock', + isNode: true, + fields: [ + { + name: 'atomic', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'langIsTrusted', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'langOid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'source_text', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'InsertStmt', + isNode: true, + fields: [ + { + name: 'cols', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'onConflictClause', + type: 'OnConflictClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'override', + type: 'OverridingKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'returningList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'selectStmt', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'withClause', + type: 'WithClause', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'Integer', + isNode: true, + fields: [ + { + name: 'ival', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'IntList', + isNode: true, + fields: [ + { + name: 'items', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'IntoClause', + isNode: true, + fields: [ + { + name: 'accessMethod', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'colNames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'onCommit', + type: 'OnCommitAction', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rel', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'skipData', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'tableSpaceName', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'viewQuery', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JoinExpr', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'isNatural', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'join_using_alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'jointype', + type: 'JoinType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'larg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'quals', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'rarg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'rtindex', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'usingClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'JsonAggConstructor', + isNode: true, + fields: [ + { + name: 'agg_filter', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'agg_order', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'over', + type: 'WindowDef', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonArgument', + isNode: true, + fields: [ + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'val', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonArrayAgg', + isNode: true, + fields: [ + { + name: 'absent_on_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'arg', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'constructor', + type: 'JsonAggConstructor', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonArrayConstructor', + isNode: true, + fields: [ + { + name: 'absent_on_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'exprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonArrayQueryConstructor', + isNode: true, + fields: [ + { + name: 'absent_on_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'format', + type: 'JsonFormat', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonBehavior', + isNode: true, + fields: [ + { + name: 'btype', + type: 'JsonBehaviorType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'coerce', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonConstructorExpr', + isNode: true, + fields: [ + { + name: 'absent_on_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coercion', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'func', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'returning', + type: 'JsonReturning', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'type', + type: 'JsonConstructorType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'unique', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonExpr', + isNode: true, + fields: [ + { + name: 'collation', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'column_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'format', + type: 'JsonFormat', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'formatted_expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'omit_quotes', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'on_empty', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'on_error', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'op', + type: 'JsonExprOp', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'passing_names', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'passing_values', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'path_spec', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'returning', + type: 'JsonReturning', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'use_io_coercion', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'use_json_coercion', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'wrapper', + type: 'JsonWrapper', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonFormat', + isNode: true, + fields: [ + { + name: 'encoding', + type: 'JsonEncoding', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'format_type', + type: 'JsonFormatType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonFuncExpr', + isNode: true, + fields: [ + { + name: 'column_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'context_item', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'on_empty', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'on_error', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'op', + type: 'JsonExprOp', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'passing', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pathspec', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'quotes', + type: 'JsonQuotes', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'wrapper', + type: 'JsonWrapper', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonIsPredicate', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'format', + type: 'JsonFormat', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'item_type', + type: 'JsonValueType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'unique_keys', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonKeyValue', + isNode: true, + fields: [ + { + name: 'key', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'value', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonObjectAgg', + isNode: true, + fields: [ + { + name: 'absent_on_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'arg', + type: 'JsonKeyValue', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'constructor', + type: 'JsonAggConstructor', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'unique', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonObjectConstructor', + isNode: true, + fields: [ + { + name: 'absent_on_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'exprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'unique', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonOutput', + isNode: true, + fields: [ + { + name: 'returning', + type: 'JsonReturning', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonParseExpr', + isNode: true, + fields: [ + { + name: 'expr', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'unique_keys', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonReturning', + isNode: true, + fields: [ + { + name: 'format', + type: 'JsonFormat', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'typid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonScalarExpr', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonSerializeExpr', + isNode: true, + fields: [ + { + name: 'expr', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'output', + type: 'JsonOutput', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonTable', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'columns', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'context_item', + type: 'JsonValueExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'lateral', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'on_error', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'passing', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pathspec', + type: 'JsonTablePathSpec', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonTableColumn', + isNode: true, + fields: [ + { + name: 'coltype', + type: 'JsonTableColumnType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'columns', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'format', + type: 'JsonFormat', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'on_empty', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'on_error', + type: 'JsonBehavior', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'pathspec', + type: 'JsonTablePathSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'quotes', + type: 'JsonQuotes', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'wrapper', + type: 'JsonWrapper', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonTablePath', + isNode: true, + fields: [ + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonTablePathScan', + isNode: true, + fields: [ + { + name: 'child', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'colMax', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'colMin', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'errorOnError', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'path', + type: 'JsonTablePath', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'plan', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonTablePathSpec', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name_location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'string', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonTableSiblingJoin', + isNode: true, + fields: [ + { + name: 'lplan', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'plan', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'rplan', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'JsonValueExpr', + isNode: true, + fields: [ + { + name: 'format', + type: 'JsonFormat', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'formatted_expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'raw_expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'List', + isNode: true, + fields: [ + { + name: 'items', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'ListenStmt', + isNode: true, + fields: [ + { + name: 'conditionname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'LoadStmt', + isNode: true, + fields: [ + { + name: 'filename', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'LockingClause', + isNode: true, + fields: [ + { + name: 'lockedRels', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'strength', + type: 'LockClauseStrength', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'waitPolicy', + type: 'LockWaitPolicy', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'LockStmt', + isNode: true, + fields: [ + { + name: 'mode', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nowait', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'MergeAction', + isNode: true, + fields: [ + { + name: 'commandType', + type: 'CmdType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'matchKind', + type: 'MergeMatchKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'override', + type: 'OverridingKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'qual', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'targetList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'updateColnos', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'MergeStmt', + isNode: true, + fields: [ + { + name: 'joinCondition', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'mergeWhenClauses', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'returningList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'sourceRelation', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'withClause', + type: 'WithClause', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'MergeSupportFunc', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'msfcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'msftype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'MergeWhenClause', + isNode: true, + fields: [ + { + name: 'commandType', + type: 'CmdType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'condition', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'matchKind', + type: 'MergeMatchKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'override', + type: 'OverridingKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'targetList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'values', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'MinMaxExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'minmaxcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'minmaxtype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'op', + type: 'MinMaxOp', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'MultiAssignRef', + isNode: true, + fields: [ + { + name: 'colno', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ncolumns', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'source', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'NamedArgExpr', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'argnumber', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'NextValueExpr', + isNode: true, + fields: [ + { + name: 'seqid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeId', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'NotifyStmt', + isNode: true, + fields: [ + { + name: 'conditionname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'payload', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'NullIfExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opno', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opresulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opretset', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'NullTest', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'argisrow', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nulltesttype', + type: 'NullTestType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ObjectWithArgs', + isNode: true, + fields: [ + { + name: 'args_unspecified', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'objargs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'objfuncargs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'objname', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'OidList', + isNode: true, + fields: [ + { + name: 'items', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'OnConflictClause', + isNode: true, + fields: [ + { + name: 'action', + type: 'OnConflictAction', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'infer', + type: 'InferClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'targetList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'OnConflictExpr', + isNode: true, + fields: [ + { + name: 'action', + type: 'OnConflictAction', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'arbiterElems', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'arbiterWhere', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'constraint', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'exclRelIndex', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'exclRelTlist', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'onConflictSet', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'onConflictWhere', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'OpExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opno', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opresulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opretset', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'Param', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'paramcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'paramid', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'paramkind', + type: 'ParamKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'paramtype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'paramtypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ParamRef', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'number', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ParseResult', + isNode: false, + fields: [ + { + name: 'stmts', + type: 'RawStmt', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'version', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'PartitionBoundSpec', + isNode: true, + fields: [ + { + name: 'is_default', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'listdatums', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'lowerdatums', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'modulus', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'remainder', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'strategy', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'upperdatums', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'PartitionCmd', + isNode: true, + fields: [ + { + name: 'bound', + type: 'PartitionBoundSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'concurrent', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'PartitionElem', + isNode: true, + fields: [ + { + name: 'collation', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opclass', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'PartitionRangeDatum', + isNode: true, + fields: [ + { + name: 'kind', + type: 'PartitionRangeDatumKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'value', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'PartitionSpec', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'partParams', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'strategy', + type: 'PartitionStrategy', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'PLAssignStmt', + isNode: true, + fields: [ + { + name: 'indirection', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nnames', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'val', + type: 'SelectStmt', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'PrepareStmt', + isNode: true, + fields: [ + { + name: 'argtypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'PublicationObjSpec', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'pubobjtype', + type: 'PublicationObjSpecType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'pubtable', + type: 'PublicationTable', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'PublicationTable', + isNode: true, + fields: [ + { + name: 'columns', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'Query', + isNode: true, + fields: [ + { + name: 'canSetTag', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'commandType', + type: 'CmdType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'constraintDeps', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'cteList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'distinctClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'groupClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'groupDistinct', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'groupingSets', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'hasAggs', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasDistinctOn', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasForUpdate', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasModifyingCTE', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasRecursive', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasRowSecurity', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasSubLinks', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasTargetSRFs', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hasWindowFuncs', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'havingQual', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'isReturn', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'jointree', + type: 'FromExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'limitCount', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'limitOffset', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'limitOption', + type: 'LimitOption', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'mergeActionList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'mergeJoinCondition', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'mergeTargetRelation', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'onConflict', + type: 'OnConflictExpr', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'override', + type: 'OverridingKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'querySource', + type: 'QuerySource', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resultRelation', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'returningList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rowMarks', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rtable', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rteperminfos', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'setOperations', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'sortClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'stmt_len', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'stmt_location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'targetList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'utilityStmt', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'windowClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'withCheckOptions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'RangeFunction', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'coldeflist', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'functions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'is_rowsfrom', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'lateral', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ordinality', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'RangeSubselect', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'lateral', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subquery', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RangeTableFunc', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'columns', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'docexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'lateral', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'namespaces', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rowexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RangeTableFuncCol', + isNode: true, + fields: [ + { + name: 'coldefexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'colexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'colname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'for_ordinality', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'is_not_null', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RangeTableSample', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'method', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'relation', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'repeatable', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RangeTblEntry', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'colcollations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coltypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coltypmods', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ctelevelsup', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ctename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'enrname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'enrtuples', + type: 'double', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'eref', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'funcordinality', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'functions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inFromCl', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inh', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'join_using_alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'joinaliasvars', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'joinleftcols', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'joinmergedcols', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'joinrightcols', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'jointype', + type: 'JoinType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'lateral', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'perminfoindex', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relkind', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rellockmode', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rtekind', + type: 'RTEKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'security_barrier', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'securityQuals', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'self_reference', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subquery', + type: 'Query', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'tablefunc', + type: 'TableFunc', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'tablesample', + type: 'TableSampleClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'values_lists', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'RangeTblFunction', + isNode: true, + fields: [ + { + name: 'funccolcollations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'funccolcount', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'funccolnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'funccoltypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'funccoltypmods', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'funcexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'funcparams', + type: 'uint64', + isNode: false, + isArray: true, + optional: true + } + ] + }, + { + name: 'RangeTblRef', + isNode: true, + fields: [ + { + name: 'rtindex', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'RangeVar', + isNode: true, + fields: [ + { + name: 'alias', + type: 'Alias', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'catalogname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inh', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relpersistence', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'schemaname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'RawStmt', + isNode: true, + fields: [ + { + name: 'stmt', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'stmt_len', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'stmt_location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ReassignOwnedStmt', + isNode: true, + fields: [ + { + name: 'newrole', + type: 'RoleSpec', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'roles', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'RefreshMatViewStmt', + isNode: true, + fields: [ + { + name: 'concurrent', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'skipData', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ReindexStmt', + isNode: true, + fields: [ + { + name: 'kind', + type: 'ReindexObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'params', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RelabelType', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relabelformat', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resultcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resulttypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RenameStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'missing_ok', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'newname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'relationType', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'renameType', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ReplicaIdentityStmt', + isNode: true, + fields: [ + { + name: 'identity_type', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ResTarget', + isNode: true, + fields: [ + { + name: 'indirection', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'val', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ReturnStmt', + isNode: true, + fields: [ + { + name: 'returnval', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RoleSpec', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rolename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'roletype', + type: 'RoleSpecType', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'RowCompareExpr', + isNode: true, + fields: [ + { + name: 'inputcollids', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'largs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'opfamilies', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'opnos', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rargs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rctype', + type: 'RowCompareType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RowExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'colnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'row_format', + type: 'CoercionForm', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'row_typeid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'RowMarkClause', + isNode: true, + fields: [ + { + name: 'pushedDown', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rti', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'strength', + type: 'LockClauseStrength', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'waitPolicy', + type: 'LockWaitPolicy', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'RTEPermissionInfo', + isNode: true, + fields: [ + { + name: 'checkAsUser', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inh', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'insertedCols', + type: 'uint64', + isNode: false, + isArray: true, + optional: true + }, + { + name: 'relid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'requiredPerms', + type: 'uint64', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'selectedCols', + type: 'uint64', + isNode: false, + isArray: true, + optional: true + }, + { + name: 'updatedCols', + type: 'uint64', + isNode: false, + isArray: true, + optional: true + } + ] + }, + { + name: 'RuleStmt', + isNode: true, + fields: [ + { + name: 'actions', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'event', + type: 'CmdType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'instead', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rulename', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ScalarArrayOpExpr', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opno', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'useOr', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'ScanResult', + isNode: false, + fields: [ + { + name: 'tokens', + type: 'ScanToken', + isNode: false, + isArray: true, + optional: true + }, + { + name: 'version', + type: 'int32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ScanToken', + isNode: false, + fields: [ + { + name: 'end', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'keywordKind', + type: 'KeywordKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'start', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'token', + type: 'Token', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'SecLabelStmt', + isNode: true, + fields: [ + { + name: 'label', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'object', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'objtype', + type: 'ObjectType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'provider', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'SelectStmt', + isNode: true, + fields: [ + { + name: 'all', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'distinctClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'fromClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'groupClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'groupDistinct', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'havingClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'intoClause', + type: 'IntoClause', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'larg', + type: 'SelectStmt', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'limitCount', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'limitOffset', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'limitOption', + type: 'LimitOption', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'lockingClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'op', + type: 'SetOperation', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rarg', + type: 'SelectStmt', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'sortClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'targetList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'valuesLists', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'windowClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'withClause', + type: 'WithClause', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'SetOperationStmt', + isNode: true, + fields: [ + { + name: 'all', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'colCollations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'colTypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'colTypmods', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'groupClauses', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'larg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'op', + type: 'SetOperation', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'rarg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'SetToDefault', + isNode: true, + fields: [ + { + name: 'collation', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeId', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeMod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'SinglePartitionSpec', + isNode: true, + fields: [ + + ] + }, + { + name: 'SortBy', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'node', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'sortby_dir', + type: 'SortByDir', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'sortby_nulls', + type: 'SortByNulls', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'useOp', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'SortGroupClause', + isNode: true, + fields: [ + { + name: 'eqop', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'hashable', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'nulls_first', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'sortop', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'tleSortGroupRef', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'SQLValueFunction', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'op', + type: 'SQLValueFunctionOp', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'type', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'StatsElem', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'String', + isNode: true, + fields: [ + { + name: 'sval', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'SubLink', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'operName', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'subLinkId', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subLinkType', + type: 'SubLinkType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subselect', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'testexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'SubPlan', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'firstColCollation', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'firstColType', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'firstColTypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'parallel_safe', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'paramIds', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'parParam', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'per_call_cost', + type: 'double', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'plan_id', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'plan_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'setParam', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'startup_cost', + type: 'double', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'subLinkType', + type: 'SubLinkType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'testexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'unknownEqFalse', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'useHashTable', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'SubscriptingRef', + isNode: true, + fields: [ + { + name: 'refassgnexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'refcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'refcontainertype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'refelemtype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'refexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'reflowerindexpr', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'refrestype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'reftypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'refupperindexpr', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'TableFunc', + isNode: true, + fields: [ + { + name: 'colcollations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coldefexprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'colexprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'colnames', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coltypes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'coltypmods', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'colvalexprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'docexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'functype', + type: 'TableFuncType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'notnulls', + type: 'uint64', + isNode: false, + isArray: true, + optional: true + }, + { + name: 'ns_names', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ns_uris', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'ordinalitycol', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'passingvalexprs', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'plan', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'rowexpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'TableLikeClause', + isNode: true, + fields: [ + { + name: 'options', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'relationOid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'TableSampleClause', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'repeatable', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'tsmhandler', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'TargetEntry', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'resjunk', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resno', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resorigcol', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'resorigtbl', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'ressortgroupref', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'TransactionStmt', + isNode: true, + fields: [ + { + name: 'chain', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'gid', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'kind', + type: 'TransactionStmtKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'savepoint_name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'TriggerTransition', + isNode: true, + fields: [ + { + name: 'isNew', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'isTable', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'TruncateStmt', + isNode: true, + fields: [ + { + name: 'behavior', + type: 'DropBehavior', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relations', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'restart_seqs', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'TypeCast', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'TypeName', + isNode: true, + fields: [ + { + name: 'arrayBounds', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'names', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'pct_type', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'setof', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typemod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeOid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typmods', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'UnlistenStmt', + isNode: true, + fields: [ + { + name: 'conditionname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'UpdateStmt', + isNode: true, + fields: [ + { + name: 'fromClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'returningList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'targetList', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'whereClause', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'withClause', + type: 'WithClause', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'VacuumRelation', + isNode: true, + fields: [ + { + name: 'oid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'relation', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'va_cols', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'VacuumStmt', + isNode: true, + fields: [ + { + name: 'is_vacuumcmd', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'rels', + type: 'Node', + isNode: true, + isArray: true, + optional: true + } + ] + }, + { + name: 'Var', + isNode: true, + fields: [ + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'varattno', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'varcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'varlevelsup', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'varno', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'varnullingrels', + type: 'uint64', + isNode: false, + isArray: true, + optional: true + }, + { + name: 'vartype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'vartypmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'VariableSetStmt', + isNode: true, + fields: [ + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'is_local', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'kind', + type: 'VariableSetKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'VariableShowStmt', + isNode: true, + fields: [ + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'ViewStmt', + isNode: true, + fields: [ + { + name: 'aliases', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'options', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'query', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'replace', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'view', + type: 'RangeVar', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'withCheckOption', + type: 'ViewCheckOption', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'WindowClause', + isNode: true, + fields: [ + { + name: 'copiedOrder', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'endInRangeFunc', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'endOffset', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'frameOptions', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inRangeAsc', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inRangeColl', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'inRangeNullsFirst', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'orderClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'partitionClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'refname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'startInRangeFunc', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'startOffset', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'winref', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'WindowDef', + isNode: true, + fields: [ + { + name: 'endOffset', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'frameOptions', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'orderClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'partitionClause', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'refname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'startOffset', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'WindowFunc', + isNode: true, + fields: [ + { + name: 'aggfilter', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'runCondition', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'winagg', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'wincollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'winfnoid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'winref', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'winstar', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'wintype', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'WindowFuncRunCondition', + isNode: true, + fields: [ + { + name: 'arg', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'inputcollid', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'opno', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'wfunc_left', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'WithCheckOption', + isNode: true, + fields: [ + { + name: 'cascaded', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'kind', + type: 'WCOKind', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'polname', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'qual', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'relname', + type: 'string', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'WithClause', + isNode: true, + fields: [ + { + name: 'ctes', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'recursive', + type: 'bool', + isNode: false, + isArray: false, + optional: true + } + ] + }, + { + name: 'XmlExpr', + isNode: true, + fields: [ + { + name: 'arg_names', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'indent', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'name', + type: 'string', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'named_args', + type: 'Node', + isNode: true, + isArray: true, + optional: true + }, + { + name: 'op', + type: 'XmlExprOp', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'type', + type: 'uint32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typmod', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xmloption', + type: 'XmlOptionType', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'xpr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + } + ] + }, + { + name: 'XmlSerialize', + isNode: true, + fields: [ + { + name: 'expr', + type: 'Node', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'indent', + type: 'bool', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'location', + type: 'int32', + isNode: false, + isArray: false, + optional: true + }, + { + name: 'typeName', + type: 'TypeName', + isNode: true, + isArray: false, + optional: true + }, + { + name: 'xmloption', + type: 'XmlOptionType', + isNode: false, + isArray: false, + optional: true + } + ] + } +]; \ No newline at end of file diff --git a/packages/proto-parser/test-utils/meta/wrapped.ts b/packages/proto-parser/test-utils/meta/wrapped.ts new file mode 100644 index 00000000..b85c67cc --- /dev/null +++ b/packages/proto-parser/test-utils/meta/wrapped.ts @@ -0,0 +1,3574 @@ +/** +* This file was automatically generated by pg-proto-parser@1.29.0. +* DO NOT MODIFY IT BY HAND. Instead, modify the source proto file, +* and run the pg-proto-parser generate command to regenerate this file. +*/ +import _o from "nested-obj"; +import { ParseResult, ScanResult, Integer, Float, Boolean, String, BitString, List, OidList, IntList, A_Const, Alias, RangeVar, TableFunc, IntoClause, Var, Param, Aggref, GroupingFunc, WindowFunc, WindowFuncRunCondition, MergeSupportFunc, SubscriptingRef, FuncExpr, NamedArgExpr, OpExpr, DistinctExpr, NullIfExpr, ScalarArrayOpExpr, BoolExpr, SubLink, SubPlan, AlternativeSubPlan, FieldSelect, FieldStore, RelabelType, CoerceViaIO, ArrayCoerceExpr, ConvertRowtypeExpr, CollateExpr, CaseExpr, CaseWhen, CaseTestExpr, ArrayExpr, RowExpr, RowCompareExpr, CoalesceExpr, MinMaxExpr, SQLValueFunction, XmlExpr, JsonFormat, JsonReturning, JsonValueExpr, JsonConstructorExpr, JsonIsPredicate, JsonBehavior, JsonExpr, JsonTablePath, JsonTablePathScan, JsonTableSiblingJoin, NullTest, BooleanTest, MergeAction, CoerceToDomain, CoerceToDomainValue, SetToDefault, CurrentOfExpr, NextValueExpr, InferenceElem, TargetEntry, RangeTblRef, JoinExpr, FromExpr, OnConflictExpr, Query, TypeName, ColumnRef, ParamRef, A_Expr, TypeCast, CollateClause, RoleSpec, FuncCall, A_Star, A_Indices, A_Indirection, A_ArrayExpr, ResTarget, MultiAssignRef, SortBy, WindowDef, RangeSubselect, RangeFunction, RangeTableFunc, RangeTableFuncCol, RangeTableSample, ColumnDef, TableLikeClause, IndexElem, DefElem, LockingClause, XmlSerialize, PartitionElem, PartitionSpec, PartitionBoundSpec, PartitionRangeDatum, SinglePartitionSpec, PartitionCmd, RangeTblEntry, RTEPermissionInfo, RangeTblFunction, TableSampleClause, WithCheckOption, SortGroupClause, GroupingSet, WindowClause, RowMarkClause, WithClause, InferClause, OnConflictClause, CTESearchClause, CTECycleClause, CommonTableExpr, MergeWhenClause, TriggerTransition, JsonOutput, JsonArgument, JsonFuncExpr, JsonTablePathSpec, JsonTable, JsonTableColumn, JsonKeyValue, JsonParseExpr, JsonScalarExpr, JsonSerializeExpr, JsonObjectConstructor, JsonArrayConstructor, JsonArrayQueryConstructor, JsonAggConstructor, JsonObjectAgg, JsonArrayAgg, RawStmt, InsertStmt, DeleteStmt, UpdateStmt, MergeStmt, SelectStmt, SetOperationStmt, ReturnStmt, PLAssignStmt, CreateSchemaStmt, AlterTableStmt, ReplicaIdentityStmt, AlterTableCmd, AlterCollationStmt, AlterDomainStmt, GrantStmt, ObjectWithArgs, AccessPriv, GrantRoleStmt, AlterDefaultPrivilegesStmt, CopyStmt, VariableSetStmt, VariableShowStmt, CreateStmt, Constraint, CreateTableSpaceStmt, DropTableSpaceStmt, AlterTableSpaceOptionsStmt, AlterTableMoveAllStmt, CreateExtensionStmt, AlterExtensionStmt, AlterExtensionContentsStmt, CreateFdwStmt, AlterFdwStmt, CreateForeignServerStmt, AlterForeignServerStmt, CreateForeignTableStmt, CreateUserMappingStmt, AlterUserMappingStmt, DropUserMappingStmt, ImportForeignSchemaStmt, CreatePolicyStmt, AlterPolicyStmt, CreateAmStmt, CreateTrigStmt, CreateEventTrigStmt, AlterEventTrigStmt, CreatePLangStmt, CreateRoleStmt, AlterRoleStmt, AlterRoleSetStmt, DropRoleStmt, CreateSeqStmt, AlterSeqStmt, DefineStmt, CreateDomainStmt, CreateOpClassStmt, CreateOpClassItem, CreateOpFamilyStmt, AlterOpFamilyStmt, DropStmt, TruncateStmt, CommentStmt, SecLabelStmt, DeclareCursorStmt, ClosePortalStmt, FetchStmt, IndexStmt, CreateStatsStmt, StatsElem, AlterStatsStmt, CreateFunctionStmt, FunctionParameter, AlterFunctionStmt, DoStmt, InlineCodeBlock, CallStmt, CallContext, RenameStmt, AlterObjectDependsStmt, AlterObjectSchemaStmt, AlterOwnerStmt, AlterOperatorStmt, AlterTypeStmt, RuleStmt, NotifyStmt, ListenStmt, UnlistenStmt, TransactionStmt, CompositeTypeStmt, CreateEnumStmt, CreateRangeStmt, AlterEnumStmt, ViewStmt, LoadStmt, CreatedbStmt, AlterDatabaseStmt, AlterDatabaseRefreshCollStmt, AlterDatabaseSetStmt, DropdbStmt, AlterSystemStmt, ClusterStmt, VacuumStmt, VacuumRelation, ExplainStmt, CreateTableAsStmt, RefreshMatViewStmt, CheckPointStmt, DiscardStmt, LockStmt, ConstraintsSetStmt, ReindexStmt, CreateConversionStmt, CreateCastStmt, CreateTransformStmt, PrepareStmt, ExecuteStmt, DeallocateStmt, DropOwnedStmt, ReassignOwnedStmt, AlterTSDictionaryStmt, AlterTSConfigurationStmt, PublicationTable, PublicationObjSpec, CreatePublicationStmt, AlterPublicationStmt, CreateSubscriptionStmt, AlterSubscriptionStmt, DropSubscriptionStmt, ScanToken } from "@pgsql/types"; +export default { + parseResult(_p?: ParseResult): { + ParseResult: ParseResult; + } { + const _j = {} as ParseResult; + _o.set(_j, "version", _p?.version); + _o.set(_j, "stmts", _p?.stmts); + return { + ParseResult: _j + }; + }, + scanResult(_p?: ScanResult): { + ScanResult: ScanResult; + } { + const _j = {} as ScanResult; + _o.set(_j, "version", _p?.version); + _o.set(_j, "tokens", _p?.tokens); + return { + ScanResult: _j + }; + }, + integer(_p?: Integer): { + Integer: Integer; + } { + const _j = {} as Integer; + _o.set(_j, "ival", _p?.ival); + return { + Integer: _j + }; + }, + float(_p?: Float): { + Float: Float; + } { + const _j = {} as Float; + _o.set(_j, "fval", _p?.fval); + return { + Float: _j + }; + }, + boolean(_p?: Boolean): { + Boolean: Boolean; + } { + const _j = {} as Boolean; + _o.set(_j, "boolval", _p?.boolval); + return { + Boolean: _j + }; + }, + string(_p?: String): { + String: String; + } { + const _j = {} as String; + _o.set(_j, "sval", _p?.sval); + return { + String: _j + }; + }, + bitString(_p?: BitString): { + BitString: BitString; + } { + const _j = {} as BitString; + _o.set(_j, "bsval", _p?.bsval); + return { + BitString: _j + }; + }, + list(_p?: List): { + List: List; + } { + const _j = {} as List; + _o.set(_j, "items", _p?.items); + return { + List: _j + }; + }, + oidList(_p?: OidList): { + OidList: OidList; + } { + const _j = {} as OidList; + _o.set(_j, "items", _p?.items); + return { + OidList: _j + }; + }, + intList(_p?: IntList): { + IntList: IntList; + } { + const _j = {} as IntList; + _o.set(_j, "items", _p?.items); + return { + IntList: _j + }; + }, + aConst(_p?: A_Const): { + A_Const: A_Const; + } { + const _j = {} as A_Const; + _o.set(_j, "ival", _p?.ival); + _o.set(_j, "fval", _p?.fval); + _o.set(_j, "boolval", _p?.boolval); + _o.set(_j, "sval", _p?.sval); + _o.set(_j, "bsval", _p?.bsval); + _o.set(_j, "isnull", _p?.isnull); + _o.set(_j, "location", _p?.location); + return { + A_Const: _j + }; + }, + alias(_p?: Alias): { + Alias: Alias; + } { + const _j = {} as Alias; + _o.set(_j, "aliasname", _p?.aliasname); + _o.set(_j, "colnames", _p?.colnames); + return { + Alias: _j + }; + }, + rangeVar(_p?: RangeVar): { + RangeVar: RangeVar; + } { + const _j = {} as RangeVar; + _o.set(_j, "catalogname", _p?.catalogname); + _o.set(_j, "schemaname", _p?.schemaname); + _o.set(_j, "relname", _p?.relname); + _o.set(_j, "inh", _p?.inh); + _o.set(_j, "relpersistence", _p?.relpersistence); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "location", _p?.location); + return { + RangeVar: _j + }; + }, + tableFunc(_p?: TableFunc): { + TableFunc: TableFunc; + } { + const _j = {} as TableFunc; + _o.set(_j, "functype", _p?.functype); + _o.set(_j, "ns_uris", _p?.ns_uris); + _o.set(_j, "ns_names", _p?.ns_names); + _o.set(_j, "docexpr", _p?.docexpr); + _o.set(_j, "rowexpr", _p?.rowexpr); + _o.set(_j, "colnames", _p?.colnames); + _o.set(_j, "coltypes", _p?.coltypes); + _o.set(_j, "coltypmods", _p?.coltypmods); + _o.set(_j, "colcollations", _p?.colcollations); + _o.set(_j, "colexprs", _p?.colexprs); + _o.set(_j, "coldefexprs", _p?.coldefexprs); + _o.set(_j, "colvalexprs", _p?.colvalexprs); + _o.set(_j, "passingvalexprs", _p?.passingvalexprs); + _o.set(_j, "notnulls", _p?.notnulls); + _o.set(_j, "plan", _p?.plan); + _o.set(_j, "ordinalitycol", _p?.ordinalitycol); + _o.set(_j, "location", _p?.location); + return { + TableFunc: _j + }; + }, + intoClause(_p?: IntoClause): { + IntoClause: IntoClause; + } { + const _j = {} as IntoClause; + _o.set(_j, "rel", _p?.rel); + _o.set(_j, "colNames", _p?.colNames); + _o.set(_j, "accessMethod", _p?.accessMethod); + _o.set(_j, "options", _p?.options); + _o.set(_j, "onCommit", _p?.onCommit); + _o.set(_j, "tableSpaceName", _p?.tableSpaceName); + _o.set(_j, "viewQuery", _p?.viewQuery); + _o.set(_j, "skipData", _p?.skipData); + return { + IntoClause: _j + }; + }, + var(_p?: Var): { + Var: Var; + } { + const _j = {} as Var; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "varno", _p?.varno); + _o.set(_j, "varattno", _p?.varattno); + _o.set(_j, "vartype", _p?.vartype); + _o.set(_j, "vartypmod", _p?.vartypmod); + _o.set(_j, "varcollid", _p?.varcollid); + _o.set(_j, "varnullingrels", _p?.varnullingrels); + _o.set(_j, "varlevelsup", _p?.varlevelsup); + _o.set(_j, "location", _p?.location); + return { + Var: _j + }; + }, + param(_p?: Param): { + Param: Param; + } { + const _j = {} as Param; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "paramkind", _p?.paramkind); + _o.set(_j, "paramid", _p?.paramid); + _o.set(_j, "paramtype", _p?.paramtype); + _o.set(_j, "paramtypmod", _p?.paramtypmod); + _o.set(_j, "paramcollid", _p?.paramcollid); + _o.set(_j, "location", _p?.location); + return { + Param: _j + }; + }, + aggref(_p?: Aggref): { + Aggref: Aggref; + } { + const _j = {} as Aggref; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "aggfnoid", _p?.aggfnoid); + _o.set(_j, "aggtype", _p?.aggtype); + _o.set(_j, "aggcollid", _p?.aggcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "aggargtypes", _p?.aggargtypes); + _o.set(_j, "aggdirectargs", _p?.aggdirectargs); + _o.set(_j, "args", _p?.args); + _o.set(_j, "aggorder", _p?.aggorder); + _o.set(_j, "aggdistinct", _p?.aggdistinct); + _o.set(_j, "aggfilter", _p?.aggfilter); + _o.set(_j, "aggstar", _p?.aggstar); + _o.set(_j, "aggvariadic", _p?.aggvariadic); + _o.set(_j, "aggkind", _p?.aggkind); + _o.set(_j, "agglevelsup", _p?.agglevelsup); + _o.set(_j, "aggsplit", _p?.aggsplit); + _o.set(_j, "aggno", _p?.aggno); + _o.set(_j, "aggtransno", _p?.aggtransno); + _o.set(_j, "location", _p?.location); + return { + Aggref: _j + }; + }, + groupingFunc(_p?: GroupingFunc): { + GroupingFunc: GroupingFunc; + } { + const _j = {} as GroupingFunc; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "args", _p?.args); + _o.set(_j, "refs", _p?.refs); + _o.set(_j, "agglevelsup", _p?.agglevelsup); + _o.set(_j, "location", _p?.location); + return { + GroupingFunc: _j + }; + }, + windowFunc(_p?: WindowFunc): { + WindowFunc: WindowFunc; + } { + const _j = {} as WindowFunc; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "winfnoid", _p?.winfnoid); + _o.set(_j, "wintype", _p?.wintype); + _o.set(_j, "wincollid", _p?.wincollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "aggfilter", _p?.aggfilter); + _o.set(_j, "runCondition", _p?.runCondition); + _o.set(_j, "winref", _p?.winref); + _o.set(_j, "winstar", _p?.winstar); + _o.set(_j, "winagg", _p?.winagg); + _o.set(_j, "location", _p?.location); + return { + WindowFunc: _j + }; + }, + windowFuncRunCondition(_p?: WindowFuncRunCondition): { + WindowFuncRunCondition: WindowFuncRunCondition; + } { + const _j = {} as WindowFuncRunCondition; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "wfunc_left", _p?.wfunc_left); + _o.set(_j, "arg", _p?.arg); + return { + WindowFuncRunCondition: _j + }; + }, + mergeSupportFunc(_p?: MergeSupportFunc): { + MergeSupportFunc: MergeSupportFunc; + } { + const _j = {} as MergeSupportFunc; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "msftype", _p?.msftype); + _o.set(_j, "msfcollid", _p?.msfcollid); + _o.set(_j, "location", _p?.location); + return { + MergeSupportFunc: _j + }; + }, + subscriptingRef(_p?: SubscriptingRef): { + SubscriptingRef: SubscriptingRef; + } { + const _j = {} as SubscriptingRef; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "refcontainertype", _p?.refcontainertype); + _o.set(_j, "refelemtype", _p?.refelemtype); + _o.set(_j, "refrestype", _p?.refrestype); + _o.set(_j, "reftypmod", _p?.reftypmod); + _o.set(_j, "refcollid", _p?.refcollid); + _o.set(_j, "refupperindexpr", _p?.refupperindexpr); + _o.set(_j, "reflowerindexpr", _p?.reflowerindexpr); + _o.set(_j, "refexpr", _p?.refexpr); + _o.set(_j, "refassgnexpr", _p?.refassgnexpr); + return { + SubscriptingRef: _j + }; + }, + funcExpr(_p?: FuncExpr): { + FuncExpr: FuncExpr; + } { + const _j = {} as FuncExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "funcid", _p?.funcid); + _o.set(_j, "funcresulttype", _p?.funcresulttype); + _o.set(_j, "funcretset", _p?.funcretset); + _o.set(_j, "funcvariadic", _p?.funcvariadic); + _o.set(_j, "funcformat", _p?.funcformat); + _o.set(_j, "funccollid", _p?.funccollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + FuncExpr: _j + }; + }, + namedArgExpr(_p?: NamedArgExpr): { + NamedArgExpr: NamedArgExpr; + } { + const _j = {} as NamedArgExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "name", _p?.name); + _o.set(_j, "argnumber", _p?.argnumber); + _o.set(_j, "location", _p?.location); + return { + NamedArgExpr: _j + }; + }, + opExpr(_p?: OpExpr): { + OpExpr: OpExpr; + } { + const _j = {} as OpExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "opresulttype", _p?.opresulttype); + _o.set(_j, "opretset", _p?.opretset); + _o.set(_j, "opcollid", _p?.opcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + OpExpr: _j + }; + }, + distinctExpr(_p?: DistinctExpr): { + DistinctExpr: DistinctExpr; + } { + const _j = {} as DistinctExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "opresulttype", _p?.opresulttype); + _o.set(_j, "opretset", _p?.opretset); + _o.set(_j, "opcollid", _p?.opcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + DistinctExpr: _j + }; + }, + nullIfExpr(_p?: NullIfExpr): { + NullIfExpr: NullIfExpr; + } { + const _j = {} as NullIfExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "opresulttype", _p?.opresulttype); + _o.set(_j, "opretset", _p?.opretset); + _o.set(_j, "opcollid", _p?.opcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + NullIfExpr: _j + }; + }, + scalarArrayOpExpr(_p?: ScalarArrayOpExpr): { + ScalarArrayOpExpr: ScalarArrayOpExpr; + } { + const _j = {} as ScalarArrayOpExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "opno", _p?.opno); + _o.set(_j, "useOr", _p?.useOr); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + ScalarArrayOpExpr: _j + }; + }, + boolExpr(_p?: BoolExpr): { + BoolExpr: BoolExpr; + } { + const _j = {} as BoolExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "boolop", _p?.boolop); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + BoolExpr: _j + }; + }, + subLink(_p?: SubLink): { + SubLink: SubLink; + } { + const _j = {} as SubLink; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "subLinkType", _p?.subLinkType); + _o.set(_j, "subLinkId", _p?.subLinkId); + _o.set(_j, "testexpr", _p?.testexpr); + _o.set(_j, "operName", _p?.operName); + _o.set(_j, "subselect", _p?.subselect); + _o.set(_j, "location", _p?.location); + return { + SubLink: _j + }; + }, + subPlan(_p?: SubPlan): { + SubPlan: SubPlan; + } { + const _j = {} as SubPlan; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "subLinkType", _p?.subLinkType); + _o.set(_j, "testexpr", _p?.testexpr); + _o.set(_j, "paramIds", _p?.paramIds); + _o.set(_j, "plan_id", _p?.plan_id); + _o.set(_j, "plan_name", _p?.plan_name); + _o.set(_j, "firstColType", _p?.firstColType); + _o.set(_j, "firstColTypmod", _p?.firstColTypmod); + _o.set(_j, "firstColCollation", _p?.firstColCollation); + _o.set(_j, "useHashTable", _p?.useHashTable); + _o.set(_j, "unknownEqFalse", _p?.unknownEqFalse); + _o.set(_j, "parallel_safe", _p?.parallel_safe); + _o.set(_j, "setParam", _p?.setParam); + _o.set(_j, "parParam", _p?.parParam); + _o.set(_j, "args", _p?.args); + _o.set(_j, "startup_cost", _p?.startup_cost); + _o.set(_j, "per_call_cost", _p?.per_call_cost); + return { + SubPlan: _j + }; + }, + alternativeSubPlan(_p?: AlternativeSubPlan): { + AlternativeSubPlan: AlternativeSubPlan; + } { + const _j = {} as AlternativeSubPlan; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "subplans", _p?.subplans); + return { + AlternativeSubPlan: _j + }; + }, + fieldSelect(_p?: FieldSelect): { + FieldSelect: FieldSelect; + } { + const _j = {} as FieldSelect; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "fieldnum", _p?.fieldnum); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + return { + FieldSelect: _j + }; + }, + fieldStore(_p?: FieldStore): { + FieldStore: FieldStore; + } { + const _j = {} as FieldStore; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "newvals", _p?.newvals); + _o.set(_j, "fieldnums", _p?.fieldnums); + _o.set(_j, "resulttype", _p?.resulttype); + return { + FieldStore: _j + }; + }, + relabelType(_p?: RelabelType): { + RelabelType: RelabelType; + } { + const _j = {} as RelabelType; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "relabelformat", _p?.relabelformat); + _o.set(_j, "location", _p?.location); + return { + RelabelType: _j + }; + }, + coerceViaio(_p?: CoerceViaIO): { + CoerceViaIO: CoerceViaIO; + } { + const _j = {} as CoerceViaIO; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "coerceformat", _p?.coerceformat); + _o.set(_j, "location", _p?.location); + return { + CoerceViaIO: _j + }; + }, + arrayCoerceExpr(_p?: ArrayCoerceExpr): { + ArrayCoerceExpr: ArrayCoerceExpr; + } { + const _j = {} as ArrayCoerceExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "elemexpr", _p?.elemexpr); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "coerceformat", _p?.coerceformat); + _o.set(_j, "location", _p?.location); + return { + ArrayCoerceExpr: _j + }; + }, + convertRowtypeExpr(_p?: ConvertRowtypeExpr): { + ConvertRowtypeExpr: ConvertRowtypeExpr; + } { + const _j = {} as ConvertRowtypeExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "convertformat", _p?.convertformat); + _o.set(_j, "location", _p?.location); + return { + ConvertRowtypeExpr: _j + }; + }, + collateExpr(_p?: CollateExpr): { + CollateExpr: CollateExpr; + } { + const _j = {} as CollateExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "collOid", _p?.collOid); + _o.set(_j, "location", _p?.location); + return { + CollateExpr: _j + }; + }, + caseExpr(_p?: CaseExpr): { + CaseExpr: CaseExpr; + } { + const _j = {} as CaseExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "casetype", _p?.casetype); + _o.set(_j, "casecollid", _p?.casecollid); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "args", _p?.args); + _o.set(_j, "defresult", _p?.defresult); + _o.set(_j, "location", _p?.location); + return { + CaseExpr: _j + }; + }, + caseWhen(_p?: CaseWhen): { + CaseWhen: CaseWhen; + } { + const _j = {} as CaseWhen; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "result", _p?.result); + _o.set(_j, "location", _p?.location); + return { + CaseWhen: _j + }; + }, + caseTestExpr(_p?: CaseTestExpr): { + CaseTestExpr: CaseTestExpr; + } { + const _j = {} as CaseTestExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "typeId", _p?.typeId); + _o.set(_j, "typeMod", _p?.typeMod); + _o.set(_j, "collation", _p?.collation); + return { + CaseTestExpr: _j + }; + }, + arrayExpr(_p?: ArrayExpr): { + ArrayExpr: ArrayExpr; + } { + const _j = {} as ArrayExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "array_typeid", _p?.array_typeid); + _o.set(_j, "array_collid", _p?.array_collid); + _o.set(_j, "element_typeid", _p?.element_typeid); + _o.set(_j, "elements", _p?.elements); + _o.set(_j, "multidims", _p?.multidims); + _o.set(_j, "location", _p?.location); + return { + ArrayExpr: _j + }; + }, + rowExpr(_p?: RowExpr): { + RowExpr: RowExpr; + } { + const _j = {} as RowExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "args", _p?.args); + _o.set(_j, "row_typeid", _p?.row_typeid); + _o.set(_j, "row_format", _p?.row_format); + _o.set(_j, "colnames", _p?.colnames); + _o.set(_j, "location", _p?.location); + return { + RowExpr: _j + }; + }, + rowCompareExpr(_p?: RowCompareExpr): { + RowCompareExpr: RowCompareExpr; + } { + const _j = {} as RowCompareExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "rctype", _p?.rctype); + _o.set(_j, "opnos", _p?.opnos); + _o.set(_j, "opfamilies", _p?.opfamilies); + _o.set(_j, "inputcollids", _p?.inputcollids); + _o.set(_j, "largs", _p?.largs); + _o.set(_j, "rargs", _p?.rargs); + return { + RowCompareExpr: _j + }; + }, + coalesceExpr(_p?: CoalesceExpr): { + CoalesceExpr: CoalesceExpr; + } { + const _j = {} as CoalesceExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "coalescetype", _p?.coalescetype); + _o.set(_j, "coalescecollid", _p?.coalescecollid); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + CoalesceExpr: _j + }; + }, + minMaxExpr(_p?: MinMaxExpr): { + MinMaxExpr: MinMaxExpr; + } { + const _j = {} as MinMaxExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "minmaxtype", _p?.minmaxtype); + _o.set(_j, "minmaxcollid", _p?.minmaxcollid); + _o.set(_j, "inputcollid", _p?.inputcollid); + _o.set(_j, "op", _p?.op); + _o.set(_j, "args", _p?.args); + _o.set(_j, "location", _p?.location); + return { + MinMaxExpr: _j + }; + }, + sqlValueFunction(_p?: SQLValueFunction): { + SQLValueFunction: SQLValueFunction; + } { + const _j = {} as SQLValueFunction; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "op", _p?.op); + _o.set(_j, "type", _p?.type); + _o.set(_j, "typmod", _p?.typmod); + _o.set(_j, "location", _p?.location); + return { + SQLValueFunction: _j + }; + }, + xmlExpr(_p?: XmlExpr): { + XmlExpr: XmlExpr; + } { + const _j = {} as XmlExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "op", _p?.op); + _o.set(_j, "name", _p?.name); + _o.set(_j, "named_args", _p?.named_args); + _o.set(_j, "arg_names", _p?.arg_names); + _o.set(_j, "args", _p?.args); + _o.set(_j, "xmloption", _p?.xmloption); + _o.set(_j, "indent", _p?.indent); + _o.set(_j, "type", _p?.type); + _o.set(_j, "typmod", _p?.typmod); + _o.set(_j, "location", _p?.location); + return { + XmlExpr: _j + }; + }, + jsonFormat(_p?: JsonFormat): { + JsonFormat: JsonFormat; + } { + const _j = {} as JsonFormat; + _o.set(_j, "format_type", _p?.format_type); + _o.set(_j, "encoding", _p?.encoding); + _o.set(_j, "location", _p?.location); + return { + JsonFormat: _j + }; + }, + jsonReturning(_p?: JsonReturning): { + JsonReturning: JsonReturning; + } { + const _j = {} as JsonReturning; + _o.set(_j, "format", _p?.format); + _o.set(_j, "typid", _p?.typid); + _o.set(_j, "typmod", _p?.typmod); + return { + JsonReturning: _j + }; + }, + jsonValueExpr(_p?: JsonValueExpr): { + JsonValueExpr: JsonValueExpr; + } { + const _j = {} as JsonValueExpr; + _o.set(_j, "raw_expr", _p?.raw_expr); + _o.set(_j, "formatted_expr", _p?.formatted_expr); + _o.set(_j, "format", _p?.format); + return { + JsonValueExpr: _j + }; + }, + jsonConstructorExpr(_p?: JsonConstructorExpr): { + JsonConstructorExpr: JsonConstructorExpr; + } { + const _j = {} as JsonConstructorExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "type", _p?.type); + _o.set(_j, "args", _p?.args); + _o.set(_j, "func", _p?.func); + _o.set(_j, "coercion", _p?.coercion); + _o.set(_j, "returning", _p?.returning); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "unique", _p?.unique); + _o.set(_j, "location", _p?.location); + return { + JsonConstructorExpr: _j + }; + }, + jsonIsPredicate(_p?: JsonIsPredicate): { + JsonIsPredicate: JsonIsPredicate; + } { + const _j = {} as JsonIsPredicate; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "format", _p?.format); + _o.set(_j, "item_type", _p?.item_type); + _o.set(_j, "unique_keys", _p?.unique_keys); + _o.set(_j, "location", _p?.location); + return { + JsonIsPredicate: _j + }; + }, + jsonBehavior(_p?: JsonBehavior): { + JsonBehavior: JsonBehavior; + } { + const _j = {} as JsonBehavior; + _o.set(_j, "btype", _p?.btype); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "coerce", _p?.coerce); + _o.set(_j, "location", _p?.location); + return { + JsonBehavior: _j + }; + }, + jsonExpr(_p?: JsonExpr): { + JsonExpr: JsonExpr; + } { + const _j = {} as JsonExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "op", _p?.op); + _o.set(_j, "column_name", _p?.column_name); + _o.set(_j, "formatted_expr", _p?.formatted_expr); + _o.set(_j, "format", _p?.format); + _o.set(_j, "path_spec", _p?.path_spec); + _o.set(_j, "returning", _p?.returning); + _o.set(_j, "passing_names", _p?.passing_names); + _o.set(_j, "passing_values", _p?.passing_values); + _o.set(_j, "on_empty", _p?.on_empty); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "use_io_coercion", _p?.use_io_coercion); + _o.set(_j, "use_json_coercion", _p?.use_json_coercion); + _o.set(_j, "wrapper", _p?.wrapper); + _o.set(_j, "omit_quotes", _p?.omit_quotes); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "location", _p?.location); + return { + JsonExpr: _j + }; + }, + jsonTablePath(_p?: JsonTablePath): { + JsonTablePath: JsonTablePath; + } { + const _j = {} as JsonTablePath; + _o.set(_j, "name", _p?.name); + return { + JsonTablePath: _j + }; + }, + jsonTablePathScan(_p?: JsonTablePathScan): { + JsonTablePathScan: JsonTablePathScan; + } { + const _j = {} as JsonTablePathScan; + _o.set(_j, "plan", _p?.plan); + _o.set(_j, "path", _p?.path); + _o.set(_j, "errorOnError", _p?.errorOnError); + _o.set(_j, "child", _p?.child); + _o.set(_j, "colMin", _p?.colMin); + _o.set(_j, "colMax", _p?.colMax); + return { + JsonTablePathScan: _j + }; + }, + jsonTableSiblingJoin(_p?: JsonTableSiblingJoin): { + JsonTableSiblingJoin: JsonTableSiblingJoin; + } { + const _j = {} as JsonTableSiblingJoin; + _o.set(_j, "plan", _p?.plan); + _o.set(_j, "lplan", _p?.lplan); + _o.set(_j, "rplan", _p?.rplan); + return { + JsonTableSiblingJoin: _j + }; + }, + nullTest(_p?: NullTest): { + NullTest: NullTest; + } { + const _j = {} as NullTest; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "nulltesttype", _p?.nulltesttype); + _o.set(_j, "argisrow", _p?.argisrow); + _o.set(_j, "location", _p?.location); + return { + NullTest: _j + }; + }, + booleanTest(_p?: BooleanTest): { + BooleanTest: BooleanTest; + } { + const _j = {} as BooleanTest; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "booltesttype", _p?.booltesttype); + _o.set(_j, "location", _p?.location); + return { + BooleanTest: _j + }; + }, + mergeAction(_p?: MergeAction): { + MergeAction: MergeAction; + } { + const _j = {} as MergeAction; + _o.set(_j, "matchKind", _p?.matchKind); + _o.set(_j, "commandType", _p?.commandType); + _o.set(_j, "override", _p?.override); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "updateColnos", _p?.updateColnos); + return { + MergeAction: _j + }; + }, + coerceToDomain(_p?: CoerceToDomain): { + CoerceToDomain: CoerceToDomain; + } { + const _j = {} as CoerceToDomain; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "resulttype", _p?.resulttype); + _o.set(_j, "resulttypmod", _p?.resulttypmod); + _o.set(_j, "resultcollid", _p?.resultcollid); + _o.set(_j, "coercionformat", _p?.coercionformat); + _o.set(_j, "location", _p?.location); + return { + CoerceToDomain: _j + }; + }, + coerceToDomainValue(_p?: CoerceToDomainValue): { + CoerceToDomainValue: CoerceToDomainValue; + } { + const _j = {} as CoerceToDomainValue; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "typeId", _p?.typeId); + _o.set(_j, "typeMod", _p?.typeMod); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "location", _p?.location); + return { + CoerceToDomainValue: _j + }; + }, + setToDefault(_p?: SetToDefault): { + SetToDefault: SetToDefault; + } { + const _j = {} as SetToDefault; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "typeId", _p?.typeId); + _o.set(_j, "typeMod", _p?.typeMod); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "location", _p?.location); + return { + SetToDefault: _j + }; + }, + currentOfExpr(_p?: CurrentOfExpr): { + CurrentOfExpr: CurrentOfExpr; + } { + const _j = {} as CurrentOfExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "cvarno", _p?.cvarno); + _o.set(_j, "cursor_name", _p?.cursor_name); + _o.set(_j, "cursor_param", _p?.cursor_param); + return { + CurrentOfExpr: _j + }; + }, + nextValueExpr(_p?: NextValueExpr): { + NextValueExpr: NextValueExpr; + } { + const _j = {} as NextValueExpr; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "seqid", _p?.seqid); + _o.set(_j, "typeId", _p?.typeId); + return { + NextValueExpr: _j + }; + }, + inferenceElem(_p?: InferenceElem): { + InferenceElem: InferenceElem; + } { + const _j = {} as InferenceElem; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "infercollid", _p?.infercollid); + _o.set(_j, "inferopclass", _p?.inferopclass); + return { + InferenceElem: _j + }; + }, + targetEntry(_p?: TargetEntry): { + TargetEntry: TargetEntry; + } { + const _j = {} as TargetEntry; + _o.set(_j, "xpr", _p?.xpr); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "resno", _p?.resno); + _o.set(_j, "resname", _p?.resname); + _o.set(_j, "ressortgroupref", _p?.ressortgroupref); + _o.set(_j, "resorigtbl", _p?.resorigtbl); + _o.set(_j, "resorigcol", _p?.resorigcol); + _o.set(_j, "resjunk", _p?.resjunk); + return { + TargetEntry: _j + }; + }, + rangeTblRef(_p?: RangeTblRef): { + RangeTblRef: RangeTblRef; + } { + const _j = {} as RangeTblRef; + _o.set(_j, "rtindex", _p?.rtindex); + return { + RangeTblRef: _j + }; + }, + joinExpr(_p?: JoinExpr): { + JoinExpr: JoinExpr; + } { + const _j = {} as JoinExpr; + _o.set(_j, "jointype", _p?.jointype); + _o.set(_j, "isNatural", _p?.isNatural); + _o.set(_j, "larg", _p?.larg); + _o.set(_j, "rarg", _p?.rarg); + _o.set(_j, "usingClause", _p?.usingClause); + _o.set(_j, "join_using_alias", _p?.join_using_alias); + _o.set(_j, "quals", _p?.quals); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "rtindex", _p?.rtindex); + return { + JoinExpr: _j + }; + }, + fromExpr(_p?: FromExpr): { + FromExpr: FromExpr; + } { + const _j = {} as FromExpr; + _o.set(_j, "fromlist", _p?.fromlist); + _o.set(_j, "quals", _p?.quals); + return { + FromExpr: _j + }; + }, + onConflictExpr(_p?: OnConflictExpr): { + OnConflictExpr: OnConflictExpr; + } { + const _j = {} as OnConflictExpr; + _o.set(_j, "action", _p?.action); + _o.set(_j, "arbiterElems", _p?.arbiterElems); + _o.set(_j, "arbiterWhere", _p?.arbiterWhere); + _o.set(_j, "constraint", _p?.constraint); + _o.set(_j, "onConflictSet", _p?.onConflictSet); + _o.set(_j, "onConflictWhere", _p?.onConflictWhere); + _o.set(_j, "exclRelIndex", _p?.exclRelIndex); + _o.set(_j, "exclRelTlist", _p?.exclRelTlist); + return { + OnConflictExpr: _j + }; + }, + query(_p?: Query): { + Query: Query; + } { + const _j = {} as Query; + _o.set(_j, "commandType", _p?.commandType); + _o.set(_j, "querySource", _p?.querySource); + _o.set(_j, "canSetTag", _p?.canSetTag); + _o.set(_j, "utilityStmt", _p?.utilityStmt); + _o.set(_j, "resultRelation", _p?.resultRelation); + _o.set(_j, "hasAggs", _p?.hasAggs); + _o.set(_j, "hasWindowFuncs", _p?.hasWindowFuncs); + _o.set(_j, "hasTargetSRFs", _p?.hasTargetSRFs); + _o.set(_j, "hasSubLinks", _p?.hasSubLinks); + _o.set(_j, "hasDistinctOn", _p?.hasDistinctOn); + _o.set(_j, "hasRecursive", _p?.hasRecursive); + _o.set(_j, "hasModifyingCTE", _p?.hasModifyingCTE); + _o.set(_j, "hasForUpdate", _p?.hasForUpdate); + _o.set(_j, "hasRowSecurity", _p?.hasRowSecurity); + _o.set(_j, "isReturn", _p?.isReturn); + _o.set(_j, "cteList", _p?.cteList); + _o.set(_j, "rtable", _p?.rtable); + _o.set(_j, "rteperminfos", _p?.rteperminfos); + _o.set(_j, "jointree", _p?.jointree); + _o.set(_j, "mergeActionList", _p?.mergeActionList); + _o.set(_j, "mergeTargetRelation", _p?.mergeTargetRelation); + _o.set(_j, "mergeJoinCondition", _p?.mergeJoinCondition); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "override", _p?.override); + _o.set(_j, "onConflict", _p?.onConflict); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "groupClause", _p?.groupClause); + _o.set(_j, "groupDistinct", _p?.groupDistinct); + _o.set(_j, "groupingSets", _p?.groupingSets); + _o.set(_j, "havingQual", _p?.havingQual); + _o.set(_j, "windowClause", _p?.windowClause); + _o.set(_j, "distinctClause", _p?.distinctClause); + _o.set(_j, "sortClause", _p?.sortClause); + _o.set(_j, "limitOffset", _p?.limitOffset); + _o.set(_j, "limitCount", _p?.limitCount); + _o.set(_j, "limitOption", _p?.limitOption); + _o.set(_j, "rowMarks", _p?.rowMarks); + _o.set(_j, "setOperations", _p?.setOperations); + _o.set(_j, "constraintDeps", _p?.constraintDeps); + _o.set(_j, "withCheckOptions", _p?.withCheckOptions); + _o.set(_j, "stmt_location", _p?.stmt_location); + _o.set(_j, "stmt_len", _p?.stmt_len); + return { + Query: _j + }; + }, + typeName(_p?: TypeName): { + TypeName: TypeName; + } { + const _j = {} as TypeName; + _o.set(_j, "names", _p?.names); + _o.set(_j, "typeOid", _p?.typeOid); + _o.set(_j, "setof", _p?.setof); + _o.set(_j, "pct_type", _p?.pct_type); + _o.set(_j, "typmods", _p?.typmods); + _o.set(_j, "typemod", _p?.typemod); + _o.set(_j, "arrayBounds", _p?.arrayBounds); + _o.set(_j, "location", _p?.location); + return { + TypeName: _j + }; + }, + columnRef(_p?: ColumnRef): { + ColumnRef: ColumnRef; + } { + const _j = {} as ColumnRef; + _o.set(_j, "fields", _p?.fields); + _o.set(_j, "location", _p?.location); + return { + ColumnRef: _j + }; + }, + paramRef(_p?: ParamRef): { + ParamRef: ParamRef; + } { + const _j = {} as ParamRef; + _o.set(_j, "number", _p?.number); + _o.set(_j, "location", _p?.location); + return { + ParamRef: _j + }; + }, + aExpr(_p?: A_Expr): { + A_Expr: A_Expr; + } { + const _j = {} as A_Expr; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "name", _p?.name); + _o.set(_j, "lexpr", _p?.lexpr); + _o.set(_j, "rexpr", _p?.rexpr); + _o.set(_j, "location", _p?.location); + return { + A_Expr: _j + }; + }, + typeCast(_p?: TypeCast): { + TypeCast: TypeCast; + } { + const _j = {} as TypeCast; + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "location", _p?.location); + return { + TypeCast: _j + }; + }, + collateClause(_p?: CollateClause): { + CollateClause: CollateClause; + } { + const _j = {} as CollateClause; + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "collname", _p?.collname); + _o.set(_j, "location", _p?.location); + return { + CollateClause: _j + }; + }, + roleSpec(_p?: RoleSpec): { + RoleSpec: RoleSpec; + } { + const _j = {} as RoleSpec; + _o.set(_j, "roletype", _p?.roletype); + _o.set(_j, "rolename", _p?.rolename); + _o.set(_j, "location", _p?.location); + return { + RoleSpec: _j + }; + }, + funcCall(_p?: FuncCall): { + FuncCall: FuncCall; + } { + const _j = {} as FuncCall; + _o.set(_j, "funcname", _p?.funcname); + _o.set(_j, "args", _p?.args); + _o.set(_j, "agg_order", _p?.agg_order); + _o.set(_j, "agg_filter", _p?.agg_filter); + _o.set(_j, "over", _p?.over); + _o.set(_j, "agg_within_group", _p?.agg_within_group); + _o.set(_j, "agg_star", _p?.agg_star); + _o.set(_j, "agg_distinct", _p?.agg_distinct); + _o.set(_j, "func_variadic", _p?.func_variadic); + _o.set(_j, "funcformat", _p?.funcformat); + _o.set(_j, "location", _p?.location); + return { + FuncCall: _j + }; + }, + aStar(_p?: A_Star): { + A_Star: A_Star; + } { + const _j = {} as A_Star; + return { + A_Star: _j + }; + }, + aIndices(_p?: A_Indices): { + A_Indices: A_Indices; + } { + const _j = {} as A_Indices; + _o.set(_j, "is_slice", _p?.is_slice); + _o.set(_j, "lidx", _p?.lidx); + _o.set(_j, "uidx", _p?.uidx); + return { + A_Indices: _j + }; + }, + aIndirection(_p?: A_Indirection): { + A_Indirection: A_Indirection; + } { + const _j = {} as A_Indirection; + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "indirection", _p?.indirection); + return { + A_Indirection: _j + }; + }, + aArrayExpr(_p?: A_ArrayExpr): { + A_ArrayExpr: A_ArrayExpr; + } { + const _j = {} as A_ArrayExpr; + _o.set(_j, "elements", _p?.elements); + _o.set(_j, "location", _p?.location); + return { + A_ArrayExpr: _j + }; + }, + resTarget(_p?: ResTarget): { + ResTarget: ResTarget; + } { + const _j = {} as ResTarget; + _o.set(_j, "name", _p?.name); + _o.set(_j, "indirection", _p?.indirection); + _o.set(_j, "val", _p?.val); + _o.set(_j, "location", _p?.location); + return { + ResTarget: _j + }; + }, + multiAssignRef(_p?: MultiAssignRef): { + MultiAssignRef: MultiAssignRef; + } { + const _j = {} as MultiAssignRef; + _o.set(_j, "source", _p?.source); + _o.set(_j, "colno", _p?.colno); + _o.set(_j, "ncolumns", _p?.ncolumns); + return { + MultiAssignRef: _j + }; + }, + sortBy(_p?: SortBy): { + SortBy: SortBy; + } { + const _j = {} as SortBy; + _o.set(_j, "node", _p?.node); + _o.set(_j, "sortby_dir", _p?.sortby_dir); + _o.set(_j, "sortby_nulls", _p?.sortby_nulls); + _o.set(_j, "useOp", _p?.useOp); + _o.set(_j, "location", _p?.location); + return { + SortBy: _j + }; + }, + windowDef(_p?: WindowDef): { + WindowDef: WindowDef; + } { + const _j = {} as WindowDef; + _o.set(_j, "name", _p?.name); + _o.set(_j, "refname", _p?.refname); + _o.set(_j, "partitionClause", _p?.partitionClause); + _o.set(_j, "orderClause", _p?.orderClause); + _o.set(_j, "frameOptions", _p?.frameOptions); + _o.set(_j, "startOffset", _p?.startOffset); + _o.set(_j, "endOffset", _p?.endOffset); + _o.set(_j, "location", _p?.location); + return { + WindowDef: _j + }; + }, + rangeSubselect(_p?: RangeSubselect): { + RangeSubselect: RangeSubselect; + } { + const _j = {} as RangeSubselect; + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "subquery", _p?.subquery); + _o.set(_j, "alias", _p?.alias); + return { + RangeSubselect: _j + }; + }, + rangeFunction(_p?: RangeFunction): { + RangeFunction: RangeFunction; + } { + const _j = {} as RangeFunction; + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "ordinality", _p?.ordinality); + _o.set(_j, "is_rowsfrom", _p?.is_rowsfrom); + _o.set(_j, "functions", _p?.functions); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "coldeflist", _p?.coldeflist); + return { + RangeFunction: _j + }; + }, + rangeTableFunc(_p?: RangeTableFunc): { + RangeTableFunc: RangeTableFunc; + } { + const _j = {} as RangeTableFunc; + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "docexpr", _p?.docexpr); + _o.set(_j, "rowexpr", _p?.rowexpr); + _o.set(_j, "namespaces", _p?.namespaces); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "location", _p?.location); + return { + RangeTableFunc: _j + }; + }, + rangeTableFuncCol(_p?: RangeTableFuncCol): { + RangeTableFuncCol: RangeTableFuncCol; + } { + const _j = {} as RangeTableFuncCol; + _o.set(_j, "colname", _p?.colname); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "for_ordinality", _p?.for_ordinality); + _o.set(_j, "is_not_null", _p?.is_not_null); + _o.set(_j, "colexpr", _p?.colexpr); + _o.set(_j, "coldefexpr", _p?.coldefexpr); + _o.set(_j, "location", _p?.location); + return { + RangeTableFuncCol: _j + }; + }, + rangeTableSample(_p?: RangeTableSample): { + RangeTableSample: RangeTableSample; + } { + const _j = {} as RangeTableSample; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "method", _p?.method); + _o.set(_j, "args", _p?.args); + _o.set(_j, "repeatable", _p?.repeatable); + _o.set(_j, "location", _p?.location); + return { + RangeTableSample: _j + }; + }, + columnDef(_p?: ColumnDef): { + ColumnDef: ColumnDef; + } { + const _j = {} as ColumnDef; + _o.set(_j, "colname", _p?.colname); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "compression", _p?.compression); + _o.set(_j, "inhcount", _p?.inhcount); + _o.set(_j, "is_local", _p?.is_local); + _o.set(_j, "is_not_null", _p?.is_not_null); + _o.set(_j, "is_from_type", _p?.is_from_type); + _o.set(_j, "storage", _p?.storage); + _o.set(_j, "storage_name", _p?.storage_name); + _o.set(_j, "raw_default", _p?.raw_default); + _o.set(_j, "cooked_default", _p?.cooked_default); + _o.set(_j, "identity", _p?.identity); + _o.set(_j, "identitySequence", _p?.identitySequence); + _o.set(_j, "generated", _p?.generated); + _o.set(_j, "collClause", _p?.collClause); + _o.set(_j, "collOid", _p?.collOid); + _o.set(_j, "constraints", _p?.constraints); + _o.set(_j, "fdwoptions", _p?.fdwoptions); + _o.set(_j, "location", _p?.location); + return { + ColumnDef: _j + }; + }, + tableLikeClause(_p?: TableLikeClause): { + TableLikeClause: TableLikeClause; + } { + const _j = {} as TableLikeClause; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "options", _p?.options); + _o.set(_j, "relationOid", _p?.relationOid); + return { + TableLikeClause: _j + }; + }, + indexElem(_p?: IndexElem): { + IndexElem: IndexElem; + } { + const _j = {} as IndexElem; + _o.set(_j, "name", _p?.name); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "indexcolname", _p?.indexcolname); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "opclass", _p?.opclass); + _o.set(_j, "opclassopts", _p?.opclassopts); + _o.set(_j, "ordering", _p?.ordering); + _o.set(_j, "nulls_ordering", _p?.nulls_ordering); + return { + IndexElem: _j + }; + }, + defElem(_p?: DefElem): { + DefElem: DefElem; + } { + const _j = {} as DefElem; + _o.set(_j, "defnamespace", _p?.defnamespace); + _o.set(_j, "defname", _p?.defname); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "defaction", _p?.defaction); + _o.set(_j, "location", _p?.location); + return { + DefElem: _j + }; + }, + lockingClause(_p?: LockingClause): { + LockingClause: LockingClause; + } { + const _j = {} as LockingClause; + _o.set(_j, "lockedRels", _p?.lockedRels); + _o.set(_j, "strength", _p?.strength); + _o.set(_j, "waitPolicy", _p?.waitPolicy); + return { + LockingClause: _j + }; + }, + xmlSerialize(_p?: XmlSerialize): { + XmlSerialize: XmlSerialize; + } { + const _j = {} as XmlSerialize; + _o.set(_j, "xmloption", _p?.xmloption); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "indent", _p?.indent); + _o.set(_j, "location", _p?.location); + return { + XmlSerialize: _j + }; + }, + partitionElem(_p?: PartitionElem): { + PartitionElem: PartitionElem; + } { + const _j = {} as PartitionElem; + _o.set(_j, "name", _p?.name); + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "collation", _p?.collation); + _o.set(_j, "opclass", _p?.opclass); + _o.set(_j, "location", _p?.location); + return { + PartitionElem: _j + }; + }, + partitionSpec(_p?: PartitionSpec): { + PartitionSpec: PartitionSpec; + } { + const _j = {} as PartitionSpec; + _o.set(_j, "strategy", _p?.strategy); + _o.set(_j, "partParams", _p?.partParams); + _o.set(_j, "location", _p?.location); + return { + PartitionSpec: _j + }; + }, + partitionBoundSpec(_p?: PartitionBoundSpec): { + PartitionBoundSpec: PartitionBoundSpec; + } { + const _j = {} as PartitionBoundSpec; + _o.set(_j, "strategy", _p?.strategy); + _o.set(_j, "is_default", _p?.is_default); + _o.set(_j, "modulus", _p?.modulus); + _o.set(_j, "remainder", _p?.remainder); + _o.set(_j, "listdatums", _p?.listdatums); + _o.set(_j, "lowerdatums", _p?.lowerdatums); + _o.set(_j, "upperdatums", _p?.upperdatums); + _o.set(_j, "location", _p?.location); + return { + PartitionBoundSpec: _j + }; + }, + partitionRangeDatum(_p?: PartitionRangeDatum): { + PartitionRangeDatum: PartitionRangeDatum; + } { + const _j = {} as PartitionRangeDatum; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "value", _p?.value); + _o.set(_j, "location", _p?.location); + return { + PartitionRangeDatum: _j + }; + }, + singlePartitionSpec(_p?: SinglePartitionSpec): { + SinglePartitionSpec: SinglePartitionSpec; + } { + const _j = {} as SinglePartitionSpec; + return { + SinglePartitionSpec: _j + }; + }, + partitionCmd(_p?: PartitionCmd): { + PartitionCmd: PartitionCmd; + } { + const _j = {} as PartitionCmd; + _o.set(_j, "name", _p?.name); + _o.set(_j, "bound", _p?.bound); + _o.set(_j, "concurrent", _p?.concurrent); + return { + PartitionCmd: _j + }; + }, + rangeTblEntry(_p?: RangeTblEntry): { + RangeTblEntry: RangeTblEntry; + } { + const _j = {} as RangeTblEntry; + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "eref", _p?.eref); + _o.set(_j, "rtekind", _p?.rtekind); + _o.set(_j, "relid", _p?.relid); + _o.set(_j, "inh", _p?.inh); + _o.set(_j, "relkind", _p?.relkind); + _o.set(_j, "rellockmode", _p?.rellockmode); + _o.set(_j, "perminfoindex", _p?.perminfoindex); + _o.set(_j, "tablesample", _p?.tablesample); + _o.set(_j, "subquery", _p?.subquery); + _o.set(_j, "security_barrier", _p?.security_barrier); + _o.set(_j, "jointype", _p?.jointype); + _o.set(_j, "joinmergedcols", _p?.joinmergedcols); + _o.set(_j, "joinaliasvars", _p?.joinaliasvars); + _o.set(_j, "joinleftcols", _p?.joinleftcols); + _o.set(_j, "joinrightcols", _p?.joinrightcols); + _o.set(_j, "join_using_alias", _p?.join_using_alias); + _o.set(_j, "functions", _p?.functions); + _o.set(_j, "funcordinality", _p?.funcordinality); + _o.set(_j, "tablefunc", _p?.tablefunc); + _o.set(_j, "values_lists", _p?.values_lists); + _o.set(_j, "ctename", _p?.ctename); + _o.set(_j, "ctelevelsup", _p?.ctelevelsup); + _o.set(_j, "self_reference", _p?.self_reference); + _o.set(_j, "coltypes", _p?.coltypes); + _o.set(_j, "coltypmods", _p?.coltypmods); + _o.set(_j, "colcollations", _p?.colcollations); + _o.set(_j, "enrname", _p?.enrname); + _o.set(_j, "enrtuples", _p?.enrtuples); + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "inFromCl", _p?.inFromCl); + _o.set(_j, "securityQuals", _p?.securityQuals); + return { + RangeTblEntry: _j + }; + }, + rtePermissionInfo(_p?: RTEPermissionInfo): { + RTEPermissionInfo: RTEPermissionInfo; + } { + const _j = {} as RTEPermissionInfo; + _o.set(_j, "relid", _p?.relid); + _o.set(_j, "inh", _p?.inh); + _o.set(_j, "requiredPerms", _p?.requiredPerms); + _o.set(_j, "checkAsUser", _p?.checkAsUser); + _o.set(_j, "selectedCols", _p?.selectedCols); + _o.set(_j, "insertedCols", _p?.insertedCols); + _o.set(_j, "updatedCols", _p?.updatedCols); + return { + RTEPermissionInfo: _j + }; + }, + rangeTblFunction(_p?: RangeTblFunction): { + RangeTblFunction: RangeTblFunction; + } { + const _j = {} as RangeTblFunction; + _o.set(_j, "funcexpr", _p?.funcexpr); + _o.set(_j, "funccolcount", _p?.funccolcount); + _o.set(_j, "funccolnames", _p?.funccolnames); + _o.set(_j, "funccoltypes", _p?.funccoltypes); + _o.set(_j, "funccoltypmods", _p?.funccoltypmods); + _o.set(_j, "funccolcollations", _p?.funccolcollations); + _o.set(_j, "funcparams", _p?.funcparams); + return { + RangeTblFunction: _j + }; + }, + tableSampleClause(_p?: TableSampleClause): { + TableSampleClause: TableSampleClause; + } { + const _j = {} as TableSampleClause; + _o.set(_j, "tsmhandler", _p?.tsmhandler); + _o.set(_j, "args", _p?.args); + _o.set(_j, "repeatable", _p?.repeatable); + return { + TableSampleClause: _j + }; + }, + withCheckOption(_p?: WithCheckOption): { + WithCheckOption: WithCheckOption; + } { + const _j = {} as WithCheckOption; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "relname", _p?.relname); + _o.set(_j, "polname", _p?.polname); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "cascaded", _p?.cascaded); + return { + WithCheckOption: _j + }; + }, + sortGroupClause(_p?: SortGroupClause): { + SortGroupClause: SortGroupClause; + } { + const _j = {} as SortGroupClause; + _o.set(_j, "tleSortGroupRef", _p?.tleSortGroupRef); + _o.set(_j, "eqop", _p?.eqop); + _o.set(_j, "sortop", _p?.sortop); + _o.set(_j, "nulls_first", _p?.nulls_first); + _o.set(_j, "hashable", _p?.hashable); + return { + SortGroupClause: _j + }; + }, + groupingSet(_p?: GroupingSet): { + GroupingSet: GroupingSet; + } { + const _j = {} as GroupingSet; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "content", _p?.content); + _o.set(_j, "location", _p?.location); + return { + GroupingSet: _j + }; + }, + windowClause(_p?: WindowClause): { + WindowClause: WindowClause; + } { + const _j = {} as WindowClause; + _o.set(_j, "name", _p?.name); + _o.set(_j, "refname", _p?.refname); + _o.set(_j, "partitionClause", _p?.partitionClause); + _o.set(_j, "orderClause", _p?.orderClause); + _o.set(_j, "frameOptions", _p?.frameOptions); + _o.set(_j, "startOffset", _p?.startOffset); + _o.set(_j, "endOffset", _p?.endOffset); + _o.set(_j, "startInRangeFunc", _p?.startInRangeFunc); + _o.set(_j, "endInRangeFunc", _p?.endInRangeFunc); + _o.set(_j, "inRangeColl", _p?.inRangeColl); + _o.set(_j, "inRangeAsc", _p?.inRangeAsc); + _o.set(_j, "inRangeNullsFirst", _p?.inRangeNullsFirst); + _o.set(_j, "winref", _p?.winref); + _o.set(_j, "copiedOrder", _p?.copiedOrder); + return { + WindowClause: _j + }; + }, + rowMarkClause(_p?: RowMarkClause): { + RowMarkClause: RowMarkClause; + } { + const _j = {} as RowMarkClause; + _o.set(_j, "rti", _p?.rti); + _o.set(_j, "strength", _p?.strength); + _o.set(_j, "waitPolicy", _p?.waitPolicy); + _o.set(_j, "pushedDown", _p?.pushedDown); + return { + RowMarkClause: _j + }; + }, + withClause(_p?: WithClause): { + WithClause: WithClause; + } { + const _j = {} as WithClause; + _o.set(_j, "ctes", _p?.ctes); + _o.set(_j, "recursive", _p?.recursive); + _o.set(_j, "location", _p?.location); + return { + WithClause: _j + }; + }, + inferClause(_p?: InferClause): { + InferClause: InferClause; + } { + const _j = {} as InferClause; + _o.set(_j, "indexElems", _p?.indexElems); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "conname", _p?.conname); + _o.set(_j, "location", _p?.location); + return { + InferClause: _j + }; + }, + onConflictClause(_p?: OnConflictClause): { + OnConflictClause: OnConflictClause; + } { + const _j = {} as OnConflictClause; + _o.set(_j, "action", _p?.action); + _o.set(_j, "infer", _p?.infer); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "location", _p?.location); + return { + OnConflictClause: _j + }; + }, + cteSearchClause(_p?: CTESearchClause): { + CTESearchClause: CTESearchClause; + } { + const _j = {} as CTESearchClause; + _o.set(_j, "search_col_list", _p?.search_col_list); + _o.set(_j, "search_breadth_first", _p?.search_breadth_first); + _o.set(_j, "search_seq_column", _p?.search_seq_column); + _o.set(_j, "location", _p?.location); + return { + CTESearchClause: _j + }; + }, + cteCycleClause(_p?: CTECycleClause): { + CTECycleClause: CTECycleClause; + } { + const _j = {} as CTECycleClause; + _o.set(_j, "cycle_col_list", _p?.cycle_col_list); + _o.set(_j, "cycle_mark_column", _p?.cycle_mark_column); + _o.set(_j, "cycle_mark_value", _p?.cycle_mark_value); + _o.set(_j, "cycle_mark_default", _p?.cycle_mark_default); + _o.set(_j, "cycle_path_column", _p?.cycle_path_column); + _o.set(_j, "location", _p?.location); + _o.set(_j, "cycle_mark_type", _p?.cycle_mark_type); + _o.set(_j, "cycle_mark_typmod", _p?.cycle_mark_typmod); + _o.set(_j, "cycle_mark_collation", _p?.cycle_mark_collation); + _o.set(_j, "cycle_mark_neop", _p?.cycle_mark_neop); + return { + CTECycleClause: _j + }; + }, + commonTableExpr(_p?: CommonTableExpr): { + CommonTableExpr: CommonTableExpr; + } { + const _j = {} as CommonTableExpr; + _o.set(_j, "ctename", _p?.ctename); + _o.set(_j, "aliascolnames", _p?.aliascolnames); + _o.set(_j, "ctematerialized", _p?.ctematerialized); + _o.set(_j, "ctequery", _p?.ctequery); + _o.set(_j, "search_clause", _p?.search_clause); + _o.set(_j, "cycle_clause", _p?.cycle_clause); + _o.set(_j, "location", _p?.location); + _o.set(_j, "cterecursive", _p?.cterecursive); + _o.set(_j, "cterefcount", _p?.cterefcount); + _o.set(_j, "ctecolnames", _p?.ctecolnames); + _o.set(_j, "ctecoltypes", _p?.ctecoltypes); + _o.set(_j, "ctecoltypmods", _p?.ctecoltypmods); + _o.set(_j, "ctecolcollations", _p?.ctecolcollations); + return { + CommonTableExpr: _j + }; + }, + mergeWhenClause(_p?: MergeWhenClause): { + MergeWhenClause: MergeWhenClause; + } { + const _j = {} as MergeWhenClause; + _o.set(_j, "matchKind", _p?.matchKind); + _o.set(_j, "commandType", _p?.commandType); + _o.set(_j, "override", _p?.override); + _o.set(_j, "condition", _p?.condition); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "values", _p?.values); + return { + MergeWhenClause: _j + }; + }, + triggerTransition(_p?: TriggerTransition): { + TriggerTransition: TriggerTransition; + } { + const _j = {} as TriggerTransition; + _o.set(_j, "name", _p?.name); + _o.set(_j, "isNew", _p?.isNew); + _o.set(_j, "isTable", _p?.isTable); + return { + TriggerTransition: _j + }; + }, + jsonOutput(_p?: JsonOutput): { + JsonOutput: JsonOutput; + } { + const _j = {} as JsonOutput; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "returning", _p?.returning); + return { + JsonOutput: _j + }; + }, + jsonArgument(_p?: JsonArgument): { + JsonArgument: JsonArgument; + } { + const _j = {} as JsonArgument; + _o.set(_j, "val", _p?.val); + _o.set(_j, "name", _p?.name); + return { + JsonArgument: _j + }; + }, + jsonFuncExpr(_p?: JsonFuncExpr): { + JsonFuncExpr: JsonFuncExpr; + } { + const _j = {} as JsonFuncExpr; + _o.set(_j, "op", _p?.op); + _o.set(_j, "column_name", _p?.column_name); + _o.set(_j, "context_item", _p?.context_item); + _o.set(_j, "pathspec", _p?.pathspec); + _o.set(_j, "passing", _p?.passing); + _o.set(_j, "output", _p?.output); + _o.set(_j, "on_empty", _p?.on_empty); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "wrapper", _p?.wrapper); + _o.set(_j, "quotes", _p?.quotes); + _o.set(_j, "location", _p?.location); + return { + JsonFuncExpr: _j + }; + }, + jsonTablePathSpec(_p?: JsonTablePathSpec): { + JsonTablePathSpec: JsonTablePathSpec; + } { + const _j = {} as JsonTablePathSpec; + _o.set(_j, "string", _p?.string); + _o.set(_j, "name", _p?.name); + _o.set(_j, "name_location", _p?.name_location); + _o.set(_j, "location", _p?.location); + return { + JsonTablePathSpec: _j + }; + }, + jsonTable(_p?: JsonTable): { + JsonTable: JsonTable; + } { + const _j = {} as JsonTable; + _o.set(_j, "context_item", _p?.context_item); + _o.set(_j, "pathspec", _p?.pathspec); + _o.set(_j, "passing", _p?.passing); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "alias", _p?.alias); + _o.set(_j, "lateral", _p?.lateral); + _o.set(_j, "location", _p?.location); + return { + JsonTable: _j + }; + }, + jsonTableColumn(_p?: JsonTableColumn): { + JsonTableColumn: JsonTableColumn; + } { + const _j = {} as JsonTableColumn; + _o.set(_j, "coltype", _p?.coltype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "pathspec", _p?.pathspec); + _o.set(_j, "format", _p?.format); + _o.set(_j, "wrapper", _p?.wrapper); + _o.set(_j, "quotes", _p?.quotes); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "on_empty", _p?.on_empty); + _o.set(_j, "on_error", _p?.on_error); + _o.set(_j, "location", _p?.location); + return { + JsonTableColumn: _j + }; + }, + jsonKeyValue(_p?: JsonKeyValue): { + JsonKeyValue: JsonKeyValue; + } { + const _j = {} as JsonKeyValue; + _o.set(_j, "key", _p?.key); + _o.set(_j, "value", _p?.value); + return { + JsonKeyValue: _j + }; + }, + jsonParseExpr(_p?: JsonParseExpr): { + JsonParseExpr: JsonParseExpr; + } { + const _j = {} as JsonParseExpr; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "output", _p?.output); + _o.set(_j, "unique_keys", _p?.unique_keys); + _o.set(_j, "location", _p?.location); + return { + JsonParseExpr: _j + }; + }, + jsonScalarExpr(_p?: JsonScalarExpr): { + JsonScalarExpr: JsonScalarExpr; + } { + const _j = {} as JsonScalarExpr; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "output", _p?.output); + _o.set(_j, "location", _p?.location); + return { + JsonScalarExpr: _j + }; + }, + jsonSerializeExpr(_p?: JsonSerializeExpr): { + JsonSerializeExpr: JsonSerializeExpr; + } { + const _j = {} as JsonSerializeExpr; + _o.set(_j, "expr", _p?.expr); + _o.set(_j, "output", _p?.output); + _o.set(_j, "location", _p?.location); + return { + JsonSerializeExpr: _j + }; + }, + jsonObjectConstructor(_p?: JsonObjectConstructor): { + JsonObjectConstructor: JsonObjectConstructor; + } { + const _j = {} as JsonObjectConstructor; + _o.set(_j, "exprs", _p?.exprs); + _o.set(_j, "output", _p?.output); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "unique", _p?.unique); + _o.set(_j, "location", _p?.location); + return { + JsonObjectConstructor: _j + }; + }, + jsonArrayConstructor(_p?: JsonArrayConstructor): { + JsonArrayConstructor: JsonArrayConstructor; + } { + const _j = {} as JsonArrayConstructor; + _o.set(_j, "exprs", _p?.exprs); + _o.set(_j, "output", _p?.output); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "location", _p?.location); + return { + JsonArrayConstructor: _j + }; + }, + jsonArrayQueryConstructor(_p?: JsonArrayQueryConstructor): { + JsonArrayQueryConstructor: JsonArrayQueryConstructor; + } { + const _j = {} as JsonArrayQueryConstructor; + _o.set(_j, "query", _p?.query); + _o.set(_j, "output", _p?.output); + _o.set(_j, "format", _p?.format); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "location", _p?.location); + return { + JsonArrayQueryConstructor: _j + }; + }, + jsonAggConstructor(_p?: JsonAggConstructor): { + JsonAggConstructor: JsonAggConstructor; + } { + const _j = {} as JsonAggConstructor; + _o.set(_j, "output", _p?.output); + _o.set(_j, "agg_filter", _p?.agg_filter); + _o.set(_j, "agg_order", _p?.agg_order); + _o.set(_j, "over", _p?.over); + _o.set(_j, "location", _p?.location); + return { + JsonAggConstructor: _j + }; + }, + jsonObjectAgg(_p?: JsonObjectAgg): { + JsonObjectAgg: JsonObjectAgg; + } { + const _j = {} as JsonObjectAgg; + _o.set(_j, "constructor", _p?.constructor); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + _o.set(_j, "unique", _p?.unique); + return { + JsonObjectAgg: _j + }; + }, + jsonArrayAgg(_p?: JsonArrayAgg): { + JsonArrayAgg: JsonArrayAgg; + } { + const _j = {} as JsonArrayAgg; + _o.set(_j, "constructor", _p?.constructor); + _o.set(_j, "arg", _p?.arg); + _o.set(_j, "absent_on_null", _p?.absent_on_null); + return { + JsonArrayAgg: _j + }; + }, + rawStmt(_p?: RawStmt): { + RawStmt: RawStmt; + } { + const _j = {} as RawStmt; + _o.set(_j, "stmt", _p?.stmt); + _o.set(_j, "stmt_location", _p?.stmt_location); + _o.set(_j, "stmt_len", _p?.stmt_len); + return { + RawStmt: _j + }; + }, + insertStmt(_p?: InsertStmt): { + InsertStmt: InsertStmt; + } { + const _j = {} as InsertStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "cols", _p?.cols); + _o.set(_j, "selectStmt", _p?.selectStmt); + _o.set(_j, "onConflictClause", _p?.onConflictClause); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + _o.set(_j, "override", _p?.override); + return { + InsertStmt: _j + }; + }, + deleteStmt(_p?: DeleteStmt): { + DeleteStmt: DeleteStmt; + } { + const _j = {} as DeleteStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "usingClause", _p?.usingClause); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + return { + DeleteStmt: _j + }; + }, + updateStmt(_p?: UpdateStmt): { + UpdateStmt: UpdateStmt; + } { + const _j = {} as UpdateStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "fromClause", _p?.fromClause); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + return { + UpdateStmt: _j + }; + }, + mergeStmt(_p?: MergeStmt): { + MergeStmt: MergeStmt; + } { + const _j = {} as MergeStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "sourceRelation", _p?.sourceRelation); + _o.set(_j, "joinCondition", _p?.joinCondition); + _o.set(_j, "mergeWhenClauses", _p?.mergeWhenClauses); + _o.set(_j, "returningList", _p?.returningList); + _o.set(_j, "withClause", _p?.withClause); + return { + MergeStmt: _j + }; + }, + selectStmt(_p?: SelectStmt): { + SelectStmt: SelectStmt; + } { + const _j = {} as SelectStmt; + _o.set(_j, "distinctClause", _p?.distinctClause); + _o.set(_j, "intoClause", _p?.intoClause); + _o.set(_j, "targetList", _p?.targetList); + _o.set(_j, "fromClause", _p?.fromClause); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "groupClause", _p?.groupClause); + _o.set(_j, "groupDistinct", _p?.groupDistinct); + _o.set(_j, "havingClause", _p?.havingClause); + _o.set(_j, "windowClause", _p?.windowClause); + _o.set(_j, "valuesLists", _p?.valuesLists); + _o.set(_j, "sortClause", _p?.sortClause); + _o.set(_j, "limitOffset", _p?.limitOffset); + _o.set(_j, "limitCount", _p?.limitCount); + _o.set(_j, "limitOption", _p?.limitOption); + _o.set(_j, "lockingClause", _p?.lockingClause); + _o.set(_j, "withClause", _p?.withClause); + _o.set(_j, "op", _p?.op); + _o.set(_j, "all", _p?.all); + _o.set(_j, "larg", _p?.larg); + _o.set(_j, "rarg", _p?.rarg); + return { + SelectStmt: _j + }; + }, + setOperationStmt(_p?: SetOperationStmt): { + SetOperationStmt: SetOperationStmt; + } { + const _j = {} as SetOperationStmt; + _o.set(_j, "op", _p?.op); + _o.set(_j, "all", _p?.all); + _o.set(_j, "larg", _p?.larg); + _o.set(_j, "rarg", _p?.rarg); + _o.set(_j, "colTypes", _p?.colTypes); + _o.set(_j, "colTypmods", _p?.colTypmods); + _o.set(_j, "colCollations", _p?.colCollations); + _o.set(_j, "groupClauses", _p?.groupClauses); + return { + SetOperationStmt: _j + }; + }, + returnStmt(_p?: ReturnStmt): { + ReturnStmt: ReturnStmt; + } { + const _j = {} as ReturnStmt; + _o.set(_j, "returnval", _p?.returnval); + return { + ReturnStmt: _j + }; + }, + plAssignStmt(_p?: PLAssignStmt): { + PLAssignStmt: PLAssignStmt; + } { + const _j = {} as PLAssignStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "indirection", _p?.indirection); + _o.set(_j, "nnames", _p?.nnames); + _o.set(_j, "val", _p?.val); + _o.set(_j, "location", _p?.location); + return { + PLAssignStmt: _j + }; + }, + createSchemaStmt(_p?: CreateSchemaStmt): { + CreateSchemaStmt: CreateSchemaStmt; + } { + const _j = {} as CreateSchemaStmt; + _o.set(_j, "schemaname", _p?.schemaname); + _o.set(_j, "authrole", _p?.authrole); + _o.set(_j, "schemaElts", _p?.schemaElts); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return { + CreateSchemaStmt: _j + }; + }, + alterTableStmt(_p?: AlterTableStmt): { + AlterTableStmt: AlterTableStmt; + } { + const _j = {} as AlterTableStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "cmds", _p?.cmds); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + AlterTableStmt: _j + }; + }, + replicaIdentityStmt(_p?: ReplicaIdentityStmt): { + ReplicaIdentityStmt: ReplicaIdentityStmt; + } { + const _j = {} as ReplicaIdentityStmt; + _o.set(_j, "identity_type", _p?.identity_type); + _o.set(_j, "name", _p?.name); + return { + ReplicaIdentityStmt: _j + }; + }, + alterTableCmd(_p?: AlterTableCmd): { + AlterTableCmd: AlterTableCmd; + } { + const _j = {} as AlterTableCmd; + _o.set(_j, "subtype", _p?.subtype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "num", _p?.num); + _o.set(_j, "newowner", _p?.newowner); + _o.set(_j, "def", _p?.def); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "recurse", _p?.recurse); + return { + AlterTableCmd: _j + }; + }, + alterCollationStmt(_p?: AlterCollationStmt): { + AlterCollationStmt: AlterCollationStmt; + } { + const _j = {} as AlterCollationStmt; + _o.set(_j, "collname", _p?.collname); + return { + AlterCollationStmt: _j + }; + }, + alterDomainStmt(_p?: AlterDomainStmt): { + AlterDomainStmt: AlterDomainStmt; + } { + const _j = {} as AlterDomainStmt; + _o.set(_j, "subtype", _p?.subtype); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "name", _p?.name); + _o.set(_j, "def", _p?.def); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + AlterDomainStmt: _j + }; + }, + grantStmt(_p?: GrantStmt): { + GrantStmt: GrantStmt; + } { + const _j = {} as GrantStmt; + _o.set(_j, "is_grant", _p?.is_grant); + _o.set(_j, "targtype", _p?.targtype); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "objects", _p?.objects); + _o.set(_j, "privileges", _p?.privileges); + _o.set(_j, "grantees", _p?.grantees); + _o.set(_j, "grant_option", _p?.grant_option); + _o.set(_j, "grantor", _p?.grantor); + _o.set(_j, "behavior", _p?.behavior); + return { + GrantStmt: _j + }; + }, + objectWithArgs(_p?: ObjectWithArgs): { + ObjectWithArgs: ObjectWithArgs; + } { + const _j = {} as ObjectWithArgs; + _o.set(_j, "objname", _p?.objname); + _o.set(_j, "objargs", _p?.objargs); + _o.set(_j, "objfuncargs", _p?.objfuncargs); + _o.set(_j, "args_unspecified", _p?.args_unspecified); + return { + ObjectWithArgs: _j + }; + }, + accessPriv(_p?: AccessPriv): { + AccessPriv: AccessPriv; + } { + const _j = {} as AccessPriv; + _o.set(_j, "priv_name", _p?.priv_name); + _o.set(_j, "cols", _p?.cols); + return { + AccessPriv: _j + }; + }, + grantRoleStmt(_p?: GrantRoleStmt): { + GrantRoleStmt: GrantRoleStmt; + } { + const _j = {} as GrantRoleStmt; + _o.set(_j, "granted_roles", _p?.granted_roles); + _o.set(_j, "grantee_roles", _p?.grantee_roles); + _o.set(_j, "is_grant", _p?.is_grant); + _o.set(_j, "opt", _p?.opt); + _o.set(_j, "grantor", _p?.grantor); + _o.set(_j, "behavior", _p?.behavior); + return { + GrantRoleStmt: _j + }; + }, + alterDefaultPrivilegesStmt(_p?: AlterDefaultPrivilegesStmt): { + AlterDefaultPrivilegesStmt: AlterDefaultPrivilegesStmt; + } { + const _j = {} as AlterDefaultPrivilegesStmt; + _o.set(_j, "options", _p?.options); + _o.set(_j, "action", _p?.action); + return { + AlterDefaultPrivilegesStmt: _j + }; + }, + copyStmt(_p?: CopyStmt): { + CopyStmt: CopyStmt; + } { + const _j = {} as CopyStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "query", _p?.query); + _o.set(_j, "attlist", _p?.attlist); + _o.set(_j, "is_from", _p?.is_from); + _o.set(_j, "is_program", _p?.is_program); + _o.set(_j, "filename", _p?.filename); + _o.set(_j, "options", _p?.options); + _o.set(_j, "whereClause", _p?.whereClause); + return { + CopyStmt: _j + }; + }, + variableSetStmt(_p?: VariableSetStmt): { + VariableSetStmt: VariableSetStmt; + } { + const _j = {} as VariableSetStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "name", _p?.name); + _o.set(_j, "args", _p?.args); + _o.set(_j, "is_local", _p?.is_local); + return { + VariableSetStmt: _j + }; + }, + variableShowStmt(_p?: VariableShowStmt): { + VariableShowStmt: VariableShowStmt; + } { + const _j = {} as VariableShowStmt; + _o.set(_j, "name", _p?.name); + return { + VariableShowStmt: _j + }; + }, + createStmt(_p?: CreateStmt): { + CreateStmt: CreateStmt; + } { + const _j = {} as CreateStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "tableElts", _p?.tableElts); + _o.set(_j, "inhRelations", _p?.inhRelations); + _o.set(_j, "partbound", _p?.partbound); + _o.set(_j, "partspec", _p?.partspec); + _o.set(_j, "ofTypename", _p?.ofTypename); + _o.set(_j, "constraints", _p?.constraints); + _o.set(_j, "options", _p?.options); + _o.set(_j, "oncommit", _p?.oncommit); + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "accessMethod", _p?.accessMethod); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return { + CreateStmt: _j + }; + }, + constraint(_p?: Constraint): { + Constraint: Constraint; + } { + const _j = {} as Constraint; + _o.set(_j, "contype", _p?.contype); + _o.set(_j, "conname", _p?.conname); + _o.set(_j, "deferrable", _p?.deferrable); + _o.set(_j, "initdeferred", _p?.initdeferred); + _o.set(_j, "skip_validation", _p?.skip_validation); + _o.set(_j, "initially_valid", _p?.initially_valid); + _o.set(_j, "is_no_inherit", _p?.is_no_inherit); + _o.set(_j, "raw_expr", _p?.raw_expr); + _o.set(_j, "cooked_expr", _p?.cooked_expr); + _o.set(_j, "generated_when", _p?.generated_when); + _o.set(_j, "inhcount", _p?.inhcount); + _o.set(_j, "nulls_not_distinct", _p?.nulls_not_distinct); + _o.set(_j, "keys", _p?.keys); + _o.set(_j, "including", _p?.including); + _o.set(_j, "exclusions", _p?.exclusions); + _o.set(_j, "options", _p?.options); + _o.set(_j, "indexname", _p?.indexname); + _o.set(_j, "indexspace", _p?.indexspace); + _o.set(_j, "reset_default_tblspc", _p?.reset_default_tblspc); + _o.set(_j, "access_method", _p?.access_method); + _o.set(_j, "where_clause", _p?.where_clause); + _o.set(_j, "pktable", _p?.pktable); + _o.set(_j, "fk_attrs", _p?.fk_attrs); + _o.set(_j, "pk_attrs", _p?.pk_attrs); + _o.set(_j, "fk_matchtype", _p?.fk_matchtype); + _o.set(_j, "fk_upd_action", _p?.fk_upd_action); + _o.set(_j, "fk_del_action", _p?.fk_del_action); + _o.set(_j, "fk_del_set_cols", _p?.fk_del_set_cols); + _o.set(_j, "old_conpfeqop", _p?.old_conpfeqop); + _o.set(_j, "old_pktable_oid", _p?.old_pktable_oid); + _o.set(_j, "location", _p?.location); + return { + Constraint: _j + }; + }, + createTableSpaceStmt(_p?: CreateTableSpaceStmt): { + CreateTableSpaceStmt: CreateTableSpaceStmt; + } { + const _j = {} as CreateTableSpaceStmt; + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "owner", _p?.owner); + _o.set(_j, "location", _p?.location); + _o.set(_j, "options", _p?.options); + return { + CreateTableSpaceStmt: _j + }; + }, + dropTableSpaceStmt(_p?: DropTableSpaceStmt): { + DropTableSpaceStmt: DropTableSpaceStmt; + } { + const _j = {} as DropTableSpaceStmt; + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + DropTableSpaceStmt: _j + }; + }, + alterTableSpaceOptionsStmt(_p?: AlterTableSpaceOptionsStmt): { + AlterTableSpaceOptionsStmt: AlterTableSpaceOptionsStmt; + } { + const _j = {} as AlterTableSpaceOptionsStmt; + _o.set(_j, "tablespacename", _p?.tablespacename); + _o.set(_j, "options", _p?.options); + _o.set(_j, "isReset", _p?.isReset); + return { + AlterTableSpaceOptionsStmt: _j + }; + }, + alterTableMoveAllStmt(_p?: AlterTableMoveAllStmt): { + AlterTableMoveAllStmt: AlterTableMoveAllStmt; + } { + const _j = {} as AlterTableMoveAllStmt; + _o.set(_j, "orig_tablespacename", _p?.orig_tablespacename); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "new_tablespacename", _p?.new_tablespacename); + _o.set(_j, "nowait", _p?.nowait); + return { + AlterTableMoveAllStmt: _j + }; + }, + createExtensionStmt(_p?: CreateExtensionStmt): { + CreateExtensionStmt: CreateExtensionStmt; + } { + const _j = {} as CreateExtensionStmt; + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "options", _p?.options); + return { + CreateExtensionStmt: _j + }; + }, + alterExtensionStmt(_p?: AlterExtensionStmt): { + AlterExtensionStmt: AlterExtensionStmt; + } { + const _j = {} as AlterExtensionStmt; + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "options", _p?.options); + return { + AlterExtensionStmt: _j + }; + }, + alterExtensionContentsStmt(_p?: AlterExtensionContentsStmt): { + AlterExtensionContentsStmt: AlterExtensionContentsStmt; + } { + const _j = {} as AlterExtensionContentsStmt; + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "action", _p?.action); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "object", _p?.object); + return { + AlterExtensionContentsStmt: _j + }; + }, + createFdwStmt(_p?: CreateFdwStmt): { + CreateFdwStmt: CreateFdwStmt; + } { + const _j = {} as CreateFdwStmt; + _o.set(_j, "fdwname", _p?.fdwname); + _o.set(_j, "func_options", _p?.func_options); + _o.set(_j, "options", _p?.options); + return { + CreateFdwStmt: _j + }; + }, + alterFdwStmt(_p?: AlterFdwStmt): { + AlterFdwStmt: AlterFdwStmt; + } { + const _j = {} as AlterFdwStmt; + _o.set(_j, "fdwname", _p?.fdwname); + _o.set(_j, "func_options", _p?.func_options); + _o.set(_j, "options", _p?.options); + return { + AlterFdwStmt: _j + }; + }, + createForeignServerStmt(_p?: CreateForeignServerStmt): { + CreateForeignServerStmt: CreateForeignServerStmt; + } { + const _j = {} as CreateForeignServerStmt; + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "servertype", _p?.servertype); + _o.set(_j, "version", _p?.version); + _o.set(_j, "fdwname", _p?.fdwname); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "options", _p?.options); + return { + CreateForeignServerStmt: _j + }; + }, + alterForeignServerStmt(_p?: AlterForeignServerStmt): { + AlterForeignServerStmt: AlterForeignServerStmt; + } { + const _j = {} as AlterForeignServerStmt; + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "version", _p?.version); + _o.set(_j, "options", _p?.options); + _o.set(_j, "has_version", _p?.has_version); + return { + AlterForeignServerStmt: _j + }; + }, + createForeignTableStmt(_p?: CreateForeignTableStmt): { + CreateForeignTableStmt: CreateForeignTableStmt; + } { + const _j = {} as CreateForeignTableStmt; + _o.set(_j, "base", _p?.base); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "options", _p?.options); + return { + CreateForeignTableStmt: _j + }; + }, + createUserMappingStmt(_p?: CreateUserMappingStmt): { + CreateUserMappingStmt: CreateUserMappingStmt; + } { + const _j = {} as CreateUserMappingStmt; + _o.set(_j, "user", _p?.user); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "options", _p?.options); + return { + CreateUserMappingStmt: _j + }; + }, + alterUserMappingStmt(_p?: AlterUserMappingStmt): { + AlterUserMappingStmt: AlterUserMappingStmt; + } { + const _j = {} as AlterUserMappingStmt; + _o.set(_j, "user", _p?.user); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "options", _p?.options); + return { + AlterUserMappingStmt: _j + }; + }, + dropUserMappingStmt(_p?: DropUserMappingStmt): { + DropUserMappingStmt: DropUserMappingStmt; + } { + const _j = {} as DropUserMappingStmt; + _o.set(_j, "user", _p?.user); + _o.set(_j, "servername", _p?.servername); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + DropUserMappingStmt: _j + }; + }, + importForeignSchemaStmt(_p?: ImportForeignSchemaStmt): { + ImportForeignSchemaStmt: ImportForeignSchemaStmt; + } { + const _j = {} as ImportForeignSchemaStmt; + _o.set(_j, "server_name", _p?.server_name); + _o.set(_j, "remote_schema", _p?.remote_schema); + _o.set(_j, "local_schema", _p?.local_schema); + _o.set(_j, "list_type", _p?.list_type); + _o.set(_j, "table_list", _p?.table_list); + _o.set(_j, "options", _p?.options); + return { + ImportForeignSchemaStmt: _j + }; + }, + createPolicyStmt(_p?: CreatePolicyStmt): { + CreatePolicyStmt: CreatePolicyStmt; + } { + const _j = {} as CreatePolicyStmt; + _o.set(_j, "policy_name", _p?.policy_name); + _o.set(_j, "table", _p?.table); + _o.set(_j, "cmd_name", _p?.cmd_name); + _o.set(_j, "permissive", _p?.permissive); + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "with_check", _p?.with_check); + return { + CreatePolicyStmt: _j + }; + }, + alterPolicyStmt(_p?: AlterPolicyStmt): { + AlterPolicyStmt: AlterPolicyStmt; + } { + const _j = {} as AlterPolicyStmt; + _o.set(_j, "policy_name", _p?.policy_name); + _o.set(_j, "table", _p?.table); + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "qual", _p?.qual); + _o.set(_j, "with_check", _p?.with_check); + return { + AlterPolicyStmt: _j + }; + }, + createAmStmt(_p?: CreateAmStmt): { + CreateAmStmt: CreateAmStmt; + } { + const _j = {} as CreateAmStmt; + _o.set(_j, "amname", _p?.amname); + _o.set(_j, "handler_name", _p?.handler_name); + _o.set(_j, "amtype", _p?.amtype); + return { + CreateAmStmt: _j + }; + }, + createTrigStmt(_p?: CreateTrigStmt): { + CreateTrigStmt: CreateTrigStmt; + } { + const _j = {} as CreateTrigStmt; + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "isconstraint", _p?.isconstraint); + _o.set(_j, "trigname", _p?.trigname); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "funcname", _p?.funcname); + _o.set(_j, "args", _p?.args); + _o.set(_j, "row", _p?.row); + _o.set(_j, "timing", _p?.timing); + _o.set(_j, "events", _p?.events); + _o.set(_j, "columns", _p?.columns); + _o.set(_j, "whenClause", _p?.whenClause); + _o.set(_j, "transitionRels", _p?.transitionRels); + _o.set(_j, "deferrable", _p?.deferrable); + _o.set(_j, "initdeferred", _p?.initdeferred); + _o.set(_j, "constrrel", _p?.constrrel); + return { + CreateTrigStmt: _j + }; + }, + createEventTrigStmt(_p?: CreateEventTrigStmt): { + CreateEventTrigStmt: CreateEventTrigStmt; + } { + const _j = {} as CreateEventTrigStmt; + _o.set(_j, "trigname", _p?.trigname); + _o.set(_j, "eventname", _p?.eventname); + _o.set(_j, "whenclause", _p?.whenclause); + _o.set(_j, "funcname", _p?.funcname); + return { + CreateEventTrigStmt: _j + }; + }, + alterEventTrigStmt(_p?: AlterEventTrigStmt): { + AlterEventTrigStmt: AlterEventTrigStmt; + } { + const _j = {} as AlterEventTrigStmt; + _o.set(_j, "trigname", _p?.trigname); + _o.set(_j, "tgenabled", _p?.tgenabled); + return { + AlterEventTrigStmt: _j + }; + }, + createpLangStmt(_p?: CreatePLangStmt): { + CreatePLangStmt: CreatePLangStmt; + } { + const _j = {} as CreatePLangStmt; + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "plname", _p?.plname); + _o.set(_j, "plhandler", _p?.plhandler); + _o.set(_j, "plinline", _p?.plinline); + _o.set(_j, "plvalidator", _p?.plvalidator); + _o.set(_j, "pltrusted", _p?.pltrusted); + return { + CreatePLangStmt: _j + }; + }, + createRoleStmt(_p?: CreateRoleStmt): { + CreateRoleStmt: CreateRoleStmt; + } { + const _j = {} as CreateRoleStmt; + _o.set(_j, "stmt_type", _p?.stmt_type); + _o.set(_j, "role", _p?.role); + _o.set(_j, "options", _p?.options); + return { + CreateRoleStmt: _j + }; + }, + alterRoleStmt(_p?: AlterRoleStmt): { + AlterRoleStmt: AlterRoleStmt; + } { + const _j = {} as AlterRoleStmt; + _o.set(_j, "role", _p?.role); + _o.set(_j, "options", _p?.options); + _o.set(_j, "action", _p?.action); + return { + AlterRoleStmt: _j + }; + }, + alterRoleSetStmt(_p?: AlterRoleSetStmt): { + AlterRoleSetStmt: AlterRoleSetStmt; + } { + const _j = {} as AlterRoleSetStmt; + _o.set(_j, "role", _p?.role); + _o.set(_j, "database", _p?.database); + _o.set(_j, "setstmt", _p?.setstmt); + return { + AlterRoleSetStmt: _j + }; + }, + dropRoleStmt(_p?: DropRoleStmt): { + DropRoleStmt: DropRoleStmt; + } { + const _j = {} as DropRoleStmt; + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + DropRoleStmt: _j + }; + }, + createSeqStmt(_p?: CreateSeqStmt): { + CreateSeqStmt: CreateSeqStmt; + } { + const _j = {} as CreateSeqStmt; + _o.set(_j, "sequence", _p?.sequence); + _o.set(_j, "options", _p?.options); + _o.set(_j, "ownerId", _p?.ownerId); + _o.set(_j, "for_identity", _p?.for_identity); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return { + CreateSeqStmt: _j + }; + }, + alterSeqStmt(_p?: AlterSeqStmt): { + AlterSeqStmt: AlterSeqStmt; + } { + const _j = {} as AlterSeqStmt; + _o.set(_j, "sequence", _p?.sequence); + _o.set(_j, "options", _p?.options); + _o.set(_j, "for_identity", _p?.for_identity); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + AlterSeqStmt: _j + }; + }, + defineStmt(_p?: DefineStmt): { + DefineStmt: DefineStmt; + } { + const _j = {} as DefineStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "oldstyle", _p?.oldstyle); + _o.set(_j, "defnames", _p?.defnames); + _o.set(_j, "args", _p?.args); + _o.set(_j, "definition", _p?.definition); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "replace", _p?.replace); + return { + DefineStmt: _j + }; + }, + createDomainStmt(_p?: CreateDomainStmt): { + CreateDomainStmt: CreateDomainStmt; + } { + const _j = {} as CreateDomainStmt; + _o.set(_j, "domainname", _p?.domainname); + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "collClause", _p?.collClause); + _o.set(_j, "constraints", _p?.constraints); + return { + CreateDomainStmt: _j + }; + }, + createOpClassStmt(_p?: CreateOpClassStmt): { + CreateOpClassStmt: CreateOpClassStmt; + } { + const _j = {} as CreateOpClassStmt; + _o.set(_j, "opclassname", _p?.opclassname); + _o.set(_j, "opfamilyname", _p?.opfamilyname); + _o.set(_j, "amname", _p?.amname); + _o.set(_j, "datatype", _p?.datatype); + _o.set(_j, "items", _p?.items); + _o.set(_j, "isDefault", _p?.isDefault); + return { + CreateOpClassStmt: _j + }; + }, + createOpClassItem(_p?: CreateOpClassItem): { + CreateOpClassItem: CreateOpClassItem; + } { + const _j = {} as CreateOpClassItem; + _o.set(_j, "itemtype", _p?.itemtype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "number", _p?.number); + _o.set(_j, "order_family", _p?.order_family); + _o.set(_j, "class_args", _p?.class_args); + _o.set(_j, "storedtype", _p?.storedtype); + return { + CreateOpClassItem: _j + }; + }, + createOpFamilyStmt(_p?: CreateOpFamilyStmt): { + CreateOpFamilyStmt: CreateOpFamilyStmt; + } { + const _j = {} as CreateOpFamilyStmt; + _o.set(_j, "opfamilyname", _p?.opfamilyname); + _o.set(_j, "amname", _p?.amname); + return { + CreateOpFamilyStmt: _j + }; + }, + alterOpFamilyStmt(_p?: AlterOpFamilyStmt): { + AlterOpFamilyStmt: AlterOpFamilyStmt; + } { + const _j = {} as AlterOpFamilyStmt; + _o.set(_j, "opfamilyname", _p?.opfamilyname); + _o.set(_j, "amname", _p?.amname); + _o.set(_j, "isDrop", _p?.isDrop); + _o.set(_j, "items", _p?.items); + return { + AlterOpFamilyStmt: _j + }; + }, + dropStmt(_p?: DropStmt): { + DropStmt: DropStmt; + } { + const _j = {} as DropStmt; + _o.set(_j, "objects", _p?.objects); + _o.set(_j, "removeType", _p?.removeType); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "concurrent", _p?.concurrent); + return { + DropStmt: _j + }; + }, + truncateStmt(_p?: TruncateStmt): { + TruncateStmt: TruncateStmt; + } { + const _j = {} as TruncateStmt; + _o.set(_j, "relations", _p?.relations); + _o.set(_j, "restart_seqs", _p?.restart_seqs); + _o.set(_j, "behavior", _p?.behavior); + return { + TruncateStmt: _j + }; + }, + commentStmt(_p?: CommentStmt): { + CommentStmt: CommentStmt; + } { + const _j = {} as CommentStmt; + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "object", _p?.object); + _o.set(_j, "comment", _p?.comment); + return { + CommentStmt: _j + }; + }, + secLabelStmt(_p?: SecLabelStmt): { + SecLabelStmt: SecLabelStmt; + } { + const _j = {} as SecLabelStmt; + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "object", _p?.object); + _o.set(_j, "provider", _p?.provider); + _o.set(_j, "label", _p?.label); + return { + SecLabelStmt: _j + }; + }, + declareCursorStmt(_p?: DeclareCursorStmt): { + DeclareCursorStmt: DeclareCursorStmt; + } { + const _j = {} as DeclareCursorStmt; + _o.set(_j, "portalname", _p?.portalname); + _o.set(_j, "options", _p?.options); + _o.set(_j, "query", _p?.query); + return { + DeclareCursorStmt: _j + }; + }, + closePortalStmt(_p?: ClosePortalStmt): { + ClosePortalStmt: ClosePortalStmt; + } { + const _j = {} as ClosePortalStmt; + _o.set(_j, "portalname", _p?.portalname); + return { + ClosePortalStmt: _j + }; + }, + fetchStmt(_p?: FetchStmt): { + FetchStmt: FetchStmt; + } { + const _j = {} as FetchStmt; + _o.set(_j, "direction", _p?.direction); + _o.set(_j, "howMany", _p?.howMany); + _o.set(_j, "portalname", _p?.portalname); + _o.set(_j, "ismove", _p?.ismove); + return { + FetchStmt: _j + }; + }, + indexStmt(_p?: IndexStmt): { + IndexStmt: IndexStmt; + } { + const _j = {} as IndexStmt; + _o.set(_j, "idxname", _p?.idxname); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "accessMethod", _p?.accessMethod); + _o.set(_j, "tableSpace", _p?.tableSpace); + _o.set(_j, "indexParams", _p?.indexParams); + _o.set(_j, "indexIncludingParams", _p?.indexIncludingParams); + _o.set(_j, "options", _p?.options); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "excludeOpNames", _p?.excludeOpNames); + _o.set(_j, "idxcomment", _p?.idxcomment); + _o.set(_j, "indexOid", _p?.indexOid); + _o.set(_j, "oldNumber", _p?.oldNumber); + _o.set(_j, "oldCreateSubid", _p?.oldCreateSubid); + _o.set(_j, "oldFirstRelfilelocatorSubid", _p?.oldFirstRelfilelocatorSubid); + _o.set(_j, "unique", _p?.unique); + _o.set(_j, "nulls_not_distinct", _p?.nulls_not_distinct); + _o.set(_j, "primary", _p?.primary); + _o.set(_j, "isconstraint", _p?.isconstraint); + _o.set(_j, "deferrable", _p?.deferrable); + _o.set(_j, "initdeferred", _p?.initdeferred); + _o.set(_j, "transformed", _p?.transformed); + _o.set(_j, "concurrent", _p?.concurrent); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + _o.set(_j, "reset_default_tblspc", _p?.reset_default_tblspc); + return { + IndexStmt: _j + }; + }, + createStatsStmt(_p?: CreateStatsStmt): { + CreateStatsStmt: CreateStatsStmt; + } { + const _j = {} as CreateStatsStmt; + _o.set(_j, "defnames", _p?.defnames); + _o.set(_j, "stat_types", _p?.stat_types); + _o.set(_j, "exprs", _p?.exprs); + _o.set(_j, "relations", _p?.relations); + _o.set(_j, "stxcomment", _p?.stxcomment); + _o.set(_j, "transformed", _p?.transformed); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return { + CreateStatsStmt: _j + }; + }, + statsElem(_p?: StatsElem): { + StatsElem: StatsElem; + } { + const _j = {} as StatsElem; + _o.set(_j, "name", _p?.name); + _o.set(_j, "expr", _p?.expr); + return { + StatsElem: _j + }; + }, + alterStatsStmt(_p?: AlterStatsStmt): { + AlterStatsStmt: AlterStatsStmt; + } { + const _j = {} as AlterStatsStmt; + _o.set(_j, "defnames", _p?.defnames); + _o.set(_j, "stxstattarget", _p?.stxstattarget); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + AlterStatsStmt: _j + }; + }, + createFunctionStmt(_p?: CreateFunctionStmt): { + CreateFunctionStmt: CreateFunctionStmt; + } { + const _j = {} as CreateFunctionStmt; + _o.set(_j, "is_procedure", _p?.is_procedure); + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "funcname", _p?.funcname); + _o.set(_j, "parameters", _p?.parameters); + _o.set(_j, "returnType", _p?.returnType); + _o.set(_j, "options", _p?.options); + _o.set(_j, "sql_body", _p?.sql_body); + return { + CreateFunctionStmt: _j + }; + }, + functionParameter(_p?: FunctionParameter): { + FunctionParameter: FunctionParameter; + } { + const _j = {} as FunctionParameter; + _o.set(_j, "name", _p?.name); + _o.set(_j, "argType", _p?.argType); + _o.set(_j, "mode", _p?.mode); + _o.set(_j, "defexpr", _p?.defexpr); + return { + FunctionParameter: _j + }; + }, + alterFunctionStmt(_p?: AlterFunctionStmt): { + AlterFunctionStmt: AlterFunctionStmt; + } { + const _j = {} as AlterFunctionStmt; + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "func", _p?.func); + _o.set(_j, "actions", _p?.actions); + return { + AlterFunctionStmt: _j + }; + }, + doStmt(_p?: DoStmt): { + DoStmt: DoStmt; + } { + const _j = {} as DoStmt; + _o.set(_j, "args", _p?.args); + return { + DoStmt: _j + }; + }, + inlineCodeBlock(_p?: InlineCodeBlock): { + InlineCodeBlock: InlineCodeBlock; + } { + const _j = {} as InlineCodeBlock; + _o.set(_j, "source_text", _p?.source_text); + _o.set(_j, "langOid", _p?.langOid); + _o.set(_j, "langIsTrusted", _p?.langIsTrusted); + _o.set(_j, "atomic", _p?.atomic); + return { + InlineCodeBlock: _j + }; + }, + callStmt(_p?: CallStmt): { + CallStmt: CallStmt; + } { + const _j = {} as CallStmt; + _o.set(_j, "funccall", _p?.funccall); + _o.set(_j, "funcexpr", _p?.funcexpr); + _o.set(_j, "outargs", _p?.outargs); + return { + CallStmt: _j + }; + }, + callContext(_p?: CallContext): { + CallContext: CallContext; + } { + const _j = {} as CallContext; + _o.set(_j, "atomic", _p?.atomic); + return { + CallContext: _j + }; + }, + renameStmt(_p?: RenameStmt): { + RenameStmt: RenameStmt; + } { + const _j = {} as RenameStmt; + _o.set(_j, "renameType", _p?.renameType); + _o.set(_j, "relationType", _p?.relationType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "newname", _p?.newname); + _o.set(_j, "behavior", _p?.behavior); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + RenameStmt: _j + }; + }, + alterObjectDependsStmt(_p?: AlterObjectDependsStmt): { + AlterObjectDependsStmt: AlterObjectDependsStmt; + } { + const _j = {} as AlterObjectDependsStmt; + _o.set(_j, "objectType", _p?.objectType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "extname", _p?.extname); + _o.set(_j, "remove", _p?.remove); + return { + AlterObjectDependsStmt: _j + }; + }, + alterObjectSchemaStmt(_p?: AlterObjectSchemaStmt): { + AlterObjectSchemaStmt: AlterObjectSchemaStmt; + } { + const _j = {} as AlterObjectSchemaStmt; + _o.set(_j, "objectType", _p?.objectType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "newschema", _p?.newschema); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + AlterObjectSchemaStmt: _j + }; + }, + alterOwnerStmt(_p?: AlterOwnerStmt): { + AlterOwnerStmt: AlterOwnerStmt; + } { + const _j = {} as AlterOwnerStmt; + _o.set(_j, "objectType", _p?.objectType); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "object", _p?.object); + _o.set(_j, "newowner", _p?.newowner); + return { + AlterOwnerStmt: _j + }; + }, + alterOperatorStmt(_p?: AlterOperatorStmt): { + AlterOperatorStmt: AlterOperatorStmt; + } { + const _j = {} as AlterOperatorStmt; + _o.set(_j, "opername", _p?.opername); + _o.set(_j, "options", _p?.options); + return { + AlterOperatorStmt: _j + }; + }, + alterTypeStmt(_p?: AlterTypeStmt): { + AlterTypeStmt: AlterTypeStmt; + } { + const _j = {} as AlterTypeStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "options", _p?.options); + return { + AlterTypeStmt: _j + }; + }, + ruleStmt(_p?: RuleStmt): { + RuleStmt: RuleStmt; + } { + const _j = {} as RuleStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "rulename", _p?.rulename); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "event", _p?.event); + _o.set(_j, "instead", _p?.instead); + _o.set(_j, "actions", _p?.actions); + _o.set(_j, "replace", _p?.replace); + return { + RuleStmt: _j + }; + }, + notifyStmt(_p?: NotifyStmt): { + NotifyStmt: NotifyStmt; + } { + const _j = {} as NotifyStmt; + _o.set(_j, "conditionname", _p?.conditionname); + _o.set(_j, "payload", _p?.payload); + return { + NotifyStmt: _j + }; + }, + listenStmt(_p?: ListenStmt): { + ListenStmt: ListenStmt; + } { + const _j = {} as ListenStmt; + _o.set(_j, "conditionname", _p?.conditionname); + return { + ListenStmt: _j + }; + }, + unlistenStmt(_p?: UnlistenStmt): { + UnlistenStmt: UnlistenStmt; + } { + const _j = {} as UnlistenStmt; + _o.set(_j, "conditionname", _p?.conditionname); + return { + UnlistenStmt: _j + }; + }, + transactionStmt(_p?: TransactionStmt): { + TransactionStmt: TransactionStmt; + } { + const _j = {} as TransactionStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "options", _p?.options); + _o.set(_j, "savepoint_name", _p?.savepoint_name); + _o.set(_j, "gid", _p?.gid); + _o.set(_j, "chain", _p?.chain); + _o.set(_j, "location", _p?.location); + return { + TransactionStmt: _j + }; + }, + compositeTypeStmt(_p?: CompositeTypeStmt): { + CompositeTypeStmt: CompositeTypeStmt; + } { + const _j = {} as CompositeTypeStmt; + _o.set(_j, "typevar", _p?.typevar); + _o.set(_j, "coldeflist", _p?.coldeflist); + return { + CompositeTypeStmt: _j + }; + }, + createEnumStmt(_p?: CreateEnumStmt): { + CreateEnumStmt: CreateEnumStmt; + } { + const _j = {} as CreateEnumStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "vals", _p?.vals); + return { + CreateEnumStmt: _j + }; + }, + createRangeStmt(_p?: CreateRangeStmt): { + CreateRangeStmt: CreateRangeStmt; + } { + const _j = {} as CreateRangeStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "params", _p?.params); + return { + CreateRangeStmt: _j + }; + }, + alterEnumStmt(_p?: AlterEnumStmt): { + AlterEnumStmt: AlterEnumStmt; + } { + const _j = {} as AlterEnumStmt; + _o.set(_j, "typeName", _p?.typeName); + _o.set(_j, "oldVal", _p?.oldVal); + _o.set(_j, "newVal", _p?.newVal); + _o.set(_j, "newValNeighbor", _p?.newValNeighbor); + _o.set(_j, "newValIsAfter", _p?.newValIsAfter); + _o.set(_j, "skipIfNewValExists", _p?.skipIfNewValExists); + return { + AlterEnumStmt: _j + }; + }, + viewStmt(_p?: ViewStmt): { + ViewStmt: ViewStmt; + } { + const _j = {} as ViewStmt; + _o.set(_j, "view", _p?.view); + _o.set(_j, "aliases", _p?.aliases); + _o.set(_j, "query", _p?.query); + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "options", _p?.options); + _o.set(_j, "withCheckOption", _p?.withCheckOption); + return { + ViewStmt: _j + }; + }, + loadStmt(_p?: LoadStmt): { + LoadStmt: LoadStmt; + } { + const _j = {} as LoadStmt; + _o.set(_j, "filename", _p?.filename); + return { + LoadStmt: _j + }; + }, + createdbStmt(_p?: CreatedbStmt): { + CreatedbStmt: CreatedbStmt; + } { + const _j = {} as CreatedbStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "options", _p?.options); + return { + CreatedbStmt: _j + }; + }, + alterDatabaseStmt(_p?: AlterDatabaseStmt): { + AlterDatabaseStmt: AlterDatabaseStmt; + } { + const _j = {} as AlterDatabaseStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "options", _p?.options); + return { + AlterDatabaseStmt: _j + }; + }, + alterDatabaseRefreshCollStmt(_p?: AlterDatabaseRefreshCollStmt): { + AlterDatabaseRefreshCollStmt: AlterDatabaseRefreshCollStmt; + } { + const _j = {} as AlterDatabaseRefreshCollStmt; + _o.set(_j, "dbname", _p?.dbname); + return { + AlterDatabaseRefreshCollStmt: _j + }; + }, + alterDatabaseSetStmt(_p?: AlterDatabaseSetStmt): { + AlterDatabaseSetStmt: AlterDatabaseSetStmt; + } { + const _j = {} as AlterDatabaseSetStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "setstmt", _p?.setstmt); + return { + AlterDatabaseSetStmt: _j + }; + }, + dropdbStmt(_p?: DropdbStmt): { + DropdbStmt: DropdbStmt; + } { + const _j = {} as DropdbStmt; + _o.set(_j, "dbname", _p?.dbname); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "options", _p?.options); + return { + DropdbStmt: _j + }; + }, + alterSystemStmt(_p?: AlterSystemStmt): { + AlterSystemStmt: AlterSystemStmt; + } { + const _j = {} as AlterSystemStmt; + _o.set(_j, "setstmt", _p?.setstmt); + return { + AlterSystemStmt: _j + }; + }, + clusterStmt(_p?: ClusterStmt): { + ClusterStmt: ClusterStmt; + } { + const _j = {} as ClusterStmt; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "indexname", _p?.indexname); + _o.set(_j, "params", _p?.params); + return { + ClusterStmt: _j + }; + }, + vacuumStmt(_p?: VacuumStmt): { + VacuumStmt: VacuumStmt; + } { + const _j = {} as VacuumStmt; + _o.set(_j, "options", _p?.options); + _o.set(_j, "rels", _p?.rels); + _o.set(_j, "is_vacuumcmd", _p?.is_vacuumcmd); + return { + VacuumStmt: _j + }; + }, + vacuumRelation(_p?: VacuumRelation): { + VacuumRelation: VacuumRelation; + } { + const _j = {} as VacuumRelation; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "oid", _p?.oid); + _o.set(_j, "va_cols", _p?.va_cols); + return { + VacuumRelation: _j + }; + }, + explainStmt(_p?: ExplainStmt): { + ExplainStmt: ExplainStmt; + } { + const _j = {} as ExplainStmt; + _o.set(_j, "query", _p?.query); + _o.set(_j, "options", _p?.options); + return { + ExplainStmt: _j + }; + }, + createTableAsStmt(_p?: CreateTableAsStmt): { + CreateTableAsStmt: CreateTableAsStmt; + } { + const _j = {} as CreateTableAsStmt; + _o.set(_j, "query", _p?.query); + _o.set(_j, "into", _p?.into); + _o.set(_j, "objtype", _p?.objtype); + _o.set(_j, "is_select_into", _p?.is_select_into); + _o.set(_j, "if_not_exists", _p?.if_not_exists); + return { + CreateTableAsStmt: _j + }; + }, + refreshMatViewStmt(_p?: RefreshMatViewStmt): { + RefreshMatViewStmt: RefreshMatViewStmt; + } { + const _j = {} as RefreshMatViewStmt; + _o.set(_j, "concurrent", _p?.concurrent); + _o.set(_j, "skipData", _p?.skipData); + _o.set(_j, "relation", _p?.relation); + return { + RefreshMatViewStmt: _j + }; + }, + checkPointStmt(_p?: CheckPointStmt): { + CheckPointStmt: CheckPointStmt; + } { + const _j = {} as CheckPointStmt; + return { + CheckPointStmt: _j + }; + }, + discardStmt(_p?: DiscardStmt): { + DiscardStmt: DiscardStmt; + } { + const _j = {} as DiscardStmt; + _o.set(_j, "target", _p?.target); + return { + DiscardStmt: _j + }; + }, + lockStmt(_p?: LockStmt): { + LockStmt: LockStmt; + } { + const _j = {} as LockStmt; + _o.set(_j, "relations", _p?.relations); + _o.set(_j, "mode", _p?.mode); + _o.set(_j, "nowait", _p?.nowait); + return { + LockStmt: _j + }; + }, + constraintsSetStmt(_p?: ConstraintsSetStmt): { + ConstraintsSetStmt: ConstraintsSetStmt; + } { + const _j = {} as ConstraintsSetStmt; + _o.set(_j, "constraints", _p?.constraints); + _o.set(_j, "deferred", _p?.deferred); + return { + ConstraintsSetStmt: _j + }; + }, + reindexStmt(_p?: ReindexStmt): { + ReindexStmt: ReindexStmt; + } { + const _j = {} as ReindexStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "name", _p?.name); + _o.set(_j, "params", _p?.params); + return { + ReindexStmt: _j + }; + }, + createConversionStmt(_p?: CreateConversionStmt): { + CreateConversionStmt: CreateConversionStmt; + } { + const _j = {} as CreateConversionStmt; + _o.set(_j, "conversion_name", _p?.conversion_name); + _o.set(_j, "for_encoding_name", _p?.for_encoding_name); + _o.set(_j, "to_encoding_name", _p?.to_encoding_name); + _o.set(_j, "func_name", _p?.func_name); + _o.set(_j, "def", _p?.def); + return { + CreateConversionStmt: _j + }; + }, + createCastStmt(_p?: CreateCastStmt): { + CreateCastStmt: CreateCastStmt; + } { + const _j = {} as CreateCastStmt; + _o.set(_j, "sourcetype", _p?.sourcetype); + _o.set(_j, "targettype", _p?.targettype); + _o.set(_j, "func", _p?.func); + _o.set(_j, "context", _p?.context); + _o.set(_j, "inout", _p?.inout); + return { + CreateCastStmt: _j + }; + }, + createTransformStmt(_p?: CreateTransformStmt): { + CreateTransformStmt: CreateTransformStmt; + } { + const _j = {} as CreateTransformStmt; + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "type_name", _p?.type_name); + _o.set(_j, "lang", _p?.lang); + _o.set(_j, "fromsql", _p?.fromsql); + _o.set(_j, "tosql", _p?.tosql); + return { + CreateTransformStmt: _j + }; + }, + prepareStmt(_p?: PrepareStmt): { + PrepareStmt: PrepareStmt; + } { + const _j = {} as PrepareStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "argtypes", _p?.argtypes); + _o.set(_j, "query", _p?.query); + return { + PrepareStmt: _j + }; + }, + executeStmt(_p?: ExecuteStmt): { + ExecuteStmt: ExecuteStmt; + } { + const _j = {} as ExecuteStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "params", _p?.params); + return { + ExecuteStmt: _j + }; + }, + deallocateStmt(_p?: DeallocateStmt): { + DeallocateStmt: DeallocateStmt; + } { + const _j = {} as DeallocateStmt; + _o.set(_j, "name", _p?.name); + _o.set(_j, "isall", _p?.isall); + _o.set(_j, "location", _p?.location); + return { + DeallocateStmt: _j + }; + }, + dropOwnedStmt(_p?: DropOwnedStmt): { + DropOwnedStmt: DropOwnedStmt; + } { + const _j = {} as DropOwnedStmt; + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "behavior", _p?.behavior); + return { + DropOwnedStmt: _j + }; + }, + reassignOwnedStmt(_p?: ReassignOwnedStmt): { + ReassignOwnedStmt: ReassignOwnedStmt; + } { + const _j = {} as ReassignOwnedStmt; + _o.set(_j, "roles", _p?.roles); + _o.set(_j, "newrole", _p?.newrole); + return { + ReassignOwnedStmt: _j + }; + }, + altertsDictionaryStmt(_p?: AlterTSDictionaryStmt): { + AlterTSDictionaryStmt: AlterTSDictionaryStmt; + } { + const _j = {} as AlterTSDictionaryStmt; + _o.set(_j, "dictname", _p?.dictname); + _o.set(_j, "options", _p?.options); + return { + AlterTSDictionaryStmt: _j + }; + }, + altertsConfigurationStmt(_p?: AlterTSConfigurationStmt): { + AlterTSConfigurationStmt: AlterTSConfigurationStmt; + } { + const _j = {} as AlterTSConfigurationStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "cfgname", _p?.cfgname); + _o.set(_j, "tokentype", _p?.tokentype); + _o.set(_j, "dicts", _p?.dicts); + _o.set(_j, "override", _p?.override); + _o.set(_j, "replace", _p?.replace); + _o.set(_j, "missing_ok", _p?.missing_ok); + return { + AlterTSConfigurationStmt: _j + }; + }, + publicationTable(_p?: PublicationTable): { + PublicationTable: PublicationTable; + } { + const _j = {} as PublicationTable; + _o.set(_j, "relation", _p?.relation); + _o.set(_j, "whereClause", _p?.whereClause); + _o.set(_j, "columns", _p?.columns); + return { + PublicationTable: _j + }; + }, + publicationObjSpec(_p?: PublicationObjSpec): { + PublicationObjSpec: PublicationObjSpec; + } { + const _j = {} as PublicationObjSpec; + _o.set(_j, "pubobjtype", _p?.pubobjtype); + _o.set(_j, "name", _p?.name); + _o.set(_j, "pubtable", _p?.pubtable); + _o.set(_j, "location", _p?.location); + return { + PublicationObjSpec: _j + }; + }, + createPublicationStmt(_p?: CreatePublicationStmt): { + CreatePublicationStmt: CreatePublicationStmt; + } { + const _j = {} as CreatePublicationStmt; + _o.set(_j, "pubname", _p?.pubname); + _o.set(_j, "options", _p?.options); + _o.set(_j, "pubobjects", _p?.pubobjects); + _o.set(_j, "for_all_tables", _p?.for_all_tables); + return { + CreatePublicationStmt: _j + }; + }, + alterPublicationStmt(_p?: AlterPublicationStmt): { + AlterPublicationStmt: AlterPublicationStmt; + } { + const _j = {} as AlterPublicationStmt; + _o.set(_j, "pubname", _p?.pubname); + _o.set(_j, "options", _p?.options); + _o.set(_j, "pubobjects", _p?.pubobjects); + _o.set(_j, "for_all_tables", _p?.for_all_tables); + _o.set(_j, "action", _p?.action); + return { + AlterPublicationStmt: _j + }; + }, + createSubscriptionStmt(_p?: CreateSubscriptionStmt): { + CreateSubscriptionStmt: CreateSubscriptionStmt; + } { + const _j = {} as CreateSubscriptionStmt; + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "conninfo", _p?.conninfo); + _o.set(_j, "publication", _p?.publication); + _o.set(_j, "options", _p?.options); + return { + CreateSubscriptionStmt: _j + }; + }, + alterSubscriptionStmt(_p?: AlterSubscriptionStmt): { + AlterSubscriptionStmt: AlterSubscriptionStmt; + } { + const _j = {} as AlterSubscriptionStmt; + _o.set(_j, "kind", _p?.kind); + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "conninfo", _p?.conninfo); + _o.set(_j, "publication", _p?.publication); + _o.set(_j, "options", _p?.options); + return { + AlterSubscriptionStmt: _j + }; + }, + dropSubscriptionStmt(_p?: DropSubscriptionStmt): { + DropSubscriptionStmt: DropSubscriptionStmt; + } { + const _j = {} as DropSubscriptionStmt; + _o.set(_j, "subname", _p?.subname); + _o.set(_j, "missing_ok", _p?.missing_ok); + _o.set(_j, "behavior", _p?.behavior); + return { + DropSubscriptionStmt: _j + }; + }, + scanToken(_p?: ScanToken): { + ScanToken: ScanToken; + } { + const _j = {} as ScanToken; + _o.set(_j, "start", _p?.start); + _o.set(_j, "end", _p?.end); + _o.set(_j, "token", _p?.token); + _o.set(_j, "keywordKind", _p?.keywordKind); + return { + ScanToken: _j + }; + } +}; \ No newline at end of file diff --git a/packages/proto-parser/test-utils/utils/asts.ts b/packages/proto-parser/test-utils/utils/asts.ts deleted file mode 100644 index 5075f6c7..00000000 --- a/packages/proto-parser/test-utils/utils/asts.ts +++ /dev/null @@ -1,2838 +0,0 @@ -/** -* This file was automatically generated by pg-proto-parser@1.21.0. -* DO NOT MODIFY IT BY HAND. Instead, modify the source proto file, -* and run the pg-proto-parser generate command to regenerate this file. -*/ -import _o from "nested-obj"; -import { ParseResult, ScanResult, Integer, Float, Boolean, String, BitString, List, OidList, IntList, A_Const, Alias, RangeVar, TableFunc, IntoClause, Var, Param, Aggref, GroupingFunc, WindowFunc, SubscriptingRef, FuncExpr, NamedArgExpr, OpExpr, DistinctExpr, NullIfExpr, ScalarArrayOpExpr, BoolExpr, SubLink, SubPlan, AlternativeSubPlan, FieldSelect, FieldStore, RelabelType, CoerceViaIO, ArrayCoerceExpr, ConvertRowtypeExpr, CollateExpr, CaseExpr, CaseWhen, CaseTestExpr, ArrayExpr, RowExpr, RowCompareExpr, CoalesceExpr, MinMaxExpr, SQLValueFunction, XmlExpr, JsonFormat, JsonReturning, JsonValueExpr, JsonConstructorExpr, JsonIsPredicate, NullTest, BooleanTest, CoerceToDomain, CoerceToDomainValue, SetToDefault, CurrentOfExpr, NextValueExpr, InferenceElem, TargetEntry, RangeTblRef, JoinExpr, FromExpr, OnConflictExpr, Query, TypeName, ColumnRef, ParamRef, A_Expr, TypeCast, CollateClause, RoleSpec, FuncCall, A_Star, A_Indices, A_Indirection, A_ArrayExpr, ResTarget, MultiAssignRef, SortBy, WindowDef, RangeSubselect, RangeFunction, RangeTableFunc, RangeTableFuncCol, RangeTableSample, ColumnDef, TableLikeClause, IndexElem, DefElem, LockingClause, XmlSerialize, PartitionElem, PartitionSpec, PartitionBoundSpec, PartitionRangeDatum, PartitionCmd, RangeTblEntry, RTEPermissionInfo, RangeTblFunction, TableSampleClause, WithCheckOption, SortGroupClause, GroupingSet, WindowClause, RowMarkClause, WithClause, InferClause, OnConflictClause, CTESearchClause, CTECycleClause, CommonTableExpr, MergeWhenClause, MergeAction, TriggerTransition, JsonOutput, JsonKeyValue, JsonObjectConstructor, JsonArrayConstructor, JsonArrayQueryConstructor, JsonAggConstructor, JsonObjectAgg, JsonArrayAgg, RawStmt, InsertStmt, DeleteStmt, UpdateStmt, MergeStmt, SelectStmt, SetOperationStmt, ReturnStmt, PLAssignStmt, CreateSchemaStmt, AlterTableStmt, ReplicaIdentityStmt, AlterTableCmd, AlterCollationStmt, AlterDomainStmt, GrantStmt, ObjectWithArgs, AccessPriv, GrantRoleStmt, AlterDefaultPrivilegesStmt, CopyStmt, VariableSetStmt, VariableShowStmt, CreateStmt, Constraint, CreateTableSpaceStmt, DropTableSpaceStmt, AlterTableSpaceOptionsStmt, AlterTableMoveAllStmt, CreateExtensionStmt, AlterExtensionStmt, AlterExtensionContentsStmt, CreateFdwStmt, AlterFdwStmt, CreateForeignServerStmt, AlterForeignServerStmt, CreateForeignTableStmt, CreateUserMappingStmt, AlterUserMappingStmt, DropUserMappingStmt, ImportForeignSchemaStmt, CreatePolicyStmt, AlterPolicyStmt, CreateAmStmt, CreateTrigStmt, CreateEventTrigStmt, AlterEventTrigStmt, CreatePLangStmt, CreateRoleStmt, AlterRoleStmt, AlterRoleSetStmt, DropRoleStmt, CreateSeqStmt, AlterSeqStmt, DefineStmt, CreateDomainStmt, CreateOpClassStmt, CreateOpClassItem, CreateOpFamilyStmt, AlterOpFamilyStmt, DropStmt, TruncateStmt, CommentStmt, SecLabelStmt, DeclareCursorStmt, ClosePortalStmt, FetchStmt, IndexStmt, CreateStatsStmt, StatsElem, AlterStatsStmt, CreateFunctionStmt, FunctionParameter, AlterFunctionStmt, DoStmt, InlineCodeBlock, CallStmt, CallContext, RenameStmt, AlterObjectDependsStmt, AlterObjectSchemaStmt, AlterOwnerStmt, AlterOperatorStmt, AlterTypeStmt, RuleStmt, NotifyStmt, ListenStmt, UnlistenStmt, TransactionStmt, CompositeTypeStmt, CreateEnumStmt, CreateRangeStmt, AlterEnumStmt, ViewStmt, LoadStmt, CreatedbStmt, AlterDatabaseStmt, AlterDatabaseRefreshCollStmt, AlterDatabaseSetStmt, DropdbStmt, AlterSystemStmt, ClusterStmt, VacuumStmt, VacuumRelation, ExplainStmt, CreateTableAsStmt, RefreshMatViewStmt, CheckPointStmt, DiscardStmt, LockStmt, ConstraintsSetStmt, ReindexStmt, CreateConversionStmt, CreateCastStmt, CreateTransformStmt, PrepareStmt, ExecuteStmt, DeallocateStmt, DropOwnedStmt, ReassignOwnedStmt, AlterTSDictionaryStmt, AlterTSConfigurationStmt, PublicationTable, PublicationObjSpec, CreatePublicationStmt, AlterPublicationStmt, CreateSubscriptionStmt, AlterSubscriptionStmt, DropSubscriptionStmt, ScanToken } from "./wrapped"; -export default { - parseResult(_p?: ParseResult["ParseResult"]): ParseResult { - const _j = ({ - ParseResult: {} - } as ParseResult); - _o.set(_j, "ParseResult.version", _p?.version); - _o.set(_j, "ParseResult.stmts", _p?.stmts); - return _j; - }, - scanResult(_p?: ScanResult["ScanResult"]): ScanResult { - const _j = ({ - ScanResult: {} - } as ScanResult); - _o.set(_j, "ScanResult.version", _p?.version); - _o.set(_j, "ScanResult.tokens", _p?.tokens); - return _j; - }, - integer(_p?: Integer["Integer"]): Integer { - const _j = ({ - Integer: {} - } as Integer); - _o.set(_j, "Integer.ival", _p?.ival); - return _j; - }, - float(_p?: Float["Float"]): Float { - const _j = ({ - Float: {} - } as Float); - _o.set(_j, "Float.fval", _p?.fval); - return _j; - }, - boolean(_p?: Boolean["Boolean"]): Boolean { - const _j = ({ - Boolean: {} - } as Boolean); - _o.set(_j, "Boolean.boolval", _p?.boolval); - return _j; - }, - string(_p?: String["String"]): String { - const _j = ({ - String: {} - } as String); - _o.set(_j, "String.sval", _p?.sval); - return _j; - }, - bitString(_p?: BitString["BitString"]): BitString { - const _j = ({ - BitString: {} - } as BitString); - _o.set(_j, "BitString.bsval", _p?.bsval); - return _j; - }, - list(_p?: List["List"]): List { - const _j = ({ - List: {} - } as List); - _o.set(_j, "List.items", _p?.items); - return _j; - }, - oidList(_p?: OidList["OidList"]): OidList { - const _j = ({ - OidList: {} - } as OidList); - _o.set(_j, "OidList.items", _p?.items); - return _j; - }, - intList(_p?: IntList["IntList"]): IntList { - const _j = ({ - IntList: {} - } as IntList); - _o.set(_j, "IntList.items", _p?.items); - return _j; - }, - aConst(_p?: A_Const["A_Const"]): A_Const { - const _j = ({ - A_Const: {} - } as A_Const); - _o.set(_j, "A_Const.ival", _p?.ival); - _o.set(_j, "A_Const.fval", _p?.fval); - _o.set(_j, "A_Const.boolval", _p?.boolval); - _o.set(_j, "A_Const.sval", _p?.sval); - _o.set(_j, "A_Const.bsval", _p?.bsval); - _o.set(_j, "A_Const.isnull", _p?.isnull); - _o.set(_j, "A_Const.location", _p?.location); - return _j; - }, - alias(_p?: Alias["Alias"]): Alias { - const _j = ({ - Alias: {} - } as Alias); - _o.set(_j, "Alias.aliasname", _p?.aliasname); - _o.set(_j, "Alias.colnames", _p?.colnames); - return _j; - }, - rangeVar(_p?: RangeVar["RangeVar"]): RangeVar { - const _j = ({ - RangeVar: {} - } as RangeVar); - _o.set(_j, "RangeVar.catalogname", _p?.catalogname); - _o.set(_j, "RangeVar.schemaname", _p?.schemaname); - _o.set(_j, "RangeVar.relname", _p?.relname); - _o.set(_j, "RangeVar.inh", _p?.inh); - _o.set(_j, "RangeVar.relpersistence", _p?.relpersistence); - _o.set(_j, "RangeVar.alias", _p?.alias); - _o.set(_j, "RangeVar.location", _p?.location); - return _j; - }, - tableFunc(_p?: TableFunc["TableFunc"]): TableFunc { - const _j = ({ - TableFunc: {} - } as TableFunc); - _o.set(_j, "TableFunc.ns_uris", _p?.ns_uris); - _o.set(_j, "TableFunc.ns_names", _p?.ns_names); - _o.set(_j, "TableFunc.docexpr", _p?.docexpr); - _o.set(_j, "TableFunc.rowexpr", _p?.rowexpr); - _o.set(_j, "TableFunc.colnames", _p?.colnames); - _o.set(_j, "TableFunc.coltypes", _p?.coltypes); - _o.set(_j, "TableFunc.coltypmods", _p?.coltypmods); - _o.set(_j, "TableFunc.colcollations", _p?.colcollations); - _o.set(_j, "TableFunc.colexprs", _p?.colexprs); - _o.set(_j, "TableFunc.coldefexprs", _p?.coldefexprs); - _o.set(_j, "TableFunc.notnulls", _p?.notnulls); - _o.set(_j, "TableFunc.ordinalitycol", _p?.ordinalitycol); - _o.set(_j, "TableFunc.location", _p?.location); - return _j; - }, - intoClause(_p?: IntoClause["IntoClause"]): IntoClause { - const _j = ({ - IntoClause: {} - } as IntoClause); - _o.set(_j, "IntoClause.rel", _p?.rel); - _o.set(_j, "IntoClause.colNames", _p?.colNames); - _o.set(_j, "IntoClause.accessMethod", _p?.accessMethod); - _o.set(_j, "IntoClause.options", _p?.options); - _o.set(_j, "IntoClause.onCommit", _p?.onCommit); - _o.set(_j, "IntoClause.tableSpaceName", _p?.tableSpaceName); - _o.set(_j, "IntoClause.viewQuery", _p?.viewQuery); - _o.set(_j, "IntoClause.skipData", _p?.skipData); - return _j; - }, - var(_p?: Var["Var"]): Var { - const _j = ({ - Var: {} - } as Var); - _o.set(_j, "Var.xpr", _p?.xpr); - _o.set(_j, "Var.varno", _p?.varno); - _o.set(_j, "Var.varattno", _p?.varattno); - _o.set(_j, "Var.vartype", _p?.vartype); - _o.set(_j, "Var.vartypmod", _p?.vartypmod); - _o.set(_j, "Var.varcollid", _p?.varcollid); - _o.set(_j, "Var.varnullingrels", _p?.varnullingrels); - _o.set(_j, "Var.varlevelsup", _p?.varlevelsup); - _o.set(_j, "Var.location", _p?.location); - return _j; - }, - param(_p?: Param["Param"]): Param { - const _j = ({ - Param: {} - } as Param); - _o.set(_j, "Param.xpr", _p?.xpr); - _o.set(_j, "Param.paramkind", _p?.paramkind); - _o.set(_j, "Param.paramid", _p?.paramid); - _o.set(_j, "Param.paramtype", _p?.paramtype); - _o.set(_j, "Param.paramtypmod", _p?.paramtypmod); - _o.set(_j, "Param.paramcollid", _p?.paramcollid); - _o.set(_j, "Param.location", _p?.location); - return _j; - }, - aggref(_p?: Aggref["Aggref"]): Aggref { - const _j = ({ - Aggref: {} - } as Aggref); - _o.set(_j, "Aggref.xpr", _p?.xpr); - _o.set(_j, "Aggref.aggfnoid", _p?.aggfnoid); - _o.set(_j, "Aggref.aggtype", _p?.aggtype); - _o.set(_j, "Aggref.aggcollid", _p?.aggcollid); - _o.set(_j, "Aggref.inputcollid", _p?.inputcollid); - _o.set(_j, "Aggref.aggargtypes", _p?.aggargtypes); - _o.set(_j, "Aggref.aggdirectargs", _p?.aggdirectargs); - _o.set(_j, "Aggref.args", _p?.args); - _o.set(_j, "Aggref.aggorder", _p?.aggorder); - _o.set(_j, "Aggref.aggdistinct", _p?.aggdistinct); - _o.set(_j, "Aggref.aggfilter", _p?.aggfilter); - _o.set(_j, "Aggref.aggstar", _p?.aggstar); - _o.set(_j, "Aggref.aggvariadic", _p?.aggvariadic); - _o.set(_j, "Aggref.aggkind", _p?.aggkind); - _o.set(_j, "Aggref.agglevelsup", _p?.agglevelsup); - _o.set(_j, "Aggref.aggsplit", _p?.aggsplit); - _o.set(_j, "Aggref.aggno", _p?.aggno); - _o.set(_j, "Aggref.aggtransno", _p?.aggtransno); - _o.set(_j, "Aggref.location", _p?.location); - return _j; - }, - groupingFunc(_p?: GroupingFunc["GroupingFunc"]): GroupingFunc { - const _j = ({ - GroupingFunc: {} - } as GroupingFunc); - _o.set(_j, "GroupingFunc.xpr", _p?.xpr); - _o.set(_j, "GroupingFunc.args", _p?.args); - _o.set(_j, "GroupingFunc.refs", _p?.refs); - _o.set(_j, "GroupingFunc.agglevelsup", _p?.agglevelsup); - _o.set(_j, "GroupingFunc.location", _p?.location); - return _j; - }, - windowFunc(_p?: WindowFunc["WindowFunc"]): WindowFunc { - const _j = ({ - WindowFunc: {} - } as WindowFunc); - _o.set(_j, "WindowFunc.xpr", _p?.xpr); - _o.set(_j, "WindowFunc.winfnoid", _p?.winfnoid); - _o.set(_j, "WindowFunc.wintype", _p?.wintype); - _o.set(_j, "WindowFunc.wincollid", _p?.wincollid); - _o.set(_j, "WindowFunc.inputcollid", _p?.inputcollid); - _o.set(_j, "WindowFunc.args", _p?.args); - _o.set(_j, "WindowFunc.aggfilter", _p?.aggfilter); - _o.set(_j, "WindowFunc.winref", _p?.winref); - _o.set(_j, "WindowFunc.winstar", _p?.winstar); - _o.set(_j, "WindowFunc.winagg", _p?.winagg); - _o.set(_j, "WindowFunc.location", _p?.location); - return _j; - }, - subscriptingRef(_p?: SubscriptingRef["SubscriptingRef"]): SubscriptingRef { - const _j = ({ - SubscriptingRef: {} - } as SubscriptingRef); - _o.set(_j, "SubscriptingRef.xpr", _p?.xpr); - _o.set(_j, "SubscriptingRef.refcontainertype", _p?.refcontainertype); - _o.set(_j, "SubscriptingRef.refelemtype", _p?.refelemtype); - _o.set(_j, "SubscriptingRef.refrestype", _p?.refrestype); - _o.set(_j, "SubscriptingRef.reftypmod", _p?.reftypmod); - _o.set(_j, "SubscriptingRef.refcollid", _p?.refcollid); - _o.set(_j, "SubscriptingRef.refupperindexpr", _p?.refupperindexpr); - _o.set(_j, "SubscriptingRef.reflowerindexpr", _p?.reflowerindexpr); - _o.set(_j, "SubscriptingRef.refexpr", _p?.refexpr); - _o.set(_j, "SubscriptingRef.refassgnexpr", _p?.refassgnexpr); - return _j; - }, - funcExpr(_p?: FuncExpr["FuncExpr"]): FuncExpr { - const _j = ({ - FuncExpr: {} - } as FuncExpr); - _o.set(_j, "FuncExpr.xpr", _p?.xpr); - _o.set(_j, "FuncExpr.funcid", _p?.funcid); - _o.set(_j, "FuncExpr.funcresulttype", _p?.funcresulttype); - _o.set(_j, "FuncExpr.funcretset", _p?.funcretset); - _o.set(_j, "FuncExpr.funcvariadic", _p?.funcvariadic); - _o.set(_j, "FuncExpr.funcformat", _p?.funcformat); - _o.set(_j, "FuncExpr.funccollid", _p?.funccollid); - _o.set(_j, "FuncExpr.inputcollid", _p?.inputcollid); - _o.set(_j, "FuncExpr.args", _p?.args); - _o.set(_j, "FuncExpr.location", _p?.location); - return _j; - }, - namedArgExpr(_p?: NamedArgExpr["NamedArgExpr"]): NamedArgExpr { - const _j = ({ - NamedArgExpr: {} - } as NamedArgExpr); - _o.set(_j, "NamedArgExpr.xpr", _p?.xpr); - _o.set(_j, "NamedArgExpr.arg", _p?.arg); - _o.set(_j, "NamedArgExpr.name", _p?.name); - _o.set(_j, "NamedArgExpr.argnumber", _p?.argnumber); - _o.set(_j, "NamedArgExpr.location", _p?.location); - return _j; - }, - opExpr(_p?: OpExpr["OpExpr"]): OpExpr { - const _j = ({ - OpExpr: {} - } as OpExpr); - _o.set(_j, "OpExpr.xpr", _p?.xpr); - _o.set(_j, "OpExpr.opno", _p?.opno); - _o.set(_j, "OpExpr.opresulttype", _p?.opresulttype); - _o.set(_j, "OpExpr.opretset", _p?.opretset); - _o.set(_j, "OpExpr.opcollid", _p?.opcollid); - _o.set(_j, "OpExpr.inputcollid", _p?.inputcollid); - _o.set(_j, "OpExpr.args", _p?.args); - _o.set(_j, "OpExpr.location", _p?.location); - return _j; - }, - distinctExpr(_p?: DistinctExpr["DistinctExpr"]): DistinctExpr { - const _j = ({ - DistinctExpr: {} - } as DistinctExpr); - _o.set(_j, "DistinctExpr.xpr", _p?.xpr); - _o.set(_j, "DistinctExpr.opno", _p?.opno); - _o.set(_j, "DistinctExpr.opresulttype", _p?.opresulttype); - _o.set(_j, "DistinctExpr.opretset", _p?.opretset); - _o.set(_j, "DistinctExpr.opcollid", _p?.opcollid); - _o.set(_j, "DistinctExpr.inputcollid", _p?.inputcollid); - _o.set(_j, "DistinctExpr.args", _p?.args); - _o.set(_j, "DistinctExpr.location", _p?.location); - return _j; - }, - nullIfExpr(_p?: NullIfExpr["NullIfExpr"]): NullIfExpr { - const _j = ({ - NullIfExpr: {} - } as NullIfExpr); - _o.set(_j, "NullIfExpr.xpr", _p?.xpr); - _o.set(_j, "NullIfExpr.opno", _p?.opno); - _o.set(_j, "NullIfExpr.opresulttype", _p?.opresulttype); - _o.set(_j, "NullIfExpr.opretset", _p?.opretset); - _o.set(_j, "NullIfExpr.opcollid", _p?.opcollid); - _o.set(_j, "NullIfExpr.inputcollid", _p?.inputcollid); - _o.set(_j, "NullIfExpr.args", _p?.args); - _o.set(_j, "NullIfExpr.location", _p?.location); - return _j; - }, - scalarArrayOpExpr(_p?: ScalarArrayOpExpr["ScalarArrayOpExpr"]): ScalarArrayOpExpr { - const _j = ({ - ScalarArrayOpExpr: {} - } as ScalarArrayOpExpr); - _o.set(_j, "ScalarArrayOpExpr.xpr", _p?.xpr); - _o.set(_j, "ScalarArrayOpExpr.opno", _p?.opno); - _o.set(_j, "ScalarArrayOpExpr.useOr", _p?.useOr); - _o.set(_j, "ScalarArrayOpExpr.inputcollid", _p?.inputcollid); - _o.set(_j, "ScalarArrayOpExpr.args", _p?.args); - _o.set(_j, "ScalarArrayOpExpr.location", _p?.location); - return _j; - }, - boolExpr(_p?: BoolExpr["BoolExpr"]): BoolExpr { - const _j = ({ - BoolExpr: {} - } as BoolExpr); - _o.set(_j, "BoolExpr.xpr", _p?.xpr); - _o.set(_j, "BoolExpr.boolop", _p?.boolop); - _o.set(_j, "BoolExpr.args", _p?.args); - _o.set(_j, "BoolExpr.location", _p?.location); - return _j; - }, - subLink(_p?: SubLink["SubLink"]): SubLink { - const _j = ({ - SubLink: {} - } as SubLink); - _o.set(_j, "SubLink.xpr", _p?.xpr); - _o.set(_j, "SubLink.subLinkType", _p?.subLinkType); - _o.set(_j, "SubLink.subLinkId", _p?.subLinkId); - _o.set(_j, "SubLink.testexpr", _p?.testexpr); - _o.set(_j, "SubLink.operName", _p?.operName); - _o.set(_j, "SubLink.subselect", _p?.subselect); - _o.set(_j, "SubLink.location", _p?.location); - return _j; - }, - subPlan(_p?: SubPlan["SubPlan"]): SubPlan { - const _j = ({ - SubPlan: {} - } as SubPlan); - _o.set(_j, "SubPlan.xpr", _p?.xpr); - _o.set(_j, "SubPlan.subLinkType", _p?.subLinkType); - _o.set(_j, "SubPlan.testexpr", _p?.testexpr); - _o.set(_j, "SubPlan.paramIds", _p?.paramIds); - _o.set(_j, "SubPlan.plan_id", _p?.plan_id); - _o.set(_j, "SubPlan.plan_name", _p?.plan_name); - _o.set(_j, "SubPlan.firstColType", _p?.firstColType); - _o.set(_j, "SubPlan.firstColTypmod", _p?.firstColTypmod); - _o.set(_j, "SubPlan.firstColCollation", _p?.firstColCollation); - _o.set(_j, "SubPlan.useHashTable", _p?.useHashTable); - _o.set(_j, "SubPlan.unknownEqFalse", _p?.unknownEqFalse); - _o.set(_j, "SubPlan.parallel_safe", _p?.parallel_safe); - _o.set(_j, "SubPlan.setParam", _p?.setParam); - _o.set(_j, "SubPlan.parParam", _p?.parParam); - _o.set(_j, "SubPlan.args", _p?.args); - _o.set(_j, "SubPlan.startup_cost", _p?.startup_cost); - _o.set(_j, "SubPlan.per_call_cost", _p?.per_call_cost); - return _j; - }, - alternativeSubPlan(_p?: AlternativeSubPlan["AlternativeSubPlan"]): AlternativeSubPlan { - const _j = ({ - AlternativeSubPlan: {} - } as AlternativeSubPlan); - _o.set(_j, "AlternativeSubPlan.xpr", _p?.xpr); - _o.set(_j, "AlternativeSubPlan.subplans", _p?.subplans); - return _j; - }, - fieldSelect(_p?: FieldSelect["FieldSelect"]): FieldSelect { - const _j = ({ - FieldSelect: {} - } as FieldSelect); - _o.set(_j, "FieldSelect.xpr", _p?.xpr); - _o.set(_j, "FieldSelect.arg", _p?.arg); - _o.set(_j, "FieldSelect.fieldnum", _p?.fieldnum); - _o.set(_j, "FieldSelect.resulttype", _p?.resulttype); - _o.set(_j, "FieldSelect.resulttypmod", _p?.resulttypmod); - _o.set(_j, "FieldSelect.resultcollid", _p?.resultcollid); - return _j; - }, - fieldStore(_p?: FieldStore["FieldStore"]): FieldStore { - const _j = ({ - FieldStore: {} - } as FieldStore); - _o.set(_j, "FieldStore.xpr", _p?.xpr); - _o.set(_j, "FieldStore.arg", _p?.arg); - _o.set(_j, "FieldStore.newvals", _p?.newvals); - _o.set(_j, "FieldStore.fieldnums", _p?.fieldnums); - _o.set(_j, "FieldStore.resulttype", _p?.resulttype); - return _j; - }, - relabelType(_p?: RelabelType["RelabelType"]): RelabelType { - const _j = ({ - RelabelType: {} - } as RelabelType); - _o.set(_j, "RelabelType.xpr", _p?.xpr); - _o.set(_j, "RelabelType.arg", _p?.arg); - _o.set(_j, "RelabelType.resulttype", _p?.resulttype); - _o.set(_j, "RelabelType.resulttypmod", _p?.resulttypmod); - _o.set(_j, "RelabelType.resultcollid", _p?.resultcollid); - _o.set(_j, "RelabelType.relabelformat", _p?.relabelformat); - _o.set(_j, "RelabelType.location", _p?.location); - return _j; - }, - coerceViaio(_p?: CoerceViaIO["CoerceViaIO"]): CoerceViaIO { - const _j = ({ - CoerceViaIO: {} - } as CoerceViaIO); - _o.set(_j, "CoerceViaIO.xpr", _p?.xpr); - _o.set(_j, "CoerceViaIO.arg", _p?.arg); - _o.set(_j, "CoerceViaIO.resulttype", _p?.resulttype); - _o.set(_j, "CoerceViaIO.resultcollid", _p?.resultcollid); - _o.set(_j, "CoerceViaIO.coerceformat", _p?.coerceformat); - _o.set(_j, "CoerceViaIO.location", _p?.location); - return _j; - }, - arrayCoerceExpr(_p?: ArrayCoerceExpr["ArrayCoerceExpr"]): ArrayCoerceExpr { - const _j = ({ - ArrayCoerceExpr: {} - } as ArrayCoerceExpr); - _o.set(_j, "ArrayCoerceExpr.xpr", _p?.xpr); - _o.set(_j, "ArrayCoerceExpr.arg", _p?.arg); - _o.set(_j, "ArrayCoerceExpr.elemexpr", _p?.elemexpr); - _o.set(_j, "ArrayCoerceExpr.resulttype", _p?.resulttype); - _o.set(_j, "ArrayCoerceExpr.resulttypmod", _p?.resulttypmod); - _o.set(_j, "ArrayCoerceExpr.resultcollid", _p?.resultcollid); - _o.set(_j, "ArrayCoerceExpr.coerceformat", _p?.coerceformat); - _o.set(_j, "ArrayCoerceExpr.location", _p?.location); - return _j; - }, - convertRowtypeExpr(_p?: ConvertRowtypeExpr["ConvertRowtypeExpr"]): ConvertRowtypeExpr { - const _j = ({ - ConvertRowtypeExpr: {} - } as ConvertRowtypeExpr); - _o.set(_j, "ConvertRowtypeExpr.xpr", _p?.xpr); - _o.set(_j, "ConvertRowtypeExpr.arg", _p?.arg); - _o.set(_j, "ConvertRowtypeExpr.resulttype", _p?.resulttype); - _o.set(_j, "ConvertRowtypeExpr.convertformat", _p?.convertformat); - _o.set(_j, "ConvertRowtypeExpr.location", _p?.location); - return _j; - }, - collateExpr(_p?: CollateExpr["CollateExpr"]): CollateExpr { - const _j = ({ - CollateExpr: {} - } as CollateExpr); - _o.set(_j, "CollateExpr.xpr", _p?.xpr); - _o.set(_j, "CollateExpr.arg", _p?.arg); - _o.set(_j, "CollateExpr.collOid", _p?.collOid); - _o.set(_j, "CollateExpr.location", _p?.location); - return _j; - }, - caseExpr(_p?: CaseExpr["CaseExpr"]): CaseExpr { - const _j = ({ - CaseExpr: {} - } as CaseExpr); - _o.set(_j, "CaseExpr.xpr", _p?.xpr); - _o.set(_j, "CaseExpr.casetype", _p?.casetype); - _o.set(_j, "CaseExpr.casecollid", _p?.casecollid); - _o.set(_j, "CaseExpr.arg", _p?.arg); - _o.set(_j, "CaseExpr.args", _p?.args); - _o.set(_j, "CaseExpr.defresult", _p?.defresult); - _o.set(_j, "CaseExpr.location", _p?.location); - return _j; - }, - caseWhen(_p?: CaseWhen["CaseWhen"]): CaseWhen { - const _j = ({ - CaseWhen: {} - } as CaseWhen); - _o.set(_j, "CaseWhen.xpr", _p?.xpr); - _o.set(_j, "CaseWhen.expr", _p?.expr); - _o.set(_j, "CaseWhen.result", _p?.result); - _o.set(_j, "CaseWhen.location", _p?.location); - return _j; - }, - caseTestExpr(_p?: CaseTestExpr["CaseTestExpr"]): CaseTestExpr { - const _j = ({ - CaseTestExpr: {} - } as CaseTestExpr); - _o.set(_j, "CaseTestExpr.xpr", _p?.xpr); - _o.set(_j, "CaseTestExpr.typeId", _p?.typeId); - _o.set(_j, "CaseTestExpr.typeMod", _p?.typeMod); - _o.set(_j, "CaseTestExpr.collation", _p?.collation); - return _j; - }, - arrayExpr(_p?: ArrayExpr["ArrayExpr"]): ArrayExpr { - const _j = ({ - ArrayExpr: {} - } as ArrayExpr); - _o.set(_j, "ArrayExpr.xpr", _p?.xpr); - _o.set(_j, "ArrayExpr.array_typeid", _p?.array_typeid); - _o.set(_j, "ArrayExpr.array_collid", _p?.array_collid); - _o.set(_j, "ArrayExpr.element_typeid", _p?.element_typeid); - _o.set(_j, "ArrayExpr.elements", _p?.elements); - _o.set(_j, "ArrayExpr.multidims", _p?.multidims); - _o.set(_j, "ArrayExpr.location", _p?.location); - return _j; - }, - rowExpr(_p?: RowExpr["RowExpr"]): RowExpr { - const _j = ({ - RowExpr: {} - } as RowExpr); - _o.set(_j, "RowExpr.xpr", _p?.xpr); - _o.set(_j, "RowExpr.args", _p?.args); - _o.set(_j, "RowExpr.row_typeid", _p?.row_typeid); - _o.set(_j, "RowExpr.row_format", _p?.row_format); - _o.set(_j, "RowExpr.colnames", _p?.colnames); - _o.set(_j, "RowExpr.location", _p?.location); - return _j; - }, - rowCompareExpr(_p?: RowCompareExpr["RowCompareExpr"]): RowCompareExpr { - const _j = ({ - RowCompareExpr: {} - } as RowCompareExpr); - _o.set(_j, "RowCompareExpr.xpr", _p?.xpr); - _o.set(_j, "RowCompareExpr.rctype", _p?.rctype); - _o.set(_j, "RowCompareExpr.opnos", _p?.opnos); - _o.set(_j, "RowCompareExpr.opfamilies", _p?.opfamilies); - _o.set(_j, "RowCompareExpr.inputcollids", _p?.inputcollids); - _o.set(_j, "RowCompareExpr.largs", _p?.largs); - _o.set(_j, "RowCompareExpr.rargs", _p?.rargs); - return _j; - }, - coalesceExpr(_p?: CoalesceExpr["CoalesceExpr"]): CoalesceExpr { - const _j = ({ - CoalesceExpr: {} - } as CoalesceExpr); - _o.set(_j, "CoalesceExpr.xpr", _p?.xpr); - _o.set(_j, "CoalesceExpr.coalescetype", _p?.coalescetype); - _o.set(_j, "CoalesceExpr.coalescecollid", _p?.coalescecollid); - _o.set(_j, "CoalesceExpr.args", _p?.args); - _o.set(_j, "CoalesceExpr.location", _p?.location); - return _j; - }, - minMaxExpr(_p?: MinMaxExpr["MinMaxExpr"]): MinMaxExpr { - const _j = ({ - MinMaxExpr: {} - } as MinMaxExpr); - _o.set(_j, "MinMaxExpr.xpr", _p?.xpr); - _o.set(_j, "MinMaxExpr.minmaxtype", _p?.minmaxtype); - _o.set(_j, "MinMaxExpr.minmaxcollid", _p?.minmaxcollid); - _o.set(_j, "MinMaxExpr.inputcollid", _p?.inputcollid); - _o.set(_j, "MinMaxExpr.op", _p?.op); - _o.set(_j, "MinMaxExpr.args", _p?.args); - _o.set(_j, "MinMaxExpr.location", _p?.location); - return _j; - }, - sqlValueFunction(_p?: SQLValueFunction["SQLValueFunction"]): SQLValueFunction { - const _j = ({ - SQLValueFunction: {} - } as SQLValueFunction); - _o.set(_j, "SQLValueFunction.xpr", _p?.xpr); - _o.set(_j, "SQLValueFunction.op", _p?.op); - _o.set(_j, "SQLValueFunction.type", _p?.type); - _o.set(_j, "SQLValueFunction.typmod", _p?.typmod); - _o.set(_j, "SQLValueFunction.location", _p?.location); - return _j; - }, - xmlExpr(_p?: XmlExpr["XmlExpr"]): XmlExpr { - const _j = ({ - XmlExpr: {} - } as XmlExpr); - _o.set(_j, "XmlExpr.xpr", _p?.xpr); - _o.set(_j, "XmlExpr.op", _p?.op); - _o.set(_j, "XmlExpr.name", _p?.name); - _o.set(_j, "XmlExpr.named_args", _p?.named_args); - _o.set(_j, "XmlExpr.arg_names", _p?.arg_names); - _o.set(_j, "XmlExpr.args", _p?.args); - _o.set(_j, "XmlExpr.xmloption", _p?.xmloption); - _o.set(_j, "XmlExpr.indent", _p?.indent); - _o.set(_j, "XmlExpr.type", _p?.type); - _o.set(_j, "XmlExpr.typmod", _p?.typmod); - _o.set(_j, "XmlExpr.location", _p?.location); - return _j; - }, - jsonFormat(_p?: JsonFormat["JsonFormat"]): JsonFormat { - const _j = ({ - JsonFormat: {} - } as JsonFormat); - _o.set(_j, "JsonFormat.format_type", _p?.format_type); - _o.set(_j, "JsonFormat.encoding", _p?.encoding); - _o.set(_j, "JsonFormat.location", _p?.location); - return _j; - }, - jsonReturning(_p?: JsonReturning["JsonReturning"]): JsonReturning { - const _j = ({ - JsonReturning: {} - } as JsonReturning); - _o.set(_j, "JsonReturning.format", _p?.format); - _o.set(_j, "JsonReturning.typid", _p?.typid); - _o.set(_j, "JsonReturning.typmod", _p?.typmod); - return _j; - }, - jsonValueExpr(_p?: JsonValueExpr["JsonValueExpr"]): JsonValueExpr { - const _j = ({ - JsonValueExpr: {} - } as JsonValueExpr); - _o.set(_j, "JsonValueExpr.raw_expr", _p?.raw_expr); - _o.set(_j, "JsonValueExpr.formatted_expr", _p?.formatted_expr); - _o.set(_j, "JsonValueExpr.format", _p?.format); - return _j; - }, - jsonConstructorExpr(_p?: JsonConstructorExpr["JsonConstructorExpr"]): JsonConstructorExpr { - const _j = ({ - JsonConstructorExpr: {} - } as JsonConstructorExpr); - _o.set(_j, "JsonConstructorExpr.xpr", _p?.xpr); - _o.set(_j, "JsonConstructorExpr.type", _p?.type); - _o.set(_j, "JsonConstructorExpr.args", _p?.args); - _o.set(_j, "JsonConstructorExpr.func", _p?.func); - _o.set(_j, "JsonConstructorExpr.coercion", _p?.coercion); - _o.set(_j, "JsonConstructorExpr.returning", _p?.returning); - _o.set(_j, "JsonConstructorExpr.absent_on_null", _p?.absent_on_null); - _o.set(_j, "JsonConstructorExpr.unique", _p?.unique); - _o.set(_j, "JsonConstructorExpr.location", _p?.location); - return _j; - }, - jsonIsPredicate(_p?: JsonIsPredicate["JsonIsPredicate"]): JsonIsPredicate { - const _j = ({ - JsonIsPredicate: {} - } as JsonIsPredicate); - _o.set(_j, "JsonIsPredicate.expr", _p?.expr); - _o.set(_j, "JsonIsPredicate.format", _p?.format); - _o.set(_j, "JsonIsPredicate.item_type", _p?.item_type); - _o.set(_j, "JsonIsPredicate.unique_keys", _p?.unique_keys); - _o.set(_j, "JsonIsPredicate.location", _p?.location); - return _j; - }, - nullTest(_p?: NullTest["NullTest"]): NullTest { - const _j = ({ - NullTest: {} - } as NullTest); - _o.set(_j, "NullTest.xpr", _p?.xpr); - _o.set(_j, "NullTest.arg", _p?.arg); - _o.set(_j, "NullTest.nulltesttype", _p?.nulltesttype); - _o.set(_j, "NullTest.argisrow", _p?.argisrow); - _o.set(_j, "NullTest.location", _p?.location); - return _j; - }, - booleanTest(_p?: BooleanTest["BooleanTest"]): BooleanTest { - const _j = ({ - BooleanTest: {} - } as BooleanTest); - _o.set(_j, "BooleanTest.xpr", _p?.xpr); - _o.set(_j, "BooleanTest.arg", _p?.arg); - _o.set(_j, "BooleanTest.booltesttype", _p?.booltesttype); - _o.set(_j, "BooleanTest.location", _p?.location); - return _j; - }, - coerceToDomain(_p?: CoerceToDomain["CoerceToDomain"]): CoerceToDomain { - const _j = ({ - CoerceToDomain: {} - } as CoerceToDomain); - _o.set(_j, "CoerceToDomain.xpr", _p?.xpr); - _o.set(_j, "CoerceToDomain.arg", _p?.arg); - _o.set(_j, "CoerceToDomain.resulttype", _p?.resulttype); - _o.set(_j, "CoerceToDomain.resulttypmod", _p?.resulttypmod); - _o.set(_j, "CoerceToDomain.resultcollid", _p?.resultcollid); - _o.set(_j, "CoerceToDomain.coercionformat", _p?.coercionformat); - _o.set(_j, "CoerceToDomain.location", _p?.location); - return _j; - }, - coerceToDomainValue(_p?: CoerceToDomainValue["CoerceToDomainValue"]): CoerceToDomainValue { - const _j = ({ - CoerceToDomainValue: {} - } as CoerceToDomainValue); - _o.set(_j, "CoerceToDomainValue.xpr", _p?.xpr); - _o.set(_j, "CoerceToDomainValue.typeId", _p?.typeId); - _o.set(_j, "CoerceToDomainValue.typeMod", _p?.typeMod); - _o.set(_j, "CoerceToDomainValue.collation", _p?.collation); - _o.set(_j, "CoerceToDomainValue.location", _p?.location); - return _j; - }, - setToDefault(_p?: SetToDefault["SetToDefault"]): SetToDefault { - const _j = ({ - SetToDefault: {} - } as SetToDefault); - _o.set(_j, "SetToDefault.xpr", _p?.xpr); - _o.set(_j, "SetToDefault.typeId", _p?.typeId); - _o.set(_j, "SetToDefault.typeMod", _p?.typeMod); - _o.set(_j, "SetToDefault.collation", _p?.collation); - _o.set(_j, "SetToDefault.location", _p?.location); - return _j; - }, - currentOfExpr(_p?: CurrentOfExpr["CurrentOfExpr"]): CurrentOfExpr { - const _j = ({ - CurrentOfExpr: {} - } as CurrentOfExpr); - _o.set(_j, "CurrentOfExpr.xpr", _p?.xpr); - _o.set(_j, "CurrentOfExpr.cvarno", _p?.cvarno); - _o.set(_j, "CurrentOfExpr.cursor_name", _p?.cursor_name); - _o.set(_j, "CurrentOfExpr.cursor_param", _p?.cursor_param); - return _j; - }, - nextValueExpr(_p?: NextValueExpr["NextValueExpr"]): NextValueExpr { - const _j = ({ - NextValueExpr: {} - } as NextValueExpr); - _o.set(_j, "NextValueExpr.xpr", _p?.xpr); - _o.set(_j, "NextValueExpr.seqid", _p?.seqid); - _o.set(_j, "NextValueExpr.typeId", _p?.typeId); - return _j; - }, - inferenceElem(_p?: InferenceElem["InferenceElem"]): InferenceElem { - const _j = ({ - InferenceElem: {} - } as InferenceElem); - _o.set(_j, "InferenceElem.xpr", _p?.xpr); - _o.set(_j, "InferenceElem.expr", _p?.expr); - _o.set(_j, "InferenceElem.infercollid", _p?.infercollid); - _o.set(_j, "InferenceElem.inferopclass", _p?.inferopclass); - return _j; - }, - targetEntry(_p?: TargetEntry["TargetEntry"]): TargetEntry { - const _j = ({ - TargetEntry: {} - } as TargetEntry); - _o.set(_j, "TargetEntry.xpr", _p?.xpr); - _o.set(_j, "TargetEntry.expr", _p?.expr); - _o.set(_j, "TargetEntry.resno", _p?.resno); - _o.set(_j, "TargetEntry.resname", _p?.resname); - _o.set(_j, "TargetEntry.ressortgroupref", _p?.ressortgroupref); - _o.set(_j, "TargetEntry.resorigtbl", _p?.resorigtbl); - _o.set(_j, "TargetEntry.resorigcol", _p?.resorigcol); - _o.set(_j, "TargetEntry.resjunk", _p?.resjunk); - return _j; - }, - rangeTblRef(_p?: RangeTblRef["RangeTblRef"]): RangeTblRef { - const _j = ({ - RangeTblRef: {} - } as RangeTblRef); - _o.set(_j, "RangeTblRef.rtindex", _p?.rtindex); - return _j; - }, - joinExpr(_p?: JoinExpr["JoinExpr"]): JoinExpr { - const _j = ({ - JoinExpr: {} - } as JoinExpr); - _o.set(_j, "JoinExpr.jointype", _p?.jointype); - _o.set(_j, "JoinExpr.isNatural", _p?.isNatural); - _o.set(_j, "JoinExpr.larg", _p?.larg); - _o.set(_j, "JoinExpr.rarg", _p?.rarg); - _o.set(_j, "JoinExpr.usingClause", _p?.usingClause); - _o.set(_j, "JoinExpr.join_using_alias", _p?.join_using_alias); - _o.set(_j, "JoinExpr.quals", _p?.quals); - _o.set(_j, "JoinExpr.alias", _p?.alias); - _o.set(_j, "JoinExpr.rtindex", _p?.rtindex); - return _j; - }, - fromExpr(_p?: FromExpr["FromExpr"]): FromExpr { - const _j = ({ - FromExpr: {} - } as FromExpr); - _o.set(_j, "FromExpr.fromlist", _p?.fromlist); - _o.set(_j, "FromExpr.quals", _p?.quals); - return _j; - }, - onConflictExpr(_p?: OnConflictExpr["OnConflictExpr"]): OnConflictExpr { - const _j = ({ - OnConflictExpr: {} - } as OnConflictExpr); - _o.set(_j, "OnConflictExpr.action", _p?.action); - _o.set(_j, "OnConflictExpr.arbiterElems", _p?.arbiterElems); - _o.set(_j, "OnConflictExpr.arbiterWhere", _p?.arbiterWhere); - _o.set(_j, "OnConflictExpr.constraint", _p?.constraint); - _o.set(_j, "OnConflictExpr.onConflictSet", _p?.onConflictSet); - _o.set(_j, "OnConflictExpr.onConflictWhere", _p?.onConflictWhere); - _o.set(_j, "OnConflictExpr.exclRelIndex", _p?.exclRelIndex); - _o.set(_j, "OnConflictExpr.exclRelTlist", _p?.exclRelTlist); - return _j; - }, - query(_p?: Query["Query"]): Query { - const _j = ({ - Query: {} - } as Query); - _o.set(_j, "Query.commandType", _p?.commandType); - _o.set(_j, "Query.querySource", _p?.querySource); - _o.set(_j, "Query.canSetTag", _p?.canSetTag); - _o.set(_j, "Query.utilityStmt", _p?.utilityStmt); - _o.set(_j, "Query.resultRelation", _p?.resultRelation); - _o.set(_j, "Query.hasAggs", _p?.hasAggs); - _o.set(_j, "Query.hasWindowFuncs", _p?.hasWindowFuncs); - _o.set(_j, "Query.hasTargetSRFs", _p?.hasTargetSRFs); - _o.set(_j, "Query.hasSubLinks", _p?.hasSubLinks); - _o.set(_j, "Query.hasDistinctOn", _p?.hasDistinctOn); - _o.set(_j, "Query.hasRecursive", _p?.hasRecursive); - _o.set(_j, "Query.hasModifyingCTE", _p?.hasModifyingCTE); - _o.set(_j, "Query.hasForUpdate", _p?.hasForUpdate); - _o.set(_j, "Query.hasRowSecurity", _p?.hasRowSecurity); - _o.set(_j, "Query.isReturn", _p?.isReturn); - _o.set(_j, "Query.cteList", _p?.cteList); - _o.set(_j, "Query.rtable", _p?.rtable); - _o.set(_j, "Query.rteperminfos", _p?.rteperminfos); - _o.set(_j, "Query.jointree", _p?.jointree); - _o.set(_j, "Query.mergeActionList", _p?.mergeActionList); - _o.set(_j, "Query.mergeUseOuterJoin", _p?.mergeUseOuterJoin); - _o.set(_j, "Query.targetList", _p?.targetList); - _o.set(_j, "Query.override", _p?.override); - _o.set(_j, "Query.onConflict", _p?.onConflict); - _o.set(_j, "Query.returningList", _p?.returningList); - _o.set(_j, "Query.groupClause", _p?.groupClause); - _o.set(_j, "Query.groupDistinct", _p?.groupDistinct); - _o.set(_j, "Query.groupingSets", _p?.groupingSets); - _o.set(_j, "Query.havingQual", _p?.havingQual); - _o.set(_j, "Query.windowClause", _p?.windowClause); - _o.set(_j, "Query.distinctClause", _p?.distinctClause); - _o.set(_j, "Query.sortClause", _p?.sortClause); - _o.set(_j, "Query.limitOffset", _p?.limitOffset); - _o.set(_j, "Query.limitCount", _p?.limitCount); - _o.set(_j, "Query.limitOption", _p?.limitOption); - _o.set(_j, "Query.rowMarks", _p?.rowMarks); - _o.set(_j, "Query.setOperations", _p?.setOperations); - _o.set(_j, "Query.constraintDeps", _p?.constraintDeps); - _o.set(_j, "Query.withCheckOptions", _p?.withCheckOptions); - _o.set(_j, "Query.stmt_location", _p?.stmt_location); - _o.set(_j, "Query.stmt_len", _p?.stmt_len); - return _j; - }, - typeName(_p?: TypeName): TypeName { - const _j = ({} as TypeName); - _o.set(_j, "names", _p?.names); - _o.set(_j, "typeOid", _p?.typeOid); - _o.set(_j, "setof", _p?.setof); - _o.set(_j, "pct_type", _p?.pct_type); - _o.set(_j, "typmods", _p?.typmods); - _o.set(_j, "typemod", _p?.typemod); - _o.set(_j, "arrayBounds", _p?.arrayBounds); - _o.set(_j, "location", _p?.location); - return _j; - }, - columnRef(_p?: ColumnRef["ColumnRef"]): ColumnRef { - const _j = ({ - ColumnRef: {} - } as ColumnRef); - _o.set(_j, "ColumnRef.fields", _p?.fields); - _o.set(_j, "ColumnRef.location", _p?.location); - return _j; - }, - paramRef(_p?: ParamRef["ParamRef"]): ParamRef { - const _j = ({ - ParamRef: {} - } as ParamRef); - _o.set(_j, "ParamRef.number", _p?.number); - _o.set(_j, "ParamRef.location", _p?.location); - return _j; - }, - aExpr(_p?: A_Expr["A_Expr"]): A_Expr { - const _j = ({ - A_Expr: {} - } as A_Expr); - _o.set(_j, "A_Expr.kind", _p?.kind); - _o.set(_j, "A_Expr.name", _p?.name); - _o.set(_j, "A_Expr.lexpr", _p?.lexpr); - _o.set(_j, "A_Expr.rexpr", _p?.rexpr); - _o.set(_j, "A_Expr.location", _p?.location); - return _j; - }, - typeCast(_p?: TypeCast["TypeCast"]): TypeCast { - const _j = ({ - TypeCast: {} - } as TypeCast); - _o.set(_j, "TypeCast.arg", _p?.arg); - _o.set(_j, "TypeCast.typeName", _p?.typeName); - _o.set(_j, "TypeCast.location", _p?.location); - return _j; - }, - collateClause(_p?: CollateClause["CollateClause"]): CollateClause { - const _j = ({ - CollateClause: {} - } as CollateClause); - _o.set(_j, "CollateClause.arg", _p?.arg); - _o.set(_j, "CollateClause.collname", _p?.collname); - _o.set(_j, "CollateClause.location", _p?.location); - return _j; - }, - roleSpec(_p?: RoleSpec["RoleSpec"]): RoleSpec { - const _j = ({ - RoleSpec: {} - } as RoleSpec); - _o.set(_j, "RoleSpec.roletype", _p?.roletype); - _o.set(_j, "RoleSpec.rolename", _p?.rolename); - _o.set(_j, "RoleSpec.location", _p?.location); - return _j; - }, - funcCall(_p?: FuncCall["FuncCall"]): FuncCall { - const _j = ({ - FuncCall: {} - } as FuncCall); - _o.set(_j, "FuncCall.funcname", _p?.funcname); - _o.set(_j, "FuncCall.args", _p?.args); - _o.set(_j, "FuncCall.agg_order", _p?.agg_order); - _o.set(_j, "FuncCall.agg_filter", _p?.agg_filter); - _o.set(_j, "FuncCall.over", _p?.over); - _o.set(_j, "FuncCall.agg_within_group", _p?.agg_within_group); - _o.set(_j, "FuncCall.agg_star", _p?.agg_star); - _o.set(_j, "FuncCall.agg_distinct", _p?.agg_distinct); - _o.set(_j, "FuncCall.func_variadic", _p?.func_variadic); - _o.set(_j, "FuncCall.funcformat", _p?.funcformat); - _o.set(_j, "FuncCall.location", _p?.location); - return _j; - }, - aStar(_p?: A_Star["A_Star"]): A_Star { - const _j = ({ - A_Star: {} - } as A_Star); - return _j; - }, - aIndices(_p?: A_Indices["A_Indices"]): A_Indices { - const _j = ({ - A_Indices: {} - } as A_Indices); - _o.set(_j, "A_Indices.is_slice", _p?.is_slice); - _o.set(_j, "A_Indices.lidx", _p?.lidx); - _o.set(_j, "A_Indices.uidx", _p?.uidx); - return _j; - }, - aIndirection(_p?: A_Indirection["A_Indirection"]): A_Indirection { - const _j = ({ - A_Indirection: {} - } as A_Indirection); - _o.set(_j, "A_Indirection.arg", _p?.arg); - _o.set(_j, "A_Indirection.indirection", _p?.indirection); - return _j; - }, - aArrayExpr(_p?: A_ArrayExpr["A_ArrayExpr"]): A_ArrayExpr { - const _j = ({ - A_ArrayExpr: {} - } as A_ArrayExpr); - _o.set(_j, "A_ArrayExpr.elements", _p?.elements); - _o.set(_j, "A_ArrayExpr.location", _p?.location); - return _j; - }, - resTarget(_p?: ResTarget["ResTarget"]): ResTarget { - const _j = ({ - ResTarget: {} - } as ResTarget); - _o.set(_j, "ResTarget.name", _p?.name); - _o.set(_j, "ResTarget.indirection", _p?.indirection); - _o.set(_j, "ResTarget.val", _p?.val); - _o.set(_j, "ResTarget.location", _p?.location); - return _j; - }, - multiAssignRef(_p?: MultiAssignRef["MultiAssignRef"]): MultiAssignRef { - const _j = ({ - MultiAssignRef: {} - } as MultiAssignRef); - _o.set(_j, "MultiAssignRef.source", _p?.source); - _o.set(_j, "MultiAssignRef.colno", _p?.colno); - _o.set(_j, "MultiAssignRef.ncolumns", _p?.ncolumns); - return _j; - }, - sortBy(_p?: SortBy["SortBy"]): SortBy { - const _j = ({ - SortBy: {} - } as SortBy); - _o.set(_j, "SortBy.node", _p?.node); - _o.set(_j, "SortBy.sortby_dir", _p?.sortby_dir); - _o.set(_j, "SortBy.sortby_nulls", _p?.sortby_nulls); - _o.set(_j, "SortBy.useOp", _p?.useOp); - _o.set(_j, "SortBy.location", _p?.location); - return _j; - }, - windowDef(_p?: WindowDef["WindowDef"]): WindowDef { - const _j = ({ - WindowDef: {} - } as WindowDef); - _o.set(_j, "WindowDef.name", _p?.name); - _o.set(_j, "WindowDef.refname", _p?.refname); - _o.set(_j, "WindowDef.partitionClause", _p?.partitionClause); - _o.set(_j, "WindowDef.orderClause", _p?.orderClause); - _o.set(_j, "WindowDef.frameOptions", _p?.frameOptions); - _o.set(_j, "WindowDef.startOffset", _p?.startOffset); - _o.set(_j, "WindowDef.endOffset", _p?.endOffset); - _o.set(_j, "WindowDef.location", _p?.location); - return _j; - }, - rangeSubselect(_p?: RangeSubselect["RangeSubselect"]): RangeSubselect { - const _j = ({ - RangeSubselect: {} - } as RangeSubselect); - _o.set(_j, "RangeSubselect.lateral", _p?.lateral); - _o.set(_j, "RangeSubselect.subquery", _p?.subquery); - _o.set(_j, "RangeSubselect.alias", _p?.alias); - return _j; - }, - rangeFunction(_p?: RangeFunction["RangeFunction"]): RangeFunction { - const _j = ({ - RangeFunction: {} - } as RangeFunction); - _o.set(_j, "RangeFunction.lateral", _p?.lateral); - _o.set(_j, "RangeFunction.ordinality", _p?.ordinality); - _o.set(_j, "RangeFunction.is_rowsfrom", _p?.is_rowsfrom); - _o.set(_j, "RangeFunction.functions", _p?.functions); - _o.set(_j, "RangeFunction.alias", _p?.alias); - _o.set(_j, "RangeFunction.coldeflist", _p?.coldeflist); - return _j; - }, - rangeTableFunc(_p?: RangeTableFunc["RangeTableFunc"]): RangeTableFunc { - const _j = ({ - RangeTableFunc: {} - } as RangeTableFunc); - _o.set(_j, "RangeTableFunc.lateral", _p?.lateral); - _o.set(_j, "RangeTableFunc.docexpr", _p?.docexpr); - _o.set(_j, "RangeTableFunc.rowexpr", _p?.rowexpr); - _o.set(_j, "RangeTableFunc.namespaces", _p?.namespaces); - _o.set(_j, "RangeTableFunc.columns", _p?.columns); - _o.set(_j, "RangeTableFunc.alias", _p?.alias); - _o.set(_j, "RangeTableFunc.location", _p?.location); - return _j; - }, - rangeTableFuncCol(_p?: RangeTableFuncCol["RangeTableFuncCol"]): RangeTableFuncCol { - const _j = ({ - RangeTableFuncCol: {} - } as RangeTableFuncCol); - _o.set(_j, "RangeTableFuncCol.colname", _p?.colname); - _o.set(_j, "RangeTableFuncCol.typeName", _p?.typeName); - _o.set(_j, "RangeTableFuncCol.for_ordinality", _p?.for_ordinality); - _o.set(_j, "RangeTableFuncCol.is_not_null", _p?.is_not_null); - _o.set(_j, "RangeTableFuncCol.colexpr", _p?.colexpr); - _o.set(_j, "RangeTableFuncCol.coldefexpr", _p?.coldefexpr); - _o.set(_j, "RangeTableFuncCol.location", _p?.location); - return _j; - }, - rangeTableSample(_p?: RangeTableSample["RangeTableSample"]): RangeTableSample { - const _j = ({ - RangeTableSample: {} - } as RangeTableSample); - _o.set(_j, "RangeTableSample.relation", _p?.relation); - _o.set(_j, "RangeTableSample.method", _p?.method); - _o.set(_j, "RangeTableSample.args", _p?.args); - _o.set(_j, "RangeTableSample.repeatable", _p?.repeatable); - _o.set(_j, "RangeTableSample.location", _p?.location); - return _j; - }, - columnDef(_p?: ColumnDef["ColumnDef"]): ColumnDef { - const _j = ({ - ColumnDef: {} - } as ColumnDef); - _o.set(_j, "ColumnDef.colname", _p?.colname); - _o.set(_j, "ColumnDef.typeName", _p?.typeName); - _o.set(_j, "ColumnDef.compression", _p?.compression); - _o.set(_j, "ColumnDef.inhcount", _p?.inhcount); - _o.set(_j, "ColumnDef.is_local", _p?.is_local); - _o.set(_j, "ColumnDef.is_not_null", _p?.is_not_null); - _o.set(_j, "ColumnDef.is_from_type", _p?.is_from_type); - _o.set(_j, "ColumnDef.storage", _p?.storage); - _o.set(_j, "ColumnDef.storage_name", _p?.storage_name); - _o.set(_j, "ColumnDef.raw_default", _p?.raw_default); - _o.set(_j, "ColumnDef.cooked_default", _p?.cooked_default); - _o.set(_j, "ColumnDef.identity", _p?.identity); - _o.set(_j, "ColumnDef.identitySequence", _p?.identitySequence); - _o.set(_j, "ColumnDef.generated", _p?.generated); - _o.set(_j, "ColumnDef.collClause", _p?.collClause); - _o.set(_j, "ColumnDef.collOid", _p?.collOid); - _o.set(_j, "ColumnDef.constraints", _p?.constraints); - _o.set(_j, "ColumnDef.fdwoptions", _p?.fdwoptions); - _o.set(_j, "ColumnDef.location", _p?.location); - return _j; - }, - tableLikeClause(_p?: TableLikeClause["TableLikeClause"]): TableLikeClause { - const _j = ({ - TableLikeClause: {} - } as TableLikeClause); - _o.set(_j, "TableLikeClause.relation", _p?.relation); - _o.set(_j, "TableLikeClause.options", _p?.options); - _o.set(_j, "TableLikeClause.relationOid", _p?.relationOid); - return _j; - }, - indexElem(_p?: IndexElem["IndexElem"]): IndexElem { - const _j = ({ - IndexElem: {} - } as IndexElem); - _o.set(_j, "IndexElem.name", _p?.name); - _o.set(_j, "IndexElem.expr", _p?.expr); - _o.set(_j, "IndexElem.indexcolname", _p?.indexcolname); - _o.set(_j, "IndexElem.collation", _p?.collation); - _o.set(_j, "IndexElem.opclass", _p?.opclass); - _o.set(_j, "IndexElem.opclassopts", _p?.opclassopts); - _o.set(_j, "IndexElem.ordering", _p?.ordering); - _o.set(_j, "IndexElem.nulls_ordering", _p?.nulls_ordering); - return _j; - }, - defElem(_p?: DefElem["DefElem"]): DefElem { - const _j = ({ - DefElem: {} - } as DefElem); - _o.set(_j, "DefElem.defnamespace", _p?.defnamespace); - _o.set(_j, "DefElem.defname", _p?.defname); - _o.set(_j, "DefElem.arg", _p?.arg); - _o.set(_j, "DefElem.defaction", _p?.defaction); - _o.set(_j, "DefElem.location", _p?.location); - return _j; - }, - lockingClause(_p?: LockingClause["LockingClause"]): LockingClause { - const _j = ({ - LockingClause: {} - } as LockingClause); - _o.set(_j, "LockingClause.lockedRels", _p?.lockedRels); - _o.set(_j, "LockingClause.strength", _p?.strength); - _o.set(_j, "LockingClause.waitPolicy", _p?.waitPolicy); - return _j; - }, - xmlSerialize(_p?: XmlSerialize["XmlSerialize"]): XmlSerialize { - const _j = ({ - XmlSerialize: {} - } as XmlSerialize); - _o.set(_j, "XmlSerialize.xmloption", _p?.xmloption); - _o.set(_j, "XmlSerialize.expr", _p?.expr); - _o.set(_j, "XmlSerialize.typeName", _p?.typeName); - _o.set(_j, "XmlSerialize.indent", _p?.indent); - _o.set(_j, "XmlSerialize.location", _p?.location); - return _j; - }, - partitionElem(_p?: PartitionElem["PartitionElem"]): PartitionElem { - const _j = ({ - PartitionElem: {} - } as PartitionElem); - _o.set(_j, "PartitionElem.name", _p?.name); - _o.set(_j, "PartitionElem.expr", _p?.expr); - _o.set(_j, "PartitionElem.collation", _p?.collation); - _o.set(_j, "PartitionElem.opclass", _p?.opclass); - _o.set(_j, "PartitionElem.location", _p?.location); - return _j; - }, - partitionSpec(_p?: PartitionSpec["PartitionSpec"]): PartitionSpec { - const _j = ({ - PartitionSpec: {} - } as PartitionSpec); - _o.set(_j, "PartitionSpec.strategy", _p?.strategy); - _o.set(_j, "PartitionSpec.partParams", _p?.partParams); - _o.set(_j, "PartitionSpec.location", _p?.location); - return _j; - }, - partitionBoundSpec(_p?: PartitionBoundSpec["PartitionBoundSpec"]): PartitionBoundSpec { - const _j = ({ - PartitionBoundSpec: {} - } as PartitionBoundSpec); - _o.set(_j, "PartitionBoundSpec.strategy", _p?.strategy); - _o.set(_j, "PartitionBoundSpec.is_default", _p?.is_default); - _o.set(_j, "PartitionBoundSpec.modulus", _p?.modulus); - _o.set(_j, "PartitionBoundSpec.remainder", _p?.remainder); - _o.set(_j, "PartitionBoundSpec.listdatums", _p?.listdatums); - _o.set(_j, "PartitionBoundSpec.lowerdatums", _p?.lowerdatums); - _o.set(_j, "PartitionBoundSpec.upperdatums", _p?.upperdatums); - _o.set(_j, "PartitionBoundSpec.location", _p?.location); - return _j; - }, - partitionRangeDatum(_p?: PartitionRangeDatum["PartitionRangeDatum"]): PartitionRangeDatum { - const _j = ({ - PartitionRangeDatum: {} - } as PartitionRangeDatum); - _o.set(_j, "PartitionRangeDatum.kind", _p?.kind); - _o.set(_j, "PartitionRangeDatum.value", _p?.value); - _o.set(_j, "PartitionRangeDatum.location", _p?.location); - return _j; - }, - partitionCmd(_p?: PartitionCmd["PartitionCmd"]): PartitionCmd { - const _j = ({ - PartitionCmd: {} - } as PartitionCmd); - _o.set(_j, "PartitionCmd.name", _p?.name); - _o.set(_j, "PartitionCmd.bound", _p?.bound); - _o.set(_j, "PartitionCmd.concurrent", _p?.concurrent); - return _j; - }, - rangeTblEntry(_p?: RangeTblEntry["RangeTblEntry"]): RangeTblEntry { - const _j = ({ - RangeTblEntry: {} - } as RangeTblEntry); - _o.set(_j, "RangeTblEntry.rtekind", _p?.rtekind); - _o.set(_j, "RangeTblEntry.relid", _p?.relid); - _o.set(_j, "RangeTblEntry.relkind", _p?.relkind); - _o.set(_j, "RangeTblEntry.rellockmode", _p?.rellockmode); - _o.set(_j, "RangeTblEntry.tablesample", _p?.tablesample); - _o.set(_j, "RangeTblEntry.perminfoindex", _p?.perminfoindex); - _o.set(_j, "RangeTblEntry.subquery", _p?.subquery); - _o.set(_j, "RangeTblEntry.security_barrier", _p?.security_barrier); - _o.set(_j, "RangeTblEntry.jointype", _p?.jointype); - _o.set(_j, "RangeTblEntry.joinmergedcols", _p?.joinmergedcols); - _o.set(_j, "RangeTblEntry.joinaliasvars", _p?.joinaliasvars); - _o.set(_j, "RangeTblEntry.joinleftcols", _p?.joinleftcols); - _o.set(_j, "RangeTblEntry.joinrightcols", _p?.joinrightcols); - _o.set(_j, "RangeTblEntry.join_using_alias", _p?.join_using_alias); - _o.set(_j, "RangeTblEntry.functions", _p?.functions); - _o.set(_j, "RangeTblEntry.funcordinality", _p?.funcordinality); - _o.set(_j, "RangeTblEntry.tablefunc", _p?.tablefunc); - _o.set(_j, "RangeTblEntry.values_lists", _p?.values_lists); - _o.set(_j, "RangeTblEntry.ctename", _p?.ctename); - _o.set(_j, "RangeTblEntry.ctelevelsup", _p?.ctelevelsup); - _o.set(_j, "RangeTblEntry.self_reference", _p?.self_reference); - _o.set(_j, "RangeTblEntry.coltypes", _p?.coltypes); - _o.set(_j, "RangeTblEntry.coltypmods", _p?.coltypmods); - _o.set(_j, "RangeTblEntry.colcollations", _p?.colcollations); - _o.set(_j, "RangeTblEntry.enrname", _p?.enrname); - _o.set(_j, "RangeTblEntry.enrtuples", _p?.enrtuples); - _o.set(_j, "RangeTblEntry.alias", _p?.alias); - _o.set(_j, "RangeTblEntry.eref", _p?.eref); - _o.set(_j, "RangeTblEntry.lateral", _p?.lateral); - _o.set(_j, "RangeTblEntry.inh", _p?.inh); - _o.set(_j, "RangeTblEntry.inFromCl", _p?.inFromCl); - _o.set(_j, "RangeTblEntry.securityQuals", _p?.securityQuals); - return _j; - }, - rtePermissionInfo(_p?: RTEPermissionInfo["RTEPermissionInfo"]): RTEPermissionInfo { - const _j = ({ - RTEPermissionInfo: {} - } as RTEPermissionInfo); - _o.set(_j, "RTEPermissionInfo.relid", _p?.relid); - _o.set(_j, "RTEPermissionInfo.inh", _p?.inh); - _o.set(_j, "RTEPermissionInfo.requiredPerms", _p?.requiredPerms); - _o.set(_j, "RTEPermissionInfo.checkAsUser", _p?.checkAsUser); - _o.set(_j, "RTEPermissionInfo.selectedCols", _p?.selectedCols); - _o.set(_j, "RTEPermissionInfo.insertedCols", _p?.insertedCols); - _o.set(_j, "RTEPermissionInfo.updatedCols", _p?.updatedCols); - return _j; - }, - rangeTblFunction(_p?: RangeTblFunction["RangeTblFunction"]): RangeTblFunction { - const _j = ({ - RangeTblFunction: {} - } as RangeTblFunction); - _o.set(_j, "RangeTblFunction.funcexpr", _p?.funcexpr); - _o.set(_j, "RangeTblFunction.funccolcount", _p?.funccolcount); - _o.set(_j, "RangeTblFunction.funccolnames", _p?.funccolnames); - _o.set(_j, "RangeTblFunction.funccoltypes", _p?.funccoltypes); - _o.set(_j, "RangeTblFunction.funccoltypmods", _p?.funccoltypmods); - _o.set(_j, "RangeTblFunction.funccolcollations", _p?.funccolcollations); - _o.set(_j, "RangeTblFunction.funcparams", _p?.funcparams); - return _j; - }, - tableSampleClause(_p?: TableSampleClause["TableSampleClause"]): TableSampleClause { - const _j = ({ - TableSampleClause: {} - } as TableSampleClause); - _o.set(_j, "TableSampleClause.tsmhandler", _p?.tsmhandler); - _o.set(_j, "TableSampleClause.args", _p?.args); - _o.set(_j, "TableSampleClause.repeatable", _p?.repeatable); - return _j; - }, - withCheckOption(_p?: WithCheckOption["WithCheckOption"]): WithCheckOption { - const _j = ({ - WithCheckOption: {} - } as WithCheckOption); - _o.set(_j, "WithCheckOption.kind", _p?.kind); - _o.set(_j, "WithCheckOption.relname", _p?.relname); - _o.set(_j, "WithCheckOption.polname", _p?.polname); - _o.set(_j, "WithCheckOption.qual", _p?.qual); - _o.set(_j, "WithCheckOption.cascaded", _p?.cascaded); - return _j; - }, - sortGroupClause(_p?: SortGroupClause["SortGroupClause"]): SortGroupClause { - const _j = ({ - SortGroupClause: {} - } as SortGroupClause); - _o.set(_j, "SortGroupClause.tleSortGroupRef", _p?.tleSortGroupRef); - _o.set(_j, "SortGroupClause.eqop", _p?.eqop); - _o.set(_j, "SortGroupClause.sortop", _p?.sortop); - _o.set(_j, "SortGroupClause.nulls_first", _p?.nulls_first); - _o.set(_j, "SortGroupClause.hashable", _p?.hashable); - return _j; - }, - groupingSet(_p?: GroupingSet["GroupingSet"]): GroupingSet { - const _j = ({ - GroupingSet: {} - } as GroupingSet); - _o.set(_j, "GroupingSet.kind", _p?.kind); - _o.set(_j, "GroupingSet.content", _p?.content); - _o.set(_j, "GroupingSet.location", _p?.location); - return _j; - }, - windowClause(_p?: WindowClause["WindowClause"]): WindowClause { - const _j = ({ - WindowClause: {} - } as WindowClause); - _o.set(_j, "WindowClause.name", _p?.name); - _o.set(_j, "WindowClause.refname", _p?.refname); - _o.set(_j, "WindowClause.partitionClause", _p?.partitionClause); - _o.set(_j, "WindowClause.orderClause", _p?.orderClause); - _o.set(_j, "WindowClause.frameOptions", _p?.frameOptions); - _o.set(_j, "WindowClause.startOffset", _p?.startOffset); - _o.set(_j, "WindowClause.endOffset", _p?.endOffset); - _o.set(_j, "WindowClause.runCondition", _p?.runCondition); - _o.set(_j, "WindowClause.startInRangeFunc", _p?.startInRangeFunc); - _o.set(_j, "WindowClause.endInRangeFunc", _p?.endInRangeFunc); - _o.set(_j, "WindowClause.inRangeColl", _p?.inRangeColl); - _o.set(_j, "WindowClause.inRangeAsc", _p?.inRangeAsc); - _o.set(_j, "WindowClause.inRangeNullsFirst", _p?.inRangeNullsFirst); - _o.set(_j, "WindowClause.winref", _p?.winref); - _o.set(_j, "WindowClause.copiedOrder", _p?.copiedOrder); - return _j; - }, - rowMarkClause(_p?: RowMarkClause["RowMarkClause"]): RowMarkClause { - const _j = ({ - RowMarkClause: {} - } as RowMarkClause); - _o.set(_j, "RowMarkClause.rti", _p?.rti); - _o.set(_j, "RowMarkClause.strength", _p?.strength); - _o.set(_j, "RowMarkClause.waitPolicy", _p?.waitPolicy); - _o.set(_j, "RowMarkClause.pushedDown", _p?.pushedDown); - return _j; - }, - withClause(_p?: WithClause["WithClause"]): WithClause { - const _j = ({ - WithClause: {} - } as WithClause); - _o.set(_j, "WithClause.ctes", _p?.ctes); - _o.set(_j, "WithClause.recursive", _p?.recursive); - _o.set(_j, "WithClause.location", _p?.location); - return _j; - }, - inferClause(_p?: InferClause["InferClause"]): InferClause { - const _j = ({ - InferClause: {} - } as InferClause); - _o.set(_j, "InferClause.indexElems", _p?.indexElems); - _o.set(_j, "InferClause.whereClause", _p?.whereClause); - _o.set(_j, "InferClause.conname", _p?.conname); - _o.set(_j, "InferClause.location", _p?.location); - return _j; - }, - onConflictClause(_p?: OnConflictClause["OnConflictClause"]): OnConflictClause { - const _j = ({ - OnConflictClause: {} - } as OnConflictClause); - _o.set(_j, "OnConflictClause.action", _p?.action); - _o.set(_j, "OnConflictClause.infer", _p?.infer); - _o.set(_j, "OnConflictClause.targetList", _p?.targetList); - _o.set(_j, "OnConflictClause.whereClause", _p?.whereClause); - _o.set(_j, "OnConflictClause.location", _p?.location); - return _j; - }, - cteSearchClause(_p?: CTESearchClause["CTESearchClause"]): CTESearchClause { - const _j = ({ - CTESearchClause: {} - } as CTESearchClause); - _o.set(_j, "CTESearchClause.search_col_list", _p?.search_col_list); - _o.set(_j, "CTESearchClause.search_breadth_first", _p?.search_breadth_first); - _o.set(_j, "CTESearchClause.search_seq_column", _p?.search_seq_column); - _o.set(_j, "CTESearchClause.location", _p?.location); - return _j; - }, - cteCycleClause(_p?: CTECycleClause["CTECycleClause"]): CTECycleClause { - const _j = ({ - CTECycleClause: {} - } as CTECycleClause); - _o.set(_j, "CTECycleClause.cycle_col_list", _p?.cycle_col_list); - _o.set(_j, "CTECycleClause.cycle_mark_column", _p?.cycle_mark_column); - _o.set(_j, "CTECycleClause.cycle_mark_value", _p?.cycle_mark_value); - _o.set(_j, "CTECycleClause.cycle_mark_default", _p?.cycle_mark_default); - _o.set(_j, "CTECycleClause.cycle_path_column", _p?.cycle_path_column); - _o.set(_j, "CTECycleClause.location", _p?.location); - _o.set(_j, "CTECycleClause.cycle_mark_type", _p?.cycle_mark_type); - _o.set(_j, "CTECycleClause.cycle_mark_typmod", _p?.cycle_mark_typmod); - _o.set(_j, "CTECycleClause.cycle_mark_collation", _p?.cycle_mark_collation); - _o.set(_j, "CTECycleClause.cycle_mark_neop", _p?.cycle_mark_neop); - return _j; - }, - commonTableExpr(_p?: CommonTableExpr["CommonTableExpr"]): CommonTableExpr { - const _j = ({ - CommonTableExpr: {} - } as CommonTableExpr); - _o.set(_j, "CommonTableExpr.ctename", _p?.ctename); - _o.set(_j, "CommonTableExpr.aliascolnames", _p?.aliascolnames); - _o.set(_j, "CommonTableExpr.ctematerialized", _p?.ctematerialized); - _o.set(_j, "CommonTableExpr.ctequery", _p?.ctequery); - _o.set(_j, "CommonTableExpr.search_clause", _p?.search_clause); - _o.set(_j, "CommonTableExpr.cycle_clause", _p?.cycle_clause); - _o.set(_j, "CommonTableExpr.location", _p?.location); - _o.set(_j, "CommonTableExpr.cterecursive", _p?.cterecursive); - _o.set(_j, "CommonTableExpr.cterefcount", _p?.cterefcount); - _o.set(_j, "CommonTableExpr.ctecolnames", _p?.ctecolnames); - _o.set(_j, "CommonTableExpr.ctecoltypes", _p?.ctecoltypes); - _o.set(_j, "CommonTableExpr.ctecoltypmods", _p?.ctecoltypmods); - _o.set(_j, "CommonTableExpr.ctecolcollations", _p?.ctecolcollations); - return _j; - }, - mergeWhenClause(_p?: MergeWhenClause["MergeWhenClause"]): MergeWhenClause { - const _j = ({ - MergeWhenClause: {} - } as MergeWhenClause); - _o.set(_j, "MergeWhenClause.matched", _p?.matched); - _o.set(_j, "MergeWhenClause.commandType", _p?.commandType); - _o.set(_j, "MergeWhenClause.override", _p?.override); - _o.set(_j, "MergeWhenClause.condition", _p?.condition); - _o.set(_j, "MergeWhenClause.targetList", _p?.targetList); - _o.set(_j, "MergeWhenClause.values", _p?.values); - return _j; - }, - mergeAction(_p?: MergeAction["MergeAction"]): MergeAction { - const _j = ({ - MergeAction: {} - } as MergeAction); - _o.set(_j, "MergeAction.matched", _p?.matched); - _o.set(_j, "MergeAction.commandType", _p?.commandType); - _o.set(_j, "MergeAction.override", _p?.override); - _o.set(_j, "MergeAction.qual", _p?.qual); - _o.set(_j, "MergeAction.targetList", _p?.targetList); - _o.set(_j, "MergeAction.updateColnos", _p?.updateColnos); - return _j; - }, - triggerTransition(_p?: TriggerTransition["TriggerTransition"]): TriggerTransition { - const _j = ({ - TriggerTransition: {} - } as TriggerTransition); - _o.set(_j, "TriggerTransition.name", _p?.name); - _o.set(_j, "TriggerTransition.isNew", _p?.isNew); - _o.set(_j, "TriggerTransition.isTable", _p?.isTable); - return _j; - }, - jsonOutput(_p?: JsonOutput["JsonOutput"]): JsonOutput { - const _j = ({ - JsonOutput: {} - } as JsonOutput); - _o.set(_j, "JsonOutput.typeName", _p?.typeName); - _o.set(_j, "JsonOutput.returning", _p?.returning); - return _j; - }, - jsonKeyValue(_p?: JsonKeyValue["JsonKeyValue"]): JsonKeyValue { - const _j = ({ - JsonKeyValue: {} - } as JsonKeyValue); - _o.set(_j, "JsonKeyValue.key", _p?.key); - _o.set(_j, "JsonKeyValue.value", _p?.value); - return _j; - }, - jsonObjectConstructor(_p?: JsonObjectConstructor["JsonObjectConstructor"]): JsonObjectConstructor { - const _j = ({ - JsonObjectConstructor: {} - } as JsonObjectConstructor); - _o.set(_j, "JsonObjectConstructor.exprs", _p?.exprs); - _o.set(_j, "JsonObjectConstructor.output", _p?.output); - _o.set(_j, "JsonObjectConstructor.absent_on_null", _p?.absent_on_null); - _o.set(_j, "JsonObjectConstructor.unique", _p?.unique); - _o.set(_j, "JsonObjectConstructor.location", _p?.location); - return _j; - }, - jsonArrayConstructor(_p?: JsonArrayConstructor["JsonArrayConstructor"]): JsonArrayConstructor { - const _j = ({ - JsonArrayConstructor: {} - } as JsonArrayConstructor); - _o.set(_j, "JsonArrayConstructor.exprs", _p?.exprs); - _o.set(_j, "JsonArrayConstructor.output", _p?.output); - _o.set(_j, "JsonArrayConstructor.absent_on_null", _p?.absent_on_null); - _o.set(_j, "JsonArrayConstructor.location", _p?.location); - return _j; - }, - jsonArrayQueryConstructor(_p?: JsonArrayQueryConstructor["JsonArrayQueryConstructor"]): JsonArrayQueryConstructor { - const _j = ({ - JsonArrayQueryConstructor: {} - } as JsonArrayQueryConstructor); - _o.set(_j, "JsonArrayQueryConstructor.query", _p?.query); - _o.set(_j, "JsonArrayQueryConstructor.output", _p?.output); - _o.set(_j, "JsonArrayQueryConstructor.format", _p?.format); - _o.set(_j, "JsonArrayQueryConstructor.absent_on_null", _p?.absent_on_null); - _o.set(_j, "JsonArrayQueryConstructor.location", _p?.location); - return _j; - }, - jsonAggConstructor(_p?: JsonAggConstructor["JsonAggConstructor"]): JsonAggConstructor { - const _j = ({ - JsonAggConstructor: {} - } as JsonAggConstructor); - _o.set(_j, "JsonAggConstructor.output", _p?.output); - _o.set(_j, "JsonAggConstructor.agg_filter", _p?.agg_filter); - _o.set(_j, "JsonAggConstructor.agg_order", _p?.agg_order); - _o.set(_j, "JsonAggConstructor.over", _p?.over); - _o.set(_j, "JsonAggConstructor.location", _p?.location); - return _j; - }, - jsonObjectAgg(_p?: JsonObjectAgg["JsonObjectAgg"]): JsonObjectAgg { - const _j = ({ - JsonObjectAgg: {} - } as JsonObjectAgg); - _o.set(_j, "JsonObjectAgg.constructor", _p?.constructor); - _o.set(_j, "JsonObjectAgg.arg", _p?.arg); - _o.set(_j, "JsonObjectAgg.absent_on_null", _p?.absent_on_null); - _o.set(_j, "JsonObjectAgg.unique", _p?.unique); - return _j; - }, - jsonArrayAgg(_p?: JsonArrayAgg["JsonArrayAgg"]): JsonArrayAgg { - const _j = ({ - JsonArrayAgg: {} - } as JsonArrayAgg); - _o.set(_j, "JsonArrayAgg.constructor", _p?.constructor); - _o.set(_j, "JsonArrayAgg.arg", _p?.arg); - _o.set(_j, "JsonArrayAgg.absent_on_null", _p?.absent_on_null); - return _j; - }, - rawStmt(_p?: RawStmt["RawStmt"]): RawStmt { - const _j = ({ - RawStmt: {} - } as RawStmt); - _o.set(_j, "RawStmt.stmt", _p?.stmt); - _o.set(_j, "RawStmt.stmt_location", _p?.stmt_location); - _o.set(_j, "RawStmt.stmt_len", _p?.stmt_len); - return _j; - }, - insertStmt(_p?: InsertStmt["InsertStmt"]): InsertStmt { - const _j = ({ - InsertStmt: {} - } as InsertStmt); - _o.set(_j, "InsertStmt.relation", _p?.relation); - _o.set(_j, "InsertStmt.cols", _p?.cols); - _o.set(_j, "InsertStmt.selectStmt", _p?.selectStmt); - _o.set(_j, "InsertStmt.onConflictClause", _p?.onConflictClause); - _o.set(_j, "InsertStmt.returningList", _p?.returningList); - _o.set(_j, "InsertStmt.withClause", _p?.withClause); - _o.set(_j, "InsertStmt.override", _p?.override); - return _j; - }, - deleteStmt(_p?: DeleteStmt["DeleteStmt"]): DeleteStmt { - const _j = ({ - DeleteStmt: {} - } as DeleteStmt); - _o.set(_j, "DeleteStmt.relation", _p?.relation); - _o.set(_j, "DeleteStmt.usingClause", _p?.usingClause); - _o.set(_j, "DeleteStmt.whereClause", _p?.whereClause); - _o.set(_j, "DeleteStmt.returningList", _p?.returningList); - _o.set(_j, "DeleteStmt.withClause", _p?.withClause); - return _j; - }, - updateStmt(_p?: UpdateStmt["UpdateStmt"]): UpdateStmt { - const _j = ({ - UpdateStmt: {} - } as UpdateStmt); - _o.set(_j, "UpdateStmt.relation", _p?.relation); - _o.set(_j, "UpdateStmt.targetList", _p?.targetList); - _o.set(_j, "UpdateStmt.whereClause", _p?.whereClause); - _o.set(_j, "UpdateStmt.fromClause", _p?.fromClause); - _o.set(_j, "UpdateStmt.returningList", _p?.returningList); - _o.set(_j, "UpdateStmt.withClause", _p?.withClause); - return _j; - }, - mergeStmt(_p?: MergeStmt["MergeStmt"]): MergeStmt { - const _j = ({ - MergeStmt: {} - } as MergeStmt); - _o.set(_j, "MergeStmt.relation", _p?.relation); - _o.set(_j, "MergeStmt.sourceRelation", _p?.sourceRelation); - _o.set(_j, "MergeStmt.joinCondition", _p?.joinCondition); - _o.set(_j, "MergeStmt.mergeWhenClauses", _p?.mergeWhenClauses); - _o.set(_j, "MergeStmt.withClause", _p?.withClause); - return _j; - }, - selectStmt(_p?: SelectStmt["SelectStmt"]): SelectStmt { - const _j = ({ - SelectStmt: {} - } as SelectStmt); - _o.set(_j, "SelectStmt.distinctClause", _p?.distinctClause); - _o.set(_j, "SelectStmt.intoClause", _p?.intoClause); - _o.set(_j, "SelectStmt.targetList", _p?.targetList); - _o.set(_j, "SelectStmt.fromClause", _p?.fromClause); - _o.set(_j, "SelectStmt.whereClause", _p?.whereClause); - _o.set(_j, "SelectStmt.groupClause", _p?.groupClause); - _o.set(_j, "SelectStmt.groupDistinct", _p?.groupDistinct); - _o.set(_j, "SelectStmt.havingClause", _p?.havingClause); - _o.set(_j, "SelectStmt.windowClause", _p?.windowClause); - _o.set(_j, "SelectStmt.valuesLists", _p?.valuesLists); - _o.set(_j, "SelectStmt.sortClause", _p?.sortClause); - _o.set(_j, "SelectStmt.limitOffset", _p?.limitOffset); - _o.set(_j, "SelectStmt.limitCount", _p?.limitCount); - _o.set(_j, "SelectStmt.limitOption", _p?.limitOption); - _o.set(_j, "SelectStmt.lockingClause", _p?.lockingClause); - _o.set(_j, "SelectStmt.withClause", _p?.withClause); - _o.set(_j, "SelectStmt.op", _p?.op); - _o.set(_j, "SelectStmt.all", _p?.all); - _o.set(_j, "SelectStmt.larg", _p?.larg); - _o.set(_j, "SelectStmt.rarg", _p?.rarg); - return _j; - }, - setOperationStmt(_p?: SetOperationStmt["SetOperationStmt"]): SetOperationStmt { - const _j = ({ - SetOperationStmt: {} - } as SetOperationStmt); - _o.set(_j, "SetOperationStmt.op", _p?.op); - _o.set(_j, "SetOperationStmt.all", _p?.all); - _o.set(_j, "SetOperationStmt.larg", _p?.larg); - _o.set(_j, "SetOperationStmt.rarg", _p?.rarg); - _o.set(_j, "SetOperationStmt.colTypes", _p?.colTypes); - _o.set(_j, "SetOperationStmt.colTypmods", _p?.colTypmods); - _o.set(_j, "SetOperationStmt.colCollations", _p?.colCollations); - _o.set(_j, "SetOperationStmt.groupClauses", _p?.groupClauses); - return _j; - }, - returnStmt(_p?: ReturnStmt["ReturnStmt"]): ReturnStmt { - const _j = ({ - ReturnStmt: {} - } as ReturnStmt); - _o.set(_j, "ReturnStmt.returnval", _p?.returnval); - return _j; - }, - plAssignStmt(_p?: PLAssignStmt["PLAssignStmt"]): PLAssignStmt { - const _j = ({ - PLAssignStmt: {} - } as PLAssignStmt); - _o.set(_j, "PLAssignStmt.name", _p?.name); - _o.set(_j, "PLAssignStmt.indirection", _p?.indirection); - _o.set(_j, "PLAssignStmt.nnames", _p?.nnames); - _o.set(_j, "PLAssignStmt.val", _p?.val); - _o.set(_j, "PLAssignStmt.location", _p?.location); - return _j; - }, - createSchemaStmt(_p?: CreateSchemaStmt["CreateSchemaStmt"]): CreateSchemaStmt { - const _j = ({ - CreateSchemaStmt: {} - } as CreateSchemaStmt); - _o.set(_j, "CreateSchemaStmt.schemaname", _p?.schemaname); - _o.set(_j, "CreateSchemaStmt.authrole", _p?.authrole); - _o.set(_j, "CreateSchemaStmt.schemaElts", _p?.schemaElts); - _o.set(_j, "CreateSchemaStmt.if_not_exists", _p?.if_not_exists); - return _j; - }, - alterTableStmt(_p?: AlterTableStmt["AlterTableStmt"]): AlterTableStmt { - const _j = ({ - AlterTableStmt: {} - } as AlterTableStmt); - _o.set(_j, "AlterTableStmt.relation", _p?.relation); - _o.set(_j, "AlterTableStmt.cmds", _p?.cmds); - _o.set(_j, "AlterTableStmt.objtype", _p?.objtype); - _o.set(_j, "AlterTableStmt.missing_ok", _p?.missing_ok); - return _j; - }, - replicaIdentityStmt(_p?: ReplicaIdentityStmt["ReplicaIdentityStmt"]): ReplicaIdentityStmt { - const _j = ({ - ReplicaIdentityStmt: {} - } as ReplicaIdentityStmt); - _o.set(_j, "ReplicaIdentityStmt.identity_type", _p?.identity_type); - _o.set(_j, "ReplicaIdentityStmt.name", _p?.name); - return _j; - }, - alterTableCmd(_p?: AlterTableCmd["AlterTableCmd"]): AlterTableCmd { - const _j = ({ - AlterTableCmd: {} - } as AlterTableCmd); - _o.set(_j, "AlterTableCmd.subtype", _p?.subtype); - _o.set(_j, "AlterTableCmd.name", _p?.name); - _o.set(_j, "AlterTableCmd.num", _p?.num); - _o.set(_j, "AlterTableCmd.newowner", _p?.newowner); - _o.set(_j, "AlterTableCmd.def", _p?.def); - _o.set(_j, "AlterTableCmd.behavior", _p?.behavior); - _o.set(_j, "AlterTableCmd.missing_ok", _p?.missing_ok); - _o.set(_j, "AlterTableCmd.recurse", _p?.recurse); - return _j; - }, - alterCollationStmt(_p?: AlterCollationStmt["AlterCollationStmt"]): AlterCollationStmt { - const _j = ({ - AlterCollationStmt: {} - } as AlterCollationStmt); - _o.set(_j, "AlterCollationStmt.collname", _p?.collname); - return _j; - }, - alterDomainStmt(_p?: AlterDomainStmt["AlterDomainStmt"]): AlterDomainStmt { - const _j = ({ - AlterDomainStmt: {} - } as AlterDomainStmt); - _o.set(_j, "AlterDomainStmt.subtype", _p?.subtype); - _o.set(_j, "AlterDomainStmt.typeName", _p?.typeName); - _o.set(_j, "AlterDomainStmt.name", _p?.name); - _o.set(_j, "AlterDomainStmt.def", _p?.def); - _o.set(_j, "AlterDomainStmt.behavior", _p?.behavior); - _o.set(_j, "AlterDomainStmt.missing_ok", _p?.missing_ok); - return _j; - }, - grantStmt(_p?: GrantStmt["GrantStmt"]): GrantStmt { - const _j = ({ - GrantStmt: {} - } as GrantStmt); - _o.set(_j, "GrantStmt.is_grant", _p?.is_grant); - _o.set(_j, "GrantStmt.targtype", _p?.targtype); - _o.set(_j, "GrantStmt.objtype", _p?.objtype); - _o.set(_j, "GrantStmt.objects", _p?.objects); - _o.set(_j, "GrantStmt.privileges", _p?.privileges); - _o.set(_j, "GrantStmt.grantees", _p?.grantees); - _o.set(_j, "GrantStmt.grant_option", _p?.grant_option); - _o.set(_j, "GrantStmt.grantor", _p?.grantor); - _o.set(_j, "GrantStmt.behavior", _p?.behavior); - return _j; - }, - objectWithArgs(_p?: ObjectWithArgs["ObjectWithArgs"]): ObjectWithArgs { - const _j = ({ - ObjectWithArgs: {} - } as ObjectWithArgs); - _o.set(_j, "ObjectWithArgs.objname", _p?.objname); - _o.set(_j, "ObjectWithArgs.objargs", _p?.objargs); - _o.set(_j, "ObjectWithArgs.objfuncargs", _p?.objfuncargs); - _o.set(_j, "ObjectWithArgs.args_unspecified", _p?.args_unspecified); - return _j; - }, - accessPriv(_p?: AccessPriv["AccessPriv"]): AccessPriv { - const _j = ({ - AccessPriv: {} - } as AccessPriv); - _o.set(_j, "AccessPriv.priv_name", _p?.priv_name); - _o.set(_j, "AccessPriv.cols", _p?.cols); - return _j; - }, - grantRoleStmt(_p?: GrantRoleStmt["GrantRoleStmt"]): GrantRoleStmt { - const _j = ({ - GrantRoleStmt: {} - } as GrantRoleStmt); - _o.set(_j, "GrantRoleStmt.granted_roles", _p?.granted_roles); - _o.set(_j, "GrantRoleStmt.grantee_roles", _p?.grantee_roles); - _o.set(_j, "GrantRoleStmt.is_grant", _p?.is_grant); - _o.set(_j, "GrantRoleStmt.opt", _p?.opt); - _o.set(_j, "GrantRoleStmt.grantor", _p?.grantor); - _o.set(_j, "GrantRoleStmt.behavior", _p?.behavior); - return _j; - }, - alterDefaultPrivilegesStmt(_p?: AlterDefaultPrivilegesStmt["AlterDefaultPrivilegesStmt"]): AlterDefaultPrivilegesStmt { - const _j = ({ - AlterDefaultPrivilegesStmt: {} - } as AlterDefaultPrivilegesStmt); - _o.set(_j, "AlterDefaultPrivilegesStmt.options", _p?.options); - _o.set(_j, "AlterDefaultPrivilegesStmt.action", _p?.action); - return _j; - }, - copyStmt(_p?: CopyStmt["CopyStmt"]): CopyStmt { - const _j = ({ - CopyStmt: {} - } as CopyStmt); - _o.set(_j, "CopyStmt.relation", _p?.relation); - _o.set(_j, "CopyStmt.query", _p?.query); - _o.set(_j, "CopyStmt.attlist", _p?.attlist); - _o.set(_j, "CopyStmt.is_from", _p?.is_from); - _o.set(_j, "CopyStmt.is_program", _p?.is_program); - _o.set(_j, "CopyStmt.filename", _p?.filename); - _o.set(_j, "CopyStmt.options", _p?.options); - _o.set(_j, "CopyStmt.whereClause", _p?.whereClause); - return _j; - }, - variableSetStmt(_p?: VariableSetStmt["VariableSetStmt"]): VariableSetStmt { - const _j = ({ - VariableSetStmt: {} - } as VariableSetStmt); - _o.set(_j, "VariableSetStmt.kind", _p?.kind); - _o.set(_j, "VariableSetStmt.name", _p?.name); - _o.set(_j, "VariableSetStmt.args", _p?.args); - _o.set(_j, "VariableSetStmt.is_local", _p?.is_local); - return _j; - }, - variableShowStmt(_p?: VariableShowStmt["VariableShowStmt"]): VariableShowStmt { - const _j = ({ - VariableShowStmt: {} - } as VariableShowStmt); - _o.set(_j, "VariableShowStmt.name", _p?.name); - return _j; - }, - createStmt(_p?: CreateStmt["CreateStmt"]): CreateStmt { - const _j = ({ - CreateStmt: {} - } as CreateStmt); - _o.set(_j, "CreateStmt.relation", _p?.relation); - _o.set(_j, "CreateStmt.tableElts", _p?.tableElts); - _o.set(_j, "CreateStmt.inhRelations", _p?.inhRelations); - _o.set(_j, "CreateStmt.partbound", _p?.partbound); - _o.set(_j, "CreateStmt.partspec", _p?.partspec); - _o.set(_j, "CreateStmt.ofTypename", _p?.ofTypename); - _o.set(_j, "CreateStmt.constraints", _p?.constraints); - _o.set(_j, "CreateStmt.options", _p?.options); - _o.set(_j, "CreateStmt.oncommit", _p?.oncommit); - _o.set(_j, "CreateStmt.tablespacename", _p?.tablespacename); - _o.set(_j, "CreateStmt.accessMethod", _p?.accessMethod); - _o.set(_j, "CreateStmt.if_not_exists", _p?.if_not_exists); - return _j; - }, - constraint(_p?: Constraint["Constraint"]): Constraint { - const _j = ({ - Constraint: {} - } as Constraint); - _o.set(_j, "Constraint.contype", _p?.contype); - _o.set(_j, "Constraint.conname", _p?.conname); - _o.set(_j, "Constraint.deferrable", _p?.deferrable); - _o.set(_j, "Constraint.initdeferred", _p?.initdeferred); - _o.set(_j, "Constraint.location", _p?.location); - _o.set(_j, "Constraint.is_no_inherit", _p?.is_no_inherit); - _o.set(_j, "Constraint.raw_expr", _p?.raw_expr); - _o.set(_j, "Constraint.cooked_expr", _p?.cooked_expr); - _o.set(_j, "Constraint.generated_when", _p?.generated_when); - _o.set(_j, "Constraint.nulls_not_distinct", _p?.nulls_not_distinct); - _o.set(_j, "Constraint.keys", _p?.keys); - _o.set(_j, "Constraint.including", _p?.including); - _o.set(_j, "Constraint.exclusions", _p?.exclusions); - _o.set(_j, "Constraint.options", _p?.options); - _o.set(_j, "Constraint.indexname", _p?.indexname); - _o.set(_j, "Constraint.indexspace", _p?.indexspace); - _o.set(_j, "Constraint.reset_default_tblspc", _p?.reset_default_tblspc); - _o.set(_j, "Constraint.access_method", _p?.access_method); - _o.set(_j, "Constraint.where_clause", _p?.where_clause); - _o.set(_j, "Constraint.pktable", _p?.pktable); - _o.set(_j, "Constraint.fk_attrs", _p?.fk_attrs); - _o.set(_j, "Constraint.pk_attrs", _p?.pk_attrs); - _o.set(_j, "Constraint.fk_matchtype", _p?.fk_matchtype); - _o.set(_j, "Constraint.fk_upd_action", _p?.fk_upd_action); - _o.set(_j, "Constraint.fk_del_action", _p?.fk_del_action); - _o.set(_j, "Constraint.fk_del_set_cols", _p?.fk_del_set_cols); - _o.set(_j, "Constraint.old_conpfeqop", _p?.old_conpfeqop); - _o.set(_j, "Constraint.old_pktable_oid", _p?.old_pktable_oid); - _o.set(_j, "Constraint.skip_validation", _p?.skip_validation); - _o.set(_j, "Constraint.initially_valid", _p?.initially_valid); - return _j; - }, - createTableSpaceStmt(_p?: CreateTableSpaceStmt["CreateTableSpaceStmt"]): CreateTableSpaceStmt { - const _j = ({ - CreateTableSpaceStmt: {} - } as CreateTableSpaceStmt); - _o.set(_j, "CreateTableSpaceStmt.tablespacename", _p?.tablespacename); - _o.set(_j, "CreateTableSpaceStmt.owner", _p?.owner); - _o.set(_j, "CreateTableSpaceStmt.location", _p?.location); - _o.set(_j, "CreateTableSpaceStmt.options", _p?.options); - return _j; - }, - dropTableSpaceStmt(_p?: DropTableSpaceStmt["DropTableSpaceStmt"]): DropTableSpaceStmt { - const _j = ({ - DropTableSpaceStmt: {} - } as DropTableSpaceStmt); - _o.set(_j, "DropTableSpaceStmt.tablespacename", _p?.tablespacename); - _o.set(_j, "DropTableSpaceStmt.missing_ok", _p?.missing_ok); - return _j; - }, - alterTableSpaceOptionsStmt(_p?: AlterTableSpaceOptionsStmt["AlterTableSpaceOptionsStmt"]): AlterTableSpaceOptionsStmt { - const _j = ({ - AlterTableSpaceOptionsStmt: {} - } as AlterTableSpaceOptionsStmt); - _o.set(_j, "AlterTableSpaceOptionsStmt.tablespacename", _p?.tablespacename); - _o.set(_j, "AlterTableSpaceOptionsStmt.options", _p?.options); - _o.set(_j, "AlterTableSpaceOptionsStmt.isReset", _p?.isReset); - return _j; - }, - alterTableMoveAllStmt(_p?: AlterTableMoveAllStmt["AlterTableMoveAllStmt"]): AlterTableMoveAllStmt { - const _j = ({ - AlterTableMoveAllStmt: {} - } as AlterTableMoveAllStmt); - _o.set(_j, "AlterTableMoveAllStmt.orig_tablespacename", _p?.orig_tablespacename); - _o.set(_j, "AlterTableMoveAllStmt.objtype", _p?.objtype); - _o.set(_j, "AlterTableMoveAllStmt.roles", _p?.roles); - _o.set(_j, "AlterTableMoveAllStmt.new_tablespacename", _p?.new_tablespacename); - _o.set(_j, "AlterTableMoveAllStmt.nowait", _p?.nowait); - return _j; - }, - createExtensionStmt(_p?: CreateExtensionStmt["CreateExtensionStmt"]): CreateExtensionStmt { - const _j = ({ - CreateExtensionStmt: {} - } as CreateExtensionStmt); - _o.set(_j, "CreateExtensionStmt.extname", _p?.extname); - _o.set(_j, "CreateExtensionStmt.if_not_exists", _p?.if_not_exists); - _o.set(_j, "CreateExtensionStmt.options", _p?.options); - return _j; - }, - alterExtensionStmt(_p?: AlterExtensionStmt["AlterExtensionStmt"]): AlterExtensionStmt { - const _j = ({ - AlterExtensionStmt: {} - } as AlterExtensionStmt); - _o.set(_j, "AlterExtensionStmt.extname", _p?.extname); - _o.set(_j, "AlterExtensionStmt.options", _p?.options); - return _j; - }, - alterExtensionContentsStmt(_p?: AlterExtensionContentsStmt["AlterExtensionContentsStmt"]): AlterExtensionContentsStmt { - const _j = ({ - AlterExtensionContentsStmt: {} - } as AlterExtensionContentsStmt); - _o.set(_j, "AlterExtensionContentsStmt.extname", _p?.extname); - _o.set(_j, "AlterExtensionContentsStmt.action", _p?.action); - _o.set(_j, "AlterExtensionContentsStmt.objtype", _p?.objtype); - _o.set(_j, "AlterExtensionContentsStmt.object", _p?.object); - return _j; - }, - createFdwStmt(_p?: CreateFdwStmt["CreateFdwStmt"]): CreateFdwStmt { - const _j = ({ - CreateFdwStmt: {} - } as CreateFdwStmt); - _o.set(_j, "CreateFdwStmt.fdwname", _p?.fdwname); - _o.set(_j, "CreateFdwStmt.func_options", _p?.func_options); - _o.set(_j, "CreateFdwStmt.options", _p?.options); - return _j; - }, - alterFdwStmt(_p?: AlterFdwStmt["AlterFdwStmt"]): AlterFdwStmt { - const _j = ({ - AlterFdwStmt: {} - } as AlterFdwStmt); - _o.set(_j, "AlterFdwStmt.fdwname", _p?.fdwname); - _o.set(_j, "AlterFdwStmt.func_options", _p?.func_options); - _o.set(_j, "AlterFdwStmt.options", _p?.options); - return _j; - }, - createForeignServerStmt(_p?: CreateForeignServerStmt["CreateForeignServerStmt"]): CreateForeignServerStmt { - const _j = ({ - CreateForeignServerStmt: {} - } as CreateForeignServerStmt); - _o.set(_j, "CreateForeignServerStmt.servername", _p?.servername); - _o.set(_j, "CreateForeignServerStmt.servertype", _p?.servertype); - _o.set(_j, "CreateForeignServerStmt.version", _p?.version); - _o.set(_j, "CreateForeignServerStmt.fdwname", _p?.fdwname); - _o.set(_j, "CreateForeignServerStmt.if_not_exists", _p?.if_not_exists); - _o.set(_j, "CreateForeignServerStmt.options", _p?.options); - return _j; - }, - alterForeignServerStmt(_p?: AlterForeignServerStmt["AlterForeignServerStmt"]): AlterForeignServerStmt { - const _j = ({ - AlterForeignServerStmt: {} - } as AlterForeignServerStmt); - _o.set(_j, "AlterForeignServerStmt.servername", _p?.servername); - _o.set(_j, "AlterForeignServerStmt.version", _p?.version); - _o.set(_j, "AlterForeignServerStmt.options", _p?.options); - _o.set(_j, "AlterForeignServerStmt.has_version", _p?.has_version); - return _j; - }, - createForeignTableStmt(_p?: CreateForeignTableStmt["CreateForeignTableStmt"]): CreateForeignTableStmt { - const _j = ({ - CreateForeignTableStmt: {} - } as CreateForeignTableStmt); - _o.set(_j, "CreateForeignTableStmt.base", _p?.base); - _o.set(_j, "CreateForeignTableStmt.servername", _p?.servername); - _o.set(_j, "CreateForeignTableStmt.options", _p?.options); - return _j; - }, - createUserMappingStmt(_p?: CreateUserMappingStmt["CreateUserMappingStmt"]): CreateUserMappingStmt { - const _j = ({ - CreateUserMappingStmt: {} - } as CreateUserMappingStmt); - _o.set(_j, "CreateUserMappingStmt.user", _p?.user); - _o.set(_j, "CreateUserMappingStmt.servername", _p?.servername); - _o.set(_j, "CreateUserMappingStmt.if_not_exists", _p?.if_not_exists); - _o.set(_j, "CreateUserMappingStmt.options", _p?.options); - return _j; - }, - alterUserMappingStmt(_p?: AlterUserMappingStmt["AlterUserMappingStmt"]): AlterUserMappingStmt { - const _j = ({ - AlterUserMappingStmt: {} - } as AlterUserMappingStmt); - _o.set(_j, "AlterUserMappingStmt.user", _p?.user); - _o.set(_j, "AlterUserMappingStmt.servername", _p?.servername); - _o.set(_j, "AlterUserMappingStmt.options", _p?.options); - return _j; - }, - dropUserMappingStmt(_p?: DropUserMappingStmt["DropUserMappingStmt"]): DropUserMappingStmt { - const _j = ({ - DropUserMappingStmt: {} - } as DropUserMappingStmt); - _o.set(_j, "DropUserMappingStmt.user", _p?.user); - _o.set(_j, "DropUserMappingStmt.servername", _p?.servername); - _o.set(_j, "DropUserMappingStmt.missing_ok", _p?.missing_ok); - return _j; - }, - importForeignSchemaStmt(_p?: ImportForeignSchemaStmt["ImportForeignSchemaStmt"]): ImportForeignSchemaStmt { - const _j = ({ - ImportForeignSchemaStmt: {} - } as ImportForeignSchemaStmt); - _o.set(_j, "ImportForeignSchemaStmt.server_name", _p?.server_name); - _o.set(_j, "ImportForeignSchemaStmt.remote_schema", _p?.remote_schema); - _o.set(_j, "ImportForeignSchemaStmt.local_schema", _p?.local_schema); - _o.set(_j, "ImportForeignSchemaStmt.list_type", _p?.list_type); - _o.set(_j, "ImportForeignSchemaStmt.table_list", _p?.table_list); - _o.set(_j, "ImportForeignSchemaStmt.options", _p?.options); - return _j; - }, - createPolicyStmt(_p?: CreatePolicyStmt["CreatePolicyStmt"]): CreatePolicyStmt { - const _j = ({ - CreatePolicyStmt: {} - } as CreatePolicyStmt); - _o.set(_j, "CreatePolicyStmt.policy_name", _p?.policy_name); - _o.set(_j, "CreatePolicyStmt.table", _p?.table); - _o.set(_j, "CreatePolicyStmt.cmd_name", _p?.cmd_name); - _o.set(_j, "CreatePolicyStmt.permissive", _p?.permissive); - _o.set(_j, "CreatePolicyStmt.roles", _p?.roles); - _o.set(_j, "CreatePolicyStmt.qual", _p?.qual); - _o.set(_j, "CreatePolicyStmt.with_check", _p?.with_check); - return _j; - }, - alterPolicyStmt(_p?: AlterPolicyStmt["AlterPolicyStmt"]): AlterPolicyStmt { - const _j = ({ - AlterPolicyStmt: {} - } as AlterPolicyStmt); - _o.set(_j, "AlterPolicyStmt.policy_name", _p?.policy_name); - _o.set(_j, "AlterPolicyStmt.table", _p?.table); - _o.set(_j, "AlterPolicyStmt.roles", _p?.roles); - _o.set(_j, "AlterPolicyStmt.qual", _p?.qual); - _o.set(_j, "AlterPolicyStmt.with_check", _p?.with_check); - return _j; - }, - createAmStmt(_p?: CreateAmStmt["CreateAmStmt"]): CreateAmStmt { - const _j = ({ - CreateAmStmt: {} - } as CreateAmStmt); - _o.set(_j, "CreateAmStmt.amname", _p?.amname); - _o.set(_j, "CreateAmStmt.handler_name", _p?.handler_name); - _o.set(_j, "CreateAmStmt.amtype", _p?.amtype); - return _j; - }, - createTrigStmt(_p?: CreateTrigStmt["CreateTrigStmt"]): CreateTrigStmt { - const _j = ({ - CreateTrigStmt: {} - } as CreateTrigStmt); - _o.set(_j, "CreateTrigStmt.replace", _p?.replace); - _o.set(_j, "CreateTrigStmt.isconstraint", _p?.isconstraint); - _o.set(_j, "CreateTrigStmt.trigname", _p?.trigname); - _o.set(_j, "CreateTrigStmt.relation", _p?.relation); - _o.set(_j, "CreateTrigStmt.funcname", _p?.funcname); - _o.set(_j, "CreateTrigStmt.args", _p?.args); - _o.set(_j, "CreateTrigStmt.row", _p?.row); - _o.set(_j, "CreateTrigStmt.timing", _p?.timing); - _o.set(_j, "CreateTrigStmt.events", _p?.events); - _o.set(_j, "CreateTrigStmt.columns", _p?.columns); - _o.set(_j, "CreateTrigStmt.whenClause", _p?.whenClause); - _o.set(_j, "CreateTrigStmt.transitionRels", _p?.transitionRels); - _o.set(_j, "CreateTrigStmt.deferrable", _p?.deferrable); - _o.set(_j, "CreateTrigStmt.initdeferred", _p?.initdeferred); - _o.set(_j, "CreateTrigStmt.constrrel", _p?.constrrel); - return _j; - }, - createEventTrigStmt(_p?: CreateEventTrigStmt["CreateEventTrigStmt"]): CreateEventTrigStmt { - const _j = ({ - CreateEventTrigStmt: {} - } as CreateEventTrigStmt); - _o.set(_j, "CreateEventTrigStmt.trigname", _p?.trigname); - _o.set(_j, "CreateEventTrigStmt.eventname", _p?.eventname); - _o.set(_j, "CreateEventTrigStmt.whenclause", _p?.whenclause); - _o.set(_j, "CreateEventTrigStmt.funcname", _p?.funcname); - return _j; - }, - alterEventTrigStmt(_p?: AlterEventTrigStmt["AlterEventTrigStmt"]): AlterEventTrigStmt { - const _j = ({ - AlterEventTrigStmt: {} - } as AlterEventTrigStmt); - _o.set(_j, "AlterEventTrigStmt.trigname", _p?.trigname); - _o.set(_j, "AlterEventTrigStmt.tgenabled", _p?.tgenabled); - return _j; - }, - createpLangStmt(_p?: CreatePLangStmt["CreatePLangStmt"]): CreatePLangStmt { - const _j = ({ - CreatePLangStmt: {} - } as CreatePLangStmt); - _o.set(_j, "CreatePLangStmt.replace", _p?.replace); - _o.set(_j, "CreatePLangStmt.plname", _p?.plname); - _o.set(_j, "CreatePLangStmt.plhandler", _p?.plhandler); - _o.set(_j, "CreatePLangStmt.plinline", _p?.plinline); - _o.set(_j, "CreatePLangStmt.plvalidator", _p?.plvalidator); - _o.set(_j, "CreatePLangStmt.pltrusted", _p?.pltrusted); - return _j; - }, - createRoleStmt(_p?: CreateRoleStmt["CreateRoleStmt"]): CreateRoleStmt { - const _j = ({ - CreateRoleStmt: {} - } as CreateRoleStmt); - _o.set(_j, "CreateRoleStmt.stmt_type", _p?.stmt_type); - _o.set(_j, "CreateRoleStmt.role", _p?.role); - _o.set(_j, "CreateRoleStmt.options", _p?.options); - return _j; - }, - alterRoleStmt(_p?: AlterRoleStmt["AlterRoleStmt"]): AlterRoleStmt { - const _j = ({ - AlterRoleStmt: {} - } as AlterRoleStmt); - _o.set(_j, "AlterRoleStmt.role", _p?.role); - _o.set(_j, "AlterRoleStmt.options", _p?.options); - _o.set(_j, "AlterRoleStmt.action", _p?.action); - return _j; - }, - alterRoleSetStmt(_p?: AlterRoleSetStmt["AlterRoleSetStmt"]): AlterRoleSetStmt { - const _j = ({ - AlterRoleSetStmt: {} - } as AlterRoleSetStmt); - _o.set(_j, "AlterRoleSetStmt.role", _p?.role); - _o.set(_j, "AlterRoleSetStmt.database", _p?.database); - _o.set(_j, "AlterRoleSetStmt.setstmt", _p?.setstmt); - return _j; - }, - dropRoleStmt(_p?: DropRoleStmt["DropRoleStmt"]): DropRoleStmt { - const _j = ({ - DropRoleStmt: {} - } as DropRoleStmt); - _o.set(_j, "DropRoleStmt.roles", _p?.roles); - _o.set(_j, "DropRoleStmt.missing_ok", _p?.missing_ok); - return _j; - }, - createSeqStmt(_p?: CreateSeqStmt["CreateSeqStmt"]): CreateSeqStmt { - const _j = ({ - CreateSeqStmt: {} - } as CreateSeqStmt); - _o.set(_j, "CreateSeqStmt.sequence", _p?.sequence); - _o.set(_j, "CreateSeqStmt.options", _p?.options); - _o.set(_j, "CreateSeqStmt.ownerId", _p?.ownerId); - _o.set(_j, "CreateSeqStmt.for_identity", _p?.for_identity); - _o.set(_j, "CreateSeqStmt.if_not_exists", _p?.if_not_exists); - return _j; - }, - alterSeqStmt(_p?: AlterSeqStmt["AlterSeqStmt"]): AlterSeqStmt { - const _j = ({ - AlterSeqStmt: {} - } as AlterSeqStmt); - _o.set(_j, "AlterSeqStmt.sequence", _p?.sequence); - _o.set(_j, "AlterSeqStmt.options", _p?.options); - _o.set(_j, "AlterSeqStmt.for_identity", _p?.for_identity); - _o.set(_j, "AlterSeqStmt.missing_ok", _p?.missing_ok); - return _j; - }, - defineStmt(_p?: DefineStmt["DefineStmt"]): DefineStmt { - const _j = ({ - DefineStmt: {} - } as DefineStmt); - _o.set(_j, "DefineStmt.kind", _p?.kind); - _o.set(_j, "DefineStmt.oldstyle", _p?.oldstyle); - _o.set(_j, "DefineStmt.defnames", _p?.defnames); - _o.set(_j, "DefineStmt.args", _p?.args); - _o.set(_j, "DefineStmt.definition", _p?.definition); - _o.set(_j, "DefineStmt.if_not_exists", _p?.if_not_exists); - _o.set(_j, "DefineStmt.replace", _p?.replace); - return _j; - }, - createDomainStmt(_p?: CreateDomainStmt["CreateDomainStmt"]): CreateDomainStmt { - const _j = ({ - CreateDomainStmt: {} - } as CreateDomainStmt); - _o.set(_j, "CreateDomainStmt.domainname", _p?.domainname); - _o.set(_j, "CreateDomainStmt.typeName", _p?.typeName); - _o.set(_j, "CreateDomainStmt.collClause", _p?.collClause); - _o.set(_j, "CreateDomainStmt.constraints", _p?.constraints); - return _j; - }, - createOpClassStmt(_p?: CreateOpClassStmt["CreateOpClassStmt"]): CreateOpClassStmt { - const _j = ({ - CreateOpClassStmt: {} - } as CreateOpClassStmt); - _o.set(_j, "CreateOpClassStmt.opclassname", _p?.opclassname); - _o.set(_j, "CreateOpClassStmt.opfamilyname", _p?.opfamilyname); - _o.set(_j, "CreateOpClassStmt.amname", _p?.amname); - _o.set(_j, "CreateOpClassStmt.datatype", _p?.datatype); - _o.set(_j, "CreateOpClassStmt.items", _p?.items); - _o.set(_j, "CreateOpClassStmt.isDefault", _p?.isDefault); - return _j; - }, - createOpClassItem(_p?: CreateOpClassItem["CreateOpClassItem"]): CreateOpClassItem { - const _j = ({ - CreateOpClassItem: {} - } as CreateOpClassItem); - _o.set(_j, "CreateOpClassItem.itemtype", _p?.itemtype); - _o.set(_j, "CreateOpClassItem.name", _p?.name); - _o.set(_j, "CreateOpClassItem.number", _p?.number); - _o.set(_j, "CreateOpClassItem.order_family", _p?.order_family); - _o.set(_j, "CreateOpClassItem.class_args", _p?.class_args); - _o.set(_j, "CreateOpClassItem.storedtype", _p?.storedtype); - return _j; - }, - createOpFamilyStmt(_p?: CreateOpFamilyStmt["CreateOpFamilyStmt"]): CreateOpFamilyStmt { - const _j = ({ - CreateOpFamilyStmt: {} - } as CreateOpFamilyStmt); - _o.set(_j, "CreateOpFamilyStmt.opfamilyname", _p?.opfamilyname); - _o.set(_j, "CreateOpFamilyStmt.amname", _p?.amname); - return _j; - }, - alterOpFamilyStmt(_p?: AlterOpFamilyStmt["AlterOpFamilyStmt"]): AlterOpFamilyStmt { - const _j = ({ - AlterOpFamilyStmt: {} - } as AlterOpFamilyStmt); - _o.set(_j, "AlterOpFamilyStmt.opfamilyname", _p?.opfamilyname); - _o.set(_j, "AlterOpFamilyStmt.amname", _p?.amname); - _o.set(_j, "AlterOpFamilyStmt.isDrop", _p?.isDrop); - _o.set(_j, "AlterOpFamilyStmt.items", _p?.items); - return _j; - }, - dropStmt(_p?: DropStmt["DropStmt"]): DropStmt { - const _j = ({ - DropStmt: {} - } as DropStmt); - _o.set(_j, "DropStmt.objects", _p?.objects); - _o.set(_j, "DropStmt.removeType", _p?.removeType); - _o.set(_j, "DropStmt.behavior", _p?.behavior); - _o.set(_j, "DropStmt.missing_ok", _p?.missing_ok); - _o.set(_j, "DropStmt.concurrent", _p?.concurrent); - return _j; - }, - truncateStmt(_p?: TruncateStmt["TruncateStmt"]): TruncateStmt { - const _j = ({ - TruncateStmt: {} - } as TruncateStmt); - _o.set(_j, "TruncateStmt.relations", _p?.relations); - _o.set(_j, "TruncateStmt.restart_seqs", _p?.restart_seqs); - _o.set(_j, "TruncateStmt.behavior", _p?.behavior); - return _j; - }, - commentStmt(_p?: CommentStmt["CommentStmt"]): CommentStmt { - const _j = ({ - CommentStmt: {} - } as CommentStmt); - _o.set(_j, "CommentStmt.objtype", _p?.objtype); - _o.set(_j, "CommentStmt.object", _p?.object); - _o.set(_j, "CommentStmt.comment", _p?.comment); - return _j; - }, - secLabelStmt(_p?: SecLabelStmt["SecLabelStmt"]): SecLabelStmt { - const _j = ({ - SecLabelStmt: {} - } as SecLabelStmt); - _o.set(_j, "SecLabelStmt.objtype", _p?.objtype); - _o.set(_j, "SecLabelStmt.object", _p?.object); - _o.set(_j, "SecLabelStmt.provider", _p?.provider); - _o.set(_j, "SecLabelStmt.label", _p?.label); - return _j; - }, - declareCursorStmt(_p?: DeclareCursorStmt["DeclareCursorStmt"]): DeclareCursorStmt { - const _j = ({ - DeclareCursorStmt: {} - } as DeclareCursorStmt); - _o.set(_j, "DeclareCursorStmt.portalname", _p?.portalname); - _o.set(_j, "DeclareCursorStmt.options", _p?.options); - _o.set(_j, "DeclareCursorStmt.query", _p?.query); - return _j; - }, - closePortalStmt(_p?: ClosePortalStmt["ClosePortalStmt"]): ClosePortalStmt { - const _j = ({ - ClosePortalStmt: {} - } as ClosePortalStmt); - _o.set(_j, "ClosePortalStmt.portalname", _p?.portalname); - return _j; - }, - fetchStmt(_p?: FetchStmt["FetchStmt"]): FetchStmt { - const _j = ({ - FetchStmt: {} - } as FetchStmt); - _o.set(_j, "FetchStmt.direction", _p?.direction); - _o.set(_j, "FetchStmt.howMany", _p?.howMany); - _o.set(_j, "FetchStmt.portalname", _p?.portalname); - _o.set(_j, "FetchStmt.ismove", _p?.ismove); - return _j; - }, - indexStmt(_p?: IndexStmt["IndexStmt"]): IndexStmt { - const _j = ({ - IndexStmt: {} - } as IndexStmt); - _o.set(_j, "IndexStmt.idxname", _p?.idxname); - _o.set(_j, "IndexStmt.relation", _p?.relation); - _o.set(_j, "IndexStmt.accessMethod", _p?.accessMethod); - _o.set(_j, "IndexStmt.tableSpace", _p?.tableSpace); - _o.set(_j, "IndexStmt.indexParams", _p?.indexParams); - _o.set(_j, "IndexStmt.indexIncludingParams", _p?.indexIncludingParams); - _o.set(_j, "IndexStmt.options", _p?.options); - _o.set(_j, "IndexStmt.whereClause", _p?.whereClause); - _o.set(_j, "IndexStmt.excludeOpNames", _p?.excludeOpNames); - _o.set(_j, "IndexStmt.idxcomment", _p?.idxcomment); - _o.set(_j, "IndexStmt.indexOid", _p?.indexOid); - _o.set(_j, "IndexStmt.oldNumber", _p?.oldNumber); - _o.set(_j, "IndexStmt.oldCreateSubid", _p?.oldCreateSubid); - _o.set(_j, "IndexStmt.oldFirstRelfilelocatorSubid", _p?.oldFirstRelfilelocatorSubid); - _o.set(_j, "IndexStmt.unique", _p?.unique); - _o.set(_j, "IndexStmt.nulls_not_distinct", _p?.nulls_not_distinct); - _o.set(_j, "IndexStmt.primary", _p?.primary); - _o.set(_j, "IndexStmt.isconstraint", _p?.isconstraint); - _o.set(_j, "IndexStmt.deferrable", _p?.deferrable); - _o.set(_j, "IndexStmt.initdeferred", _p?.initdeferred); - _o.set(_j, "IndexStmt.transformed", _p?.transformed); - _o.set(_j, "IndexStmt.concurrent", _p?.concurrent); - _o.set(_j, "IndexStmt.if_not_exists", _p?.if_not_exists); - _o.set(_j, "IndexStmt.reset_default_tblspc", _p?.reset_default_tblspc); - return _j; - }, - createStatsStmt(_p?: CreateStatsStmt["CreateStatsStmt"]): CreateStatsStmt { - const _j = ({ - CreateStatsStmt: {} - } as CreateStatsStmt); - _o.set(_j, "CreateStatsStmt.defnames", _p?.defnames); - _o.set(_j, "CreateStatsStmt.stat_types", _p?.stat_types); - _o.set(_j, "CreateStatsStmt.exprs", _p?.exprs); - _o.set(_j, "CreateStatsStmt.relations", _p?.relations); - _o.set(_j, "CreateStatsStmt.stxcomment", _p?.stxcomment); - _o.set(_j, "CreateStatsStmt.transformed", _p?.transformed); - _o.set(_j, "CreateStatsStmt.if_not_exists", _p?.if_not_exists); - return _j; - }, - statsElem(_p?: StatsElem["StatsElem"]): StatsElem { - const _j = ({ - StatsElem: {} - } as StatsElem); - _o.set(_j, "StatsElem.name", _p?.name); - _o.set(_j, "StatsElem.expr", _p?.expr); - return _j; - }, - alterStatsStmt(_p?: AlterStatsStmt["AlterStatsStmt"]): AlterStatsStmt { - const _j = ({ - AlterStatsStmt: {} - } as AlterStatsStmt); - _o.set(_j, "AlterStatsStmt.defnames", _p?.defnames); - _o.set(_j, "AlterStatsStmt.stxstattarget", _p?.stxstattarget); - _o.set(_j, "AlterStatsStmt.missing_ok", _p?.missing_ok); - return _j; - }, - createFunctionStmt(_p?: CreateFunctionStmt["CreateFunctionStmt"]): CreateFunctionStmt { - const _j = ({ - CreateFunctionStmt: {} - } as CreateFunctionStmt); - _o.set(_j, "CreateFunctionStmt.is_procedure", _p?.is_procedure); - _o.set(_j, "CreateFunctionStmt.replace", _p?.replace); - _o.set(_j, "CreateFunctionStmt.funcname", _p?.funcname); - _o.set(_j, "CreateFunctionStmt.parameters", _p?.parameters); - _o.set(_j, "CreateFunctionStmt.returnType", _p?.returnType); - _o.set(_j, "CreateFunctionStmt.options", _p?.options); - _o.set(_j, "CreateFunctionStmt.sql_body", _p?.sql_body); - return _j; - }, - functionParameter(_p?: FunctionParameter["FunctionParameter"]): FunctionParameter { - const _j = ({ - FunctionParameter: {} - } as FunctionParameter); - _o.set(_j, "FunctionParameter.name", _p?.name); - _o.set(_j, "FunctionParameter.argType", _p?.argType); - _o.set(_j, "FunctionParameter.mode", _p?.mode); - _o.set(_j, "FunctionParameter.defexpr", _p?.defexpr); - return _j; - }, - alterFunctionStmt(_p?: AlterFunctionStmt["AlterFunctionStmt"]): AlterFunctionStmt { - const _j = ({ - AlterFunctionStmt: {} - } as AlterFunctionStmt); - _o.set(_j, "AlterFunctionStmt.objtype", _p?.objtype); - _o.set(_j, "AlterFunctionStmt.func", _p?.func); - _o.set(_j, "AlterFunctionStmt.actions", _p?.actions); - return _j; - }, - doStmt(_p?: DoStmt["DoStmt"]): DoStmt { - const _j = ({ - DoStmt: {} - } as DoStmt); - _o.set(_j, "DoStmt.args", _p?.args); - return _j; - }, - inlineCodeBlock(_p?: InlineCodeBlock["InlineCodeBlock"]): InlineCodeBlock { - const _j = ({ - InlineCodeBlock: {} - } as InlineCodeBlock); - _o.set(_j, "InlineCodeBlock.source_text", _p?.source_text); - _o.set(_j, "InlineCodeBlock.langOid", _p?.langOid); - _o.set(_j, "InlineCodeBlock.langIsTrusted", _p?.langIsTrusted); - _o.set(_j, "InlineCodeBlock.atomic", _p?.atomic); - return _j; - }, - callStmt(_p?: CallStmt["CallStmt"]): CallStmt { - const _j = ({ - CallStmt: {} - } as CallStmt); - _o.set(_j, "CallStmt.funccall", _p?.funccall); - _o.set(_j, "CallStmt.funcexpr", _p?.funcexpr); - _o.set(_j, "CallStmt.outargs", _p?.outargs); - return _j; - }, - callContext(_p?: CallContext["CallContext"]): CallContext { - const _j = ({ - CallContext: {} - } as CallContext); - _o.set(_j, "CallContext.atomic", _p?.atomic); - return _j; - }, - renameStmt(_p?: RenameStmt["RenameStmt"]): RenameStmt { - const _j = ({ - RenameStmt: {} - } as RenameStmt); - _o.set(_j, "RenameStmt.renameType", _p?.renameType); - _o.set(_j, "RenameStmt.relationType", _p?.relationType); - _o.set(_j, "RenameStmt.relation", _p?.relation); - _o.set(_j, "RenameStmt.object", _p?.object); - _o.set(_j, "RenameStmt.subname", _p?.subname); - _o.set(_j, "RenameStmt.newname", _p?.newname); - _o.set(_j, "RenameStmt.behavior", _p?.behavior); - _o.set(_j, "RenameStmt.missing_ok", _p?.missing_ok); - return _j; - }, - alterObjectDependsStmt(_p?: AlterObjectDependsStmt["AlterObjectDependsStmt"]): AlterObjectDependsStmt { - const _j = ({ - AlterObjectDependsStmt: {} - } as AlterObjectDependsStmt); - _o.set(_j, "AlterObjectDependsStmt.objectType", _p?.objectType); - _o.set(_j, "AlterObjectDependsStmt.relation", _p?.relation); - _o.set(_j, "AlterObjectDependsStmt.object", _p?.object); - _o.set(_j, "AlterObjectDependsStmt.extname", _p?.extname); - _o.set(_j, "AlterObjectDependsStmt.remove", _p?.remove); - return _j; - }, - alterObjectSchemaStmt(_p?: AlterObjectSchemaStmt["AlterObjectSchemaStmt"]): AlterObjectSchemaStmt { - const _j = ({ - AlterObjectSchemaStmt: {} - } as AlterObjectSchemaStmt); - _o.set(_j, "AlterObjectSchemaStmt.objectType", _p?.objectType); - _o.set(_j, "AlterObjectSchemaStmt.relation", _p?.relation); - _o.set(_j, "AlterObjectSchemaStmt.object", _p?.object); - _o.set(_j, "AlterObjectSchemaStmt.newschema", _p?.newschema); - _o.set(_j, "AlterObjectSchemaStmt.missing_ok", _p?.missing_ok); - return _j; - }, - alterOwnerStmt(_p?: AlterOwnerStmt["AlterOwnerStmt"]): AlterOwnerStmt { - const _j = ({ - AlterOwnerStmt: {} - } as AlterOwnerStmt); - _o.set(_j, "AlterOwnerStmt.objectType", _p?.objectType); - _o.set(_j, "AlterOwnerStmt.relation", _p?.relation); - _o.set(_j, "AlterOwnerStmt.object", _p?.object); - _o.set(_j, "AlterOwnerStmt.newowner", _p?.newowner); - return _j; - }, - alterOperatorStmt(_p?: AlterOperatorStmt["AlterOperatorStmt"]): AlterOperatorStmt { - const _j = ({ - AlterOperatorStmt: {} - } as AlterOperatorStmt); - _o.set(_j, "AlterOperatorStmt.opername", _p?.opername); - _o.set(_j, "AlterOperatorStmt.options", _p?.options); - return _j; - }, - alterTypeStmt(_p?: AlterTypeStmt["AlterTypeStmt"]): AlterTypeStmt { - const _j = ({ - AlterTypeStmt: {} - } as AlterTypeStmt); - _o.set(_j, "AlterTypeStmt.typeName", _p?.typeName); - _o.set(_j, "AlterTypeStmt.options", _p?.options); - return _j; - }, - ruleStmt(_p?: RuleStmt["RuleStmt"]): RuleStmt { - const _j = ({ - RuleStmt: {} - } as RuleStmt); - _o.set(_j, "RuleStmt.relation", _p?.relation); - _o.set(_j, "RuleStmt.rulename", _p?.rulename); - _o.set(_j, "RuleStmt.whereClause", _p?.whereClause); - _o.set(_j, "RuleStmt.event", _p?.event); - _o.set(_j, "RuleStmt.instead", _p?.instead); - _o.set(_j, "RuleStmt.actions", _p?.actions); - _o.set(_j, "RuleStmt.replace", _p?.replace); - return _j; - }, - notifyStmt(_p?: NotifyStmt["NotifyStmt"]): NotifyStmt { - const _j = ({ - NotifyStmt: {} - } as NotifyStmt); - _o.set(_j, "NotifyStmt.conditionname", _p?.conditionname); - _o.set(_j, "NotifyStmt.payload", _p?.payload); - return _j; - }, - listenStmt(_p?: ListenStmt["ListenStmt"]): ListenStmt { - const _j = ({ - ListenStmt: {} - } as ListenStmt); - _o.set(_j, "ListenStmt.conditionname", _p?.conditionname); - return _j; - }, - unlistenStmt(_p?: UnlistenStmt["UnlistenStmt"]): UnlistenStmt { - const _j = ({ - UnlistenStmt: {} - } as UnlistenStmt); - _o.set(_j, "UnlistenStmt.conditionname", _p?.conditionname); - return _j; - }, - transactionStmt(_p?: TransactionStmt["TransactionStmt"]): TransactionStmt { - const _j = ({ - TransactionStmt: {} - } as TransactionStmt); - _o.set(_j, "TransactionStmt.kind", _p?.kind); - _o.set(_j, "TransactionStmt.options", _p?.options); - _o.set(_j, "TransactionStmt.savepoint_name", _p?.savepoint_name); - _o.set(_j, "TransactionStmt.gid", _p?.gid); - _o.set(_j, "TransactionStmt.chain", _p?.chain); - return _j; - }, - compositeTypeStmt(_p?: CompositeTypeStmt["CompositeTypeStmt"]): CompositeTypeStmt { - const _j = ({ - CompositeTypeStmt: {} - } as CompositeTypeStmt); - _o.set(_j, "CompositeTypeStmt.typevar", _p?.typevar); - _o.set(_j, "CompositeTypeStmt.coldeflist", _p?.coldeflist); - return _j; - }, - createEnumStmt(_p?: CreateEnumStmt["CreateEnumStmt"]): CreateEnumStmt { - const _j = ({ - CreateEnumStmt: {} - } as CreateEnumStmt); - _o.set(_j, "CreateEnumStmt.typeName", _p?.typeName); - _o.set(_j, "CreateEnumStmt.vals", _p?.vals); - return _j; - }, - createRangeStmt(_p?: CreateRangeStmt["CreateRangeStmt"]): CreateRangeStmt { - const _j = ({ - CreateRangeStmt: {} - } as CreateRangeStmt); - _o.set(_j, "CreateRangeStmt.typeName", _p?.typeName); - _o.set(_j, "CreateRangeStmt.params", _p?.params); - return _j; - }, - alterEnumStmt(_p?: AlterEnumStmt["AlterEnumStmt"]): AlterEnumStmt { - const _j = ({ - AlterEnumStmt: {} - } as AlterEnumStmt); - _o.set(_j, "AlterEnumStmt.typeName", _p?.typeName); - _o.set(_j, "AlterEnumStmt.oldVal", _p?.oldVal); - _o.set(_j, "AlterEnumStmt.newVal", _p?.newVal); - _o.set(_j, "AlterEnumStmt.newValNeighbor", _p?.newValNeighbor); - _o.set(_j, "AlterEnumStmt.newValIsAfter", _p?.newValIsAfter); - _o.set(_j, "AlterEnumStmt.skipIfNewValExists", _p?.skipIfNewValExists); - return _j; - }, - viewStmt(_p?: ViewStmt["ViewStmt"]): ViewStmt { - const _j = ({ - ViewStmt: {} - } as ViewStmt); - _o.set(_j, "ViewStmt.view", _p?.view); - _o.set(_j, "ViewStmt.aliases", _p?.aliases); - _o.set(_j, "ViewStmt.query", _p?.query); - _o.set(_j, "ViewStmt.replace", _p?.replace); - _o.set(_j, "ViewStmt.options", _p?.options); - _o.set(_j, "ViewStmt.withCheckOption", _p?.withCheckOption); - return _j; - }, - loadStmt(_p?: LoadStmt["LoadStmt"]): LoadStmt { - const _j = ({ - LoadStmt: {} - } as LoadStmt); - _o.set(_j, "LoadStmt.filename", _p?.filename); - return _j; - }, - createdbStmt(_p?: CreatedbStmt["CreatedbStmt"]): CreatedbStmt { - const _j = ({ - CreatedbStmt: {} - } as CreatedbStmt); - _o.set(_j, "CreatedbStmt.dbname", _p?.dbname); - _o.set(_j, "CreatedbStmt.options", _p?.options); - return _j; - }, - alterDatabaseStmt(_p?: AlterDatabaseStmt["AlterDatabaseStmt"]): AlterDatabaseStmt { - const _j = ({ - AlterDatabaseStmt: {} - } as AlterDatabaseStmt); - _o.set(_j, "AlterDatabaseStmt.dbname", _p?.dbname); - _o.set(_j, "AlterDatabaseStmt.options", _p?.options); - return _j; - }, - alterDatabaseRefreshCollStmt(_p?: AlterDatabaseRefreshCollStmt["AlterDatabaseRefreshCollStmt"]): AlterDatabaseRefreshCollStmt { - const _j = ({ - AlterDatabaseRefreshCollStmt: {} - } as AlterDatabaseRefreshCollStmt); - _o.set(_j, "AlterDatabaseRefreshCollStmt.dbname", _p?.dbname); - return _j; - }, - alterDatabaseSetStmt(_p?: AlterDatabaseSetStmt["AlterDatabaseSetStmt"]): AlterDatabaseSetStmt { - const _j = ({ - AlterDatabaseSetStmt: {} - } as AlterDatabaseSetStmt); - _o.set(_j, "AlterDatabaseSetStmt.dbname", _p?.dbname); - _o.set(_j, "AlterDatabaseSetStmt.setstmt", _p?.setstmt); - return _j; - }, - dropdbStmt(_p?: DropdbStmt["DropdbStmt"]): DropdbStmt { - const _j = ({ - DropdbStmt: {} - } as DropdbStmt); - _o.set(_j, "DropdbStmt.dbname", _p?.dbname); - _o.set(_j, "DropdbStmt.missing_ok", _p?.missing_ok); - _o.set(_j, "DropdbStmt.options", _p?.options); - return _j; - }, - alterSystemStmt(_p?: AlterSystemStmt["AlterSystemStmt"]): AlterSystemStmt { - const _j = ({ - AlterSystemStmt: {} - } as AlterSystemStmt); - _o.set(_j, "AlterSystemStmt.setstmt", _p?.setstmt); - return _j; - }, - clusterStmt(_p?: ClusterStmt["ClusterStmt"]): ClusterStmt { - const _j = ({ - ClusterStmt: {} - } as ClusterStmt); - _o.set(_j, "ClusterStmt.relation", _p?.relation); - _o.set(_j, "ClusterStmt.indexname", _p?.indexname); - _o.set(_j, "ClusterStmt.params", _p?.params); - return _j; - }, - vacuumStmt(_p?: VacuumStmt["VacuumStmt"]): VacuumStmt { - const _j = ({ - VacuumStmt: {} - } as VacuumStmt); - _o.set(_j, "VacuumStmt.options", _p?.options); - _o.set(_j, "VacuumStmt.rels", _p?.rels); - _o.set(_j, "VacuumStmt.is_vacuumcmd", _p?.is_vacuumcmd); - return _j; - }, - vacuumRelation(_p?: VacuumRelation["VacuumRelation"]): VacuumRelation { - const _j = ({ - VacuumRelation: {} - } as VacuumRelation); - _o.set(_j, "VacuumRelation.relation", _p?.relation); - _o.set(_j, "VacuumRelation.oid", _p?.oid); - _o.set(_j, "VacuumRelation.va_cols", _p?.va_cols); - return _j; - }, - explainStmt(_p?: ExplainStmt["ExplainStmt"]): ExplainStmt { - const _j = ({ - ExplainStmt: {} - } as ExplainStmt); - _o.set(_j, "ExplainStmt.query", _p?.query); - _o.set(_j, "ExplainStmt.options", _p?.options); - return _j; - }, - createTableAsStmt(_p?: CreateTableAsStmt["CreateTableAsStmt"]): CreateTableAsStmt { - const _j = ({ - CreateTableAsStmt: {} - } as CreateTableAsStmt); - _o.set(_j, "CreateTableAsStmt.query", _p?.query); - _o.set(_j, "CreateTableAsStmt.into", _p?.into); - _o.set(_j, "CreateTableAsStmt.objtype", _p?.objtype); - _o.set(_j, "CreateTableAsStmt.is_select_into", _p?.is_select_into); - _o.set(_j, "CreateTableAsStmt.if_not_exists", _p?.if_not_exists); - return _j; - }, - refreshMatViewStmt(_p?: RefreshMatViewStmt["RefreshMatViewStmt"]): RefreshMatViewStmt { - const _j = ({ - RefreshMatViewStmt: {} - } as RefreshMatViewStmt); - _o.set(_j, "RefreshMatViewStmt.concurrent", _p?.concurrent); - _o.set(_j, "RefreshMatViewStmt.skipData", _p?.skipData); - _o.set(_j, "RefreshMatViewStmt.relation", _p?.relation); - return _j; - }, - checkPointStmt(_p?: CheckPointStmt["CheckPointStmt"]): CheckPointStmt { - const _j = ({ - CheckPointStmt: {} - } as CheckPointStmt); - return _j; - }, - discardStmt(_p?: DiscardStmt["DiscardStmt"]): DiscardStmt { - const _j = ({ - DiscardStmt: {} - } as DiscardStmt); - _o.set(_j, "DiscardStmt.target", _p?.target); - return _j; - }, - lockStmt(_p?: LockStmt["LockStmt"]): LockStmt { - const _j = ({ - LockStmt: {} - } as LockStmt); - _o.set(_j, "LockStmt.relations", _p?.relations); - _o.set(_j, "LockStmt.mode", _p?.mode); - _o.set(_j, "LockStmt.nowait", _p?.nowait); - return _j; - }, - constraintsSetStmt(_p?: ConstraintsSetStmt["ConstraintsSetStmt"]): ConstraintsSetStmt { - const _j = ({ - ConstraintsSetStmt: {} - } as ConstraintsSetStmt); - _o.set(_j, "ConstraintsSetStmt.constraints", _p?.constraints); - _o.set(_j, "ConstraintsSetStmt.deferred", _p?.deferred); - return _j; - }, - reindexStmt(_p?: ReindexStmt["ReindexStmt"]): ReindexStmt { - const _j = ({ - ReindexStmt: {} - } as ReindexStmt); - _o.set(_j, "ReindexStmt.kind", _p?.kind); - _o.set(_j, "ReindexStmt.relation", _p?.relation); - _o.set(_j, "ReindexStmt.name", _p?.name); - _o.set(_j, "ReindexStmt.params", _p?.params); - return _j; - }, - createConversionStmt(_p?: CreateConversionStmt["CreateConversionStmt"]): CreateConversionStmt { - const _j = ({ - CreateConversionStmt: {} - } as CreateConversionStmt); - _o.set(_j, "CreateConversionStmt.conversion_name", _p?.conversion_name); - _o.set(_j, "CreateConversionStmt.for_encoding_name", _p?.for_encoding_name); - _o.set(_j, "CreateConversionStmt.to_encoding_name", _p?.to_encoding_name); - _o.set(_j, "CreateConversionStmt.func_name", _p?.func_name); - _o.set(_j, "CreateConversionStmt.def", _p?.def); - return _j; - }, - createCastStmt(_p?: CreateCastStmt["CreateCastStmt"]): CreateCastStmt { - const _j = ({ - CreateCastStmt: {} - } as CreateCastStmt); - _o.set(_j, "CreateCastStmt.sourcetype", _p?.sourcetype); - _o.set(_j, "CreateCastStmt.targettype", _p?.targettype); - _o.set(_j, "CreateCastStmt.func", _p?.func); - _o.set(_j, "CreateCastStmt.context", _p?.context); - _o.set(_j, "CreateCastStmt.inout", _p?.inout); - return _j; - }, - createTransformStmt(_p?: CreateTransformStmt["CreateTransformStmt"]): CreateTransformStmt { - const _j = ({ - CreateTransformStmt: {} - } as CreateTransformStmt); - _o.set(_j, "CreateTransformStmt.replace", _p?.replace); - _o.set(_j, "CreateTransformStmt.type_name", _p?.type_name); - _o.set(_j, "CreateTransformStmt.lang", _p?.lang); - _o.set(_j, "CreateTransformStmt.fromsql", _p?.fromsql); - _o.set(_j, "CreateTransformStmt.tosql", _p?.tosql); - return _j; - }, - prepareStmt(_p?: PrepareStmt["PrepareStmt"]): PrepareStmt { - const _j = ({ - PrepareStmt: {} - } as PrepareStmt); - _o.set(_j, "PrepareStmt.name", _p?.name); - _o.set(_j, "PrepareStmt.argtypes", _p?.argtypes); - _o.set(_j, "PrepareStmt.query", _p?.query); - return _j; - }, - executeStmt(_p?: ExecuteStmt["ExecuteStmt"]): ExecuteStmt { - const _j = ({ - ExecuteStmt: {} - } as ExecuteStmt); - _o.set(_j, "ExecuteStmt.name", _p?.name); - _o.set(_j, "ExecuteStmt.params", _p?.params); - return _j; - }, - deallocateStmt(_p?: DeallocateStmt["DeallocateStmt"]): DeallocateStmt { - const _j = ({ - DeallocateStmt: {} - } as DeallocateStmt); - _o.set(_j, "DeallocateStmt.name", _p?.name); - return _j; - }, - dropOwnedStmt(_p?: DropOwnedStmt["DropOwnedStmt"]): DropOwnedStmt { - const _j = ({ - DropOwnedStmt: {} - } as DropOwnedStmt); - _o.set(_j, "DropOwnedStmt.roles", _p?.roles); - _o.set(_j, "DropOwnedStmt.behavior", _p?.behavior); - return _j; - }, - reassignOwnedStmt(_p?: ReassignOwnedStmt["ReassignOwnedStmt"]): ReassignOwnedStmt { - const _j = ({ - ReassignOwnedStmt: {} - } as ReassignOwnedStmt); - _o.set(_j, "ReassignOwnedStmt.roles", _p?.roles); - _o.set(_j, "ReassignOwnedStmt.newrole", _p?.newrole); - return _j; - }, - altertsDictionaryStmt(_p?: AlterTSDictionaryStmt["AlterTSDictionaryStmt"]): AlterTSDictionaryStmt { - const _j = ({ - AlterTSDictionaryStmt: {} - } as AlterTSDictionaryStmt); - _o.set(_j, "AlterTSDictionaryStmt.dictname", _p?.dictname); - _o.set(_j, "AlterTSDictionaryStmt.options", _p?.options); - return _j; - }, - altertsConfigurationStmt(_p?: AlterTSConfigurationStmt["AlterTSConfigurationStmt"]): AlterTSConfigurationStmt { - const _j = ({ - AlterTSConfigurationStmt: {} - } as AlterTSConfigurationStmt); - _o.set(_j, "AlterTSConfigurationStmt.kind", _p?.kind); - _o.set(_j, "AlterTSConfigurationStmt.cfgname", _p?.cfgname); - _o.set(_j, "AlterTSConfigurationStmt.tokentype", _p?.tokentype); - _o.set(_j, "AlterTSConfigurationStmt.dicts", _p?.dicts); - _o.set(_j, "AlterTSConfigurationStmt.override", _p?.override); - _o.set(_j, "AlterTSConfigurationStmt.replace", _p?.replace); - _o.set(_j, "AlterTSConfigurationStmt.missing_ok", _p?.missing_ok); - return _j; - }, - publicationTable(_p?: PublicationTable["PublicationTable"]): PublicationTable { - const _j = ({ - PublicationTable: {} - } as PublicationTable); - _o.set(_j, "PublicationTable.relation", _p?.relation); - _o.set(_j, "PublicationTable.whereClause", _p?.whereClause); - _o.set(_j, "PublicationTable.columns", _p?.columns); - return _j; - }, - publicationObjSpec(_p?: PublicationObjSpec["PublicationObjSpec"]): PublicationObjSpec { - const _j = ({ - PublicationObjSpec: {} - } as PublicationObjSpec); - _o.set(_j, "PublicationObjSpec.pubobjtype", _p?.pubobjtype); - _o.set(_j, "PublicationObjSpec.name", _p?.name); - _o.set(_j, "PublicationObjSpec.pubtable", _p?.pubtable); - _o.set(_j, "PublicationObjSpec.location", _p?.location); - return _j; - }, - createPublicationStmt(_p?: CreatePublicationStmt["CreatePublicationStmt"]): CreatePublicationStmt { - const _j = ({ - CreatePublicationStmt: {} - } as CreatePublicationStmt); - _o.set(_j, "CreatePublicationStmt.pubname", _p?.pubname); - _o.set(_j, "CreatePublicationStmt.options", _p?.options); - _o.set(_j, "CreatePublicationStmt.pubobjects", _p?.pubobjects); - _o.set(_j, "CreatePublicationStmt.for_all_tables", _p?.for_all_tables); - return _j; - }, - alterPublicationStmt(_p?: AlterPublicationStmt["AlterPublicationStmt"]): AlterPublicationStmt { - const _j = ({ - AlterPublicationStmt: {} - } as AlterPublicationStmt); - _o.set(_j, "AlterPublicationStmt.pubname", _p?.pubname); - _o.set(_j, "AlterPublicationStmt.options", _p?.options); - _o.set(_j, "AlterPublicationStmt.pubobjects", _p?.pubobjects); - _o.set(_j, "AlterPublicationStmt.for_all_tables", _p?.for_all_tables); - _o.set(_j, "AlterPublicationStmt.action", _p?.action); - return _j; - }, - createSubscriptionStmt(_p?: CreateSubscriptionStmt["CreateSubscriptionStmt"]): CreateSubscriptionStmt { - const _j = ({ - CreateSubscriptionStmt: {} - } as CreateSubscriptionStmt); - _o.set(_j, "CreateSubscriptionStmt.subname", _p?.subname); - _o.set(_j, "CreateSubscriptionStmt.conninfo", _p?.conninfo); - _o.set(_j, "CreateSubscriptionStmt.publication", _p?.publication); - _o.set(_j, "CreateSubscriptionStmt.options", _p?.options); - return _j; - }, - alterSubscriptionStmt(_p?: AlterSubscriptionStmt["AlterSubscriptionStmt"]): AlterSubscriptionStmt { - const _j = ({ - AlterSubscriptionStmt: {} - } as AlterSubscriptionStmt); - _o.set(_j, "AlterSubscriptionStmt.kind", _p?.kind); - _o.set(_j, "AlterSubscriptionStmt.subname", _p?.subname); - _o.set(_j, "AlterSubscriptionStmt.conninfo", _p?.conninfo); - _o.set(_j, "AlterSubscriptionStmt.publication", _p?.publication); - _o.set(_j, "AlterSubscriptionStmt.options", _p?.options); - return _j; - }, - dropSubscriptionStmt(_p?: DropSubscriptionStmt["DropSubscriptionStmt"]): DropSubscriptionStmt { - const _j = ({ - DropSubscriptionStmt: {} - } as DropSubscriptionStmt); - _o.set(_j, "DropSubscriptionStmt.subname", _p?.subname); - _o.set(_j, "DropSubscriptionStmt.missing_ok", _p?.missing_ok); - _o.set(_j, "DropSubscriptionStmt.behavior", _p?.behavior); - return _j; - }, - scanToken(_p?: ScanToken["ScanToken"]): ScanToken { - const _j = ({ - ScanToken: {} - } as ScanToken); - _o.set(_j, "ScanToken.start", _p?.start); - _o.set(_j, "ScanToken.end", _p?.end); - _o.set(_j, "ScanToken.token", _p?.token); - _o.set(_j, "ScanToken.keywordKind", _p?.keywordKind); - return _j; - } -}; \ No newline at end of file diff --git a/packages/proto-parser/test-utils/utils/wrapped.ts b/packages/proto-parser/test-utils/utils/wrapped.ts deleted file mode 100644 index e978eb60..00000000 --- a/packages/proto-parser/test-utils/utils/wrapped.ts +++ /dev/null @@ -1,2324 +0,0 @@ -/** -* This file was automatically generated by pg-proto-parser@1.21.0. -* DO NOT MODIFY IT BY HAND. Instead, modify the source proto file, -* and run the pg-proto-parser generate command to regenerate this file. -*/ -import { OverridingKind, QuerySource, SortByDir, SortByNulls, SetQuantifier, A_Expr_Kind, RoleSpecType, TableLikeOption, DefElemAction, PartitionStrategy, PartitionRangeDatumKind, RTEKind, WCOKind, GroupingSetKind, CTEMaterialize, SetOperation, ObjectType, DropBehavior, AlterTableType, GrantTargetType, VariableSetKind, ConstrType, ImportForeignSchemaType, RoleStmtType, FetchDirection, FunctionParameterMode, TransactionStmtKind, ViewCheckOption, DiscardMode, ReindexObjectType, AlterTSConfigType, PublicationObjSpecType, AlterPublicationAction, AlterSubscriptionType, OnCommitAction, ParamKind, CoercionContext, CoercionForm, BoolExprType, SubLinkType, RowCompareType, MinMaxOp, SQLValueFunctionOp, XmlExprOp, XmlOptionType, JsonEncoding, JsonFormatType, JsonConstructorType, JsonValueType, NullTestType, BoolTestType, CmdType, JoinType, AggStrategy, AggSplit, SetOpCmd, SetOpStrategy, OnConflictAction, LimitOption, LockClauseStrength, LockWaitPolicy, LockTupleMode, KeywordKind, Token } from "@pgsql/types"; -export type Node = ParseResult | ScanResult | Integer | Float | Boolean | String | BitString | List | OidList | IntList | A_Const | Alias | RangeVar | TableFunc | IntoClause | Var | Param | Aggref | GroupingFunc | WindowFunc | SubscriptingRef | FuncExpr | NamedArgExpr | OpExpr | DistinctExpr | NullIfExpr | ScalarArrayOpExpr | BoolExpr | SubLink | SubPlan | AlternativeSubPlan | FieldSelect | FieldStore | RelabelType | CoerceViaIO | ArrayCoerceExpr | ConvertRowtypeExpr | CollateExpr | CaseExpr | CaseWhen | CaseTestExpr | ArrayExpr | RowExpr | RowCompareExpr | CoalesceExpr | MinMaxExpr | SQLValueFunction | XmlExpr | JsonFormat | JsonReturning | JsonValueExpr | JsonConstructorExpr | JsonIsPredicate | NullTest | BooleanTest | CoerceToDomain | CoerceToDomainValue | SetToDefault | CurrentOfExpr | NextValueExpr | InferenceElem | TargetEntry | RangeTblRef | JoinExpr | FromExpr | OnConflictExpr | Query | TypeName | ColumnRef | ParamRef | A_Expr | TypeCast | CollateClause | RoleSpec | FuncCall | A_Star | A_Indices | A_Indirection | A_ArrayExpr | ResTarget | MultiAssignRef | SortBy | WindowDef | RangeSubselect | RangeFunction | RangeTableFunc | RangeTableFuncCol | RangeTableSample | ColumnDef | TableLikeClause | IndexElem | DefElem | LockingClause | XmlSerialize | PartitionElem | PartitionSpec | PartitionBoundSpec | PartitionRangeDatum | PartitionCmd | RangeTblEntry | RTEPermissionInfo | RangeTblFunction | TableSampleClause | WithCheckOption | SortGroupClause | GroupingSet | WindowClause | RowMarkClause | WithClause | InferClause | OnConflictClause | CTESearchClause | CTECycleClause | CommonTableExpr | MergeWhenClause | MergeAction | TriggerTransition | JsonOutput | JsonKeyValue | JsonObjectConstructor | JsonArrayConstructor | JsonArrayQueryConstructor | JsonAggConstructor | JsonObjectAgg | JsonArrayAgg | RawStmt | InsertStmt | DeleteStmt | UpdateStmt | MergeStmt | SelectStmt | SetOperationStmt | ReturnStmt | PLAssignStmt | CreateSchemaStmt | AlterTableStmt | ReplicaIdentityStmt | AlterTableCmd | AlterCollationStmt | AlterDomainStmt | GrantStmt | ObjectWithArgs | AccessPriv | GrantRoleStmt | AlterDefaultPrivilegesStmt | CopyStmt | VariableSetStmt | VariableShowStmt | CreateStmt | Constraint | CreateTableSpaceStmt | DropTableSpaceStmt | AlterTableSpaceOptionsStmt | AlterTableMoveAllStmt | CreateExtensionStmt | AlterExtensionStmt | AlterExtensionContentsStmt | CreateFdwStmt | AlterFdwStmt | CreateForeignServerStmt | AlterForeignServerStmt | CreateForeignTableStmt | CreateUserMappingStmt | AlterUserMappingStmt | DropUserMappingStmt | ImportForeignSchemaStmt | CreatePolicyStmt | AlterPolicyStmt | CreateAmStmt | CreateTrigStmt | CreateEventTrigStmt | AlterEventTrigStmt | CreatePLangStmt | CreateRoleStmt | AlterRoleStmt | AlterRoleSetStmt | DropRoleStmt | CreateSeqStmt | AlterSeqStmt | DefineStmt | CreateDomainStmt | CreateOpClassStmt | CreateOpClassItem | CreateOpFamilyStmt | AlterOpFamilyStmt | DropStmt | TruncateStmt | CommentStmt | SecLabelStmt | DeclareCursorStmt | ClosePortalStmt | FetchStmt | IndexStmt | CreateStatsStmt | StatsElem | AlterStatsStmt | CreateFunctionStmt | FunctionParameter | AlterFunctionStmt | DoStmt | InlineCodeBlock | CallStmt | CallContext | RenameStmt | AlterObjectDependsStmt | AlterObjectSchemaStmt | AlterOwnerStmt | AlterOperatorStmt | AlterTypeStmt | RuleStmt | NotifyStmt | ListenStmt | UnlistenStmt | TransactionStmt | CompositeTypeStmt | CreateEnumStmt | CreateRangeStmt | AlterEnumStmt | ViewStmt | LoadStmt | CreatedbStmt | AlterDatabaseStmt | AlterDatabaseRefreshCollStmt | AlterDatabaseSetStmt | DropdbStmt | AlterSystemStmt | ClusterStmt | VacuumStmt | VacuumRelation | ExplainStmt | CreateTableAsStmt | RefreshMatViewStmt | CheckPointStmt | DiscardStmt | LockStmt | ConstraintsSetStmt | ReindexStmt | CreateConversionStmt | CreateCastStmt | CreateTransformStmt | PrepareStmt | ExecuteStmt | DeallocateStmt | DropOwnedStmt | ReassignOwnedStmt | AlterTSDictionaryStmt | AlterTSConfigurationStmt | PublicationTable | PublicationObjSpec | CreatePublicationStmt | AlterPublicationStmt | CreateSubscriptionStmt | AlterSubscriptionStmt | DropSubscriptionStmt | ScanToken; -export interface ParseResult { - ParseResult: { - version?: number; - stmts?: RawStmt[]; - }; -} -export interface ScanResult { - ScanResult: { - version?: number; - tokens?: ScanToken[]; - }; -} -export interface Integer { - Integer: { - ival?: number; - }; -} -export interface Float { - Float: { - fval?: string; - }; -} -export interface Boolean { - Boolean: { - boolval?: boolean; - }; -} -export interface String { - String: { - sval?: string; - }; -} -export interface BitString { - BitString: { - bsval?: string; - }; -} -export interface List { - List: { - items?: Node[]; - }; -} -export interface OidList { - OidList: { - items?: Node[]; - }; -} -export interface IntList { - IntList: { - items?: Node[]; - }; -} -export interface A_Const { - A_Const: { - ival?: Integer; - fval?: Float; - boolval?: Boolean; - sval?: String; - bsval?: BitString; - isnull?: boolean; - location?: number; - }; -} -export interface Alias { - Alias: { - aliasname?: string; - colnames?: Node[]; - }; -} -export interface RangeVar { - RangeVar: { - catalogname?: string; - schemaname?: string; - relname?: string; - inh?: boolean; - relpersistence?: string; - alias?: Alias; - location?: number; - }; -} -export interface TableFunc { - TableFunc: { - ns_uris?: Node[]; - ns_names?: Node[]; - docexpr?: Node; - rowexpr?: Node; - colnames?: Node[]; - coltypes?: Node[]; - coltypmods?: Node[]; - colcollations?: Node[]; - colexprs?: Node[]; - coldefexprs?: Node[]; - notnulls?: bigint[]; - ordinalitycol?: number; - location?: number; - }; -} -export interface IntoClause { - IntoClause: { - rel?: RangeVar; - colNames?: Node[]; - accessMethod?: string; - options?: Node[]; - onCommit?: OnCommitAction; - tableSpaceName?: string; - viewQuery?: Node; - skipData?: boolean; - }; -} -export interface Var { - Var: { - xpr?: Node; - varno?: number; - varattno?: number; - vartype?: number; - vartypmod?: number; - varcollid?: number; - varnullingrels?: bigint[]; - varlevelsup?: number; - location?: number; - }; -} -export interface Param { - Param: { - xpr?: Node; - paramkind?: ParamKind; - paramid?: number; - paramtype?: number; - paramtypmod?: number; - paramcollid?: number; - location?: number; - }; -} -export interface Aggref { - Aggref: { - xpr?: Node; - aggfnoid?: number; - aggtype?: number; - aggcollid?: number; - inputcollid?: number; - aggargtypes?: Node[]; - aggdirectargs?: Node[]; - args?: Node[]; - aggorder?: Node[]; - aggdistinct?: Node[]; - aggfilter?: Node; - aggstar?: boolean; - aggvariadic?: boolean; - aggkind?: string; - agglevelsup?: number; - aggsplit?: AggSplit; - aggno?: number; - aggtransno?: number; - location?: number; - }; -} -export interface GroupingFunc { - GroupingFunc: { - xpr?: Node; - args?: Node[]; - refs?: Node[]; - agglevelsup?: number; - location?: number; - }; -} -export interface WindowFunc { - WindowFunc: { - xpr?: Node; - winfnoid?: number; - wintype?: number; - wincollid?: number; - inputcollid?: number; - args?: Node[]; - aggfilter?: Node; - winref?: number; - winstar?: boolean; - winagg?: boolean; - location?: number; - }; -} -export interface SubscriptingRef { - SubscriptingRef: { - xpr?: Node; - refcontainertype?: number; - refelemtype?: number; - refrestype?: number; - reftypmod?: number; - refcollid?: number; - refupperindexpr?: Node[]; - reflowerindexpr?: Node[]; - refexpr?: Node; - refassgnexpr?: Node; - }; -} -export interface FuncExpr { - FuncExpr: { - xpr?: Node; - funcid?: number; - funcresulttype?: number; - funcretset?: boolean; - funcvariadic?: boolean; - funcformat?: CoercionForm; - funccollid?: number; - inputcollid?: number; - args?: Node[]; - location?: number; - }; -} -export interface NamedArgExpr { - NamedArgExpr: { - xpr?: Node; - arg?: Node; - name?: string; - argnumber?: number; - location?: number; - }; -} -export interface OpExpr { - OpExpr: { - xpr?: Node; - opno?: number; - opresulttype?: number; - opretset?: boolean; - opcollid?: number; - inputcollid?: number; - args?: Node[]; - location?: number; - }; -} -export interface DistinctExpr { - DistinctExpr: { - xpr?: Node; - opno?: number; - opresulttype?: number; - opretset?: boolean; - opcollid?: number; - inputcollid?: number; - args?: Node[]; - location?: number; - }; -} -export interface NullIfExpr { - NullIfExpr: { - xpr?: Node; - opno?: number; - opresulttype?: number; - opretset?: boolean; - opcollid?: number; - inputcollid?: number; - args?: Node[]; - location?: number; - }; -} -export interface ScalarArrayOpExpr { - ScalarArrayOpExpr: { - xpr?: Node; - opno?: number; - useOr?: boolean; - inputcollid?: number; - args?: Node[]; - location?: number; - }; -} -export interface BoolExpr { - BoolExpr: { - xpr?: Node; - boolop?: BoolExprType; - args?: Node[]; - location?: number; - }; -} -export interface SubLink { - SubLink: { - xpr?: Node; - subLinkType?: SubLinkType; - subLinkId?: number; - testexpr?: Node; - operName?: Node[]; - subselect?: Node; - location?: number; - }; -} -export interface SubPlan { - SubPlan: { - xpr?: Node; - subLinkType?: SubLinkType; - testexpr?: Node; - paramIds?: Node[]; - plan_id?: number; - plan_name?: string; - firstColType?: number; - firstColTypmod?: number; - firstColCollation?: number; - useHashTable?: boolean; - unknownEqFalse?: boolean; - parallel_safe?: boolean; - setParam?: Node[]; - parParam?: Node[]; - args?: Node[]; - startup_cost?: number; - per_call_cost?: number; - }; -} -export interface AlternativeSubPlan { - AlternativeSubPlan: { - xpr?: Node; - subplans?: Node[]; - }; -} -export interface FieldSelect { - FieldSelect: { - xpr?: Node; - arg?: Node; - fieldnum?: number; - resulttype?: number; - resulttypmod?: number; - resultcollid?: number; - }; -} -export interface FieldStore { - FieldStore: { - xpr?: Node; - arg?: Node; - newvals?: Node[]; - fieldnums?: Node[]; - resulttype?: number; - }; -} -export interface RelabelType { - RelabelType: { - xpr?: Node; - arg?: Node; - resulttype?: number; - resulttypmod?: number; - resultcollid?: number; - relabelformat?: CoercionForm; - location?: number; - }; -} -export interface CoerceViaIO { - CoerceViaIO: { - xpr?: Node; - arg?: Node; - resulttype?: number; - resultcollid?: number; - coerceformat?: CoercionForm; - location?: number; - }; -} -export interface ArrayCoerceExpr { - ArrayCoerceExpr: { - xpr?: Node; - arg?: Node; - elemexpr?: Node; - resulttype?: number; - resulttypmod?: number; - resultcollid?: number; - coerceformat?: CoercionForm; - location?: number; - }; -} -export interface ConvertRowtypeExpr { - ConvertRowtypeExpr: { - xpr?: Node; - arg?: Node; - resulttype?: number; - convertformat?: CoercionForm; - location?: number; - }; -} -export interface CollateExpr { - CollateExpr: { - xpr?: Node; - arg?: Node; - collOid?: number; - location?: number; - }; -} -export interface CaseExpr { - CaseExpr: { - xpr?: Node; - casetype?: number; - casecollid?: number; - arg?: Node; - args?: Node[]; - defresult?: Node; - location?: number; - }; -} -export interface CaseWhen { - CaseWhen: { - xpr?: Node; - expr?: Node; - result?: Node; - location?: number; - }; -} -export interface CaseTestExpr { - CaseTestExpr: { - xpr?: Node; - typeId?: number; - typeMod?: number; - collation?: number; - }; -} -export interface ArrayExpr { - ArrayExpr: { - xpr?: Node; - array_typeid?: number; - array_collid?: number; - element_typeid?: number; - elements?: Node[]; - multidims?: boolean; - location?: number; - }; -} -export interface RowExpr { - RowExpr: { - xpr?: Node; - args?: Node[]; - row_typeid?: number; - row_format?: CoercionForm; - colnames?: Node[]; - location?: number; - }; -} -export interface RowCompareExpr { - RowCompareExpr: { - xpr?: Node; - rctype?: RowCompareType; - opnos?: Node[]; - opfamilies?: Node[]; - inputcollids?: Node[]; - largs?: Node[]; - rargs?: Node[]; - }; -} -export interface CoalesceExpr { - CoalesceExpr: { - xpr?: Node; - coalescetype?: number; - coalescecollid?: number; - args?: Node[]; - location?: number; - }; -} -export interface MinMaxExpr { - MinMaxExpr: { - xpr?: Node; - minmaxtype?: number; - minmaxcollid?: number; - inputcollid?: number; - op?: MinMaxOp; - args?: Node[]; - location?: number; - }; -} -export interface SQLValueFunction { - SQLValueFunction: { - xpr?: Node; - op?: SQLValueFunctionOp; - type?: number; - typmod?: number; - location?: number; - }; -} -export interface XmlExpr { - XmlExpr: { - xpr?: Node; - op?: XmlExprOp; - name?: string; - named_args?: Node[]; - arg_names?: Node[]; - args?: Node[]; - xmloption?: XmlOptionType; - indent?: boolean; - type?: number; - typmod?: number; - location?: number; - }; -} -export interface JsonFormat { - JsonFormat: { - format_type?: JsonFormatType; - encoding?: JsonEncoding; - location?: number; - }; -} -export interface JsonReturning { - JsonReturning: { - format?: JsonFormat; - typid?: number; - typmod?: number; - }; -} -export interface JsonValueExpr { - JsonValueExpr: { - raw_expr?: Node; - formatted_expr?: Node; - format?: JsonFormat; - }; -} -export interface JsonConstructorExpr { - JsonConstructorExpr: { - xpr?: Node; - type?: JsonConstructorType; - args?: Node[]; - func?: Node; - coercion?: Node; - returning?: JsonReturning; - absent_on_null?: boolean; - unique?: boolean; - location?: number; - }; -} -export interface JsonIsPredicate { - JsonIsPredicate: { - expr?: Node; - format?: JsonFormat; - item_type?: JsonValueType; - unique_keys?: boolean; - location?: number; - }; -} -export interface NullTest { - NullTest: { - xpr?: Node; - arg?: Node; - nulltesttype?: NullTestType; - argisrow?: boolean; - location?: number; - }; -} -export interface BooleanTest { - BooleanTest: { - xpr?: Node; - arg?: Node; - booltesttype?: BoolTestType; - location?: number; - }; -} -export interface CoerceToDomain { - CoerceToDomain: { - xpr?: Node; - arg?: Node; - resulttype?: number; - resulttypmod?: number; - resultcollid?: number; - coercionformat?: CoercionForm; - location?: number; - }; -} -export interface CoerceToDomainValue { - CoerceToDomainValue: { - xpr?: Node; - typeId?: number; - typeMod?: number; - collation?: number; - location?: number; - }; -} -export interface SetToDefault { - SetToDefault: { - xpr?: Node; - typeId?: number; - typeMod?: number; - collation?: number; - location?: number; - }; -} -export interface CurrentOfExpr { - CurrentOfExpr: { - xpr?: Node; - cvarno?: number; - cursor_name?: string; - cursor_param?: number; - }; -} -export interface NextValueExpr { - NextValueExpr: { - xpr?: Node; - seqid?: number; - typeId?: number; - }; -} -export interface InferenceElem { - InferenceElem: { - xpr?: Node; - expr?: Node; - infercollid?: number; - inferopclass?: number; - }; -} -export interface TargetEntry { - TargetEntry: { - xpr?: Node; - expr?: Node; - resno?: number; - resname?: string; - ressortgroupref?: number; - resorigtbl?: number; - resorigcol?: number; - resjunk?: boolean; - }; -} -export interface RangeTblRef { - RangeTblRef: { - rtindex?: number; - }; -} -export interface JoinExpr { - JoinExpr: { - jointype?: JoinType; - isNatural?: boolean; - larg?: Node; - rarg?: Node; - usingClause?: Node[]; - join_using_alias?: Alias; - quals?: Node; - alias?: Alias; - rtindex?: number; - }; -} -export interface FromExpr { - FromExpr: { - fromlist?: Node[]; - quals?: Node; - }; -} -export interface OnConflictExpr { - OnConflictExpr: { - action?: OnConflictAction; - arbiterElems?: Node[]; - arbiterWhere?: Node; - constraint?: number; - onConflictSet?: Node[]; - onConflictWhere?: Node; - exclRelIndex?: number; - exclRelTlist?: Node[]; - }; -} -export interface Query { - Query: { - commandType?: CmdType; - querySource?: QuerySource; - canSetTag?: boolean; - utilityStmt?: Node; - resultRelation?: number; - hasAggs?: boolean; - hasWindowFuncs?: boolean; - hasTargetSRFs?: boolean; - hasSubLinks?: boolean; - hasDistinctOn?: boolean; - hasRecursive?: boolean; - hasModifyingCTE?: boolean; - hasForUpdate?: boolean; - hasRowSecurity?: boolean; - isReturn?: boolean; - cteList?: Node[]; - rtable?: Node[]; - rteperminfos?: Node[]; - jointree?: FromExpr; - mergeActionList?: Node[]; - mergeUseOuterJoin?: boolean; - targetList?: Node[]; - override?: OverridingKind; - onConflict?: OnConflictExpr; - returningList?: Node[]; - groupClause?: Node[]; - groupDistinct?: boolean; - groupingSets?: Node[]; - havingQual?: Node; - windowClause?: Node[]; - distinctClause?: Node[]; - sortClause?: Node[]; - limitOffset?: Node; - limitCount?: Node; - limitOption?: LimitOption; - rowMarks?: Node[]; - setOperations?: Node; - constraintDeps?: Node[]; - withCheckOptions?: Node[]; - stmt_location?: number; - stmt_len?: number; - }; -} -export interface TypeName { - names?: Node[]; - typeOid?: number; - setof?: boolean; - pct_type?: boolean; - typmods?: Node[]; - typemod?: number; - arrayBounds?: Node[]; - location?: number; -} -export interface ColumnRef { - ColumnRef: { - fields?: Node[]; - location?: number; - }; -} -export interface ParamRef { - ParamRef: { - number?: number; - location?: number; - }; -} -export interface A_Expr { - A_Expr: { - kind?: A_Expr_Kind; - name?: Node[]; - lexpr?: Node; - rexpr?: Node; - location?: number; - }; -} -export interface TypeCast { - TypeCast: { - arg?: Node; - typeName?: TypeName; - location?: number; - }; -} -export interface CollateClause { - CollateClause: { - arg?: Node; - collname?: Node[]; - location?: number; - }; -} -export interface RoleSpec { - RoleSpec: { - roletype?: RoleSpecType; - rolename?: string; - location?: number; - }; -} -export interface FuncCall { - FuncCall: { - funcname?: Node[]; - args?: Node[]; - agg_order?: Node[]; - agg_filter?: Node; - over?: WindowDef; - agg_within_group?: boolean; - agg_star?: boolean; - agg_distinct?: boolean; - func_variadic?: boolean; - funcformat?: CoercionForm; - location?: number; - }; -} -export interface A_Star { - A_Star: {}; -} -export interface A_Indices { - A_Indices: { - is_slice?: boolean; - lidx?: Node; - uidx?: Node; - }; -} -export interface A_Indirection { - A_Indirection: { - arg?: Node; - indirection?: Node[]; - }; -} -export interface A_ArrayExpr { - A_ArrayExpr: { - elements?: Node[]; - location?: number; - }; -} -export interface ResTarget { - ResTarget: { - name?: string; - indirection?: Node[]; - val?: Node; - location?: number; - }; -} -export interface MultiAssignRef { - MultiAssignRef: { - source?: Node; - colno?: number; - ncolumns?: number; - }; -} -export interface SortBy { - SortBy: { - node?: Node; - sortby_dir?: SortByDir; - sortby_nulls?: SortByNulls; - useOp?: Node[]; - location?: number; - }; -} -export interface WindowDef { - WindowDef: { - name?: string; - refname?: string; - partitionClause?: Node[]; - orderClause?: Node[]; - frameOptions?: number; - startOffset?: Node; - endOffset?: Node; - location?: number; - }; -} -export interface RangeSubselect { - RangeSubselect: { - lateral?: boolean; - subquery?: Node; - alias?: Alias; - }; -} -export interface RangeFunction { - RangeFunction: { - lateral?: boolean; - ordinality?: boolean; - is_rowsfrom?: boolean; - functions?: Node[]; - alias?: Alias; - coldeflist?: Node[]; - }; -} -export interface RangeTableFunc { - RangeTableFunc: { - lateral?: boolean; - docexpr?: Node; - rowexpr?: Node; - namespaces?: Node[]; - columns?: Node[]; - alias?: Alias; - location?: number; - }; -} -export interface RangeTableFuncCol { - RangeTableFuncCol: { - colname?: string; - typeName?: TypeName; - for_ordinality?: boolean; - is_not_null?: boolean; - colexpr?: Node; - coldefexpr?: Node; - location?: number; - }; -} -export interface RangeTableSample { - RangeTableSample: { - relation?: Node; - method?: Node[]; - args?: Node[]; - repeatable?: Node; - location?: number; - }; -} -export interface ColumnDef { - ColumnDef: { - colname?: string; - typeName?: TypeName; - compression?: string; - inhcount?: number; - is_local?: boolean; - is_not_null?: boolean; - is_from_type?: boolean; - storage?: string; - storage_name?: string; - raw_default?: Node; - cooked_default?: Node; - identity?: string; - identitySequence?: RangeVar; - generated?: string; - collClause?: CollateClause; - collOid?: number; - constraints?: Node[]; - fdwoptions?: Node[]; - location?: number; - }; -} -export interface TableLikeClause { - TableLikeClause: { - relation?: RangeVar; - options?: number; - relationOid?: number; - }; -} -export interface IndexElem { - IndexElem: { - name?: string; - expr?: Node; - indexcolname?: string; - collation?: Node[]; - opclass?: Node[]; - opclassopts?: Node[]; - ordering?: SortByDir; - nulls_ordering?: SortByNulls; - }; -} -export interface DefElem { - DefElem: { - defnamespace?: string; - defname?: string; - arg?: Node; - defaction?: DefElemAction; - location?: number; - }; -} -export interface LockingClause { - LockingClause: { - lockedRels?: Node[]; - strength?: LockClauseStrength; - waitPolicy?: LockWaitPolicy; - }; -} -export interface XmlSerialize { - XmlSerialize: { - xmloption?: XmlOptionType; - expr?: Node; - typeName?: TypeName; - indent?: boolean; - location?: number; - }; -} -export interface PartitionElem { - PartitionElem: { - name?: string; - expr?: Node; - collation?: Node[]; - opclass?: Node[]; - location?: number; - }; -} -export interface PartitionSpec { - PartitionSpec: { - strategy?: PartitionStrategy; - partParams?: Node[]; - location?: number; - }; -} -export interface PartitionBoundSpec { - PartitionBoundSpec: { - strategy?: string; - is_default?: boolean; - modulus?: number; - remainder?: number; - listdatums?: Node[]; - lowerdatums?: Node[]; - upperdatums?: Node[]; - location?: number; - }; -} -export interface PartitionRangeDatum { - PartitionRangeDatum: { - kind?: PartitionRangeDatumKind; - value?: Node; - location?: number; - }; -} -export interface PartitionCmd { - PartitionCmd: { - name?: RangeVar; - bound?: PartitionBoundSpec; - concurrent?: boolean; - }; -} -export interface RangeTblEntry { - RangeTblEntry: { - rtekind?: RTEKind; - relid?: number; - relkind?: string; - rellockmode?: number; - tablesample?: TableSampleClause; - perminfoindex?: number; - subquery?: Query; - security_barrier?: boolean; - jointype?: JoinType; - joinmergedcols?: number; - joinaliasvars?: Node[]; - joinleftcols?: Node[]; - joinrightcols?: Node[]; - join_using_alias?: Alias; - functions?: Node[]; - funcordinality?: boolean; - tablefunc?: TableFunc; - values_lists?: Node[]; - ctename?: string; - ctelevelsup?: number; - self_reference?: boolean; - coltypes?: Node[]; - coltypmods?: Node[]; - colcollations?: Node[]; - enrname?: string; - enrtuples?: number; - alias?: Alias; - eref?: Alias; - lateral?: boolean; - inh?: boolean; - inFromCl?: boolean; - securityQuals?: Node[]; - }; -} -export interface RTEPermissionInfo { - RTEPermissionInfo: { - relid?: number; - inh?: boolean; - requiredPerms?: bigint; - checkAsUser?: number; - selectedCols?: bigint[]; - insertedCols?: bigint[]; - updatedCols?: bigint[]; - }; -} -export interface RangeTblFunction { - RangeTblFunction: { - funcexpr?: Node; - funccolcount?: number; - funccolnames?: Node[]; - funccoltypes?: Node[]; - funccoltypmods?: Node[]; - funccolcollations?: Node[]; - funcparams?: bigint[]; - }; -} -export interface TableSampleClause { - TableSampleClause: { - tsmhandler?: number; - args?: Node[]; - repeatable?: Node; - }; -} -export interface WithCheckOption { - WithCheckOption: { - kind?: WCOKind; - relname?: string; - polname?: string; - qual?: Node; - cascaded?: boolean; - }; -} -export interface SortGroupClause { - SortGroupClause: { - tleSortGroupRef?: number; - eqop?: number; - sortop?: number; - nulls_first?: boolean; - hashable?: boolean; - }; -} -export interface GroupingSet { - GroupingSet: { - kind?: GroupingSetKind; - content?: Node[]; - location?: number; - }; -} -export interface WindowClause { - WindowClause: { - name?: string; - refname?: string; - partitionClause?: Node[]; - orderClause?: Node[]; - frameOptions?: number; - startOffset?: Node; - endOffset?: Node; - runCondition?: Node[]; - startInRangeFunc?: number; - endInRangeFunc?: number; - inRangeColl?: number; - inRangeAsc?: boolean; - inRangeNullsFirst?: boolean; - winref?: number; - copiedOrder?: boolean; - }; -} -export interface RowMarkClause { - RowMarkClause: { - rti?: number; - strength?: LockClauseStrength; - waitPolicy?: LockWaitPolicy; - pushedDown?: boolean; - }; -} -export interface WithClause { - WithClause: { - ctes?: Node[]; - recursive?: boolean; - location?: number; - }; -} -export interface InferClause { - InferClause: { - indexElems?: Node[]; - whereClause?: Node; - conname?: string; - location?: number; - }; -} -export interface OnConflictClause { - OnConflictClause: { - action?: OnConflictAction; - infer?: InferClause; - targetList?: Node[]; - whereClause?: Node; - location?: number; - }; -} -export interface CTESearchClause { - CTESearchClause: { - search_col_list?: Node[]; - search_breadth_first?: boolean; - search_seq_column?: string; - location?: number; - }; -} -export interface CTECycleClause { - CTECycleClause: { - cycle_col_list?: Node[]; - cycle_mark_column?: string; - cycle_mark_value?: Node; - cycle_mark_default?: Node; - cycle_path_column?: string; - location?: number; - cycle_mark_type?: number; - cycle_mark_typmod?: number; - cycle_mark_collation?: number; - cycle_mark_neop?: number; - }; -} -export interface CommonTableExpr { - CommonTableExpr: { - ctename?: string; - aliascolnames?: Node[]; - ctematerialized?: CTEMaterialize; - ctequery?: Node; - search_clause?: CTESearchClause; - cycle_clause?: CTECycleClause; - location?: number; - cterecursive?: boolean; - cterefcount?: number; - ctecolnames?: Node[]; - ctecoltypes?: Node[]; - ctecoltypmods?: Node[]; - ctecolcollations?: Node[]; - }; -} -export interface MergeWhenClause { - MergeWhenClause: { - matched?: boolean; - commandType?: CmdType; - override?: OverridingKind; - condition?: Node; - targetList?: Node[]; - values?: Node[]; - }; -} -export interface MergeAction { - MergeAction: { - matched?: boolean; - commandType?: CmdType; - override?: OverridingKind; - qual?: Node; - targetList?: Node[]; - updateColnos?: Node[]; - }; -} -export interface TriggerTransition { - TriggerTransition: { - name?: string; - isNew?: boolean; - isTable?: boolean; - }; -} -export interface JsonOutput { - JsonOutput: { - typeName?: TypeName; - returning?: JsonReturning; - }; -} -export interface JsonKeyValue { - JsonKeyValue: { - key?: Node; - value?: JsonValueExpr; - }; -} -export interface JsonObjectConstructor { - JsonObjectConstructor: { - exprs?: Node[]; - output?: JsonOutput; - absent_on_null?: boolean; - unique?: boolean; - location?: number; - }; -} -export interface JsonArrayConstructor { - JsonArrayConstructor: { - exprs?: Node[]; - output?: JsonOutput; - absent_on_null?: boolean; - location?: number; - }; -} -export interface JsonArrayQueryConstructor { - JsonArrayQueryConstructor: { - query?: Node; - output?: JsonOutput; - format?: JsonFormat; - absent_on_null?: boolean; - location?: number; - }; -} -export interface JsonAggConstructor { - JsonAggConstructor: { - output?: JsonOutput; - agg_filter?: Node; - agg_order?: Node[]; - over?: WindowDef; - location?: number; - }; -} -export interface JsonObjectAgg { - JsonObjectAgg: { - constructor?: JsonAggConstructor; - arg?: JsonKeyValue; - absent_on_null?: boolean; - unique?: boolean; - }; -} -export interface JsonArrayAgg { - JsonArrayAgg: { - constructor?: JsonAggConstructor; - arg?: JsonValueExpr; - absent_on_null?: boolean; - }; -} -export interface RawStmt { - RawStmt: { - stmt?: Node; - stmt_location?: number; - stmt_len?: number; - }; -} -export interface InsertStmt { - InsertStmt: { - relation?: RangeVar; - cols?: Node[]; - selectStmt?: Node; - onConflictClause?: OnConflictClause; - returningList?: Node[]; - withClause?: WithClause; - override?: OverridingKind; - }; -} -export interface DeleteStmt { - DeleteStmt: { - relation?: RangeVar; - usingClause?: Node[]; - whereClause?: Node; - returningList?: Node[]; - withClause?: WithClause; - }; -} -export interface UpdateStmt { - UpdateStmt: { - relation?: RangeVar; - targetList?: Node[]; - whereClause?: Node; - fromClause?: Node[]; - returningList?: Node[]; - withClause?: WithClause; - }; -} -export interface MergeStmt { - MergeStmt: { - relation?: RangeVar; - sourceRelation?: Node; - joinCondition?: Node; - mergeWhenClauses?: Node[]; - withClause?: WithClause; - }; -} -export interface SelectStmt { - SelectStmt: { - distinctClause?: Node[]; - intoClause?: IntoClause; - targetList?: Node[]; - fromClause?: Node[]; - whereClause?: Node; - groupClause?: Node[]; - groupDistinct?: boolean; - havingClause?: Node; - windowClause?: Node[]; - valuesLists?: Node[]; - sortClause?: Node[]; - limitOffset?: Node; - limitCount?: Node; - limitOption?: LimitOption; - lockingClause?: Node[]; - withClause?: WithClause; - op?: SetOperation; - all?: boolean; - larg?: SelectStmt; - rarg?: SelectStmt; - }; -} -export interface SetOperationStmt { - SetOperationStmt: { - op?: SetOperation; - all?: boolean; - larg?: Node; - rarg?: Node; - colTypes?: Node[]; - colTypmods?: Node[]; - colCollations?: Node[]; - groupClauses?: Node[]; - }; -} -export interface ReturnStmt { - ReturnStmt: { - returnval?: Node; - }; -} -export interface PLAssignStmt { - PLAssignStmt: { - name?: string; - indirection?: Node[]; - nnames?: number; - val?: SelectStmt; - location?: number; - }; -} -export interface CreateSchemaStmt { - CreateSchemaStmt: { - schemaname?: string; - authrole?: RoleSpec; - schemaElts?: Node[]; - if_not_exists?: boolean; - }; -} -export interface AlterTableStmt { - AlterTableStmt: { - relation?: RangeVar; - cmds?: Node[]; - objtype?: ObjectType; - missing_ok?: boolean; - }; -} -export interface ReplicaIdentityStmt { - ReplicaIdentityStmt: { - identity_type?: string; - name?: string; - }; -} -export interface AlterTableCmd { - AlterTableCmd: { - subtype?: AlterTableType; - name?: string; - num?: number; - newowner?: RoleSpec; - def?: Node; - behavior?: DropBehavior; - missing_ok?: boolean; - recurse?: boolean; - }; -} -export interface AlterCollationStmt { - AlterCollationStmt: { - collname?: Node[]; - }; -} -export interface AlterDomainStmt { - AlterDomainStmt: { - subtype?: string; - typeName?: Node[]; - name?: string; - def?: Node; - behavior?: DropBehavior; - missing_ok?: boolean; - }; -} -export interface GrantStmt { - GrantStmt: { - is_grant?: boolean; - targtype?: GrantTargetType; - objtype?: ObjectType; - objects?: Node[]; - privileges?: Node[]; - grantees?: Node[]; - grant_option?: boolean; - grantor?: RoleSpec; - behavior?: DropBehavior; - }; -} -export interface ObjectWithArgs { - ObjectWithArgs: { - objname?: Node[]; - objargs?: Node[]; - objfuncargs?: Node[]; - args_unspecified?: boolean; - }; -} -export interface AccessPriv { - AccessPriv: { - priv_name?: string; - cols?: Node[]; - }; -} -export interface GrantRoleStmt { - GrantRoleStmt: { - granted_roles?: Node[]; - grantee_roles?: Node[]; - is_grant?: boolean; - opt?: Node[]; - grantor?: RoleSpec; - behavior?: DropBehavior; - }; -} -export interface AlterDefaultPrivilegesStmt { - AlterDefaultPrivilegesStmt: { - options?: Node[]; - action?: GrantStmt; - }; -} -export interface CopyStmt { - CopyStmt: { - relation?: RangeVar; - query?: Node; - attlist?: Node[]; - is_from?: boolean; - is_program?: boolean; - filename?: string; - options?: Node[]; - whereClause?: Node; - }; -} -export interface VariableSetStmt { - VariableSetStmt: { - kind?: VariableSetKind; - name?: string; - args?: Node[]; - is_local?: boolean; - }; -} -export interface VariableShowStmt { - VariableShowStmt: { - name?: string; - }; -} -export interface CreateStmt { - CreateStmt: { - relation?: RangeVar; - tableElts?: Node[]; - inhRelations?: Node[]; - partbound?: PartitionBoundSpec; - partspec?: PartitionSpec; - ofTypename?: TypeName; - constraints?: Node[]; - options?: Node[]; - oncommit?: OnCommitAction; - tablespacename?: string; - accessMethod?: string; - if_not_exists?: boolean; - }; -} -export interface Constraint { - Constraint: { - contype?: ConstrType; - conname?: string; - deferrable?: boolean; - initdeferred?: boolean; - location?: number; - is_no_inherit?: boolean; - raw_expr?: Node; - cooked_expr?: string; - generated_when?: string; - nulls_not_distinct?: boolean; - keys?: Node[]; - including?: Node[]; - exclusions?: Node[]; - options?: Node[]; - indexname?: string; - indexspace?: string; - reset_default_tblspc?: boolean; - access_method?: string; - where_clause?: Node; - pktable?: RangeVar; - fk_attrs?: Node[]; - pk_attrs?: Node[]; - fk_matchtype?: string; - fk_upd_action?: string; - fk_del_action?: string; - fk_del_set_cols?: Node[]; - old_conpfeqop?: Node[]; - old_pktable_oid?: number; - skip_validation?: boolean; - initially_valid?: boolean; - }; -} -export interface CreateTableSpaceStmt { - CreateTableSpaceStmt: { - tablespacename?: string; - owner?: RoleSpec; - location?: string; - options?: Node[]; - }; -} -export interface DropTableSpaceStmt { - DropTableSpaceStmt: { - tablespacename?: string; - missing_ok?: boolean; - }; -} -export interface AlterTableSpaceOptionsStmt { - AlterTableSpaceOptionsStmt: { - tablespacename?: string; - options?: Node[]; - isReset?: boolean; - }; -} -export interface AlterTableMoveAllStmt { - AlterTableMoveAllStmt: { - orig_tablespacename?: string; - objtype?: ObjectType; - roles?: Node[]; - new_tablespacename?: string; - nowait?: boolean; - }; -} -export interface CreateExtensionStmt { - CreateExtensionStmt: { - extname?: string; - if_not_exists?: boolean; - options?: Node[]; - }; -} -export interface AlterExtensionStmt { - AlterExtensionStmt: { - extname?: string; - options?: Node[]; - }; -} -export interface AlterExtensionContentsStmt { - AlterExtensionContentsStmt: { - extname?: string; - action?: number; - objtype?: ObjectType; - object?: Node; - }; -} -export interface CreateFdwStmt { - CreateFdwStmt: { - fdwname?: string; - func_options?: Node[]; - options?: Node[]; - }; -} -export interface AlterFdwStmt { - AlterFdwStmt: { - fdwname?: string; - func_options?: Node[]; - options?: Node[]; - }; -} -export interface CreateForeignServerStmt { - CreateForeignServerStmt: { - servername?: string; - servertype?: string; - version?: string; - fdwname?: string; - if_not_exists?: boolean; - options?: Node[]; - }; -} -export interface AlterForeignServerStmt { - AlterForeignServerStmt: { - servername?: string; - version?: string; - options?: Node[]; - has_version?: boolean; - }; -} -export interface CreateForeignTableStmt { - CreateForeignTableStmt: { - base?: CreateStmt; - servername?: string; - options?: Node[]; - }; -} -export interface CreateUserMappingStmt { - CreateUserMappingStmt: { - user?: RoleSpec; - servername?: string; - if_not_exists?: boolean; - options?: Node[]; - }; -} -export interface AlterUserMappingStmt { - AlterUserMappingStmt: { - user?: RoleSpec; - servername?: string; - options?: Node[]; - }; -} -export interface DropUserMappingStmt { - DropUserMappingStmt: { - user?: RoleSpec; - servername?: string; - missing_ok?: boolean; - }; -} -export interface ImportForeignSchemaStmt { - ImportForeignSchemaStmt: { - server_name?: string; - remote_schema?: string; - local_schema?: string; - list_type?: ImportForeignSchemaType; - table_list?: Node[]; - options?: Node[]; - }; -} -export interface CreatePolicyStmt { - CreatePolicyStmt: { - policy_name?: string; - table?: RangeVar; - cmd_name?: string; - permissive?: boolean; - roles?: Node[]; - qual?: Node; - with_check?: Node; - }; -} -export interface AlterPolicyStmt { - AlterPolicyStmt: { - policy_name?: string; - table?: RangeVar; - roles?: Node[]; - qual?: Node; - with_check?: Node; - }; -} -export interface CreateAmStmt { - CreateAmStmt: { - amname?: string; - handler_name?: Node[]; - amtype?: string; - }; -} -export interface CreateTrigStmt { - CreateTrigStmt: { - replace?: boolean; - isconstraint?: boolean; - trigname?: string; - relation?: RangeVar; - funcname?: Node[]; - args?: Node[]; - row?: boolean; - timing?: number; - events?: number; - columns?: Node[]; - whenClause?: Node; - transitionRels?: Node[]; - deferrable?: boolean; - initdeferred?: boolean; - constrrel?: RangeVar; - }; -} -export interface CreateEventTrigStmt { - CreateEventTrigStmt: { - trigname?: string; - eventname?: string; - whenclause?: Node[]; - funcname?: Node[]; - }; -} -export interface AlterEventTrigStmt { - AlterEventTrigStmt: { - trigname?: string; - tgenabled?: string; - }; -} -export interface CreatePLangStmt { - CreatePLangStmt: { - replace?: boolean; - plname?: string; - plhandler?: Node[]; - plinline?: Node[]; - plvalidator?: Node[]; - pltrusted?: boolean; - }; -} -export interface CreateRoleStmt { - CreateRoleStmt: { - stmt_type?: RoleStmtType; - role?: string; - options?: Node[]; - }; -} -export interface AlterRoleStmt { - AlterRoleStmt: { - role?: RoleSpec; - options?: Node[]; - action?: number; - }; -} -export interface AlterRoleSetStmt { - AlterRoleSetStmt: { - role?: RoleSpec; - database?: string; - setstmt?: VariableSetStmt; - }; -} -export interface DropRoleStmt { - DropRoleStmt: { - roles?: Node[]; - missing_ok?: boolean; - }; -} -export interface CreateSeqStmt { - CreateSeqStmt: { - sequence?: RangeVar; - options?: Node[]; - ownerId?: number; - for_identity?: boolean; - if_not_exists?: boolean; - }; -} -export interface AlterSeqStmt { - AlterSeqStmt: { - sequence?: RangeVar; - options?: Node[]; - for_identity?: boolean; - missing_ok?: boolean; - }; -} -export interface DefineStmt { - DefineStmt: { - kind?: ObjectType; - oldstyle?: boolean; - defnames?: Node[]; - args?: Node[]; - definition?: Node[]; - if_not_exists?: boolean; - replace?: boolean; - }; -} -export interface CreateDomainStmt { - CreateDomainStmt: { - domainname?: Node[]; - typeName?: TypeName; - collClause?: CollateClause; - constraints?: Node[]; - }; -} -export interface CreateOpClassStmt { - CreateOpClassStmt: { - opclassname?: Node[]; - opfamilyname?: Node[]; - amname?: string; - datatype?: TypeName; - items?: Node[]; - isDefault?: boolean; - }; -} -export interface CreateOpClassItem { - CreateOpClassItem: { - itemtype?: number; - name?: ObjectWithArgs; - number?: number; - order_family?: Node[]; - class_args?: Node[]; - storedtype?: TypeName; - }; -} -export interface CreateOpFamilyStmt { - CreateOpFamilyStmt: { - opfamilyname?: Node[]; - amname?: string; - }; -} -export interface AlterOpFamilyStmt { - AlterOpFamilyStmt: { - opfamilyname?: Node[]; - amname?: string; - isDrop?: boolean; - items?: Node[]; - }; -} -export interface DropStmt { - DropStmt: { - objects?: Node[]; - removeType?: ObjectType; - behavior?: DropBehavior; - missing_ok?: boolean; - concurrent?: boolean; - }; -} -export interface TruncateStmt { - TruncateStmt: { - relations?: Node[]; - restart_seqs?: boolean; - behavior?: DropBehavior; - }; -} -export interface CommentStmt { - CommentStmt: { - objtype?: ObjectType; - object?: Node; - comment?: string; - }; -} -export interface SecLabelStmt { - SecLabelStmt: { - objtype?: ObjectType; - object?: Node; - provider?: string; - label?: string; - }; -} -export interface DeclareCursorStmt { - DeclareCursorStmt: { - portalname?: string; - options?: number; - query?: Node; - }; -} -export interface ClosePortalStmt { - ClosePortalStmt: { - portalname?: string; - }; -} -export interface FetchStmt { - FetchStmt: { - direction?: FetchDirection; - howMany?: bigint; - portalname?: string; - ismove?: boolean; - }; -} -export interface IndexStmt { - IndexStmt: { - idxname?: string; - relation?: RangeVar; - accessMethod?: string; - tableSpace?: string; - indexParams?: Node[]; - indexIncludingParams?: Node[]; - options?: Node[]; - whereClause?: Node; - excludeOpNames?: Node[]; - idxcomment?: string; - indexOid?: number; - oldNumber?: number; - oldCreateSubid?: number; - oldFirstRelfilelocatorSubid?: number; - unique?: boolean; - nulls_not_distinct?: boolean; - primary?: boolean; - isconstraint?: boolean; - deferrable?: boolean; - initdeferred?: boolean; - transformed?: boolean; - concurrent?: boolean; - if_not_exists?: boolean; - reset_default_tblspc?: boolean; - }; -} -export interface CreateStatsStmt { - CreateStatsStmt: { - defnames?: Node[]; - stat_types?: Node[]; - exprs?: Node[]; - relations?: Node[]; - stxcomment?: string; - transformed?: boolean; - if_not_exists?: boolean; - }; -} -export interface StatsElem { - StatsElem: { - name?: string; - expr?: Node; - }; -} -export interface AlterStatsStmt { - AlterStatsStmt: { - defnames?: Node[]; - stxstattarget?: number; - missing_ok?: boolean; - }; -} -export interface CreateFunctionStmt { - CreateFunctionStmt: { - is_procedure?: boolean; - replace?: boolean; - funcname?: Node[]; - parameters?: Node[]; - returnType?: TypeName; - options?: Node[]; - sql_body?: Node; - }; -} -export interface FunctionParameter { - FunctionParameter: { - name?: string; - argType?: TypeName; - mode?: FunctionParameterMode; - defexpr?: Node; - }; -} -export interface AlterFunctionStmt { - AlterFunctionStmt: { - objtype?: ObjectType; - func?: ObjectWithArgs; - actions?: Node[]; - }; -} -export interface DoStmt { - DoStmt: { - args?: Node[]; - }; -} -export interface InlineCodeBlock { - InlineCodeBlock: { - source_text?: string; - langOid?: number; - langIsTrusted?: boolean; - atomic?: boolean; - }; -} -export interface CallStmt { - CallStmt: { - funccall?: FuncCall; - funcexpr?: FuncExpr; - outargs?: Node[]; - }; -} -export interface CallContext { - CallContext: { - atomic?: boolean; - }; -} -export interface RenameStmt { - RenameStmt: { - renameType?: ObjectType; - relationType?: ObjectType; - relation?: RangeVar; - object?: Node; - subname?: string; - newname?: string; - behavior?: DropBehavior; - missing_ok?: boolean; - }; -} -export interface AlterObjectDependsStmt { - AlterObjectDependsStmt: { - objectType?: ObjectType; - relation?: RangeVar; - object?: Node; - extname?: String; - remove?: boolean; - }; -} -export interface AlterObjectSchemaStmt { - AlterObjectSchemaStmt: { - objectType?: ObjectType; - relation?: RangeVar; - object?: Node; - newschema?: string; - missing_ok?: boolean; - }; -} -export interface AlterOwnerStmt { - AlterOwnerStmt: { - objectType?: ObjectType; - relation?: RangeVar; - object?: Node; - newowner?: RoleSpec; - }; -} -export interface AlterOperatorStmt { - AlterOperatorStmt: { - opername?: ObjectWithArgs; - options?: Node[]; - }; -} -export interface AlterTypeStmt { - AlterTypeStmt: { - typeName?: Node[]; - options?: Node[]; - }; -} -export interface RuleStmt { - RuleStmt: { - relation?: RangeVar; - rulename?: string; - whereClause?: Node; - event?: CmdType; - instead?: boolean; - actions?: Node[]; - replace?: boolean; - }; -} -export interface NotifyStmt { - NotifyStmt: { - conditionname?: string; - payload?: string; - }; -} -export interface ListenStmt { - ListenStmt: { - conditionname?: string; - }; -} -export interface UnlistenStmt { - UnlistenStmt: { - conditionname?: string; - }; -} -export interface TransactionStmt { - TransactionStmt: { - kind?: TransactionStmtKind; - options?: Node[]; - savepoint_name?: string; - gid?: string; - chain?: boolean; - }; -} -export interface CompositeTypeStmt { - CompositeTypeStmt: { - typevar?: RangeVar; - coldeflist?: Node[]; - }; -} -export interface CreateEnumStmt { - CreateEnumStmt: { - typeName?: Node[]; - vals?: Node[]; - }; -} -export interface CreateRangeStmt { - CreateRangeStmt: { - typeName?: Node[]; - params?: Node[]; - }; -} -export interface AlterEnumStmt { - AlterEnumStmt: { - typeName?: Node[]; - oldVal?: string; - newVal?: string; - newValNeighbor?: string; - newValIsAfter?: boolean; - skipIfNewValExists?: boolean; - }; -} -export interface ViewStmt { - ViewStmt: { - view?: RangeVar; - aliases?: Node[]; - query?: Node; - replace?: boolean; - options?: Node[]; - withCheckOption?: ViewCheckOption; - }; -} -export interface LoadStmt { - LoadStmt: { - filename?: string; - }; -} -export interface CreatedbStmt { - CreatedbStmt: { - dbname?: string; - options?: Node[]; - }; -} -export interface AlterDatabaseStmt { - AlterDatabaseStmt: { - dbname?: string; - options?: Node[]; - }; -} -export interface AlterDatabaseRefreshCollStmt { - AlterDatabaseRefreshCollStmt: { - dbname?: string; - }; -} -export interface AlterDatabaseSetStmt { - AlterDatabaseSetStmt: { - dbname?: string; - setstmt?: VariableSetStmt; - }; -} -export interface DropdbStmt { - DropdbStmt: { - dbname?: string; - missing_ok?: boolean; - options?: Node[]; - }; -} -export interface AlterSystemStmt { - AlterSystemStmt: { - setstmt?: VariableSetStmt; - }; -} -export interface ClusterStmt { - ClusterStmt: { - relation?: RangeVar; - indexname?: string; - params?: Node[]; - }; -} -export interface VacuumStmt { - VacuumStmt: { - options?: Node[]; - rels?: Node[]; - is_vacuumcmd?: boolean; - }; -} -export interface VacuumRelation { - VacuumRelation: { - relation?: RangeVar; - oid?: number; - va_cols?: Node[]; - }; -} -export interface ExplainStmt { - ExplainStmt: { - query?: Node; - options?: Node[]; - }; -} -export interface CreateTableAsStmt { - CreateTableAsStmt: { - query?: Node; - into?: IntoClause; - objtype?: ObjectType; - is_select_into?: boolean; - if_not_exists?: boolean; - }; -} -export interface RefreshMatViewStmt { - RefreshMatViewStmt: { - concurrent?: boolean; - skipData?: boolean; - relation?: RangeVar; - }; -} -export interface CheckPointStmt { - CheckPointStmt: {}; -} -export interface DiscardStmt { - DiscardStmt: { - target?: DiscardMode; - }; -} -export interface LockStmt { - LockStmt: { - relations?: Node[]; - mode?: number; - nowait?: boolean; - }; -} -export interface ConstraintsSetStmt { - ConstraintsSetStmt: { - constraints?: Node[]; - deferred?: boolean; - }; -} -export interface ReindexStmt { - ReindexStmt: { - kind?: ReindexObjectType; - relation?: RangeVar; - name?: string; - params?: Node[]; - }; -} -export interface CreateConversionStmt { - CreateConversionStmt: { - conversion_name?: Node[]; - for_encoding_name?: string; - to_encoding_name?: string; - func_name?: Node[]; - def?: boolean; - }; -} -export interface CreateCastStmt { - CreateCastStmt: { - sourcetype?: TypeName; - targettype?: TypeName; - func?: ObjectWithArgs; - context?: CoercionContext; - inout?: boolean; - }; -} -export interface CreateTransformStmt { - CreateTransformStmt: { - replace?: boolean; - type_name?: TypeName; - lang?: string; - fromsql?: ObjectWithArgs; - tosql?: ObjectWithArgs; - }; -} -export interface PrepareStmt { - PrepareStmt: { - name?: string; - argtypes?: Node[]; - query?: Node; - }; -} -export interface ExecuteStmt { - ExecuteStmt: { - name?: string; - params?: Node[]; - }; -} -export interface DeallocateStmt { - DeallocateStmt: { - name?: string; - }; -} -export interface DropOwnedStmt { - DropOwnedStmt: { - roles?: Node[]; - behavior?: DropBehavior; - }; -} -export interface ReassignOwnedStmt { - ReassignOwnedStmt: { - roles?: Node[]; - newrole?: RoleSpec; - }; -} -export interface AlterTSDictionaryStmt { - AlterTSDictionaryStmt: { - dictname?: Node[]; - options?: Node[]; - }; -} -export interface AlterTSConfigurationStmt { - AlterTSConfigurationStmt: { - kind?: AlterTSConfigType; - cfgname?: Node[]; - tokentype?: Node[]; - dicts?: Node[]; - override?: boolean; - replace?: boolean; - missing_ok?: boolean; - }; -} -export interface PublicationTable { - PublicationTable: { - relation?: RangeVar; - whereClause?: Node; - columns?: Node[]; - }; -} -export interface PublicationObjSpec { - PublicationObjSpec: { - pubobjtype?: PublicationObjSpecType; - name?: string; - pubtable?: PublicationTable; - location?: number; - }; -} -export interface CreatePublicationStmt { - CreatePublicationStmt: { - pubname?: string; - options?: Node[]; - pubobjects?: Node[]; - for_all_tables?: boolean; - }; -} -export interface AlterPublicationStmt { - AlterPublicationStmt: { - pubname?: string; - options?: Node[]; - pubobjects?: Node[]; - for_all_tables?: boolean; - action?: AlterPublicationAction; - }; -} -export interface CreateSubscriptionStmt { - CreateSubscriptionStmt: { - subname?: string; - conninfo?: string; - publication?: Node[]; - options?: Node[]; - }; -} -export interface AlterSubscriptionStmt { - AlterSubscriptionStmt: { - kind?: AlterSubscriptionType; - subname?: string; - conninfo?: string; - publication?: Node[]; - options?: Node[]; - }; -} -export interface DropSubscriptionStmt { - DropSubscriptionStmt: { - subname?: string; - missing_ok?: boolean; - behavior?: DropBehavior; - }; -} -export interface ScanToken { - ScanToken: { - start?: number; - end?: number; - token?: Token; - keywordKind?: KeywordKind; - }; -} \ No newline at end of file