@devrev/meerkat-core 0.0.77

package/src/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/src/cube-filter-transformer/lte/lte.d.ts

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "lteTransform", {
+    enumerable: true,
+    get: function() {
+        return lteTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _or = require("../or/or");
+const lteTransform = (query)=>{
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('lte filter must have at least one value');
+    }
+    /**
+   * If there is only one value, we can create a simple equals condition
+   */ if (values.length === 1) {
+        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHANOREQUALTO, values[0], query.memberInfo);
+    }
+    /**
+   * If there are multiple values, we need to create an OR condition
+   */ const orCondition = (0, _or.orDuckdbCondition)();
+    values.forEach((value)=>{
+        orCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHANOREQUALTO, value, query.memberInfo));
+    });
+    return orCondition;
+};
+
+//# sourceMappingURL=lte.js.map

package/src/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/src/cube-filter-transformer/not/not.d.ts

@@ -0,0 +1,2 @@
+import { ConjunctionExpression } from '../../types/duckdb-serialization-types/index';
+export declare const notDuckdbCondition: () => ConjunctionExpression;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "notDuckdbCondition", {
+    enumerable: true,
+    get: function() {
+        return notDuckdbCondition;
+    }
+});
+const _index = require("../../types/duckdb-serialization-types/index");
+const notDuckdbCondition = ()=>{
+    return {
+        class: _index.ExpressionClass.OPERATOR,
+        type: _index.ExpressionType.OPERATOR_NOT,
+        alias: '',
+        children: []
+    };
+};
+
+//# sourceMappingURL=not.js.map

package/src/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  ConjunctionExpression,\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/index';\n\nexport const notDuckdbCondition = (): ConjunctionExpression => {\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/src/cube-filter-transformer/not-In-date-range/not-In-date-range.d.ts

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "notInDataRangeTransform", {
+    enumerable: true,
+    get: function() {
+        return notInDataRangeTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _or = require("../or/or");
+const notInDataRangeTransform = (query)=>{
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('GT filter must have at least one value');
+    }
+    /**
+   * If there are multiple values, we need to create an OR condition
+   */ const andCondition = (0, _or.orDuckdbCondition)();
+    andCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHAN, values[0], query.memberInfo));
+    andCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_GREATERTHAN, values[1], query.memberInfo));
+    return andCondition;
+};
+
+//# sourceMappingURL=not-In-date-range.js.map

package/src/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/not-contains/not-contains.d.ts

