@devrev/meerkat-core 0.0.83 → 0.0.85

package/src/types/duckdb-serialization-types/serialization/ParsedExpression.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParsedExpression.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from './Expression';\nimport { CacheCheck, Value } from './Misc';\nimport { LogicalType, OrderByNode } from './Nodes';\nimport { OrderModifier } from './ResultModifier';\nimport { SelectStatement } from './Statement';\n\nexport interface BaseParsedExpression {\n  class: ExpressionClass;\n  type: ExpressionType;\n  alias: string;\n}\n\nexport type ParsedExpression =\n  | BetweenExpression\n  | CaseExpression\n  | CastExpression\n  | CollateExpression\n  | ColumnRefExpression\n  | ComparisonExpression\n  | ConjunctionExpression\n  | ConstantExpression\n  | DefaultExpression\n  | FunctionExpression\n  | LambdaExpression\n  | OperatorExpression\n  | ParameterExpression\n  | PositionalReferenceExpression\n  | StarExpression\n  | SubqueryExpression\n  | WindowExpression;\n\nexport interface BetweenExpression extends BaseParsedExpression {\n  input: ParsedExpression;\n  lower: ParsedExpression;\n  upper: ParsedExpression;\n}\n\nexport interface CaseExpression extends BaseParsedExpression {\n  case_checks: CacheCheck[];\n  else_expr: BaseParsedExpression;\n}\n\nexport interface CastExpression extends BaseParsedExpression {\n  child: ParsedExpression;\n  cast_type: LogicalType;\n  try_cast: boolean;\n}\n\nexport interface CollateExpression extends BaseParsedExpression {\n  child: ParsedExpression;\n  collation: string;\n}\n\nexport interface ColumnRefExpression extends BaseParsedExpression {\n  column_names: string[];\n}\n\nexport interface ComparisonExpression extends BaseParsedExpression {\n  left: ParsedExpression;\n  right: ParsedExpression;\n}\n\nexport interface ConjunctionExpression extends BaseParsedExpression {\n  children: ParsedExpression[];\n}\n\nexport interface ConstantExpression extends BaseParsedExpression {\n  value: Value;\n}\n\nexport type DefaultExpression = BaseParsedExpression;\n\nexport interface FunctionExpression extends BaseParsedExpression {\n  function_name: string;\n  schema: string;\n  children: ParsedExpression[];\n  filter: ParsedExpression | null;\n  order_bys: OrderModifier;\n  distinct: boolean;\n  is_operator: boolean;\n  export_state: boolean;\n  catalog: string;\n}\n\nexport interface LambdaExpression extends BaseParsedExpression {\n  lhs: ParsedExpression;\n  expr: ParsedExpression | null;\n}\n\nexport interface OperatorExpression extends BaseParsedExpression {\n  children: ParsedExpression[];\n}\n\nexport interface ParameterExpression extends BaseParsedExpression {\n  identifier: string;\n}\n\nexport interface PositionalReferenceExpression extends BaseParsedExpression {\n  index: number;\n}\n\nexport interface StarExpression extends BaseParsedExpression {\n  relation_name: string;\n  exclude_list: Set<string> | Array<string>;\n  replace_list: Set<ParsedExpression> | Array<ParsedExpression>;\n  columns: boolean;\n  expr?: ParsedExpression;\n}\n\nexport enum SubqueryType {\n  INVALID = 'INVALID',\n  SCALAR = 'SCALAR',\n  EXISTS = 'EXISTS',\n  NOT_EXISTS = 'NOT_EXISTS',\n  ANY = 'ANY',\n}\n\nexport interface SubqueryExpression extends BaseParsedExpression {\n  subquery_type: SubqueryType;\n  subquery: SelectStatement;\n  child?: ParsedExpression;\n  comparison_type: ExpressionType;\n}\n\nexport enum WindowBoundary {\n  INVALID = 'INVALID',\n  UNBOUNDED_PRECEDING = 'UNBOUNDED_PRECEDING',\n  UNBOUNDED_FOLLOWING = 'UNBOUNDED_FOLLOWING',\n  CURRENT_ROW_RANGE = 'CURRENT_ROW_RANGE',\n  CURRENT_ROW_ROWS = 'CURRENT_ROW_ROWS',\n  EXPR_PRECEDING_ROWS = 'EXPR_PRECEDING_ROWS',\n  EXPR_FOLLOWING_ROWS = 'EXPR_FOLLOWING_ROWS',\n  EXPR_PRECEDING_RANGE = 'EXPR_PRECEDING_RANGE',\n  EXPR_FOLLOWING_RANGE = 'EXPR_FOLLOWING_RANGE',\n}\n\nexport interface WindowExpression extends BaseParsedExpression {\n  function_name: string;\n  schema: string;\n  catalog: string;\n  children: ParsedExpression[];\n  partitions: ParsedExpression[];\n  orders: OrderByNode[];\n  start: WindowBoundary;\n  end: WindowBoundary;\n  start_expr?: ParsedExpression;\n  end_expr?: ParsedExpression;\n  offset_expr?: ParsedExpression;\n  default_expr?: ParsedExpression;\n  ignore_nulls: boolean;\n  filter_expr?: ParsedExpression;\n}\n"],"names":["SubqueryType","INVALID","SCALAR","EXISTS","NOT_EXISTS","ANY","WindowBoundary","UNBOUNDED_PRECEDING","UNBOUNDED_FOLLOWING","CURRENT_ROW_RANGE","CURRENT_ROW_ROWS","EXPR_PRECEDING_ROWS","EXPR_FOLLOWING_ROWS","EXPR_PRECEDING_RANGE","EXPR_FOLLOWING_RANGE"],"mappings":";;;;;;;;;;;;;;;IA6GO;UAAKA,YAAY;IAAZA,aACVC,aAAAA;IADUD,aAEVE,YAAAA;IAFUF,aAGVG,YAAAA;IAHUH,aAIVI,gBAAAA;IAJUJ,aAKVK,SAAAA;GALUL,iBAAAA;IAeL;UAAKM,cAAc;IAAdA,eACVL,aAAAA;IADUK,eAEVC,yBAAAA;IAFUD,eAGVE,yBAAAA;IAHUF,eAIVG,uBAAAA;IAJUH,eAKVI,sBAAAA;IALUJ,eAMVK,yBAAAA;IANUL,eAOVM,yBAAAA;IAPUN,eAQVO,0BAAAA;IARUP,eASVQ,0BAAAA;GATUR,mBAAAA"}
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParsedExpression.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from './Expression';\nimport { CacheCheck, Value } from './Misc';\nimport { LogicalType, OrderByNode } from './Nodes';\nimport { OrderModifier } from './ResultModifier';\nimport { SelectStatement } from './Statement';\n\nexport interface BaseParsedExpression {\n  class: ExpressionClass;\n  type: ExpressionType;\n  alias: string;\n  query_location?: number;\n}\n\nexport type ParsedExpression =\n  | BetweenExpression\n  | CaseExpression\n  | CastExpression\n  | CollateExpression\n  | ColumnRefExpression\n  | ComparisonExpression\n  | ConjunctionExpression\n  | ConstantExpression\n  | DefaultExpression\n  | FunctionExpression\n  | LambdaExpression\n  | OperatorExpression\n  | ParameterExpression\n  | PositionalReferenceExpression\n  | StarExpression\n  | SubqueryExpression\n  | WindowExpression;\n\nexport interface BetweenExpression extends BaseParsedExpression {\n  class: ExpressionClass.BETWEEN;\n  input: ParsedExpression;\n  lower: ParsedExpression;\n  upper: ParsedExpression;\n}\n\nexport interface CaseExpression extends BaseParsedExpression {\n  class: ExpressionClass.CASE;\n  case_checks: CacheCheck[];\n  else_expr: BaseParsedExpression;\n}\n\nexport interface CastExpression extends BaseParsedExpression {\n  class: ExpressionClass.CAST;\n  child: ParsedExpression;\n  cast_type: LogicalType;\n  try_cast: boolean;\n}\n\nexport interface CollateExpression extends BaseParsedExpression {\n  class: ExpressionClass.COLLATE;\n  child: ParsedExpression;\n  collation: string;\n}\n\nexport interface ColumnRefExpression extends BaseParsedExpression {\n  class: ExpressionClass.COLUMN_REF;\n  column_names: string[];\n}\n\nexport interface ComparisonExpression extends BaseParsedExpression {\n  class: ExpressionClass.COMPARISON;\n  left: ParsedExpression;\n  right: ParsedExpression;\n}\n\nexport interface ConjunctionExpression extends BaseParsedExpression {\n  class: ExpressionClass.CONJUNCTION;\n  children: ParsedExpression[];\n}\n\nexport interface ConstantExpression extends BaseParsedExpression {\n  class: ExpressionClass.CONSTANT;\n  value: Value;\n}\n\nexport type DefaultExpression = BaseParsedExpression;\n\nexport interface FunctionExpression extends BaseParsedExpression {\n  class: ExpressionClass.FUNCTION;\n  function_name: string;\n  schema: string;\n  children: ParsedExpression[];\n  filter: ParsedExpression | null;\n  order_bys: OrderModifier;\n  distinct: boolean;\n  is_operator: boolean;\n  export_state: boolean;\n  catalog: string;\n}\n\nexport interface LambdaExpression extends BaseParsedExpression {\n  class: ExpressionClass.LAMBDA;\n  lhs: ParsedExpression;\n  expr: ParsedExpression | null;\n}\n\nexport interface OperatorExpression extends BaseParsedExpression {\n  class: ExpressionClass.OPERATOR;\n  children: ParsedExpression[];\n}\n\nexport interface ParameterExpression extends BaseParsedExpression {\n  class: ExpressionClass.PARAMETER;\n  identifier: string;\n}\n\nexport interface PositionalReferenceExpression extends BaseParsedExpression {\n  class: ExpressionClass.POSITIONAL_REFERENCE;\n  index: number;\n}\n\nexport interface StarExpression extends BaseParsedExpression {\n  class: ExpressionClass.STAR;\n  relation_name: string;\n  exclude_list: Set<string> | Array<string>;\n  replace_list: Set<ParsedExpression> | Array<ParsedExpression>;\n  columns: boolean;\n  expr?: ParsedExpression;\n}\n\nexport enum SubqueryType {\n  INVALID = 'INVALID',\n  SCALAR = 'SCALAR',\n  EXISTS = 'EXISTS',\n  NOT_EXISTS = 'NOT_EXISTS',\n  ANY = 'ANY',\n}\n\nexport interface SubqueryExpression extends BaseParsedExpression {\n  class: ExpressionClass.SUBQUERY;\n  subquery_type: SubqueryType;\n  subquery: SelectStatement;\n  child?: ParsedExpression;\n  comparison_type: ExpressionType;\n}\n\nexport enum WindowBoundary {\n  INVALID = 'INVALID',\n  UNBOUNDED_PRECEDING = 'UNBOUNDED_PRECEDING',\n  UNBOUNDED_FOLLOWING = 'UNBOUNDED_FOLLOWING',\n  CURRENT_ROW_RANGE = 'CURRENT_ROW_RANGE',\n  CURRENT_ROW_ROWS = 'CURRENT_ROW_ROWS',\n  EXPR_PRECEDING_ROWS = 'EXPR_PRECEDING_ROWS',\n  EXPR_FOLLOWING_ROWS = 'EXPR_FOLLOWING_ROWS',\n  EXPR_PRECEDING_RANGE = 'EXPR_PRECEDING_RANGE',\n  EXPR_FOLLOWING_RANGE = 'EXPR_FOLLOWING_RANGE',\n}\n\nexport interface WindowExpression extends BaseParsedExpression {\n  class: ExpressionClass.WINDOW;\n  function_name: string;\n  schema: string;\n  catalog: string;\n  children: ParsedExpression[];\n  partitions: ParsedExpression[];\n  orders: OrderByNode[];\n  start: WindowBoundary;\n  end: WindowBoundary;\n  start_expr?: ParsedExpression;\n  end_expr?: ParsedExpression;\n  offset_expr?: ParsedExpression;\n  default_expr?: ParsedExpression;\n  ignore_nulls: boolean;\n  filter_expr?: ParsedExpression;\n}\n"],"names":["SubqueryType","INVALID","SCALAR","EXISTS","NOT_EXISTS","ANY","WindowBoundary","UNBOUNDED_PRECEDING","UNBOUNDED_FOLLOWING","CURRENT_ROW_RANGE","CURRENT_ROW_ROWS","EXPR_PRECEDING_ROWS","EXPR_FOLLOWING_ROWS","EXPR_PRECEDING_RANGE","EXPR_FOLLOWING_RANGE"],"mappings":";;;;;;;;;;;;;;;IA4HO;UAAKA,YAAY;IAAZA,aACVC,aAAAA;IADUD,aAEVE,YAAAA;IAFUF,aAGVG,YAAAA;IAHUH,aAIVI,gBAAAA;IAJUJ,aAKVK,SAAAA;GALUL,iBAAAA;IAgBL;UAAKM,cAAc;IAAdA,eACVL,aAAAA;IADUK,eAEVC,yBAAAA;IAFUD,eAGVE,yBAAAA;IAHUF,eAIVG,uBAAAA;IAJUH,eAKVI,sBAAAA;IALUJ,eAMVK,yBAAAA;IANUL,eAOVM,yBAAAA;IAPUN,eAQVO,0BAAAA;IARUP,eASVQ,0BAAAA;GATUR,mBAAAA"}

