@devrev/meerkat-core 0.0.85 → 0.0.86

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "COLUMN_NAME_DELIMITER", {
+    enumerable: true,
+    get: function() {
+        return COLUMN_NAME_DELIMITER;
+    }
+});
+const COLUMN_NAME_DELIMITER = '.';
+
+//# sourceMappingURL=constant.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/constant.ts"],"sourcesContent":["export const COLUMN_NAME_DELIMITER = '.';\n"],"names":["COLUMN_NAME_DELIMITER"],"mappings":";+BAAaA;;;eAAAA;;;AAAN,MAAMA,wBAAwB"}

package/src/cube-filter-transformer/contains/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 containsDuckdbCondition = (columnName, value, memberInfo)=>{
     return {
@@ -28,7 +29,7 @@ const containsDuckdbCondition = (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/contains/contains.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/contains/contains.ts"],"sourcesContent":["import { Member, QueryFilter } from '../../types/cube-types/query';\nimport { Dimension, Measure } from '../../types/cube-types/table';\n\nimport {\n  ExpressionClass,\n  ExpressionType,\n} 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 ContainsFilters extends QueryFilter {\n  member: Member;\n  operator: 'contains';\n  values: string[];\n}\n\nexport const containsDuckdbCondition = (\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 containsTransform: 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 containsDuckdbCondition(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      containsDuckdbCondition(member, value, memberInfo)\n    );\n  });\n  return orCondition;\n};\n"],"names":["containsDuckdbCondition","containsTransform","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":";;;;;;;;IAiBaA,uBAAuB;eAAvBA;;IAqCAC,iBAAiB;eAAjBA;;;4BAhDN;sCACsB;oBAEK;AAQ3B,MAAMD,0BAA0B,CACrCE,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,oBAAoD,CAACuB;IAChE,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,wBAAwByB,QAAQC,MAAM,CAAC,EAAE,EAAEtB;IACpD;IAEA;;GAEC,GACD,MAAMyB,cAAcC,IAAAA,qBAAiB;IACrCJ,OAAOK,OAAO,CAAC,CAAC5B;QACd0B,YAAYhB,QAAQ,CAACmB,IAAI,CACvBhC,wBAAwByB,QAAQtB,OAAOC;IAE3C;IACA,OAAOyB;AACT"}
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/contains/contains.ts"],"sourcesContent":["import { Member, QueryFilter } from '../../types/cube-types/query';\nimport { Dimension, Measure } from '../../types/cube-types/table';\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';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport interface ContainsFilters extends QueryFilter {\n  member: Member;\n  operator: 'contains';\n  values: string[];\n}\n\nexport const containsDuckdbCondition = (\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 containsTransform: 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 containsDuckdbCondition(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      containsDuckdbCondition(member, value, memberInfo)\n    );\n  });\n  return orCondition;\n};\n"],"names":["containsDuckdbCondition","containsTransform","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":";;;;;;;;IAkBaA,uBAAuB;eAAvBA;;IAqCAC,iBAAiB;eAAjBA;;;4BAjDN;sCACsB;0BACS;oBAEJ;AAQ3B,MAAMD,0BAA0B,CACrCE,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,oBAAoD,CAACwB;IAChE,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,wBAAwB0B,QAAQC,MAAM,CAAC,EAAE,EAAEvB;IACpD;IAEA;;GAEC,GACD,MAAM0B,cAAcC,IAAAA,qBAAiB;IACrCJ,OAAOK,OAAO,CAAC,CAAC7B;QACd2B,YAAYjB,QAAQ,CAACoB,IAAI,CACvBjC,wBAAwB0B,QAAQvB,OAAOC;IAE3C;IACA,OAAO0B;AACT"}

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

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

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

@@ -7,49 +7,50 @@ Object.defineProperty(exports, "inTransform", {
 });
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
 const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _constant = require("../constant");
 const inDuckDbCondition = (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':
         case 'string_array':
             {
                 return {
-                    "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: ''
                 };
             }
         default:
@@ -57,7 +58,7 @@ const inDuckDbCondition = (columnName, values, memberInfo)=>{
                 return {
                     class: _Expression.ExpressionClass.OPERATOR,
                     type: _Expression.ExpressionType.COMPARE_IN,
-                    alias: "",
+                    alias: '',
                     children: [
                         columnRef,
                         ...sqlTreeValues

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/in/in.ts"],"sourcesContent":["import { 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 { CubeToParseExpressionTransform } from \"../factory\";\n\n\nconst inDuckDbCondition = (\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.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        default: {\n            return {\n                class: ExpressionClass.OPERATOR,\n                type: ExpressionType.COMPARE_IN,\n                alias: \"\",\n                children: [\n                    columnRef,\n                    ...sqlTreeValues\n                ]\n            }\n        }\n    }\n   \n}\n\n\nexport const inTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  if (!values) {\n    throw new Error('In filter must have at least one value');\n  }\n  return inDuckDbCondition(member, values, memberInfo);\n}\n"],"names":["inTransform","inDuckDbCondition","columnName","values","memberInfo","sqlTreeValues","map","value","class","ExpressionClass","CONSTANT","type","ExpressionType","VALUE_CONSTANT","alias","valueBuilder","columnRef","column_names","split","FUNCTION","OPERATOR","ARRAY_CONSTRUCTOR","children","COMPARE_IN","query","member","Error"],"mappings":";+BAyEaA;;;eAAAA;;;4BArEN;sCACsB;AAI7B,MAAMC,oBAAoB,CACtBC,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;oBACH,SAASF,2BAAe,CAACU,QAAQ;oBACjC,QAAQP,0BAAc,CAACO,QAAQ;oBAC/B,SAAS;oBACT,iBAAiB;oBACjB,UAAU;oBACV,YAAY;wBACRH;wBACA;4BACIR,OAAOC,2BAAe,CAACW,QAAQ;4BAC/BT,MAAMC,0BAAc,CAACS,iBAAiB;4BACtCP,OAAO;4BACPQ,UAAUjB;wBACd;qBACH;oBACD,UAAU;oBACV,aAAa;wBACT,QAAQ;wBACR,UAAU,EAAE;oBAChB;oBACA,YAAY;oBACZ,eAAe;oBACf,gBAAgB;oBAChB,WAAW;gBACf;YACJ;QACA;YAAS;gBACL,OAAO;oBACHG,OAAOC,2BAAe,CAACW,QAAQ;oBAC/BT,MAAMC,0BAAc,CAACW,UAAU;oBAC/BT,OAAO;oBACPQ,UAAU;wBACNN;2BACGX;qBACN;gBACL;YACJ;IACJ;AAEJ;AAGO,MAAML,cAA8C,CAACwB;IAC1D,MAAM,EAAEC,MAAM,EAAEtB,MAAM,EAAEC,UAAU,EAAE,GAAGoB;IACvC,IAAI,CAACrB,QAAQ;QACX,MAAM,IAAIuB,MAAM;IAClB;IACA,OAAOzB,kBAAkBwB,QAAQtB,QAAQC;AAC3C"}
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/in/in.ts"],"sourcesContent":["import { 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';\n\nconst inDuckDbCondition = (\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.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    default: {\n      return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.COMPARE_IN,\n        alias: '',\n        children: [columnRef, ...sqlTreeValues],\n      };\n    }\n  }\n};\n\nexport const inTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  if (!values) {\n    throw new Error('In filter must have at least one value');\n  }\n  return inDuckDbCondition(member, values, memberInfo);\n};\n"],"names":["inTransform","inDuckDbCondition","columnName","values","memberInfo","sqlTreeValues","map","value","class","ExpressionClass","CONSTANT","type","ExpressionType","VALUE_CONSTANT","alias","valueBuilder","columnRef","column_names","split","COLUMN_NAME_DELIMITER","FUNCTION","function_name","schema","children","OPERATOR","ARRAY_CONSTRUCTOR","filter","order_bys","orders","distinct","is_operator","export_state","catalog","COMPARE_IN","query","member","Error"],"mappings":";+BAoEaA;;;eAAAA;;;4BAhEN;sCACsB;0BACS;AAGtC,MAAMC,oBAAoB,CACxBC,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,CAACQ,QAAQ;oBAC7BN,OAAO;oBACPO,eAAe;oBACfC,QAAQ;oBACRC,UAAU;wBACRP;wBACA;4BACER,OAAOC,2BAAe,CAACe,QAAQ;4BAC/Bb,MAAMC,0BAAc,CAACa,iBAAiB;4BACtCX,OAAO;4BACPS,UAAUlB;wBACZ;qBACD;oBACDqB,QAAQ;oBACRC,WAAW;wBACThB,MAAM;wBACNiB,QAAQ,EAAE;oBACZ;oBACAC,UAAU;oBACVC,aAAa;oBACbC,cAAc;oBACdC,SAAS;gBACX;YACF;QACA;YAAS;gBACP,OAAO;oBACLxB,OAAOC,2BAAe,CAACe,QAAQ;oBAC/Bb,MAAMC,0BAAc,CAACqB,UAAU;oBAC/BnB,OAAO;oBACPS,UAAU;wBAACP;2BAAcX;qBAAc;gBACzC;YACF;IACF;AACF;AAEO,MAAML,cAA8C,CAACkC;IAC1D,MAAM,EAAEC,MAAM,EAAEhC,MAAM,EAAEC,UAAU,EAAE,GAAG8B;IACvC,IAAI,CAAC/B,QAAQ;QACX,MAAM,IAAIiC,MAAM;IAClB;IACA,OAAOnC,kBAAkBkC,QAAQhC,QAAQC;AAC3C"}

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

@@ -1,5 +1,5 @@
-import { Dimension, Measure } from '../../types/cube-types/table';
 import { Member, QueryFilter } from '../../types/cube-types/query';
+import { Dimension, Measure } from '../../types/cube-types/table';
 import { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';
 import { CubeToParseExpressionTransform } from '../factory';
 export interface NotContainsFilters extends QueryFilter {

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/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[];

package/src/utils/get-column-names-from-ast.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "getColumnNamesFromAst", {
+    enumerable: true,
+    get: function() {
+        return getColumnNamesFromAst;
+    }
+});
+const _constant = require("../cube-filter-transformer/constant");
+const _utils = require("../types/utils");
+const getColumnNamesFromAst = (node, columnSet = new Set())=>{
+    if (!node) return Array.from(columnSet);
+    if ((0, _utils.isBetweenExpression)(node)) {
+        getColumnNamesFromAst(node.input, columnSet);
+        getColumnNamesFromAst(node.lower, columnSet);
+        getColumnNamesFromAst(node.upper, columnSet);
+    }
+    if ((0, _utils.isColumnRefExpression)(node)) {
+        columnSet.add(node.column_names.join(_constant.COLUMN_NAME_DELIMITER));
+    }
+    if ((0, _utils.isCastExpression)(node) || (0, _utils.isCollateExpression)(node)) {
+        getColumnNamesFromAst(node.child, columnSet);
+    }
+    if ((0, _utils.isComparisonExpression)(node)) {
+        getColumnNamesFromAst(node.left, columnSet);
+        getColumnNamesFromAst(node.right, columnSet);
+    }
+    if ((0, _utils.isFunctionExpression)(node) || (0, _utils.isWindowExpression)(node) || (0, _utils.isOperatorExpression)(node) || (0, _utils.isConjunctionExpression)(node)) {
+        node.children.forEach((child)=>getColumnNamesFromAst(child, columnSet));
+    }
+    if ((0, _utils.isCaseExpression)(node)) {
+        node.case_checks.forEach((check)=>{
+            getColumnNamesFromAst(check.then_expr, columnSet);
+            getColumnNamesFromAst(check.when_expr, columnSet);
+        });
+        getColumnNamesFromAst(node.else_expr, columnSet);
+    }
+    if ((0, _utils.isSubqueryExpression)(node) && (0, _utils.isSelectNode)(node.subquery.node)) {
+        node.subquery.node.select_list.forEach((node)=>{
+            getColumnNamesFromAst(node, columnSet);
+        });
+    }
+    return Array.from(columnSet);
+};
+
+//# sourceMappingURL=get-column-names-from-ast.js.map

package/src/utils/get-column-names-from-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/utils/get-column-names-from-ast.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../cube-filter-transformer/constant';\nimport { ParsedExpression } from '../types/duckdb-serialization-types';\nimport {\n  isBetweenExpression,\n  isCaseExpression,\n  isCastExpression,\n  isCollateExpression,\n  isColumnRefExpression,\n  isComparisonExpression,\n  isConjunctionExpression,\n  isFunctionExpression,\n  isOperatorExpression,\n  isSelectNode,\n  isSubqueryExpression,\n  isWindowExpression,\n} from '../types/utils';\n\nexport const getColumnNamesFromAst = (\n  node: ParsedExpression,\n  columnSet: Set<string> = new Set()\n): string[] => {\n  if (!node) return Array.from(columnSet);\n\n  if (isBetweenExpression(node)) {\n    getColumnNamesFromAst(node.input, columnSet);\n    getColumnNamesFromAst(node.lower, columnSet);\n    getColumnNamesFromAst(node.upper, columnSet);\n  }\n\n  if (isColumnRefExpression(node)) {\n    columnSet.add(node.column_names.join(COLUMN_NAME_DELIMITER));\n  }\n\n  if (isCastExpression(node) || isCollateExpression(node)) {\n    getColumnNamesFromAst(node.child, columnSet);\n  }\n\n  if (isComparisonExpression(node)) {\n    getColumnNamesFromAst(node.left, columnSet);\n    getColumnNamesFromAst(node.right, columnSet);\n  }\n\n  if (\n    isFunctionExpression(node) ||\n    isWindowExpression(node) ||\n    isOperatorExpression(node) ||\n    isConjunctionExpression(node)\n  ) {\n    node.children.forEach((child) => getColumnNamesFromAst(child, columnSet));\n  }\n\n  if (isCaseExpression(node)) {\n    node.case_checks.forEach((check) => {\n      getColumnNamesFromAst(check.then_expr, columnSet);\n      getColumnNamesFromAst(check.when_expr, columnSet);\n    });\n    getColumnNamesFromAst(node.else_expr, columnSet);\n  }\n\n  if (isSubqueryExpression(node) && isSelectNode(node.subquery.node)) {\n    node.subquery.node.select_list.forEach((node) => {\n      getColumnNamesFromAst(node, columnSet);\n    });\n  }\n\n  return Array.from(columnSet);\n};\n"],"names":["getColumnNamesFromAst","node","columnSet","Set","Array","from","isBetweenExpression","input","lower","upper","isColumnRefExpression","add","column_names","join","COLUMN_NAME_DELIMITER","isCastExpression","isCollateExpression","child","isComparisonExpression","left","right","isFunctionExpression","isWindowExpression","isOperatorExpression","isConjunctionExpression","children","forEach","isCaseExpression","case_checks","check","then_expr","when_expr","else_expr","isSubqueryExpression","isSelectNode","subquery","select_list"],"mappings":";+BAiBaA;;;eAAAA;;;0BAjByB;uBAe/B;AAEA,MAAMA,wBAAwB,CACnCC,MACAC,YAAyB,IAAIC,KAAK;IAElC,IAAI,CAACF,MAAM,OAAOG,MAAMC,IAAI,CAACH;IAE7B,IAAII,IAAAA,0BAAmB,EAACL,OAAO;QAC7BD,sBAAsBC,KAAKM,KAAK,EAAEL;QAClCF,sBAAsBC,KAAKO,KAAK,EAAEN;QAClCF,sBAAsBC,KAAKQ,KAAK,EAAEP;IACpC;IAEA,IAAIQ,IAAAA,4BAAqB,EAACT,OAAO;QAC/BC,UAAUS,GAAG,CAACV,KAAKW,YAAY,CAACC,IAAI,CAACC,+BAAqB;IAC5D;IAEA,IAAIC,IAAAA,uBAAgB,EAACd,SAASe,IAAAA,0BAAmB,EAACf,OAAO;QACvDD,sBAAsBC,KAAKgB,KAAK,EAAEf;IACpC;IAEA,IAAIgB,IAAAA,6BAAsB,EAACjB,OAAO;QAChCD,sBAAsBC,KAAKkB,IAAI,EAAEjB;QACjCF,sBAAsBC,KAAKmB,KAAK,EAAElB;IACpC;IAEA,IACEmB,IAAAA,2BAAoB,EAACpB,SACrBqB,IAAAA,yBAAkB,EAACrB,SACnBsB,IAAAA,2BAAoB,EAACtB,SACrBuB,IAAAA,8BAAuB,EAACvB,OACxB;QACAA,KAAKwB,QAAQ,CAACC,OAAO,CAAC,CAACT,QAAUjB,sBAAsBiB,OAAOf;IAChE;IAEA,IAAIyB,IAAAA,uBAAgB,EAAC1B,OAAO;QAC1BA,KAAK2B,WAAW,CAACF,OAAO,CAAC,CAACG;YACxB7B,sBAAsB6B,MAAMC,SAAS,EAAE5B;YACvCF,sBAAsB6B,MAAME,SAAS,EAAE7B;QACzC;QACAF,sBAAsBC,KAAK+B,SAAS,EAAE9B;IACxC;IAEA,IAAI+B,IAAAA,2BAAoB,EAAChC,SAASiC,IAAAA,mBAAY,EAACjC,KAAKkC,QAAQ,CAAClC,IAAI,GAAG;QAClEA,KAAKkC,QAAQ,CAAClC,IAAI,CAACmC,WAAW,CAACV,OAAO,CAAC,CAACzB;YACtCD,sBAAsBC,MAAMC;QAC9B;IACF;IAEA,OAAOE,MAAMC,IAAI,CAACH;AACpB"}