@devrev/meerkat-core 0.0.90 → 0.0.93

package/cube-filter-transformer/equals/equals-array.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "equalsArrayTransform", {
+    enumerable: true,
+    get: function() {
+        return equalsArrayTransform;
+    }
+});
+const _constants = require("../../member-formatters/constants");
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _ResultModifier = require("../../types/duckdb-serialization-types/serialization/ResultModifier");
+const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const equalsDuckDbCondition = (columnName, values, memberInfo)=>{
+    const columnRef = {
+        class: _Expression.ExpressionClass.COLUMN_REF,
+        type: _Expression.ExpressionType.COLUMN_REF,
+        alias: '',
+        column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
+    };
+    const sqlTreeValues = values.map((value)=>{
+        const children = {
+            class: _Expression.ExpressionClass.CONSTANT,
+            type: _Expression.ExpressionType.VALUE_CONSTANT,
+            alias: '',
+            value: (0, _baseconditionbuilder.valueBuilder)(value, memberInfo)
+        };
+        return children;
+    });
+    const filterValuesArray = {
+        class: _Expression.ExpressionClass.FUNCTION,
+        type: _Expression.ExpressionType.FUNCTION,
+        alias: '',
+        function_name: 'list_value',
+        schema: 'main',
+        children: sqlTreeValues,
+        filter: null,
+        order_bys: {
+            type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
+            orders: []
+        },
+        distinct: false,
+        is_operator: false,
+        export_state: false,
+        catalog: ''
+    };
+    const sqlTree = {
+        class: _Expression.ExpressionClass.FUNCTION,
+        type: _Expression.ExpressionType.FUNCTION,
+        alias: '',
+        function_name: 'list_has_all',
+        schema: '',
+        children: [
+            columnRef,
+            filterValuesArray
+        ],
+        filter: null,
+        order_bys: {
+            type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
+            orders: []
+        },
+        distinct: false,
+        is_operator: false,
+        export_state: false,
+        catalog: ''
+    };
+    return sqlTree;
+};
+const equalsArrayTransform = (query)=>{
+    const { member, values, memberInfo } = query;
+    /**
+   * If there is only one value, we can create a simple equals condition
+   */ if (!values) {
+        throw new Error('In filter must have at least one value');
+    }
+    return equalsDuckDbCondition(member, values, memberInfo);
+};
+
+//# sourceMappingURL=equals-array.js.map

package/cube-filter-transformer/equals/equals-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/equals/equals-array.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport { Dimension, Measure } from '../../types/cube-types/table';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { ResultModifierType } from '../../types/duckdb-serialization-types/serialization/ResultModifier';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nconst equalsDuckDbCondition = (\n  columnName: string,\n  values: string[],\n  memberInfo: Measure | Dimension\n) => {\n  const columnRef = {\n    class: ExpressionClass.COLUMN_REF,\n    type: ExpressionType.COLUMN_REF,\n    alias: '',\n    column_names: columnName.split(COLUMN_NAME_DELIMITER),\n  };\n\n  const sqlTreeValues = values.map((value) => {\n    const children = {\n      class: ExpressionClass.CONSTANT,\n      type: ExpressionType.VALUE_CONSTANT,\n      alias: '',\n      value: valueBuilder(value, memberInfo),\n    };\n    return children;\n  });\n\n  const filterValuesArray = {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: 'list_value',\n    schema: 'main',\n    children: sqlTreeValues,\n    filter: null,\n    order_bys: {\n      type: ResultModifierType.ORDER_MODIFIER,\n      orders: [],\n    },\n    distinct: false,\n    is_operator: false,\n    export_state: false,\n    catalog: '',\n  };\n\n  const sqlTree = {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: 'list_has_all',\n    schema: '',\n    children: [columnRef, filterValuesArray],\n    filter: null,\n    order_bys: {\n      type: ResultModifierType.ORDER_MODIFIER,\n      orders: [],\n    },\n    distinct: false,\n    is_operator: false,\n    export_state: false,\n    catalog: '',\n  };\n  return sqlTree;\n};\n\nexport const equalsArrayTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (!values) {\n    throw new Error('In filter must have at least one value');\n  }\n  return equalsDuckDbCondition(member, values, memberInfo);\n};\n"],"names":["equalsArrayTransform","equalsDuckDbCondition","columnName","values","memberInfo","columnRef","class","ExpressionClass","COLUMN_REF","type","ExpressionType","alias","column_names","split","COLUMN_NAME_DELIMITER","sqlTreeValues","map","value","children","CONSTANT","VALUE_CONSTANT","valueBuilder","filterValuesArray","FUNCTION","function_name","schema","filter","order_bys","ResultModifierType","ORDER_MODIFIER","orders","distinct","is_operator","export_state","catalog","sqlTree","query","member","Error"],"mappings":";+BAsEaA;;;eAAAA;;;2BAtEyB;4BAK/B;gCAC4B;sCACN;AAG7B,MAAMC,wBAAwB,CAC5BC,YACAC,QACAC;IAEA,MAAMC,YAAY;QAChBC,OAAOC,2BAAe,CAACC,UAAU;QACjCC,MAAMC,0BAAc,CAACF,UAAU;QAC/BG,OAAO;QACPC,cAAcV,WAAWW,KAAK,CAACC,gCAAqB;IACtD;IAEA,MAAMC,gBAAgBZ,OAAOa,GAAG,CAAC,CAACC;QAChC,MAAMC,WAAW;YACfZ,OAAOC,2BAAe,CAACY,QAAQ;YAC/BV,MAAMC,0BAAc,CAACU,cAAc;YACnCT,OAAO;YACPM,OAAOI,IAAAA,kCAAY,EAACJ,OAAOb;QAC7B;QACA,OAAOc;IACT;IAEA,MAAMI,oBAAoB;QACxBhB,OAAOC,2BAAe,CAACgB,QAAQ;QAC/Bd,MAAMC,0BAAc,CAACa,QAAQ;QAC7BZ,OAAO;QACPa,eAAe;QACfC,QAAQ;QACRP,UAAUH;QACVW,QAAQ;QACRC,WAAW;YACTlB,MAAMmB,kCAAkB,CAACC,cAAc;YACvCC,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;IAEA,MAAMC,UAAU;QACd7B,OAAOC,2BAAe,CAACgB,QAAQ;QAC/Bd,MAAMC,0BAAc,CAACa,QAAQ;QAC7BZ,OAAO;QACPa,eAAe;QACfC,QAAQ;QACRP,UAAU;YAACb;YAAWiB;SAAkB;QACxCI,QAAQ;QACRC,WAAW;YACTlB,MAAMmB,kCAAkB,CAACC,cAAc;YACvCC,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;IACA,OAAOC;AACT;AAEO,MAAMnC,uBAAuD,CAACoC;IACnE,MAAM,EAAEC,MAAM,EAAElC,MAAM,EAAEC,UAAU,EAAE,GAAGgC;IACvC;;GAEC,GACD,IAAI,CAACjC,QAAQ;QACX,MAAM,IAAImC,MAAM;IAClB;IACA,OAAOrC,sBAAsBoC,QAAQlC,QAAQC;AAC/C"}