package/src/types/utils.d.ts

@@ -0,0 +1,19 @@
+import { BetweenExpression, CaseExpression, CastExpression, CollateExpression, ColumnRefExpression, ComparisonExpression, ConjunctionExpression, ConstantExpression, FunctionExpression, LambdaExpression, OperatorExpression, ParameterExpression, PositionalReferenceExpression, SubqueryExpression, WindowExpression } from './duckdb-serialization-types/serialization/ParsedExpression';
+import { QueryNode, SelectNode } from './duckdb-serialization-types';
+import { ParsedExpression } from './duckdb-serialization-types/serialization/ParsedExpression';
+export declare const isSelectNode: (node: QueryNode) => node is SelectNode;
+export declare const isBetweenExpression: (node: ParsedExpression) => node is BetweenExpression;
+export declare const isCaseExpression: (node: ParsedExpression) => node is CaseExpression;
+export declare const isCastExpression: (node: ParsedExpression) => node is CastExpression;
+export declare const isComparisonExpression: (node: ParsedExpression) => node is ComparisonExpression;
+export declare const isConjunctionExpression: (node: ParsedExpression) => node is ConjunctionExpression;
+export declare const isConstantExpression: (node: ParsedExpression) => node is ConstantExpression;
+export declare const isColumnRefExpression: (node: ParsedExpression) => node is ColumnRefExpression;
+export declare const isCollateExpression: (node: ParsedExpression) => node is CollateExpression;
+export declare const isFunctionExpression: (node: ParsedExpression) => node is FunctionExpression;
+export declare const isLambdaExpression: (node: ParsedExpression) => node is LambdaExpression;
+export declare const isOperatorExpression: (node: ParsedExpression) => node is OperatorExpression;
+export declare const isParameterExpression: (node: ParsedExpression) => node is ParameterExpression;
+export declare const isPositionalReferenceExpression: (node: ParsedExpression) => node is PositionalReferenceExpression;
+export declare const isSubqueryExpression: (node: ParsedExpression) => node is SubqueryExpression;
+export declare const isWindowExpression: (node: ParsedExpression) => node is WindowExpression;

