@devrev/meerkat-core 0.0.84 → 0.0.86

package/src/cube-filter-transformer/not-contains/not-contains.js

@@ -15,6 +15,7 @@ _export(exports, {
 });
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
 const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _constant = require("../constant");
 const _or = require("../or/or");
 const notContainsDuckdbCondition = (columnName, value, memberInfo)=>{
     return {
@@ -28,7 +29,7 @@ const notContainsDuckdbCondition = (columnName, value, memberInfo)=>{
                 class: 'COLUMN_REF',
                 type: 'COLUMN_REF',
                 alias: '',
-                column_names: columnName.split('.')
+                column_names: columnName.split(_constant.COLUMN_NAME_DELIMITER)
             },
             {
                 class: 'CONSTANT',

package/src/cube-filter-transformer/not-contains/not-contains.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-contains/not-contains.ts"],"sourcesContent":["import { Dimension, Measure } from '../../types/cube-types/table';\nimport { Member, QueryFilter } from '../../types/cube-types/query';\nimport { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport interface NotContainsFilters extends QueryFilter {\n  member: Member;\n  operator: 'notContains';\n  values: string[];\n}\n\nexport const notContainsDuckdbCondition = (\n  columnName: string,\n  value: string,\n  memberInfo: Measure | Dimension\n) => {\n  return {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: '!~~',\n    schema: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: columnName.split('.'),\n      },\n      {\n        class: 'CONSTANT',\n        type: 'VALUE_CONSTANT',\n        alias: '',\n        value: valueBuilder(`%${value}%`, memberInfo),\n      },\n    ],\n    filter: null,\n    order_bys: {\n      type: 'ORDER_MODIFIER',\n      orders: [],\n    },\n    distinct: false,\n    is_operator: true,\n    export_state: false,\n    catalog: '',\n  };\n};\n\nexport const notContainsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Contains filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple Contains condition\n   */\n  if (values.length === 1) {\n    return notContainsDuckdbCondition(member, values[0], memberInfo);\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      notContainsDuckdbCondition(member, value, memberInfo)\n    );\n  });\n  return orCondition;\n};\n"],"names":["notContainsDuckdbCondition","notContainsTransform","columnName","value","memberInfo","class","ExpressionClass","FUNCTION","type","ExpressionType","alias","function_name","schema","children","column_names","split","valueBuilder","filter","order_bys","orders","distinct","is_operator","export_state","catalog","query","member","values","length","Error","orCondition","orDuckdbCondition","forEach","push"],"mappings":";;;;;;;;IAaaA,0BAA0B;eAA1BA;;IAqCAC,oBAAoB;eAApBA;;;4BAhDmC;sCACnB;oBAEK;AAQ3B,MAAMD,6BAA6B,CACxCE,YACAC,OACAC;IAEA,OAAO;QACLC,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACF,QAAQ;QAC7BG,OAAO;QACPC,eAAe;QACfC,QAAQ;QACRC,UAAU;YACR;gBACER,OAAO;gBACPG,MAAM;gBACNE,OAAO;gBACPI,cAAcZ,WAAWa,KAAK,CAAC;YACjC;YACA;gBACEV,OAAO;gBACPG,MAAM;gBACNE,OAAO;gBACPP,OAAOa,IAAAA,kCAAY,EAAC,CAAC,CAAC,EAAEb,MAAM,CAAC,CAAC,EAAEC;YACpC;SACD;QACDa,QAAQ;QACRC,WAAW;YACTV,MAAM;YACNW,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;AACF;AAEO,MAAMtB,uBAAuD,CAACuB;IACnE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEtB,UAAU,EAAE,GAAGoB;IAEvC,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAO3B,2BAA2ByB,QAAQC,MAAM,CAAC,EAAE,EAAEtB;IACvD;IAEA;;GAEC,GACD,MAAMyB,cAAcC,IAAAA,qBAAiB;IACrCJ,OAAOK,OAAO,CAAC,CAAC5B;QACd0B,YAAYhB,QAAQ,CAACmB,IAAI,CACvBhC,2BAA2ByB,QAAQtB,OAAOC;IAE9C;IACA,OAAOyB;AACT"}
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-contains/not-contains.ts"],"sourcesContent":["import { Member, QueryFilter } from '../../types/cube-types/query';\nimport { Dimension, Measure } from '../../types/cube-types/table';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { COLUMN_NAME_DELIMITER } from '../constant';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport interface NotContainsFilters extends QueryFilter {\n  member: Member;\n  operator: 'notContains';\n  values: string[];\n}\n\nexport const notContainsDuckdbCondition = (\n  columnName: string,\n  value: string,\n  memberInfo: Measure | Dimension\n) => {\n  return {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: '!~~',\n    schema: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: columnName.split(COLUMN_NAME_DELIMITER),\n      },\n      {\n        class: 'CONSTANT',\n        type: 'VALUE_CONSTANT',\n        alias: '',\n        value: valueBuilder(`%${value}%`, memberInfo),\n      },\n    ],\n    filter: null,\n    order_bys: {\n      type: 'ORDER_MODIFIER',\n      orders: [],\n    },\n    distinct: false,\n    is_operator: true,\n    export_state: false,\n    catalog: '',\n  };\n};\n\nexport const notContainsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Contains filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple Contains condition\n   */\n  if (values.length === 1) {\n    return notContainsDuckdbCondition(member, values[0], memberInfo);\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      notContainsDuckdbCondition(member, value, memberInfo)\n    );\n  });\n  return orCondition;\n};\n"],"names":["notContainsDuckdbCondition","notContainsTransform","columnName","value","memberInfo","class","ExpressionClass","FUNCTION","type","ExpressionType","alias","function_name","schema","children","column_names","split","COLUMN_NAME_DELIMITER","valueBuilder","filter","order_bys","orders","distinct","is_operator","export_state","catalog","query","member","values","length","Error","orCondition","orDuckdbCondition","forEach","push"],"mappings":";;;;;;;;IAiBaA,0BAA0B;eAA1BA;;IAqCAC,oBAAoB;eAApBA;;;4BAjDN;sCACsB;0BACS;oBAEJ;AAQ3B,MAAMD,6BAA6B,CACxCE,YACAC,OACAC;IAEA,OAAO;QACLC,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACF,QAAQ;QAC7BG,OAAO;QACPC,eAAe;QACfC,QAAQ;QACRC,UAAU;YACR;gBACER,OAAO;gBACPG,MAAM;gBACNE,OAAO;gBACPI,cAAcZ,WAAWa,KAAK,CAACC,+BAAqB;YACtD;YACA;gBACEX,OAAO;gBACPG,MAAM;gBACNE,OAAO;gBACPP,OAAOc,IAAAA,kCAAY,EAAC,CAAC,CAAC,EAAEd,MAAM,CAAC,CAAC,EAAEC;YACpC;SACD;QACDc,QAAQ;QACRC,WAAW;YACTX,MAAM;YACNY,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;AACF;AAEO,MAAMvB,uBAAuD,CAACwB;IACnE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEvB,UAAU,EAAE,GAAGqB;IAEvC,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAO5B,2BAA2B0B,QAAQC,MAAM,CAAC,EAAE,EAAEvB;IACvD;IAEA;;GAEC,GACD,MAAM0B,cAAcC,IAAAA,qBAAiB;IACrCJ,OAAOK,OAAO,CAAC,CAAC7B;QACd2B,YAAYjB,QAAQ,CAACoB,IAAI,CACvBjC,2BAA2B0B,QAAQvB,OAAOC;IAE9C;IACA,OAAO0B;AACT"}