@@ -0,0 +1,65 @@
+import { Dimension, Measure } from '../../types/cube-types/table';
+import { Member, QueryFilter } from '../../types/cube-types/query';
+import { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';
+import { CubeToParseExpressionTransform } from '../factory';
+export interface NotContainsFilters extends QueryFilter {
+    member: Member;
+    operator: 'notContains';
+    values: string[];
+}
+export declare const notContainsDuckdbCondition: (columnName: string, value: string, memberInfo: Measure | Dimension) => {
+    class: ExpressionClass;
+    type: ExpressionType;
+    alias: string;
+    function_name: string;
+    schema: string;
+    children: ({
+        class: string;
+        type: string;
+        alias: string;
+        column_names: string[];
+        value?: undefined;
+    } | {
+        class: string;
+        type: string;
+        alias: string;
+        value: {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: string;
+        } | {
+            type: {
+                id: string;
+                type_info: {
+                    type: string;
+                    alias: string;
+                    width: number;
+                    scale: number;
+                };
+            };
+            is_null: boolean;
+            value: number;
+        } | {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: boolean;
+        };
+        column_names?: undefined;
+    })[];
+    filter: null;
+    order_bys: {
+        type: string;
+        orders: never[];
+    };
+    distinct: boolean;
+    is_operator: boolean;
+    export_state: boolean;
+    catalog: string;
+};
+export declare const notContainsTransform: CubeToParseExpressionTransform;

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

@@ -0,0 +1,70 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    notContainsDuckdbCondition: function() {
+        return notContainsDuckdbCondition;
+    },
+    notContainsTransform: function() {
+        return notContainsTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _or = require("../or/or");
+const notContainsDuckdbCondition = (columnName, value, memberInfo)=>{
+    return {
+        class: _Expression.ExpressionClass.FUNCTION,
+        type: _Expression.ExpressionType.FUNCTION,
+        alias: '',
+        function_name: '!~~',
+        schema: '',
+        children: [
+            {
+                class: 'COLUMN_REF',
+                type: 'COLUMN_REF',
+                alias: '',
+                column_names: columnName.split('.')
+            },
+            {
+                class: 'CONSTANT',
+                type: 'VALUE_CONSTANT',
+                alias: '',
+                value: (0, _baseconditionbuilder.valueBuilder)(`%${value}%`, memberInfo)
+            }
+        ],
+        filter: null,
+        order_bys: {
+            type: 'ORDER_MODIFIER',
+            orders: []
+        },
+        distinct: false,
+        is_operator: true,
+        export_state: false,
+        catalog: ''
+    };
+};
+const notContainsTransform = (query)=>{
+    const { member, values, memberInfo } = query;
+    if (!values || values.length === 0) {
+        throw new Error('Contains filter must have at least one value');
+    }
+    /**
+   * If there is only one value, we can create a simple Contains condition
+   */ if (values.length === 1) {
+        return notContainsDuckdbCondition(member, values[0], memberInfo);
+    }
+    /**
+   * If there are multiple values, we need to create an OR condition
+   */ const orCondition = (0, _or.orDuckdbCondition)();
+    values.forEach((value)=>{
+        orCondition.children.push(notContainsDuckdbCondition(member, value, memberInfo));
+    });
+    return orCondition;
+};
+
+//# sourceMappingURL=not-contains.js.map

package/src/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 { 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"}

package/src/cube-filter-transformer/not-equals/not-equals-array.d.ts

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "notEqualsArrayTransform", {
+    enumerable: true,
+    get: function() {
+        return notEqualsArrayTransform;
+    }
+});
+const _equalsarray = require("../equals/equals-array");
+const _not = require("../not/not");
+const notEqualsArrayTransform = (query)=>{
+    const { values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('Equals filter must have at least one value');
+    }
+    const notWrapper = (0, _not.notDuckdbCondition)();
+    const equalsCondition = (0, _equalsarray.equalsArrayTransform)(query);
+    /**
+   * We need to wrap the equals condition in a not condition
+   * Which basically means ! of ANY of the values
+   */ notWrapper.children = [
+        equalsCondition
+    ];
+    return notWrapper;
+};
+
+//# sourceMappingURL=not-equals-array.js.map

package/src/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/src/cube-filter-transformer/not-equals/not-equals.d.ts

@@ -0,0 +1,8 @@
+import { Member, QueryFilter } from '../../types/cube-types/query';
+import { CubeToParseExpressionTransform } from '../factory';
+export interface NotEqualsFilters extends QueryFilter {
+    member: Member;
+    operator: 'notEquals';
+    values: string[];
+}
+export declare const notEqualsTransform: CubeToParseExpressionTransform;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "notEqualsTransform", {
+    enumerable: true,
+    get: function() {
+        return notEqualsTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _isarraymembertype = require("../../utils/is-array-member-type");
+const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const _or = require("../or/or");
+const _notequalsarray = require("./not-equals-array");
+const notEqualsTransform = (query)=>{
+    const { member, values } = query;
+    if (!values || values.length === 0) {
+        throw new Error('Equals filter must have at least one value');
+    }
+    /**
+   * If the member is an array, we need to use the array transform
+   */ if ((0, _isarraymembertype.isArrayTypeMember)(query.memberInfo.type)) {
+        return (0, _notequalsarray.notEqualsArrayTransform)(query);
+    }
+    /**
+   * If there is only one value, we can create a simple equals condition
+   */ if (values.length === 1) {
+        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_NOTEQUAL, values[0], query.memberInfo);
+    }
+    /**
+   * If there are multiple values, we need to create an OR condition
+   */ const orCondition = (0, _or.orDuckdbCondition)();
+    values.forEach((value)=>{
+        orCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_NOTEQUAL, value, query.memberInfo));
+    });
+    return orCondition;
+};
+
+//# sourceMappingURL=not-equals.js.map

package/src/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/not-in/not-in.d.ts

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

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "notInTransform", {
+    enumerable: true,
+    get: function() {
+        return notInTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
+const notInDuckDbCondition = (columnName, values, memberInfo)=>{
+    const sqlTreeValues = values.map((value)=>{
+        return {
+            class: _Expression.ExpressionClass.CONSTANT,
+            type: _Expression.ExpressionType.VALUE_CONSTANT,
+            alias: "",
+            value: (0, _baseconditionbuilder.valueBuilder)(value, memberInfo)
+        };
+    });
+    const columnRef = {
+        class: "COLUMN_REF",
+        type: "COLUMN_REF",
+        alias: "",
+        column_names: columnName.split('.')
+    };
+    switch(memberInfo.type){
+        case 'number_array':
+        case 'string_array':
+            {
+                return {
+                    class: _Expression.ExpressionClass.OPERATOR,
+                    type: _Expression.ExpressionType.OPERATOR_NOT,
+                    alias: "",
+                    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: "",
+                                    children: sqlTreeValues
+                                }
+                            ],
+                            "filter": null,
+                            "order_bys": {
+                                "type": "ORDER_MODIFIER",
+                                "orders": []
+                            },
+                            "distinct": false,
+                            "is_operator": true,
+                            "export_state": false,
+                            "catalog": ""
+                        }
+                    ]
+                };
+            }
+        default:
+            {
+                return {
+                    class: _Expression.ExpressionClass.OPERATOR,
+                    type: _Expression.ExpressionType.COMPARE_NOT_IN,
+                    alias: "",
+                    children: [
+                        columnRef,
+                        ...sqlTreeValues
+                    ]
+                };
+            }
+    }
+};
+const notInTransform = (query)=>{
+    const { member, values, memberInfo } = query;
+    if (!values) {
+        throw new Error('Not in filter must have at least one value');
+    }
+    return notInDuckDbCondition(member, values, memberInfo);
+};
+
+//# sourceMappingURL=not-in.js.map