package/src/types/utils.js

@@ -0,0 +1,108 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isSelectNode: function() {
+        return isSelectNode;
+    },
+    isBetweenExpression: function() {
+        return isBetweenExpression;
+    },
+    isCaseExpression: function() {
+        return isCaseExpression;
+    },
+    isCastExpression: function() {
+        return isCastExpression;
+    },
+    isComparisonExpression: function() {
+        return isComparisonExpression;
+    },
+    isConjunctionExpression: function() {
+        return isConjunctionExpression;
+    },
+    isConstantExpression: function() {
+        return isConstantExpression;
+    },
+    isColumnRefExpression: function() {
+        return isColumnRefExpression;
+    },
+    isCollateExpression: function() {
+        return isCollateExpression;
+    },
+    isFunctionExpression: function() {
+        return isFunctionExpression;
+    },
+    isLambdaExpression: function() {
+        return isLambdaExpression;
+    },
+    isOperatorExpression: function() {
+        return isOperatorExpression;
+    },
+    isParameterExpression: function() {
+        return isParameterExpression;
+    },
+    isPositionalReferenceExpression: function() {
+        return isPositionalReferenceExpression;
+    },
+    isSubqueryExpression: function() {
+        return isSubqueryExpression;
+    },
+    isWindowExpression: function() {
+        return isWindowExpression;
+    }
+});
+const _duckdbserializationtypes = require("./duckdb-serialization-types");
+const isSelectNode = (node)=>{
+    return node.type === _duckdbserializationtypes.QueryNodeType.SELECT_NODE;
+};
+const isBetweenExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.BETWEEN;
+};
+const isCaseExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.CASE;
+};
+const isCastExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.CAST;
+};
+const isComparisonExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.COMPARISON;
+};
+const isConjunctionExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.CONJUNCTION;
+};
+const isConstantExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.CONSTANT;
+};
+const isColumnRefExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.COLUMN_REF;
+};
+const isCollateExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.COLLATE;
+};
+const isFunctionExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.FUNCTION;
+};
+const isLambdaExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.LAMBDA;
+};
+const isOperatorExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.OPERATOR;
+};
+const isParameterExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.PARAMETER;
+};
+const isPositionalReferenceExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.POSITIONAL_REFERENCE;
+};
+const isSubqueryExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.SUBQUERY;
+};
+const isWindowExpression = (node)=>{
+    return node.class === _duckdbserializationtypes.ExpressionClass.WINDOW;
+};
+
+//# sourceMappingURL=utils.js.map