package/src/cube-filter-transformer/not-in/not-in.d.ts

@@ -1,2 +1,2 @@
-import { CubeToParseExpressionTransform } from "../factory";
+import { CubeToParseExpressionTransform } from '../factory';
 export declare const notInTransform: CubeToParseExpressionTransform;

package/src/cube-filter-transformer/not-in/not-in.js

@@ -7,20 +7,21 @@ Object.defineProperty(exports, "notInTransform", {
 });
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
 const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _constant = require("../constant");
 const notInDuckDbCondition = (columnName, values, memberInfo)=>{
     const sqlTreeValues = values.map((value)=>{
         return {
             class: _Expression.ExpressionClass.CONSTANT,
             type: _Expression.ExpressionType.VALUE_CONSTANT,
-            alias: "",
+            alias: '',
             value: (0, _baseconditionbuilder.valueBuilder)(value, memberInfo)
         };
     });
     const columnRef = {
-        class: "COLUMN_REF",
-        type: "COLUMN_REF",
-        alias: "",
-        column_names: columnName.split('.')
+        class: 'COLUMN_REF',
+        type: 'COLUMN_REF',
+        alias: '',
+        column_names: columnName.split(_constant.COLUMN_NAME_DELIMITER)
     };
     switch(memberInfo.type){
         case 'number_array':
@@ -29,32 +30,32 @@ const notInDuckDbCondition = (columnName, values, memberInfo)=>{
                 return {
                     class: _Expression.ExpressionClass.OPERATOR,
                     type: _Expression.ExpressionType.OPERATOR_NOT,
-                    alias: "",
+                    alias: '',
                     children: [
                         {
-                            "class": _Expression.ExpressionClass.FUNCTION,
-                            "type": _Expression.ExpressionType.FUNCTION,
-                            "alias": "",
-                            "function_name": "&&",
-                            "schema": "",
-                            "children": [
+                            class: _Expression.ExpressionClass.FUNCTION,
+                            type: _Expression.ExpressionType.FUNCTION,
+                            alias: '',
+                            function_name: '&&',
+                            schema: '',
+                            children: [
                                 columnRef,
                                 {
                                     class: _Expression.ExpressionClass.OPERATOR,
                                     type: _Expression.ExpressionType.ARRAY_CONSTRUCTOR,
-                                    alias: "",
+                                    alias: '',
                                     children: sqlTreeValues
                                 }
                             ],
-                            "filter": null,
-                            "order_bys": {
-                                "type": "ORDER_MODIFIER",
-                                "orders": []
+                            filter: null,
+                            order_bys: {
+                                type: 'ORDER_MODIFIER',
+                                orders: []
                             },
-                            "distinct": false,
-                            "is_operator": true,
-                            "export_state": false,
-                            "catalog": ""
+                            distinct: false,
+                            is_operator: true,
+                            export_state: false,
+                            catalog: ''
                         }
                     ]
                 };
@@ -64,7 +65,7 @@ const notInDuckDbCondition = (columnName, values, memberInfo)=>{
                 return {
                     class: _Expression.ExpressionClass.OPERATOR,
                     type: _Expression.ExpressionType.COMPARE_NOT_IN,
-                    alias: "",
+                    alias: '',
                     children: [
                         columnRef,
                         ...sqlTreeValues

package/src/cube-filter-transformer/not-in/not-in.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-in/not-in.ts"],"sourcesContent":["import { Dimension, Measure } from '../../types/cube-types/table';\nimport { CubeToParseExpressionTransform } from \"../factory\";\n\n\nimport {\n    ExpressionClass,\n    ExpressionType\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from \"../base-condition-builder/base-condition-builder\";\n\n\nconst notInDuckDbCondition = (\n    columnName: string,\n    values: string[],\n    memberInfo: Measure | Dimension\n) => {\n    const sqlTreeValues = values.map((value) => {\n        return {\n            class: ExpressionClass.CONSTANT,\n            type: ExpressionType.VALUE_CONSTANT,\n            alias: \"\",\n            value: valueBuilder(value, memberInfo)\n        }\n    })\n    const columnRef = {\n        class: \"COLUMN_REF\",\n        type: \"COLUMN_REF\",\n        alias: \"\",\n        column_names: columnName.split('.')\n    }\n    switch (memberInfo.type) {\n        case 'number_array':\n        case 'string_array': {\n            return {\n                class: ExpressionClass.OPERATOR,\n                type: ExpressionType.OPERATOR_NOT,\n                alias: \"\",\n                children: [{\n                    \"class\": ExpressionClass.FUNCTION,\n                    \"type\": ExpressionType.FUNCTION,\n                    \"alias\": \"\",\n                    \"function_name\": \"&&\",\n                    \"schema\": \"\",\n                    \"children\": [\n                        columnRef,\n                        {\n                            class: ExpressionClass.OPERATOR,\n                            type: ExpressionType.ARRAY_CONSTRUCTOR,\n                            alias: \"\",\n                            children: sqlTreeValues,\n                        }\n                    ],\n                    \"filter\": null,\n                    \"order_bys\": {\n                        \"type\": \"ORDER_MODIFIER\",\n                        \"orders\": []\n                    },\n                    \"distinct\": false,\n                    \"is_operator\": true,\n                    \"export_state\": false,\n                    \"catalog\": \"\"\n                }]\n            }\n        }\n        default: {\n            return {\n                class: ExpressionClass.OPERATOR,\n                type: ExpressionType.COMPARE_NOT_IN,\n                alias: \"\",\n                children: [\n                    columnRef,\n                    ...sqlTreeValues\n                ]\n            }\n        }\n    }\n   \n}\n\n\nexport const notInTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  if (!values) {\n    throw new Error('Not in filter must have at least one value');\n  }\n\n  return notInDuckDbCondition(member, values, memberInfo);\n}\n"],"names":["notInTransform","notInDuckDbCondition","columnName","values","memberInfo","sqlTreeValues","map","value","class","ExpressionClass","CONSTANT","type","ExpressionType","VALUE_CONSTANT","alias","valueBuilder","columnRef","column_names","split","OPERATOR","OPERATOR_NOT","children","FUNCTION","ARRAY_CONSTRUCTOR","COMPARE_NOT_IN","query","member","Error"],"mappings":";+BAgFaA;;;eAAAA;;;4BAzEN;sCACsB;AAG7B,MAAMC,uBAAuB,CACzBC,YACAC,QACAC;IAEA,MAAMC,gBAAgBF,OAAOG,GAAG,CAAC,CAACC;QAC9B,OAAO;YACHC,OAAOC,2BAAe,CAACC,QAAQ;YAC/BC,MAAMC,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPP,OAAOQ,IAAAA,kCAAY,EAACR,OAAOH;QAC/B;IACJ;IACA,MAAMY,YAAY;QACdR,OAAO;QACPG,MAAM;QACNG,OAAO;QACPG,cAAcf,WAAWgB,KAAK,CAAC;IACnC;IACA,OAAQd,WAAWO,IAAI;QACnB,KAAK;QACL,KAAK;YAAgB;gBACjB,OAAO;oBACHH,OAAOC,2BAAe,CAACU,QAAQ;oBAC/BR,MAAMC,0BAAc,CAACQ,YAAY;oBACjCN,OAAO;oBACPO,UAAU;wBAAC;4BACP,SAASZ,2BAAe,CAACa,QAAQ;4BACjC,QAAQV,0BAAc,CAACU,QAAQ;4BAC/B,SAAS;4BACT,iBAAiB;4BACjB,UAAU;4BACV,YAAY;gCACRN;gCACA;oCACIR,OAAOC,2BAAe,CAACU,QAAQ;oCAC/BR,MAAMC,0BAAc,CAACW,iBAAiB;oCACtCT,OAAO;oCACPO,UAAUhB;gCACd;6BACH;4BACD,UAAU;4BACV,aAAa;gCACT,QAAQ;gCACR,UAAU,EAAE;4BAChB;4BACA,YAAY;4BACZ,eAAe;4BACf,gBAAgB;4BAChB,WAAW;wBACf;qBAAE;gBACN;YACJ;QACA;YAAS;gBACL,OAAO;oBACHG,OAAOC,2BAAe,CAACU,QAAQ;oBAC/BR,MAAMC,0BAAc,CAACY,cAAc;oBACnCV,OAAO;oBACPO,UAAU;wBACNL;2BACGX;qBACN;gBACL;YACJ;IACJ;AAEJ;AAGO,MAAML,iBAAiD,CAACyB;IAC7D,MAAM,EAAEC,MAAM,EAAEvB,MAAM,EAAEC,UAAU,EAAE,GAAGqB;IACvC,IAAI,CAACtB,QAAQ;QACX,MAAM,IAAIwB,MAAM;IAClB;IAEA,OAAO1B,qBAAqByB,QAAQvB,QAAQC;AAC9C"}
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-in/not-in.ts"],"sourcesContent":["import { Dimension, Measure } from '../../types/cube-types/table';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { COLUMN_NAME_DELIMITER } from '../constant';\n\nconst notInDuckDbCondition = (\n  columnName: string,\n  values: string[],\n  memberInfo: Measure | Dimension\n) => {\n  const sqlTreeValues = values.map((value) => {\n    return {\n      class: ExpressionClass.CONSTANT,\n      type: ExpressionType.VALUE_CONSTANT,\n      alias: '',\n      value: valueBuilder(value, memberInfo),\n    };\n  });\n  const columnRef = {\n    class: 'COLUMN_REF',\n    type: 'COLUMN_REF',\n    alias: '',\n    column_names: columnName.split(COLUMN_NAME_DELIMITER),\n  };\n  switch (memberInfo.type) {\n    case 'number_array':\n    case 'string_array': {\n      return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.OPERATOR_NOT,\n        alias: '',\n        children: [\n          {\n            class: ExpressionClass.FUNCTION,\n            type: ExpressionType.FUNCTION,\n            alias: '',\n            function_name: '&&',\n            schema: '',\n            children: [\n              columnRef,\n              {\n                class: ExpressionClass.OPERATOR,\n                type: ExpressionType.ARRAY_CONSTRUCTOR,\n                alias: '',\n                children: sqlTreeValues,\n              },\n            ],\n            filter: null,\n            order_bys: {\n              type: 'ORDER_MODIFIER',\n              orders: [],\n            },\n            distinct: false,\n            is_operator: true,\n            export_state: false,\n            catalog: '',\n          },\n        ],\n      };\n    }\n    default: {\n      return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.COMPARE_NOT_IN,\n        alias: '',\n        children: [columnRef, ...sqlTreeValues],\n      };\n    }\n  }\n};\n\nexport const notInTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  if (!values) {\n    throw new Error('Not in filter must have at least one value');\n  }\n\n  return notInDuckDbCondition(member, values, memberInfo);\n};\n"],"names":["notInTransform","notInDuckDbCondition","columnName","values","memberInfo","sqlTreeValues","map","value","class","ExpressionClass","CONSTANT","type","ExpressionType","VALUE_CONSTANT","alias","valueBuilder","columnRef","column_names","split","COLUMN_NAME_DELIMITER","OPERATOR","OPERATOR_NOT","children","FUNCTION","function_name","schema","ARRAY_CONSTRUCTOR","filter","order_bys","orders","distinct","is_operator","export_state","catalog","COMPARE_NOT_IN","query","member","Error"],"mappings":";+BA4EaA;;;eAAAA;;;4BAtEN;sCACsB;0BACS;AAEtC,MAAMC,uBAAuB,CAC3BC,YACAC,QACAC;IAEA,MAAMC,gBAAgBF,OAAOG,GAAG,CAAC,CAACC;QAChC,OAAO;YACLC,OAAOC,2BAAe,CAACC,QAAQ;YAC/BC,MAAMC,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPP,OAAOQ,IAAAA,kCAAY,EAACR,OAAOH;QAC7B;IACF;IACA,MAAMY,YAAY;QAChBR,OAAO;QACPG,MAAM;QACNG,OAAO;QACPG,cAAcf,WAAWgB,KAAK,CAACC,+BAAqB;IACtD;IACA,OAAQf,WAAWO,IAAI;QACrB,KAAK;QACL,KAAK;YAAgB;gBACnB,OAAO;oBACLH,OAAOC,2BAAe,CAACW,QAAQ;oBAC/BT,MAAMC,0BAAc,CAACS,YAAY;oBACjCP,OAAO;oBACPQ,UAAU;wBACR;4BACEd,OAAOC,2BAAe,CAACc,QAAQ;4BAC/BZ,MAAMC,0BAAc,CAACW,QAAQ;4BAC7BT,OAAO;4BACPU,eAAe;4BACfC,QAAQ;4BACRH,UAAU;gCACRN;gCACA;oCACER,OAAOC,2BAAe,CAACW,QAAQ;oCAC/BT,MAAMC,0BAAc,CAACc,iBAAiB;oCACtCZ,OAAO;oCACPQ,UAAUjB;gCACZ;6BACD;4BACDsB,QAAQ;4BACRC,WAAW;gCACTjB,MAAM;gCACNkB,QAAQ,EAAE;4BACZ;4BACAC,UAAU;4BACVC,aAAa;4BACbC,cAAc;4BACdC,SAAS;wBACX;qBACD;gBACH;YACF;QACA;YAAS;gBACP,OAAO;oBACLzB,OAAOC,2BAAe,CAACW,QAAQ;oBAC/BT,MAAMC,0BAAc,CAACsB,cAAc;oBACnCpB,OAAO;oBACPQ,UAAU;wBAACN;2BAAcX;qBAAc;gBACzC;YACF;IACF;AACF;AAEO,MAAML,iBAAiD,CAACmC;IAC7D,MAAM,EAAEC,MAAM,EAAEjC,MAAM,EAAEC,UAAU,EAAE,GAAG+B;IACvC,IAAI,CAAChC,QAAQ;QACX,MAAM,IAAIkC,MAAM;IAClB;IAEA,OAAOpC,qBAAqBmC,QAAQjC,QAAQC;AAC9C"}

package/src/cube-filter-transformer/not-set/not-set.d.ts

@@ -1,2 +1,2 @@
-import { CubeToParseExpressionTransform } from "../factory";
+import { CubeToParseExpressionTransform } from '../factory';
 export declare const notSetTransform: CubeToParseExpressionTransform;

package/src/cube-filter-transformer/not-set/not-set.js

@@ -6,18 +6,19 @@ Object.defineProperty(exports, "notSetTransform", {
     }
 });
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _constant = require("../constant");
 const notSetTransform = (query)=>{
     const { member } = query;
     return {
         class: _Expression.ExpressionClass.OPERATOR,
         type: _Expression.ExpressionType.OPERATOR_IS_NULL,
-        alias: "",
+        alias: '',
         children: [
             {
-                class: "COLUMN_REF",
-                type: "COLUMN_REF",
-                alias: "",
-                column_names: member.split('.')
+                class: 'COLUMN_REF',
+                type: 'COLUMN_REF',
+                alias: '',
+                column_names: member.split(_constant.COLUMN_NAME_DELIMITER)
             }
         ]
     };

package/src/cube-filter-transformer/not-set/not-set.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-set/not-set.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { CubeToParseExpressionTransform } from \"../factory\";\n\nexport const notSetTransform: CubeToParseExpressionTransform = (query)  => {\n    const { member } = query;\n    return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.OPERATOR_IS_NULL,\n        alias: \"\",\n        children: [\n            {\n                class: \"COLUMN_REF\",\n                type: \"COLUMN_REF\",\n                alias: \"\",\n                column_names: member.split('.')\n            }\n        ]\n    }\n}"],"names":["notSetTransform","query","member","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_IS_NULL","alias","children","column_names","split"],"mappings":";+BAGaA;;;eAAAA;;;4BAHmC;AAGzC,MAAMA,kBAAkD,CAACC;IAC5D,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAO;QACHE,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACC,gBAAgB;QACrCC,OAAO;QACPC,UAAU;YACN;gBACIP,OAAO;gBACPG,MAAM;gBACNG,OAAO;gBACPE,cAAcT,OAAOU,KAAK,CAAC;YAC/B;SACH;IACL;AACJ"}
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/not-set/not-set.ts"],"sourcesContent":["import {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { COLUMN_NAME_DELIMITER } from '../constant';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nexport const notSetTransform: CubeToParseExpressionTransform = (query) => {\n  const { member } = query;\n  return {\n    class: ExpressionClass.OPERATOR,\n    type: ExpressionType.OPERATOR_IS_NULL,\n    alias: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: member.split(COLUMN_NAME_DELIMITER),\n      },\n    ],\n  };\n};\n"],"names":["notSetTransform","query","member","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_IS_NULL","alias","children","column_names","split","COLUMN_NAME_DELIMITER"],"mappings":";+BAOaA;;;eAAAA;;;4BAJN;0BAC+B;AAG/B,MAAMA,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAO;QACLE,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACC,gBAAgB;QACrCC,OAAO;QACPC,UAAU;YACR;gBACEP,OAAO;gBACPG,MAAM;gBACNG,OAAO;gBACPE,cAAcT,OAAOU,KAAK,CAACC,+BAAqB;YAClD;SACD;IACH;AACF"}