package/src/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\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"}

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "notSetTransform", {
+    enumerable: true,
+    get: function() {
+        return notSetTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const notSetTransform = (query)=>{
+    const { member } = query;
+    return {
+        class: _Expression.ExpressionClass.OPERATOR,
+        type: _Expression.ExpressionType.OPERATOR_IS_NULL,
+        alias: "",
+        children: [
+            {
+                class: "COLUMN_REF",
+                type: "COLUMN_REF",
+                alias: "",
+                column_names: member.split('.')
+            }
+        ]
+    };
+};
+
+//# sourceMappingURL=not-set.js.map

package/src/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 { 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"}

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

@@ -0,0 +1,2 @@
+import { ConjunctionExpression } from '../../types/duckdb-serialization-types/serialization/ParsedExpression';
+export declare const orDuckdbCondition: () => ConjunctionExpression;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "orDuckdbCondition", {
+    enumerable: true,
+    get: function() {
+        return orDuckdbCondition;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const orDuckdbCondition = ()=>{
+    return {
+        class: _Expression.ExpressionClass.CONJUNCTION,
+        type: _Expression.ExpressionType.CONJUNCTION_OR,
+        alias: '',
+        children: []
+    };
+};
+
+//# sourceMappingURL=or.js.map

package/src/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/set/set.d.ts

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "setTransform", {
+    enumerable: true,
+    get: function() {
+        return setTransform;
+    }
+});
+const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
+const setTransform = (query)=>{
+    const { member } = query;
+    return {
+        class: _Expression.ExpressionClass.OPERATOR,
+        type: _Expression.ExpressionType.OPERATOR_IS_NOT_NULL,
+        alias: "",
+        children: [
+            {
+                class: "COLUMN_REF",
+                type: "COLUMN_REF",
+                alias: "",
+                column_names: member.split('.')
+            }
+        ]
+    };
+};
+
+//# sourceMappingURL=set.js.map

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

@@ -0,0 +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"}

package/src/cube-group-by-transformer/cube-group-by-transformer.d.ts

@@ -0,0 +1,8 @@
+import { Member } from '../types/cube-types/query';
+import { ExpressionClass, ExpressionType } from '../types/duckdb-serialization-types/serialization/Expression';
+export declare const cubeDimensionToGroupByAST: (dimensions: Member[]) => {
+    class: ExpressionClass;
+    type: ExpressionType;
+    alias: string;
+    column_names: string[];
+}[];

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "cubeDimensionToGroupByAST", {
+    enumerable: true,
+    get: function() {
+        return cubeDimensionToGroupByAST;
+    }
+});
+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 = {
+            class: _Expression.ExpressionClass.COLUMN_REF,
+            type: _Expression.ExpressionType.COLUMN_REF,
+            alias: '',
+            column_names: [
+                (0, _memberkeytosafekey.memberKeyToSafeKey)(dimension)
+            ]
+        };
+        return dimensionAST;
+    });
+    return groupByAST;
+};
+
+//# sourceMappingURL=cube-group-by-transformer.js.map

package/src/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 { Member } from '../types/cube-types/query';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\nimport { memberKeyToSafeKey } from '../utils/member-key-to-safe-key';\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;;;4BAHN;oCAC4B;AAE5B,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,sCAAkB,EAACT;aAAW;QAC/C;QAEA,OAAOC;IACT;IAEA,OAAOH;AACT"}

package/src/cube-limit-offset-transformer/cube-limit-offset-transformer.d.ts

@@ -0,0 +1,31 @@
+import { ExpressionClass, ExpressionType } from '../types/duckdb-serialization-types/serialization/Expression';
+import { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';
+export declare const cubeLimitOffsetToAST: (limit?: number | null, offset?: number | null) => {
+    type: ResultModifierType;
+    limit: {
+        class: ExpressionClass;
+        type: ExpressionType;
+        alias: string;
+        value: {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: number;
+        };
+    } | null;
+    offset: {
+        class: ExpressionClass;
+        type: ExpressionType;
+        alias: string;
+        value: {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: number;
+        };
+    } | null;
+};