package/src/types/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/types/utils.ts"],"sourcesContent":["import {\n  BetweenExpression,\n  CaseExpression,\n  CastExpression,\n  CollateExpression,\n  ColumnRefExpression,\n  ComparisonExpression,\n  ConjunctionExpression,\n  ConstantExpression,\n  FunctionExpression,\n  LambdaExpression,\n  OperatorExpression,\n  ParameterExpression,\n  PositionalReferenceExpression,\n  SubqueryExpression,\n  WindowExpression,\n} from './duckdb-serialization-types/serialization/ParsedExpression';\n\nimport {\n  ExpressionClass,\n  QueryNode,\n  QueryNodeType,\n  SelectNode,\n} from './duckdb-serialization-types';\nimport { ParsedExpression } from './duckdb-serialization-types/serialization/ParsedExpression';\n\nexport const isSelectNode = (node: QueryNode): node is SelectNode => {\n  return node.type === QueryNodeType.SELECT_NODE;\n};\n\nexport const isBetweenExpression = (\n  node: ParsedExpression\n): node is BetweenExpression => {\n  return node.class === ExpressionClass.BETWEEN;\n};\n\nexport const isCaseExpression = (\n  node: ParsedExpression\n): node is CaseExpression => {\n  return node.class === ExpressionClass.CASE;\n};\n\nexport const isCastExpression = (\n  node: ParsedExpression\n): node is CastExpression => {\n  return node.class === ExpressionClass.CAST;\n};\n\nexport const isComparisonExpression = (\n  node: ParsedExpression\n): node is ComparisonExpression => {\n  return node.class === ExpressionClass.COMPARISON;\n};\n\nexport const isConjunctionExpression = (\n  node: ParsedExpression\n): node is ConjunctionExpression => {\n  return node.class === ExpressionClass.CONJUNCTION;\n};\n\nexport const isConstantExpression = (\n  node: ParsedExpression\n): node is ConstantExpression => {\n  return node.class === ExpressionClass.CONSTANT;\n};\n\nexport const isColumnRefExpression = (\n  node: ParsedExpression\n): node is ColumnRefExpression => {\n  return node.class === ExpressionClass.COLUMN_REF;\n};\n\nexport const isCollateExpression = (\n  node: ParsedExpression\n): node is CollateExpression => {\n  return node.class === ExpressionClass.COLLATE;\n};\n\nexport const isFunctionExpression = (\n  node: ParsedExpression\n): node is FunctionExpression => {\n  return node.class === ExpressionClass.FUNCTION;\n};\n\nexport const isLambdaExpression = (\n  node: ParsedExpression\n): node is LambdaExpression => {\n  return node.class === ExpressionClass.LAMBDA;\n};\n\nexport const isOperatorExpression = (\n  node: ParsedExpression\n): node is OperatorExpression => {\n  return node.class === ExpressionClass.OPERATOR;\n};\n\nexport const isParameterExpression = (\n  node: ParsedExpression\n): node is ParameterExpression => {\n  return node.class === ExpressionClass.PARAMETER;\n};\n\nexport const isPositionalReferenceExpression = (\n  node: ParsedExpression\n): node is PositionalReferenceExpression => {\n  return node.class === ExpressionClass.POSITIONAL_REFERENCE;\n};\n\nexport const isSubqueryExpression = (\n  node: ParsedExpression\n): node is SubqueryExpression => {\n  return node.class === ExpressionClass.SUBQUERY;\n};\n\nexport const isWindowExpression = (\n  node: ParsedExpression\n): node is WindowExpression => {\n  return node.class === ExpressionClass.WINDOW;\n};\n"],"names":["isSelectNode","isBetweenExpression","isCaseExpression","isCastExpression","isComparisonExpression","isConjunctionExpression","isConstantExpression","isColumnRefExpression","isCollateExpression","isFunctionExpression","isLambdaExpression","isOperatorExpression","isParameterExpression","isPositionalReferenceExpression","isSubqueryExpression","isWindowExpression","node","type","QueryNodeType","SELECT_NODE","class","ExpressionClass","BETWEEN","CASE","CAST","COMPARISON","CONJUNCTION","CONSTANT","COLUMN_REF","COLLATE","FUNCTION","LAMBDA","OPERATOR","PARAMETER","POSITIONAL_REFERENCE","SUBQUERY","WINDOW"],"mappings":";;;;;;;;IA0BaA,YAAY;eAAZA;;IAIAC,mBAAmB;eAAnBA;;IAMAC,gBAAgB;eAAhBA;;IAMAC,gBAAgB;eAAhBA;;IAMAC,sBAAsB;eAAtBA;;IAMAC,uBAAuB;eAAvBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,qBAAqB;eAArBA;;IAMAC,mBAAmB;eAAnBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,kBAAkB;eAAlBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,qBAAqB;eAArBA;;IAMAC,+BAA+B;eAA/BA;;IAMAC,oBAAoB;eAApBA;;IAMAC,kBAAkB;eAAlBA;;;0CA3FN;AAGA,MAAMf,eAAe,CAACgB;IAC3B,OAAOA,KAAKC,IAAI,KAAKC,uCAAa,CAACC,WAAW;AAChD;AAEO,MAAMlB,sBAAsB,CACjCe;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACC,OAAO;AAC/C;AAEO,MAAMpB,mBAAmB,CAC9Bc;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACE,IAAI;AAC5C;AAEO,MAAMpB,mBAAmB,CAC9Ba;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACG,IAAI;AAC5C;AAEO,MAAMpB,yBAAyB,CACpCY;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACI,UAAU;AAClD;AAEO,MAAMpB,0BAA0B,CACrCW;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACK,WAAW;AACnD;AAEO,MAAMpB,uBAAuB,CAClCU;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACM,QAAQ;AAChD;AAEO,MAAMpB,wBAAwB,CACnCS;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACO,UAAU;AAClD;AAEO,MAAMpB,sBAAsB,CACjCQ;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACQ,OAAO;AAC/C;AAEO,MAAMpB,uBAAuB,CAClCO;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACS,QAAQ;AAChD;AAEO,MAAMpB,qBAAqB,CAChCM;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACU,MAAM;AAC9C;AAEO,MAAMpB,uBAAuB,CAClCK;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACW,QAAQ;AAChD;AAEO,MAAMpB,wBAAwB,CACnCI;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACY,SAAS;AACjD;AAEO,MAAMpB,kCAAkC,CAC7CG;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACa,oBAAoB;AAC5D;AAEO,MAAMpB,uBAAuB,CAClCE;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACc,QAAQ;AAChD;AAEO,MAAMpB,qBAAqB,CAChCC;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACe,MAAM;AAC9C"}