package/src/cube-filter-transformer/set/set.d.ts

@@ -1,2 +1,2 @@
-import { CubeToParseExpressionTransform } from "../factory";
+import { CubeToParseExpressionTransform } from '../factory';
 export declare const setTransform: CubeToParseExpressionTransform;

package/src/cube-filter-transformer/set/set.js

@@ -6,18 +6,19 @@ Object.defineProperty(exports, "setTransform", {
     }
 });
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _constant = require("../constant");
 const setTransform = (query)=>{
     const { member } = query;
     return {
         class: _Expression.ExpressionClass.OPERATOR,
         type: _Expression.ExpressionType.OPERATOR_IS_NOT_NULL,
-        alias: "",
+        alias: '',
         children: [
             {
-                class: "COLUMN_REF",
-                type: "COLUMN_REF",
-                alias: "",
-                column_names: member.split('.')
+                class: 'COLUMN_REF',
+                type: 'COLUMN_REF',
+                alias: '',
+                column_names: member.split(_constant.COLUMN_NAME_DELIMITER)
             }
         ]
     };

package/src/cube-filter-transformer/set/set.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/set/set.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { CubeToParseExpressionTransform } from \"../factory\";\n\nexport const setTransform: CubeToParseExpressionTransform = (query)  => {\n    const { member } = query;\n    return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.OPERATOR_IS_NOT_NULL,\n        alias: \"\",\n        children: [\n            {\n                class: \"COLUMN_REF\",\n                type: \"COLUMN_REF\",\n                alias: \"\",\n                column_names: member.split('.')\n            }\n        ]\n    }\n}"],"names":["setTransform","query","member","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_IS_NOT_NULL","alias","children","column_names","split"],"mappings":";+BAGaA;;;eAAAA;;;4BAHmC;AAGzC,MAAMA,eAA+C,CAACC;IACzD,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAO;QACHE,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACC,oBAAoB;QACzCC,OAAO;QACPC,UAAU;YACN;gBACIP,OAAO;gBACPG,MAAM;gBACNG,OAAO;gBACPE,cAAcT,OAAOU,KAAK,CAAC;YAC/B;SACH;IACL;AACJ"}
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/set/set.ts"],"sourcesContent":["import {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { COLUMN_NAME_DELIMITER } from '../constant';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nexport const setTransform: CubeToParseExpressionTransform = (query) => {\n  const { member } = query;\n  return {\n    class: ExpressionClass.OPERATOR,\n    type: ExpressionType.OPERATOR_IS_NOT_NULL,\n    alias: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: member.split(COLUMN_NAME_DELIMITER),\n      },\n    ],\n  };\n};\n"],"names":["setTransform","query","member","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_IS_NOT_NULL","alias","children","column_names","split","COLUMN_NAME_DELIMITER"],"mappings":";+BAOaA;;;eAAAA;;;4BAJN;0BAC+B;AAG/B,MAAMA,eAA+C,CAACC;IAC3D,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAO;QACLE,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACC,oBAAoB;QACzCC,OAAO;QACPC,UAAU;YACR;gBACEP,OAAO;gBACPG,MAAM;gBACNG,OAAO;gBACPE,cAAcT,OAAOU,KAAK,CAACC,+BAAqB;YAClD;SACD;IACH;AACF"}