package/cube-filter-transformer/equals/equals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/equals/equals.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { isArrayTypeMember } from '../../utils/is-array-member-type';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\nimport { equalsArrayTransform } from './equals-array';\n\nexport const equalsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  /**\n   * If the member is an array, we need to use the array transform\n   */\n  if (isArrayTypeMember(query.memberInfo.type)) {\n    return equalsArrayTransform(query);\n  }\n\n  if (!values || values.length === 0) {\n    throw new Error('Equals filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_EQUAL,\n      values[0],\n      query.memberInfo\n    );\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      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_EQUAL,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["equalsTransform","query","member","values","isArrayTypeMember","memberInfo","type","equalsArrayTransform","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_EQUAL","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAOaA;;;eAAAA;;;4BAPkB;mCACG;sCACE;oBAEF;6BACG;AAE9B,MAAMA,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B;;GAEC,GACD,IAAIG,IAAAA,oCAAiB,EAACH,MAAMI,UAAU,CAACC,IAAI,GAAG;QAC5C,OAAOC,IAAAA,iCAAoB,EAACN;IAC9B;IAEA,IAAI,CAACE,UAAUA,OAAOK,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIN,OAAOK,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBR,QACAS,0BAAc,CAACC,aAAa,EAC5BT,MAAM,CAAC,EAAE,EACTF,MAAMI,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMQ,cAAcC,IAAAA,qBAAiB;IACrCX,OAAOY,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBR,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,aAAa,EAC5BI,OACAf,MAAMI,UAAU;IAGtB;IACA,OAAOQ;AACT"}

package/cube-filter-transformer/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-filter-transformer/factory.ts"],"sourcesContent":["import {\n  QueryFilterWithInfo,\n  QueryFiltersWithInfo,\n  QueryOperatorsWithInfo,\n} from '../cube-to-duckdb/cube-filter-to-duckdb';\nimport { ParsedExpression } from '../types/duckdb-serialization-types/serialization/ParsedExpression';\nimport { SelectNode } from '../types/duckdb-serialization-types/serialization/QueryNode';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\nimport {\n  hasChildren,\n  isFilterArray,\n  isLogicalAnd,\n  isLogicalAndOR,\n  isLogicalOr,\n  isQueryFilter,\n} from '../utils/type-guards';\nimport { andDuckdbCondition } from './and/and';\nimport { containsTransform } from './contains/contains';\nimport { equalsTransform } from './equals/equals';\nimport { gtTransform } from './gt/gt';\nimport { gteTransform } from './gte/gte';\nimport { inDataRangeTransform } from './in-date-range/in-date-range';\nimport { inTransform } from './in/in';\nimport { ltTransform } from './lt/lt';\nimport { lteTransform } from './lte/lte';\nimport { notInDataRangeTransform } from './not-In-date-range/not-In-date-range';\nimport { notContainsTransform } from './not-contains/not-contains';\nimport { notEqualsTransform } from './not-equals/not-equals';\nimport { notInTransform } from './not-in/not-in';\nimport { notSetTransform } from './not-set/not-set';\nimport { orDuckdbCondition } from './or/or';\nimport { setTransform } from './set/set';\n\nexport type CubeToParseExpressionTransform = (\n  query: QueryOperatorsWithInfo\n) => ParsedExpression;\n\n// Comparison operators\nconst cubeFilterOperatorsToDuckdb = (cubeFilter: QueryOperatorsWithInfo) => {\n  switch (cubeFilter.operator) {\n    case 'equals':\n      return equalsTransform(cubeFilter);\n    case 'notEquals':\n      return notEqualsTransform(cubeFilter);\n    case 'in':\n      return inTransform(cubeFilter);\n    case 'notIn':\n      return notInTransform(cubeFilter);\n    case 'contains':\n      return containsTransform(cubeFilter);\n    case 'notContains':\n      return notContainsTransform(cubeFilter);\n    case 'gt':\n      return gtTransform(cubeFilter);\n    case 'gte':\n      return gteTransform(cubeFilter);\n    case 'lt':\n      return ltTransform(cubeFilter);\n    case 'lte':\n      return lteTransform(cubeFilter);\n    case 'inDateRange':\n      return inDataRangeTransform(cubeFilter);\n    case 'notInDateRange':\n      return notInDataRangeTransform(cubeFilter);\n    case 'notSet': {\n      return notSetTransform(cubeFilter);\n    }\n    case 'set': {\n      return setTransform(cubeFilter);\n    }\n    default:\n      throw new Error('Could not transform the filter');\n  }\n};\n\nconst cubeFilterLogicalAndOrToDuckdb = (\n  cubeFilter: QueryFilterWithInfo,\n  whereObj: ParsedExpression | null\n): ParsedExpression | null => {\n  /**\n   * This condition is true when you are at the leaf most level of the filter\n   */\n  if (!isFilterArray(cubeFilter) && isQueryFilter(cubeFilter)) {\n    const data = cubeFilterOperatorsToDuckdb(cubeFilter);\n    if (!data) {\n      throw new Error('Could not transform the filter');\n    }\n    return data;\n  }\n\n  if (!isFilterArray(cubeFilter) && isLogicalAnd(cubeFilter)) {\n    if (cubeFilter.and.length === 0) {\n      return null;\n    }\n    // And or Or we need to recurse\n    const andDuckdbExpression = andDuckdbCondition();\n    const data = cubeFilterLogicalAndOrToDuckdb(\n      cubeFilter.and,\n      andDuckdbExpression\n    );\n    return data;\n  }\n\n  if (!isFilterArray(cubeFilter) && isLogicalOr(cubeFilter)) {\n    if (cubeFilter.or.length === 0) {\n      return null;\n    }\n    // And or Or we need to recurse\n    const orDuckdbExpression = orDuckdbCondition();\n    const data = cubeFilterLogicalAndOrToDuckdb(\n      cubeFilter.or,\n      orDuckdbExpression\n    );\n    return data;\n  }\n\n  if (isFilterArray(cubeFilter)) {\n    for (const filter of cubeFilter) {\n      const data = cubeFilterLogicalAndOrToDuckdb(filter, whereObj);\n      if (data) {\n        if (hasChildren(whereObj)) {\n          whereObj.children.push(data);\n        } else {\n          whereObj = data;\n        }\n      }\n    }\n    return whereObj;\n  }\n  return whereObj;\n};\n\nexport const cubeFilterToDuckdbAST = (\n  cubeFilter: QueryFiltersWithInfo,\n  ast: SelectStatement\n) => {\n  let whereObj: ParsedExpression | null | undefined =\n    (ast.node as SelectNode).where_clause || null;\n\n  if (cubeFilter.length > 1) {\n    console.error('We do not support multiple filters yet');\n    throw new Error('We do not support multiple filters yet');\n  }\n\n  const filter = cubeFilter[0];\n\n  if (isQueryFilter(filter)) {\n    whereObj = cubeFilterOperatorsToDuckdb(filter);\n  }\n\n  if (isLogicalAndOR(filter)) {\n    // And or Or we need to recurse\n    whereObj = cubeFilterLogicalAndOrToDuckdb(filter, whereObj || null);\n  }\n\n  return whereObj;\n};\n"],"names":["cubeFilterToDuckdbAST","cubeFilterOperatorsToDuckdb","cubeFilter","operator","equalsTransform","notEqualsTransform","inTransform","notInTransform","containsTransform","notContainsTransform","gtTransform","gteTransform","ltTransform","lteTransform","inDataRangeTransform","notInDataRangeTransform","notSetTransform","setTransform","Error","cubeFilterLogicalAndOrToDuckdb","whereObj","isFilterArray","isQueryFilter","data","isLogicalAnd","and","length","andDuckdbExpression","andDuckdbCondition","isLogicalOr","or","orDuckdbExpression","orDuckdbCondition","filter","hasChildren","children","push","ast","node","where_clause","console","error","isLogicalAndOR"],"mappings":"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"}

package/cube-filter-transformer/gt/gt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/gt/gt.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const gtTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GT filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHAN,\n      values[0],\n      query.memberInfo\n    );\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      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_GREATERTHAN,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["gtTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_GREATERTHAN","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,cAA8C,CAACC;IAC1D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,mBAAmB,EAClCL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,mBAAmB,EAClCK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

package/cube-filter-transformer/gte/gte.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/gte/gte.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const gteTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GTE filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHANOREQUALTO,\n      values[0],\n      query.memberInfo\n    );\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      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_GREATERTHANOREQUALTO,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["gteTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_GREATERTHANOREQUALTO","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,eAA+C,CAACC;IAC3D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,4BAA4B,EAC3CL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,4BAA4B,EAC3CK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

package/{src/cube-filter-transformer → cube-filter-transformer}/in/in.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "inTransform", {
         return inTransform;
     }
 });