package/src/utils/base-ast.js

@@ -13,8 +13,8 @@ _export(exports, {
         return getBaseAST;
     }
 });
-const _QueryNode = require("../types/duckdb-serialization-types/serialization/QueryNode");
 const _Expression = require("../types/duckdb-serialization-types/serialization/Expression");
+const _QueryNode = require("../types/duckdb-serialization-types/serialization/QueryNode");
 const _TableRef = require("../types/duckdb-serialization-types/serialization/TableRef");
 const BASE_TABLE_NAME = 'REPLACE_BASE_TABLE';
 const getBaseAST = ()=>{
@@ -35,8 +35,7 @@ const getBaseAST = ()=>{
                     relation_name: '',
                     exclude_list: [],
                     replace_list: [],
-                    columns: false,
-                    expr: null
+                    columns: false
                 }
             ],
             from_table: {

package/src/utils/base-ast.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../meerkat-core/src/utils/base-ast.ts"],"sourcesContent":["import { AggregateHandling, QueryNodeType } from '../types/duckdb-serialization-types/serialization/QueryNode';\nimport { ExpressionClass, ExpressionType } from '../types/duckdb-serialization-types/serialization/Expression';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\nimport { TableReferenceType } from '../types/duckdb-serialization-types/serialization/TableRef';\n\nexport const BASE_TABLE_NAME = 'REPLACE_BASE_TABLE';\n\nexport const getBaseAST = (): SelectStatement => {\n  return {\n    node: {\n      type: QueryNodeType.SELECT_NODE,\n      modifiers: [],\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      //@ts-ignore\n      cte_map: { map: [] },\n      select_list: [\n        {\n          class: ExpressionClass.STAR,\n          type: ExpressionType.STAR,\n          alias: '',\n          relation_name: '',\n          exclude_list: [],\n          replace_list: [],\n          columns: false,\n          expr: null,\n        },\n      ],\n      from_table: {\n        type: TableReferenceType.BASE_TABLE,\n        alias: '',\n        sample: null,\n        schema_name: '',\n        table_name: BASE_TABLE_NAME,\n        column_name_alias: [],\n        catalog_name: '',\n      },\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      //@ts-ignore\n      where_clause: null,\n      group_expressions: [],\n      group_sets: [],\n      aggregate_handling: AggregateHandling.STANDARD_HANDLING,\n      having: null,\n      sample: null,\n      qualify: null,\n    },\n  };\n};\n"],"names":["BASE_TABLE_NAME","getBaseAST","node","type","QueryNodeType","SELECT_NODE","modifiers","cte_map","map","select_list","class","ExpressionClass","STAR","ExpressionType","alias","relation_name","exclude_list","replace_list","columns","expr","from_table","TableReferenceType","BASE_TABLE","sample","schema_name","table_name","column_name_alias","catalog_name","where_clause","group_expressions","group_sets","aggregate_handling","AggregateHandling","STANDARD_HANDLING","having","qualify"],"mappings":";;;;;;;;IAKaA,eAAe;eAAfA;;IAEAC,UAAU;eAAVA;;;2BAPoC;4BACD;0BAEb;AAE5B,MAAMD,kBAAkB;AAExB,MAAMC,aAAa;IACxB,OAAO;QACLC,MAAM;YACJC,MAAMC,wBAAa,CAACC,WAAW;YAC/BC,WAAW,EAAE;YACb,6DAA6D;YAC7D,YAAY;YACZC,SAAS;gBAAEC,KAAK,EAAE;YAAC;YACnBC,aAAa;gBACX;oBACEC,OAAOC,2BAAe,CAACC,IAAI;oBAC3BT,MAAMU,0BAAc,CAACD,IAAI;oBACzBE,OAAO;oBACPC,eAAe;oBACfC,cAAc,EAAE;oBAChBC,cAAc,EAAE;oBAChBC,SAAS;oBACTC,MAAM;gBACR;aACD;YACDC,YAAY;gBACVjB,MAAMkB,4BAAkB,CAACC,UAAU;gBACnCR,OAAO;gBACPS,QAAQ;gBACRC,aAAa;gBACbC,YAAYzB;gBACZ0B,mBAAmB,EAAE;gBACrBC,cAAc;YAChB;YACA,6DAA6D;YAC7D,YAAY;YACZC,cAAc;YACdC,mBAAmB,EAAE;YACrBC,YAAY,EAAE;YACdC,oBAAoBC,4BAAiB,CAACC,iBAAiB;YACvDC,QAAQ;YACRX,QAAQ;YACRY,SAAS;QACX;IACF;AACF"}
+{"version":3,"sources":["../../../../meerkat-core/src/utils/base-ast.ts"],"sourcesContent":["import {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\nimport {\n  AggregateHandling,\n  QueryNodeType,\n} from '../types/duckdb-serialization-types/serialization/QueryNode';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\nimport { TableReferenceType } from '../types/duckdb-serialization-types/serialization/TableRef';\n\nexport const BASE_TABLE_NAME = 'REPLACE_BASE_TABLE';\n\nexport const getBaseAST = (): SelectStatement => {\n  return {\n    node: {\n      type: QueryNodeType.SELECT_NODE,\n      modifiers: [],\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      //@ts-ignore\n      cte_map: { map: [] },\n      select_list: [\n        {\n          class: ExpressionClass.STAR,\n          type: ExpressionType.STAR,\n          alias: '',\n          relation_name: '',\n          exclude_list: [],\n          replace_list: [],\n          columns: false,\n        },\n      ],\n      from_table: {\n        type: TableReferenceType.BASE_TABLE,\n        alias: '',\n        sample: null,\n        schema_name: '',\n        table_name: BASE_TABLE_NAME,\n        column_name_alias: [],\n        catalog_name: '',\n      },\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      //@ts-ignore\n      where_clause: null,\n      group_expressions: [],\n      group_sets: [],\n      aggregate_handling: AggregateHandling.STANDARD_HANDLING,\n      having: null,\n      sample: null,\n      qualify: null,\n    },\n  };\n};\n"],"names":["BASE_TABLE_NAME","getBaseAST","node","type","QueryNodeType","SELECT_NODE","modifiers","cte_map","map","select_list","class","ExpressionClass","STAR","ExpressionType","alias","relation_name","exclude_list","replace_list","columns","from_table","TableReferenceType","BASE_TABLE","sample","schema_name","table_name","column_name_alias","catalog_name","where_clause","group_expressions","group_sets","aggregate_handling","AggregateHandling","STANDARD_HANDLING","having","qualify"],"mappings":";;;;;;;;IAWaA,eAAe;eAAfA;;IAEAC,UAAU;eAAVA;;;4BAVN;2BAIA;0BAE4B;AAE5B,MAAMD,kBAAkB;AAExB,MAAMC,aAAa;IACxB,OAAO;QACLC,MAAM;YACJC,MAAMC,wBAAa,CAACC,WAAW;YAC/BC,WAAW,EAAE;YACb,6DAA6D;YAC7D,YAAY;YACZC,SAAS;gBAAEC,KAAK,EAAE;YAAC;YACnBC,aAAa;gBACX;oBACEC,OAAOC,2BAAe,CAACC,IAAI;oBAC3BT,MAAMU,0BAAc,CAACD,IAAI;oBACzBE,OAAO;oBACPC,eAAe;oBACfC,cAAc,EAAE;oBAChBC,cAAc,EAAE;oBAChBC,SAAS;gBACX;aACD;YACDC,YAAY;gBACVhB,MAAMiB,4BAAkB,CAACC,UAAU;gBACnCP,OAAO;gBACPQ,QAAQ;gBACRC,aAAa;gBACbC,YAAYxB;gBACZyB,mBAAmB,EAAE;gBACrBC,cAAc;YAChB;YACA,6DAA6D;YAC7D,YAAY;YACZC,cAAc;YACdC,mBAAmB,EAAE;YACrBC,YAAY,EAAE;YACdC,oBAAoBC,4BAAiB,CAACC,iBAAiB;YACvDC,QAAQ;YACRX,QAAQ;YACRY,SAAS;QACX;IACF;AACF"}