package/src/index.d.ts

@@ -1,9 +1,11 @@
 export * from './ast-builder/ast-builder';
 export * from './ast-deserializer/ast-deserializer';
+export * from './ast-serializer/ast-serializer';
+export * from './ast-validator';
 export { detectApplyContextParamsToBaseSQL } from './context-params/context-params-ast';
 export * from './cube-measure-transformer/cube-measure-transformer';
 export * from './cube-to-duckdb/cube-filter-to-duckdb';
-export { applyFilterParamsToBaseSQL, detectAllFilterParamsFromSQL, getFilterParamsAST } from './filter-params/filter-params-ast';
+export { applyFilterParamsToBaseSQL, detectAllFilterParamsFromSQL, getFilterParamsAST, } from './filter-params/filter-params-ast';
 export { getFilterParamsSQL } from './get-filter-params-sql/get-filter-params-sql';
 export { getFinalBaseSQL } from './get-final-base-sql/get-final-base-sql';
 export { getWrappedBaseQueryWithProjections } from './get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections';
@@ -11,6 +13,7 @@ export * from './joins/joins';
 export { FilterType } from './types/cube-types';
 export * from './types/cube-types/index';
 export * from './types/duckdb-serialization-types/index';
+export * from './types/utils';
 export { BASE_TABLE_NAME } from './utils/base-ast';
 export * from './utils/cube-to-table-schema';
 export * from './utils/get-possible-nodes';

