@devrev/meerkat-core 0.0.84 → 0.0.85

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"}