+const _constants = require("../../member-formatters/constants");
 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 {
@@ -21,7 +21,7 @@ const inDuckDbCondition = (columnName, values, memberInfo)=>{
         class: 'COLUMN_REF',
         type: 'COLUMN_REF',
         alias: '',
-        column_names: columnName.split(_constant.COLUMN_NAME_DELIMITER)
+        column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
     };
     switch(memberInfo.type){
         case 'number_array':

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/in/in.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\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 { 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;;;2BApEyB;4BAK/B;sCACsB;AAG7B,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,gCAAqB;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/cube-filter-transformer/in-date-range/in-date-range.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/in-date-range/in-date-range.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { andDuckdbCondition } from '../and/and';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nexport const inDataRangeTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GT filter must have at least one value');\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const andCondition = andDuckdbCondition();\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHANOREQUALTO,\n      values[0],\n      query.memberInfo\n    )\n  );\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHANOREQUALTO,\n      values[1],\n      query.memberInfo\n    )\n  );\n\n  return andCondition;\n};\n"],"names":["inDataRangeTransform","query","member","values","length","Error","andCondition","andDuckdbCondition","children","push","baseDuckdbCondition","ExpressionType","COMPARE_GREATERTHANOREQUALTO","memberInfo","COMPARE_LESSTHANOREQUALTO"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;qBACI;sCACC;AAG7B,MAAMA,uBAAuD,CAACC;IACnE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,MAAMC,eAAeC,IAAAA,uBAAkB;IAEvCD,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,4BAA4B,EAC3CT,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpBP,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACG,yBAAyB,EACxCX,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpB,OAAOP;AACT"}

package/cube-filter-transformer/lt/lt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/lt/lt.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const ltTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('lt filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHAN,\n      values[0],\n      query.memberInfo\n    );\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      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_LESSTHAN,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["ltTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_LESSTHAN","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,cAA8C,CAACC;IAC1D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,gBAAgB,EAC/BL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,gBAAgB,EAC/BK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

package/cube-filter-transformer/lte/lte.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/lte/lte.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const lteTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('lte filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHANOREQUALTO,\n      values[0],\n      query.memberInfo\n    );\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      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_LESSTHANOREQUALTO,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["lteTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_LESSTHANOREQUALTO","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,eAA+C,CAACC;IAC3D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,yBAAyB,EACxCL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,yBAAyB,EACxCK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not/not.ts"],"sourcesContent":["import {\n  ExpressionClass,\n  ExpressionType,\n  OperatorExpression,\n} from '../../types/duckdb-serialization-types/index';\n\nexport const notDuckdbCondition = (): OperatorExpression => {\n  return {\n    class: ExpressionClass.OPERATOR,\n    type: ExpressionType.OPERATOR_NOT,\n    alias: '',\n    children: [],\n  };\n};\n"],"names":["notDuckdbCondition","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_NOT","alias","children"],"mappings":";+BAMaA;;;eAAAA;;;uBAFN;AAEA,MAAMA,qBAAqB;IAChC,OAAO;QACLC,OAAOC,sBAAe,CAACC,QAAQ;QAC/BC,MAAMC,qBAAc,CAACC,YAAY;QACjCC,OAAO;QACPC,UAAU,EAAE;IACd;AACF"}

package/cube-filter-transformer/not-In-date-range/not-In-date-range.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-In-date-range/not-In-date-range.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const notInDataRangeTransform: CubeToParseExpressionTransform = (\n  query\n) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GT filter must have at least one value');\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const andCondition = orDuckdbCondition();\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHAN,\n      values[0],\n      query.memberInfo\n    )\n  );\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHAN,\n      values[1],\n      query.memberInfo\n    )\n  );\n\n  return andCondition;\n};\n"],"names":["notInDataRangeTransform","query","member","values","length","Error","andCondition","orDuckdbCondition","children","push","baseDuckdbCondition","ExpressionType","COMPARE_LESSTHAN","memberInfo","COMPARE_GREATERTHAN"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,0BAA0D,CACrEC;IAEA,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,MAAMC,eAAeC,IAAAA,qBAAiB;IAEtCD,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,gBAAgB,EAC/BT,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpBP,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACG,mBAAmB,EAClCX,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpB,OAAOP;AACT"}

package/{src/cube-filter-transformer → cube-filter-transformer}/not-contains/not-contains.js

@@ -13,9 +13,9 @@ _export(exports, {
         return notContainsTransform;
     }
 });
+const _constants = require("../../member-formatters/constants");
 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 {
@@ -29,7 +29,7 @@ const notContainsDuckdbCondition = (columnName, value, memberInfo)=>{
                 class: 'COLUMN_REF',
                 type: 'COLUMN_REF',
                 alias: '',
-                column_names: columnName.split(_constant.COLUMN_NAME_DELIMITER)
+                column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
             },
             {
                 class: 'CONSTANT',

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-contains/not-contains.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport { 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 { 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;;;2BAtDyB;4BAM/B;sCACsB;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,CAACC,gCAAqB;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/cube-filter-transformer/not-equals/not-equals-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-equals/not-equals-array.ts"],"sourcesContent":["import { equalsArrayTransform } from '../equals/equals-array';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { notDuckdbCondition } from '../not/not';\n\nexport const notEqualsArrayTransform: CubeToParseExpressionTransform = (\n  query\n) => {\n  const { values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Equals filter must have at least one value');\n  }\n\n  const notWrapper = notDuckdbCondition();\n  const equalsCondition = equalsArrayTransform(query);\n  /**\n   * We need to wrap the equals condition in a not condition\n   * Which basically means ! of ANY of the values\n   */\n  notWrapper.children = [equalsCondition];\n\n  return notWrapper;\n};\n"],"names":["notEqualsArrayTransform","query","values","length","Error","notWrapper","notDuckdbCondition","equalsCondition","equalsArrayTransform","children"],"mappings":";+BAIaA;;;eAAAA;;;6BAJwB;qBAEF;AAE5B,MAAMA,0BAA0D,CACrEC;IAEA,MAAM,EAAEC,MAAM,EAAE,GAAGD;IAEnB,IAAI,CAACC,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,aAAaC,IAAAA,uBAAkB;IACrC,MAAMC,kBAAkBC,IAAAA,iCAAoB,EAACP;IAC7C;;;GAGC,GACDI,WAAWI,QAAQ,GAAG;QAACF;KAAgB;IAEvC,OAAOF;AACT"}

package/cube-filter-transformer/not-equals/not-equals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-equals/not-equals.ts"],"sourcesContent":["import { Member, QueryFilter } from '../../types/cube-types/query';\nimport { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { isArrayTypeMember } from '../../utils/is-array-member-type';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\nimport { notEqualsArrayTransform } from './not-equals-array';\n\nexport interface NotEqualsFilters extends QueryFilter {\n  member: Member;\n  operator: 'notEquals';\n  values: string[];\n}\n\nexport const notEqualsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Equals filter must have at least one value');\n  }\n\n  /**\n   * If the member is an array, we need to use the array transform\n   */\n  if (isArrayTypeMember(query.memberInfo.type)) {\n    return notEqualsArrayTransform(query);\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_NOTEQUAL,\n      values[0],\n      query.memberInfo\n    );\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      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_NOTEQUAL,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["notEqualsTransform","query","member","values","length","Error","isArrayTypeMember","memberInfo","type","notEqualsArrayTransform","baseDuckdbCondition","ExpressionType","COMPARE_NOTEQUAL","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAcaA;;;eAAAA;;;4BAbkB;mCACG;sCACE;oBAEF;gCACM;AAQjC,MAAMA,qBAAqD,CAACC;IACjE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIC,IAAAA,oCAAiB,EAACL,MAAMM,UAAU,CAACC,IAAI,GAAG;QAC5C,OAAOC,IAAAA,uCAAuB,EAACR;IACjC;IAEA;;GAEC,GACD,IAAIE,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOM,IAAAA,yCAAmB,EACxBR,QACAS,0BAAc,CAACC,gBAAgB,EAC/BT,MAAM,CAAC,EAAE,EACTF,MAAMM,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMM,cAAcC,IAAAA,qBAAiB;IACrCX,OAAOY,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBR,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,gBAAgB,EAC/BI,OACAf,MAAMM,UAAU;IAGtB;IACA,OAAOM;AACT"}

package/{src/cube-filter-transformer → cube-filter-transformer}/not-in/not-in.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "notInTransform", {
         return notInTransform;
     }
 });
+const _constants = require("../../member-formatters/constants");
 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 {
@@ -21,7 +21,7 @@ const notInDuckDbCondition = (columnName, values, memberInfo)=>{
         class: 'COLUMN_REF',
         type: 'COLUMN_REF',
         alias: '',
-        column_names: columnName.split(_constant.COLUMN_NAME_DELIMITER)
+        column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
     };
     switch(memberInfo.type){
         case 'number_array':

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

@@ -0,0 +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\nimport { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\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;;;2BAzEyB;4BAI/B;sCACsB;AAE7B,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,gCAAqB;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 → cube-filter-transformer}/not-set/not-set.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "notSetTransform", {
         return notSetTransform;
     }
 });
+const _constants = require("../../member-formatters/constants");
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _constant = require("../constant");
 const notSetTransform = (query)=>{
     const { member } = query;
     return {
@@ -18,7 +18,7 @@ const notSetTransform = (query)=>{
                 class: 'COLUMN_REF',
                 type: 'COLUMN_REF',
                 alias: '',
-                column_names: member.split(_constant.COLUMN_NAME_DELIMITER)
+                column_names: member.split(_constants.COLUMN_NAME_DELIMITER)
             }
         ]
     };

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-set/not-set.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} 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(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;;;2BAPyB;4BAI/B;AAGA,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,gCAAqB;YAClD;SACD;IACH;AACF"}

package/cube-filter-transformer/or/or.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/or/or.ts"],"sourcesContent":["import { ConjunctionExpression } from '../../types/duckdb-serialization-types/serialization/ParsedExpression';\nimport { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\n\nexport const orDuckdbCondition = (): ConjunctionExpression => {\n  return {\n    class: ExpressionClass.CONJUNCTION,\n    type: ExpressionType.CONJUNCTION_OR,\n    alias: '',\n    children: [],\n  };\n};\n"],"names":["orDuckdbCondition","class","ExpressionClass","CONJUNCTION","type","ExpressionType","CONJUNCTION_OR","alias","children"],"mappings":";+BAGaA;;;eAAAA;;;4BAFmC;AAEzC,MAAMA,oBAAoB;IAC/B,OAAO;QACLC,OAAOC,2BAAe,CAACC,WAAW;QAClCC,MAAMC,0BAAc,CAACC,cAAc;QACnCC,OAAO;QACPC,UAAU,EAAE;IACd;AACF"}

package/{src/cube-filter-transformer → cube-filter-transformer}/set/set.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "setTransform", {
         return setTransform;
     }
 });
+const _constants = require("../../member-formatters/constants");
 const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _constant = require("../constant");
 const setTransform = (query)=>{
     const { member } = query;
     return {
@@ -18,7 +18,7 @@ const setTransform = (query)=>{
                 class: 'COLUMN_REF',
                 type: 'COLUMN_REF',
                 alias: '',
-                column_names: member.split(_constant.COLUMN_NAME_DELIMITER)
+                column_names: member.split(_constants.COLUMN_NAME_DELIMITER)
             }
         ]
     };

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/set/set.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} 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(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;;;2BAPyB;4BAI/B;AAGA,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,gCAAqB;YAClD;SACD;IACH;AACF"}

package/{src/cube-group-by-transformer → cube-group-by-transformer}/cube-group-by-transformer.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "cubeDimensionToGroupByAST", {
         return cubeDimensionToGroupByAST;
     }
 });
+const _memberformatters = require("../member-formatters");
 const _Expression = require("../types/duckdb-serialization-types/serialization/Expression");
-const _memberkeytosafekey = require("../utils/member-key-to-safe-key");
 const cubeDimensionToGroupByAST = (dimensions)=>{
     const groupByAST = dimensions.map((dimension)=>{
         const dimensionAST = {
@@ -14,7 +14,7 @@ const cubeDimensionToGroupByAST = (dimensions)=>{
             type: _Expression.ExpressionType.COLUMN_REF,
             alias: '',
             column_names: [
-                (0, _memberkeytosafekey.memberKeyToSafeKey)(dimension)
+                (0, _memberformatters.memberKeyToSafeKey)(dimension)
             ]
         };
         return dimensionAST;

package/cube-group-by-transformer/cube-group-by-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-group-by-transformer/cube-group-by-transformer.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters';\nimport { Member } from '../types/cube-types/query';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\n\nexport const cubeDimensionToGroupByAST = (dimensions: Member[]) => {\n  const groupByAST = dimensions.map((dimension) => {\n    const dimensionAST = {\n      class: ExpressionClass.COLUMN_REF,\n      type: ExpressionType.COLUMN_REF,\n      alias: '',\n      column_names: [memberKeyToSafeKey(dimension)],\n    };\n\n    return dimensionAST;\n  });\n\n  return groupByAST;\n};\n"],"names":["cubeDimensionToGroupByAST","dimensions","groupByAST","map","dimension","dimensionAST","class","ExpressionClass","COLUMN_REF","type","ExpressionType","alias","column_names","memberKeyToSafeKey"],"mappings":";+BAOaA;;;eAAAA;;;kCAPsB;4BAK5B;AAEA,MAAMA,4BAA4B,CAACC;IACxC,MAAMC,aAAaD,WAAWE,GAAG,CAAC,CAACC;QACjC,MAAMC,eAAe;YACnBC,OAAOC,2BAAe,CAACC,UAAU;YACjCC,MAAMC,0BAAc,CAACF,UAAU;YAC/BG,OAAO;YACPC,cAAc;gBAACC,IAAAA,oCAAkB,EAACT;aAAW;QAC/C;QAEA,OAAOC;IACT;IAEA,OAAOH;AACT"}

package/cube-limit-offset-transformer/cube-limit-offset-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-limit-offset-transformer/cube-limit-offset-transformer.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from '../types/duckdb-serialization-types/serialization/Expression';\nimport { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';\n\nexport const cubeLimitOffsetToAST = (\n  limit?: number | null,\n  offset?: number | null\n) => {\n  return {\n    type: ResultModifierType.LIMIT_MODIFIER,\n    limit: limit\n      ? {\n          class: ExpressionClass.CONSTANT,\n          type: ExpressionType.VALUE_CONSTANT,\n          alias: '',\n          value: {\n            type: {\n              id: 'INTEGER',\n              type_info: null,\n            },\n            is_null: false,\n            value: limit,\n          },\n        }\n      : null,\n    offset: offset\n      ? {\n          class: ExpressionClass.CONSTANT,\n          type: ExpressionType.VALUE_CONSTANT,\n          alias: '',\n          value: {\n            type: {\n              id: 'INTEGER',\n              type_info: null,\n            },\n            is_null: false,\n            value: offset,\n          },\n        }\n      : null,\n  };\n};\n"],"names":["cubeLimitOffsetToAST","limit","offset","type","ResultModifierType","LIMIT_MODIFIER","class","ExpressionClass","CONSTANT","ExpressionType","VALUE_CONSTANT","alias","value","id","type_info","is_null"],"mappings":";+BAGaA;;;eAAAA;;;4BAHmC;gCACb;AAE5B,MAAMA,uBAAuB,CAClCC,OACAC;IAEA,OAAO;QACLC,MAAMC,kCAAkB,CAACC,cAAc;QACvCJ,OAAOA,QACH;YACEK,OAAOC,2BAAe,CAACC,QAAQ;YAC/BL,MAAMM,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPC,OAAO;gBACLT,MAAM;oBACJU,IAAI;oBACJC,WAAW;gBACb;gBACAC,SAAS;gBACTH,OAAOX;YACT;QACF,IACA;QACJC,QAAQA,SACJ;YACEI,OAAOC,2BAAe,CAACC,QAAQ;YAC/BL,MAAMM,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPC,OAAO;gBACLT,MAAM;oBACJU,IAAI;oBACJC,WAAW;gBACb;gBACAC,SAAS;gBACTH,OAAOV;YACT;QACF,IACA;IACN;AACF"}

package/{src/cube-measure-transformer → cube-measure-transformer}/cube-measure-transformer.js

@@ -6,21 +6,22 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    applyProjectionToSQLQuery: function() {
+        return applyProjectionToSQLQuery;
+    },
     cubeMeasureToSQLSelectString: function() {
         return cubeMeasureToSQLSelectString;
     },
-    getSelectReplacedSql: function() {
-        return getSelectReplacedSql;
-    },
     getAllColumnUsedInMeasures: function() {
         return getAllColumnUsedInMeasures;
     },
-    applyProjectionToSQLQuery: function() {
-        return applyProjectionToSQLQuery;
+    getSelectReplacedSql: function() {
+        return getSelectReplacedSql;
     }
 });
+const _memberkeytosafekey = require("../member-formatters/member-key-to-safe-key");
+const _splitintodatasourceandfields = require("../member-formatters/split-into-data-source-and-fields");
 const _meerkatplaceholderreplacer = require("../utils/meerkat-placeholder-replacer");
-const _memberkeytosafekey = require("../utils/member-key-to-safe-key");
 const cubeMeasureToSQLSelectString = (measures, tableSchema)=>{
     let base = 'SELECT';
     for(let i = 0; i < measures.length; i++){
@@ -29,7 +30,7 @@ const cubeMeasureToSQLSelectString = (measures, tableSchema)=>{
             base += ` ${tableSchema.name}.*`;
             continue;
         }
-        const [tableSchemaName, measureKeyWithoutTable] = measure.split('.');
+        const [tableSchemaName, measureKeyWithoutTable] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(measure);
         const aliasKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(measure);
         const measureSchema = tableSchema.measures.find((m)=>m.name === measureKeyWithoutTable);
         if (!measureSchema) {
@@ -46,7 +47,7 @@ const cubeMeasureToSQLSelectString = (measures, tableSchema)=>{
      */ const columnsUsedInMeasure = getColumnsFromSQL(meerkatReplacedSqlString, tableSchemaName);
         //Replace all the columnsUsedInMeasure with safeKey
         columnsUsedInMeasure == null ? void 0 : columnsUsedInMeasure.forEach((measureKey)=>{
-            const column = measureKey.split('.')[1];
+            const [_, column] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(measureKey);
             const memberKey = `${tableSchemaName}.${column}`;
             const columnKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(memberKey);
             meerkatReplacedSqlString = meerkatReplacedSqlString.replace(memberKey, columnKey);
@@ -62,7 +63,7 @@ const addDimensionToSQLProjection = (dimensions, selectString, tableSchema)=>{
     let newSelectString = selectString;
     for(let i = 0; i < dimensions.length; i++){
         const dimension = dimensions[i];
-        const dimensionKeyWithoutTable = dimension.split('.')[1];
+        const [_, dimensionKeyWithoutTable] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(dimension);
         const dimensionSchema = tableSchema.dimensions.find((m)=>m.name === dimensionKeyWithoutTable);
         const aliasKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(dimension);
         if (!dimensionSchema) {

package/cube-measure-transformer/cube-measure-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-measure-transformer/cube-measure-transformer.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';\nimport { Member } from '../types/cube-types/query';\nimport { Measure, TableSchema } from '../types/cube-types/table';\nimport { meerkatPlaceholderReplacer } from '../utils/meerkat-placeholder-replacer';\n\nexport const cubeMeasureToSQLSelectString = (\n  measures: Member[],\n  tableSchema: TableSchema\n) => {\n  let base = 'SELECT';\n  for (let i = 0; i < measures.length; i++) {\n    const measure = measures[i];\n    if (measure === '*') {\n      base += ` ${tableSchema.name}.*`;\n      continue;\n    }\n    const [tableSchemaName, measureKeyWithoutTable] =\n      splitIntoDataSourceAndFields(measure);\n\n    const aliasKey = memberKeyToSafeKey(measure);\n    const measureSchema = tableSchema.measures.find(\n      (m) => m.name === measureKeyWithoutTable\n    );\n    if (!measureSchema) {\n      continue;\n    }\n    if (i > 0) {\n      base += ', ';\n    }\n    let meerkatReplacedSqlString = meerkatPlaceholderReplacer(\n      measureSchema.sql,\n      tableSchema.name\n    );\n\n    /**\n     * Here we extract the columns used in the measure and replace them with the safeKey.\n     * We need to do this because the columns used in the measure are not directly available in the joined table.\n     * Thus we need to project them and use them in the join.\n     */\n\n    const columnsUsedInMeasure = getColumnsFromSQL(\n      meerkatReplacedSqlString,\n      tableSchemaName\n    );\n\n    //Replace all the columnsUsedInMeasure with safeKey\n    columnsUsedInMeasure?.forEach((measureKey) => {\n      const [_, column] = splitIntoDataSourceAndFields(measureKey);\n      const memberKey = `${tableSchemaName}.${column}`;\n      const columnKey = memberKeyToSafeKey(memberKey);\n      meerkatReplacedSqlString = meerkatReplacedSqlString.replace(\n        memberKey,\n        columnKey\n      );\n    });\n\n    base += ` ${meerkatReplacedSqlString} AS ${aliasKey} `;\n  }\n  return base;\n};\n\nconst addDimensionToSQLProjection = (\n  dimensions: Member[],\n  selectString: string,\n  tableSchema: TableSchema\n) => {\n  if (dimensions.length === 0) {\n    return selectString;\n  }\n  let newSelectString = selectString;\n  for (let i = 0; i < dimensions.length; i++) {\n    const dimension = dimensions[i];\n    const [_, dimensionKeyWithoutTable] =\n      splitIntoDataSourceAndFields(dimension);\n    const dimensionSchema = tableSchema.dimensions.find(\n      (m) => m.name === dimensionKeyWithoutTable\n    );\n    const aliasKey = memberKeyToSafeKey(dimension);\n\n    if (!dimensionSchema) {\n      continue;\n    }\n    if (i > 0) {\n      newSelectString += ',';\n    }\n    // since alias key is expected to have been unfurled in the base query, we can just use it as is.\n    newSelectString += `  ${aliasKey}`;\n  }\n  return newSelectString;\n};\n\nexport const getSelectReplacedSql = (sql: string, selectString: string) => {\n  /*\n   ** Replaces the select portion of a SQL string with the selectString passed.\n   */\n  const selectRegex = /SELECT\\s\\*/;\n  const match = sql.match(selectRegex);\n  if (!match) {\n    return sql;\n  }\n  const selectIndex = match.index;\n  if (selectIndex === undefined) {\n    throw new Error('SELECT * not found in SQL string');\n  }\n  const selectLength = match[0].length;\n  const beforeSelect = sql.substring(0, selectIndex);\n  const afterSelect = sql.substring(selectIndex + selectLength);\n  return `${beforeSelect}${selectString}${afterSelect}`;\n};\n\n/**\n * Get all the columns used in the measures.\n * This is used for extracting the columns used in the measures needed for the projection.\n * Example: The joins implementation uses this to get the columns used in the measures to join the tables.\n * like the SQL for the measure is `SUM(table.total)` and the table name is `table`, then the column used is `total`\n * table cannot be used directly here because the joined table would have column name ambiguity.\n * Thus these columns are projected and directly used in the join.\n */\nexport const getAllColumnUsedInMeasures = (\n  measures: Measure[],\n  tableSchema: TableSchema\n) => {\n  let columns: string[] = [];\n  measures.forEach((measure) => {\n    const columnMatch = getColumnsFromSQL(measure.sql, tableSchema.name);\n    if (columnMatch && columnMatch.length > 0) {\n      columns = [...columns, ...columnMatch];\n    }\n  });\n  // Remove duplicates\n  return [...new Set(columns)];\n};\n\nconst getColumnsFromSQL = (sql: string, tableName: string) => {\n  const regex = new RegExp(`(${tableName}\\\\.[a-zA-Z0-9_]+)`, 'g');\n  const columnMatch = sql.match(regex);\n  return columnMatch;\n};\n\n/**\n * Replace the first SELECT * from the sqlToReplace with the cube measure\n * @param measures\n * @param tableSchema\n * @param sqlToReplace\n * @returns\n */\nexport const applyProjectionToSQLQuery = (\n  dimensions: Member[],\n  measures: Member[],\n  tableSchema: TableSchema,\n  sqlToReplace: string\n) => {\n  let measureSelectString = cubeMeasureToSQLSelectString(measures, tableSchema);\n\n  if (measures.length > 0 && dimensions.length > 0) {\n    measureSelectString += ', ';\n  }\n  const selectString = addDimensionToSQLProjection(\n    dimensions,\n    measureSelectString,\n    tableSchema\n  );\n\n  return getSelectReplacedSql(sqlToReplace, selectString);\n};\n"],"names":["applyProjectionToSQLQuery","cubeMeasureToSQLSelectString","getAllColumnUsedInMeasures","getSelectReplacedSql","measures","tableSchema","base","i","length","measure","name","tableSchemaName","measureKeyWithoutTable","splitIntoDataSourceAndFields","aliasKey","memberKeyToSafeKey","measureSchema","find","m","meerkatReplacedSqlString","meerkatPlaceholderReplacer","sql","columnsUsedInMeasure","getColumnsFromSQL","forEach","measureKey","_","column","memberKey","columnKey","replace","addDimensionToSQLProjection","dimensions","selectString","newSelectString","dimension","dimensionKeyWithoutTable","dimensionSchema","selectRegex","match","selectIndex","index","undefined","Error","selectLength","beforeSelect","substring","afterSelect","columns","columnMatch","Set","tableName","regex","RegExp","sqlToReplace","measureSelectString"],"mappings":"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"}

package/{src/cube-order-by-transformer → cube-order-by-transformer}/cube-order-by-transformer.js

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "cubeOrderByToAST", {
         return cubeOrderByToAST;
     }
 });
+const _memberkeytosafekey = require("../member-formatters/member-key-to-safe-key");
 const _Expression = require("../types/duckdb-serialization-types/serialization/Expression");
 const _Nodes = require("../types/duckdb-serialization-types/serialization/Nodes");
 const _ResultModifier = require("../types/duckdb-serialization-types/serialization/ResultModifier");
-const _memberkeytosafekey = require("../utils/member-key-to-safe-key");
 const cubeOrderByToAST = (order)=>{
     const orderArr = [];
     for(const key in order){

package/cube-order-by-transformer/cube-order-by-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-order-by-transformer/cube-order-by-transformer.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\nimport { OrderType } from '../types/duckdb-serialization-types/serialization/Nodes';\nimport { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';\n\nexport const cubeOrderByToAST = (order: { [key: string]: 'asc' | 'desc' }) => {\n  const orderArr = [];\n  for (const key in order) {\n    const value = order[key];\n    const astOrderBy =\n      value === 'asc' ? OrderType.ASCENDING : OrderType.DESCENDING;\n    const orderByAST = {\n      type: astOrderBy,\n      null_order: OrderType.ORDER_DEFAULT,\n      expression: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        /**\n         * We need to convert the key in the __ format as they are being projected in this format\n         */\n        column_names: [memberKeyToSafeKey(key)],\n      },\n    };\n    orderArr.push(orderByAST);\n  }\n  return {\n    type: ResultModifierType.ORDER_MODIFIER,\n    orders: orderArr,\n  };\n};\n"],"names":["cubeOrderByToAST","order","orderArr","key","value","astOrderBy","OrderType","ASCENDING","DESCENDING","orderByAST","type","null_order","ORDER_DEFAULT","expression","class","ExpressionClass","COLUMN_REF","ExpressionType","alias","column_names","memberKeyToSafeKey","push","ResultModifierType","ORDER_MODIFIER","orders"],"mappings":";+BAQaA;;;eAAAA;;;oCARsB;4BAI5B;uBACmB;gCACS;AAE5B,MAAMA,mBAAmB,CAACC;IAC/B,MAAMC,WAAW,EAAE;IACnB,IAAK,MAAMC,OAAOF,MAAO;QACvB,MAAMG,QAAQH,KAAK,CAACE,IAAI;QACxB,MAAME,aACJD,UAAU,QAAQE,gBAAS,CAACC,SAAS,GAAGD,gBAAS,CAACE,UAAU;QAC9D,MAAMC,aAAa;YACjBC,MAAML;YACNM,YAAYL,gBAAS,CAACM,aAAa;YACnCC,YAAY;gBACVC,OAAOC,2BAAe,CAACC,UAAU;gBACjCN,MAAMO,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACP;;SAEC,GACDC,cAAc;oBAACC,IAAAA,sCAAkB,EAACjB;iBAAK;YACzC;QACF;QACAD,SAASmB,IAAI,CAACZ;IAChB;IACA,OAAO;QACLC,MAAMY,kCAAkB,CAACC,cAAc;QACvCC,QAAQtB;IACV;AACF"}

package/cube-to-duckdb/cube-filter-to-duckdb.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-to-duckdb/cube-filter-to-duckdb.ts"],"names":[],"mappings":""}

package/{src/filter-params → filter-params}/filter-params-ast.js

@@ -6,20 +6,20 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    traverseAndFilter: function() {
-        return traverseAndFilter;
-    },
-    getFilterByMemberKey: function() {
-        return getFilterByMemberKey;
+    applyFilterParamsToBaseSQL: function() {
+        return applyFilterParamsToBaseSQL;
     },
     detectAllFilterParamsFromSQL: function() {
         return detectAllFilterParamsFromSQL;
     },
+    getFilterByMemberKey: function() {
+        return getFilterByMemberKey;
+    },
     getFilterParamsAST: function() {
         return getFilterParamsAST;
     },
-    applyFilterParamsToBaseSQL: function() {
-        return applyFilterParamsToBaseSQL;
+    traverseAndFilter: function() {
+        return traverseAndFilter;
     }
 });
 const _astbuilder = require("../ast-builder/ast-builder");

package/filter-params/filter-params-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/filter-params/filter-params-ast.ts"],"sourcesContent":["import { cubeToDuckdbAST } from '../ast-builder/ast-builder';\nimport {\n  FilterType,\n  LogicalAndFilter,\n  LogicalOrFilter,\n  MeerkatQueryFilter,\n  Query,\n  QueryFilter,\n  TableSchema\n} from '../types/cube-types';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\n\n/**\n * Get the query filter with only where filterKey matches\n */\n\nexport const traverseAndFilter = (\n  filter: MeerkatQueryFilter,\n  callback: (value: QueryFilter) => boolean\n): MeerkatQueryFilter | null => {\n  if ('member' in filter) {\n    return callback(filter) ? filter : null;\n  }\n\n  if ('and' in filter) {\n    const filteredAndFilters = filter.and\n      .map((subFilter) => traverseAndFilter(subFilter, callback))\n      .filter(Boolean) as MeerkatQueryFilter[];\n    const obj =\n      filteredAndFilters.length > 0 ? { and: filteredAndFilters } : null;\n    return obj as LogicalAndFilter;\n  }\n\n  if ('or' in filter) {\n    const filteredOrFilters = filter.or\n      .map((subFilter) => traverseAndFilter(subFilter, callback))\n      .filter(Boolean);\n    const obj = filteredOrFilters.length > 0 ? { or: filteredOrFilters } : null;\n    return obj as LogicalOrFilter;\n  }\n\n  return null;\n};\n\n\nexport const getFilterByMemberKey = (\n  filters: MeerkatQueryFilter[] | undefined,\n  memberKey: string\n): MeerkatQueryFilter[] => {\n  if (!filters) return [];\n  return filters\n    .map((filter) => traverseAndFilter(filter, (value) =>  value.member === memberKey))\n    .filter(Boolean) as MeerkatQueryFilter[];\n};\n\n/**\n * Syntax for filter params in SQL:\n * FILTER_PARAMS.cube_name.member_name.filter(sql_expression)\n * Example:\n *  SELECT *\n *  FROM orders\n *  WHERE ${FILTER_PARAMS.order_facts.date.filter('date')}\n * @param sql\n */\nexport const detectAllFilterParamsFromSQL = (\n  sql: string\n): {\n  memberKey: string;\n  filterExpression: string;\n  matchKey: string;\n}[] => {\n  const regex = /\\${FILTER_PARAMS\\.(\\w+\\.\\w+)\\.filter\\('(\\w+)'\\)}/g;\n  const matches = [];\n  let match;\n  while ((match = regex.exec(sql)) !== null) {\n    matches.push({\n      memberKey: match[1],\n      filterExpression: match[2],\n      matchKey: match[0],\n    });\n  }\n  return matches;\n};\n\n\n\nexport const getFilterParamsAST = (\n  query: Query,\n  tableSchema: TableSchema,\n  filterType: FilterType = 'PROJECTION_FILTER'\n): {\n  memberKey: string;\n  ast: SelectStatement | null;\n  matchKey: string;\n}[] => {\n  const filterParamKeys = detectAllFilterParamsFromSQL(tableSchema.sql);\n  const filterParamsAST = [];\n  \n  for (const filterParamKey of filterParamKeys) {\n    const filters = getFilterByMemberKey(\n      query.filters,\n      filterParamKey.memberKey\n    );\n   \n    if (filters && filters.length > 0) {\n      filterParamsAST.push({\n        memberKey: filterParamKey.memberKey,\n        matchKey: filterParamKey.matchKey,\n        ast: cubeToDuckdbAST(\n          { filters, measures: [], dimensions: [] },\n          tableSchema,\n          {\n            filterType\n          }\n        ),\n      });\n    }\n  }\n\n  return filterParamsAST;\n};\n\ntype FilterParamsSQL = {\n  memberKey: string;\n  sql: string;\n  matchKey: string;\n}\n\nconst replaceWhereClauseWithFiltersParamsSQL = (baseSQL: string, filterParamsSQL: FilterParamsSQL[]) => {\n  let finalSQL = baseSQL;\n\n  for (const filterParam of filterParamsSQL) {\n    /**\n     * Get SQL expression after WHERE clause\n     */\n    const whereClause = filterParam.sql.split('WHERE')[1];\n    /**\n     * Replace filter param with SQL expression\n     */\n    finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);\n  }\n  return finalSQL\n}\n\nexport const applyFilterParamsToBaseSQL = (\n  baseSQL: string,\n  filterParamsSQL: FilterParamsSQL[]\n) => {\n  let finalSQL = replaceWhereClauseWithFiltersParamsSQL(baseSQL, filterParamsSQL);\n  for (const filterParam of filterParamsSQL) {\n    /**\n     * Get SQL expression after WHERE clause\n     */\n    const whereClause = filterParam.sql.split('WHERE')[1];\n    /**\n     * Replace filter param with SQL expression\n     */\n    finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);\n  }\n  /**\n   * Find all remaining filter params and replace them with TRUE\n   */\n  const remainingFilterParams = detectAllFilterParamsFromSQL(finalSQL);\n\n  for (const filterParam of remainingFilterParams) {\n    finalSQL = finalSQL.replace(filterParam.matchKey, 'TRUE');\n  }\n  return finalSQL;\n};\n"],"names":["applyFilterParamsToBaseSQL","detectAllFilterParamsFromSQL","getFilterByMemberKey","getFilterParamsAST","traverseAndFilter","filter","callback","filteredAndFilters","and","map","subFilter","Boolean","obj","length","filteredOrFilters","or","filters","memberKey","value","member","sql","regex","matches","match","exec","push","filterExpression","matchKey","query","tableSchema","filterType","filterParamKeys","filterParamsAST","filterParamKey","ast","cubeToDuckdbAST","measures","dimensions","replaceWhereClauseWithFiltersParamsSQL","baseSQL","filterParamsSQL","finalSQL","filterParam","whereClause","split","replace","remainingFilterParams"],"mappings":"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"}

package/get-filter-params-sql/get-filter-params-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-filter-params-sql/get-filter-params-sql.ts"],"sourcesContent":["import { astDeserializerQuery, deserializeQuery } from \"../ast-deserializer/ast-deserializer\";\nimport { getFilterParamsAST } from \"../filter-params/filter-params-ast\";\nimport { FilterType, Query, TableSchema } from \"../types/cube-types\";\n\nexport const getFilterParamsSQL = async ({\n  query,\n  tableSchema,\n  filterType,\n  getQueryOutput\n}: {\n  query: Query;\n  tableSchema: TableSchema;\n  filterType?: FilterType;\n  getQueryOutput: (query: string) => Promise<any>;\n}) => {\n  const filterParamsAST = getFilterParamsAST(\n    query,\n    tableSchema,\n    filterType\n  );\n  const filterParamsSQL = [];\n  for (const filterParamAST of filterParamsAST) {\n    if (!filterParamAST.ast) {\n      continue;\n    }\n\n    const queryOutput = await getQueryOutput(astDeserializerQuery(filterParamAST.ast))\n    const sql = deserializeQuery(queryOutput);\n\n    filterParamsSQL.push({\n      memberKey: filterParamAST.memberKey,\n      sql: sql,\n      matchKey: filterParamAST.matchKey,\n    });\n  }\n  return filterParamsSQL;\n};\n"],"names":["getFilterParamsSQL","query","tableSchema","filterType","getQueryOutput","filterParamsAST","getFilterParamsAST","filterParamsSQL","filterParamAST","ast","queryOutput","astDeserializerQuery","sql","deserializeQuery","push","memberKey","matchKey"],"mappings":";+BAIaA;;;eAAAA;;;iCAJ0C;iCACpB;AAG5B,MAAMA,qBAAqB,OAAO,EACvCC,KAAK,EACLC,WAAW,EACXC,UAAU,EACVC,cAAc,EAMf;IACC,MAAMC,kBAAkBC,IAAAA,mCAAkB,EACxCL,OACAC,aACAC;IAEF,MAAMI,kBAAkB,EAAE;IAC1B,KAAK,MAAMC,kBAAkBH,gBAAiB;QAC5C,IAAI,CAACG,eAAeC,GAAG,EAAE;YACvB;QACF;QAEA,MAAMC,cAAc,MAAMN,eAAeO,IAAAA,qCAAoB,EAACH,eAAeC,GAAG;QAChF,MAAMG,MAAMC,IAAAA,iCAAgB,EAACH;QAE7BH,gBAAgBO,IAAI,CAAC;YACnBC,WAAWP,eAAeO,SAAS;YACnCH,KAAKA;YACLI,UAAUR,eAAeQ,QAAQ;QACnC;IACF;IACA,OAAOT;AACT"}

package/get-final-base-sql/get-final-base-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-final-base-sql/get-final-base-sql.ts"],"sourcesContent":["import { applyFilterParamsToBaseSQL } from \"../filter-params/filter-params-ast\";\nimport { getFilterParamsSQL } from \"../get-filter-params-sql/get-filter-params-sql\";\nimport { getWrappedBaseQueryWithProjections } from \"../get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections\";\nimport { Query } from \"../types/cube-types/query\";\nimport { TableSchema } from \"../types/cube-types/table\";\n\nexport const getFinalBaseSQL = async ({\n  query,\n  getQueryOutput,\n  tableSchema,\n}: { query: Query, tableSchema: TableSchema, getQueryOutput: (query: string) => Promise<any> }) => {\n  /**\n   * Apply transformation to the supplied base query.\n   * This involves updating the filter placeholder with the actual filter values.\n   */\n  const baseFilterParamsSQL = await getFilterParamsSQL({\n    query: query,\n    tableSchema,\n    filterType: 'BASE_FILTER',\n    getQueryOutput,\n  });\n  const baseSQL = applyFilterParamsToBaseSQL(\n    tableSchema.sql,\n    baseFilterParamsSQL\n  );\n  const baseSQLWithFilterProjection = getWrappedBaseQueryWithProjections({\n    baseQuery: baseSQL,\n    tableSchema,\n    query: query,\n  });\n  return baseSQLWithFilterProjection;\n};\n  \n"],"names":["getFinalBaseSQL","query","getQueryOutput","tableSchema","baseFilterParamsSQL","getFilterParamsSQL","filterType","baseSQL","applyFilterParamsToBaseSQL","sql","baseSQLWithFilterProjection","getWrappedBaseQueryWithProjections","baseQuery"],"mappings":";+BAMaA;;;eAAAA;;;iCAN8B;oCACR;oDACgB;AAI5C,MAAMA,kBAAkB,OAAO,EACpCC,KAAK,EACLC,cAAc,EACdC,WAAW,EACiF;IAC5F;;;GAGC,GACD,MAAMC,sBAAsB,MAAMC,IAAAA,sCAAkB,EAAC;QACnDJ,OAAOA;QACPE;QACAG,YAAY;QACZJ;IACF;IACA,MAAMK,UAAUC,IAAAA,2CAA0B,EACxCL,YAAYM,GAAG,EACfL;IAEF,MAAMM,8BAA8BC,IAAAA,sEAAkC,EAAC;QACrEC,WAAWL;QACXJ;QACAF,OAAOA;IACT;IACA,OAAOS;AACT"}

package/{src/get-wrapped-base-query-with-projections → get-wrapped-base-query-with-projections}/get-aliased-columns-from-filters.js

@@ -6,22 +6,23 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    getAliasedColumnsFromFilters: function() {
+        return getAliasedColumnsFromFilters;
+    },
     getDimensionProjection: function() {
         return getDimensionProjection;
     },
     getFilterMeasureProjection: function() {
         return getFilterMeasureProjection;
-    },
-    getAliasedColumnsFromFilters: function() {
-        return getAliasedColumnsFromFilters;
     }
 });
+const _memberkeytosafekey = require("../member-formatters/member-key-to-safe-key");
+const _splitintodatasourceandfields = require("../member-formatters/split-into-data-source-and-fields");
 const _findintableschema = require("../utils/find-in-table-schema");
-const _memberkeytosafekey = require("../utils/member-key-to-safe-key");
 const _sqlexpressionmodifiers = require("./sql-expression-modifiers");
 const getDimensionProjection = ({ key, tableSchema, modifiers, query })=>{
     // Find the table access key
-    const [tableName, measureWithoutTable] = key.split('.');
+    const [tableName, measureWithoutTable] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(key);
     const foundMember = (0, _findintableschema.findInDimensionSchema)(measureWithoutTable, tableSchema);
     if (!foundMember || tableName !== tableSchema.name) {
         // If the selected member is not found in the table schema or if it is already selected, continue.
@@ -48,7 +49,7 @@ const getDimensionProjection = ({ key, tableSchema, modifiers, query })=>{
     };
 };
 const getFilterMeasureProjection = ({ key, tableSchema, measures })=>{
-    const [tableName, measureWithoutTable] = key.split('.');
+    const [tableName, measureWithoutTable] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(key);
     const foundMember = (0, _findintableschema.findInMeasureSchema)(measureWithoutTable, tableSchema);
     const isMeasure = measures.includes(key);
     if (!foundMember || isMeasure || tableName !== tableSchema.name) {
@@ -69,7 +70,7 @@ const getFilterMeasureProjection = ({ key, tableSchema, measures })=>{
     };
 };
 const getFilterProjections = ({ member, tableSchema, measures, query })=>{
-    const memberWithoutTable = member.split('.')[1];
+    const [, memberWithoutTable] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(member);
     const isDimension = (0, _findintableschema.findInDimensionSchema)(memberWithoutTable, tableSchema);
     if (isDimension) {
         return getDimensionProjection({