package/src/index.js

@@ -43,6 +43,8 @@ _export(exports, {
 const _export_star = require("@swc/helpers/_/_export_star");
 _export_star._(require("./ast-builder/ast-builder"), exports);
 _export_star._(require("./ast-deserializer/ast-deserializer"), exports);
+_export_star._(require("./ast-serializer/ast-serializer"), exports);
+_export_star._(require("./ast-validator"), exports);
 const _contextparamsast = require("./context-params/context-params-ast");
 _export_star._(require("./cube-measure-transformer/cube-measure-transformer"), exports);
 _export_star._(require("./cube-to-duckdb/cube-filter-to-duckdb"), exports);
@@ -54,6 +56,7 @@ _export_star._(require("./joins/joins"), exports);
 const _cubetypes = require("./types/cube-types");
 _export_star._(require("./types/cube-types/index"), exports);
 _export_star._(require("./types/duckdb-serialization-types/index"), exports);
+_export_star._(require("./types/utils"), exports);
 const _baseast = require("./utils/base-ast");
 _export_star._(require("./utils/cube-to-table-schema"), exports);
 _export_star._(require("./utils/get-possible-nodes"), exports);

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../meerkat-core/src/index.ts"],"sourcesContent":["export * from './ast-builder/ast-builder';\nexport * from './ast-deserializer/ast-deserializer';\nexport { detectApplyContextParamsToBaseSQL } from './context-params/context-params-ast';\nexport * from './cube-measure-transformer/cube-measure-transformer';\nexport * from './cube-to-duckdb/cube-filter-to-duckdb';\nexport {\n  applyFilterParamsToBaseSQL,\n  detectAllFilterParamsFromSQL,\n  getFilterParamsAST\n} from './filter-params/filter-params-ast';\nexport { getFilterParamsSQL } from './get-filter-params-sql/get-filter-params-sql';\nexport { getFinalBaseSQL } from './get-final-base-sql/get-final-base-sql';\nexport { getWrappedBaseQueryWithProjections } from './get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections';\nexport * from './joins/joins';\nexport { FilterType } from './types/cube-types';\nexport * from './types/cube-types/index';\nexport * from './types/duckdb-serialization-types/index';\nexport { BASE_TABLE_NAME } from './utils/base-ast';\nexport * from './utils/cube-to-table-schema';\nexport * from './utils/get-possible-nodes';\nexport { meerkatPlaceholderReplacer } from './utils/meerkat-placeholder-replacer';\nexport { memberKeyToSafeKey } from './utils/member-key-to-safe-key';\n\n"],"names":["detectApplyContextParamsToBaseSQL","applyFilterParamsToBaseSQL","detectAllFilterParamsFromSQL","getFilterParamsAST","getFilterParamsSQL","getFinalBaseSQL","getWrappedBaseQueryWithProjections","FilterType","BASE_TABLE_NAME","meerkatPlaceholderReplacer","memberKeyToSafeKey"],"mappings":";;;;;;;;IAESA,iCAAiC;eAAjCA,mDAAiC;;IAIxCC,0BAA0B;eAA1BA,2CAA0B;;IAC1BC,4BAA4B;eAA5BA,6CAA4B;;IAC5BC,kBAAkB;eAAlBA,mCAAkB;;IAEXC,kBAAkB;eAAlBA,sCAAkB;;IAClBC,eAAe;eAAfA,gCAAe;;IACfC,kCAAkC;eAAlCA,sEAAkC;;IAElCC,UAAU;eAAVA,qBAAU;;IAGVC,eAAe;eAAfA,wBAAe;;IAGfC,0BAA0B;eAA1BA,sDAA0B;;IAC1BC,kBAAkB;eAAlBA,sCAAkB;;;;uBArBb;uBACA;kCACoC;uBACpC;uBACA;iCAKP;oCAC4B;iCACH;oDACmB;uBACrC;2BACa;uBACb;uBACA;yBACkB;uBAClB;uBACA;4CAC6B;oCACR"}
+{"version":3,"sources":["../../../meerkat-core/src/index.ts"],"sourcesContent":["export * from './ast-builder/ast-builder';\nexport * from './ast-deserializer/ast-deserializer';\nexport * from './ast-serializer/ast-serializer';\nexport * from './ast-validator';\nexport { detectApplyContextParamsToBaseSQL } from './context-params/context-params-ast';\nexport * from './cube-measure-transformer/cube-measure-transformer';\nexport * from './cube-to-duckdb/cube-filter-to-duckdb';\nexport {\n  applyFilterParamsToBaseSQL,\n  detectAllFilterParamsFromSQL,\n  getFilterParamsAST,\n} from './filter-params/filter-params-ast';\nexport { getFilterParamsSQL } from './get-filter-params-sql/get-filter-params-sql';\nexport { getFinalBaseSQL } from './get-final-base-sql/get-final-base-sql';\nexport { getWrappedBaseQueryWithProjections } from './get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections';\nexport * from './joins/joins';\nexport { FilterType } from './types/cube-types';\nexport * from './types/cube-types/index';\nexport * from './types/duckdb-serialization-types/index';\nexport * from './types/utils';\nexport { BASE_TABLE_NAME } from './utils/base-ast';\nexport * from './utils/cube-to-table-schema';\nexport * from './utils/get-possible-nodes';\nexport { meerkatPlaceholderReplacer } from './utils/meerkat-placeholder-replacer';\nexport { memberKeyToSafeKey } from './utils/member-key-to-safe-key';\n"],"names":["detectApplyContextParamsToBaseSQL","applyFilterParamsToBaseSQL","detectAllFilterParamsFromSQL","getFilterParamsAST","getFilterParamsSQL","getFinalBaseSQL","getWrappedBaseQueryWithProjections","FilterType","BASE_TABLE_NAME","meerkatPlaceholderReplacer","memberKeyToSafeKey"],"mappings":";;;;;;;;IAISA,iCAAiC;eAAjCA,mDAAiC;;IAIxCC,0BAA0B;eAA1BA,2CAA0B;;IAC1BC,4BAA4B;eAA5BA,6CAA4B;;IAC5BC,kBAAkB;eAAlBA,mCAAkB;;IAEXC,kBAAkB;eAAlBA,sCAAkB;;IAClBC,eAAe;eAAfA,gCAAe;;IACfC,kCAAkC;eAAlCA,sEAAkC;;IAElCC,UAAU;eAAVA,qBAAU;;IAIVC,eAAe;eAAfA,wBAAe;;IAGfC,0BAA0B;eAA1BA,sDAA0B;;IAC1BC,kBAAkB;eAAlBA,sCAAkB;;;;uBAxBb;uBACA;uBACA;uBACA;kCACoC;uBACpC;uBACA;iCAKP;oCAC4B;iCACH;oDACmB;uBACrC;2BACa;uBACb;uBACA;uBACA;yBACkB;uBAClB;uBACA;4CAC6B;oCACR"}

package/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.ts

@@ -7,41 +7,51 @@ export interface BaseParsedExpression {
     class: ExpressionClass;
     type: ExpressionType;
     alias: string;
+    query_location?: number;
 }
 export type ParsedExpression = BetweenExpression | CaseExpression | CastExpression | CollateExpression | ColumnRefExpression | ComparisonExpression | ConjunctionExpression | ConstantExpression | DefaultExpression | FunctionExpression | LambdaExpression | OperatorExpression | ParameterExpression | PositionalReferenceExpression | StarExpression | SubqueryExpression | WindowExpression;
 export interface BetweenExpression extends BaseParsedExpression {
+    class: ExpressionClass.BETWEEN;
     input: ParsedExpression;
     lower: ParsedExpression;
     upper: ParsedExpression;
 }
 export interface CaseExpression extends BaseParsedExpression {
+    class: ExpressionClass.CASE;
     case_checks: CacheCheck[];
     else_expr: BaseParsedExpression;
 }
 export interface CastExpression extends BaseParsedExpression {
+    class: ExpressionClass.CAST;
     child: ParsedExpression;
     cast_type: LogicalType;
     try_cast: boolean;
 }
 export interface CollateExpression extends BaseParsedExpression {
+    class: ExpressionClass.COLLATE;
     child: ParsedExpression;
     collation: string;
 }
 export interface ColumnRefExpression extends BaseParsedExpression {
+    class: ExpressionClass.COLUMN_REF;
     column_names: string[];
 }
 export interface ComparisonExpression extends BaseParsedExpression {
+    class: ExpressionClass.COMPARISON;
     left: ParsedExpression;
     right: ParsedExpression;
 }
 export interface ConjunctionExpression extends BaseParsedExpression {
+    class: ExpressionClass.CONJUNCTION;
     children: ParsedExpression[];
 }
 export interface ConstantExpression extends BaseParsedExpression {
+    class: ExpressionClass.CONSTANT;
     value: Value;
 }
 export type DefaultExpression = BaseParsedExpression;
 export interface FunctionExpression extends BaseParsedExpression {
+    class: ExpressionClass.FUNCTION;
     function_name: string;
     schema: string;
     children: ParsedExpression[];
@@ -53,19 +63,24 @@ export interface FunctionExpression extends BaseParsedExpression {
     catalog: string;
 }
 export interface LambdaExpression extends BaseParsedExpression {
+    class: ExpressionClass.LAMBDA;
     lhs: ParsedExpression;
     expr: ParsedExpression | null;
 }
 export interface OperatorExpression extends BaseParsedExpression {
+    class: ExpressionClass.OPERATOR;
     children: ParsedExpression[];
 }
 export interface ParameterExpression extends BaseParsedExpression {
+    class: ExpressionClass.PARAMETER;
     identifier: string;
 }
 export interface PositionalReferenceExpression extends BaseParsedExpression {
+    class: ExpressionClass.POSITIONAL_REFERENCE;
     index: number;
 }
 export interface StarExpression extends BaseParsedExpression {
+    class: ExpressionClass.STAR;
     relation_name: string;
     exclude_list: Set<string> | Array<string>;
     replace_list: Set<ParsedExpression> | Array<ParsedExpression>;
@@ -80,6 +95,7 @@ export declare enum SubqueryType {
     ANY = "ANY"
 }
 export interface SubqueryExpression extends BaseParsedExpression {
+    class: ExpressionClass.SUBQUERY;
     subquery_type: SubqueryType;
     subquery: SelectStatement;
     child?: ParsedExpression;
@@ -97,6 +113,7 @@ export declare enum WindowBoundary {
     EXPR_FOLLOWING_RANGE = "EXPR_FOLLOWING_RANGE"
 }
 export interface WindowExpression extends BaseParsedExpression {
+    class: ExpressionClass.WINDOW;
     function_name: string;
     schema: string;
     catalog: string;

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

package/src/utils/get-column-names-from-ast.d.ts

@@ -0,0 +1,2 @@
+import { ParsedExpression } from '../types/duckdb-serialization-types';
+export declare const getColumnNamesFromAst: (node: ParsedExpression, columnSet?: Set<string>) => string[];