@devrev/meerkat-core 0.0.77

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "cubeLimitOffsetToAST", {
+    enumerable: true,
+    get: function() {
+        return cubeLimitOffsetToAST;
+    }
+});
+const _Expression = require("../types/duckdb-serialization-types/serialization/Expression");
+const _ResultModifier = require("../types/duckdb-serialization-types/serialization/ResultModifier");
+const cubeLimitOffsetToAST = (limit, offset)=>{
+    return {
+        type: _ResultModifier.ResultModifierType.LIMIT_MODIFIER,
+        limit: limit ? {
+            class: _Expression.ExpressionClass.CONSTANT,
+            type: _Expression.ExpressionType.VALUE_CONSTANT,
+            alias: '',
+            value: {
+                type: {
+                    id: 'INTEGER',
+                    type_info: null
+                },
+                is_null: false,
+                value: limit
+            }
+        } : null,
+        offset: offset ? {
+            class: _Expression.ExpressionClass.CONSTANT,
+            type: _Expression.ExpressionType.VALUE_CONSTANT,
+            alias: '',
+            value: {
+                type: {
+                    id: 'INTEGER',
+                    type_info: null
+                },
+                is_null: false,
+                value: offset
+            }
+        } : null
+    };
+};
+
+//# sourceMappingURL=cube-limit-offset-transformer.js.map

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

@@ -0,0 +1,21 @@
+import { Member } from '../types/cube-types/query';
+import { Measure, TableSchema } from '../types/cube-types/table';
+export declare const cubeMeasureToSQLSelectString: (measures: Member[], tableSchema: TableSchema) => string;
+export declare const getSelectReplacedSql: (sql: string, selectString: string) => string;
+/**
+ * Get all the columns used in the measures.
+ * This is used for extracting the columns used in the measures needed for the projection.
+ * Example: The joins implementation uses this to get the columns used in the measures to join the tables.
+ * like the SQL for the measure is `SUM(table.total)` and the table name is `table`, then the column used is `total`
+ * table cannot be used directly here because the joined table would have column name ambiguity.
+ * Thus these columns are projected and directly used in the join.
+ */
+export declare const getAllColumnUsedInMeasures: (measures: Measure[], tableSchema: TableSchema) => string[];
+/**
+ * Replace the first SELECT * from the sqlToReplace with the cube measure
+ * @param measures
+ * @param tableSchema
+ * @param sqlToReplace
+ * @returns
+ */
+export declare const applyProjectionToSQLQuery: (dimensions: Member[], measures: Member[], tableSchema: TableSchema, sqlToReplace: string) => string;

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

@@ -0,0 +1,126 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    cubeMeasureToSQLSelectString: function() {
+        return cubeMeasureToSQLSelectString;
+    },
+    getSelectReplacedSql: function() {
+        return getSelectReplacedSql;
+    },
+    getAllColumnUsedInMeasures: function() {
+        return getAllColumnUsedInMeasures;
+    },
+    applyProjectionToSQLQuery: function() {
+        return applyProjectionToSQLQuery;
+    }
+});
+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++){
+        const measure = measures[i];
+        if (measure === '*') {
+            base += ` ${tableSchema.name}.*`;
+            continue;
+        }
+        const [tableSchemaName, measureKeyWithoutTable] = measure.split('.');
+        const aliasKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(measure);
+        const measureSchema = tableSchema.measures.find((m)=>m.name === measureKeyWithoutTable);
+        if (!measureSchema) {
+            continue;
+        }
+        if (i > 0) {
+            base += ', ';
+        }
+        let meerkatReplacedSqlString = (0, _meerkatplaceholderreplacer.meerkatPlaceholderReplacer)(measureSchema.sql, tableSchema.name);
+        /**
+     * Here we extract the columns used in the measure and replace them with the safeKey.
+     * We need to do this because the columns used in the measure are not directly available in the joined table.
+     * Thus we need to project them and use them in the join.
+     */ const columnsUsedInMeasure = getColumnsFromSQL(meerkatReplacedSqlString, tableSchemaName);
+        //Replace all the columnsUsedInMeasure with safeKey
+        columnsUsedInMeasure == null ? void 0 : columnsUsedInMeasure.forEach((measureKey)=>{
+            const column = measureKey.split('.')[1];
+            const memberKey = `${tableSchemaName}.${column}`;
+            const columnKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(memberKey);
+            meerkatReplacedSqlString = meerkatReplacedSqlString.replace(memberKey, columnKey);
+        });
+        base += ` ${meerkatReplacedSqlString} AS ${aliasKey} `;
+    }
+    return base;
+};
+const addDimensionToSQLProjection = (dimensions, selectString, tableSchema)=>{
+    if (dimensions.length === 0) {
+        return selectString;
+    }
+    let newSelectString = selectString;
+    for(let i = 0; i < dimensions.length; i++){
+        const dimension = dimensions[i];
+        const dimensionKeyWithoutTable = dimension.split('.')[1];
+        const dimensionSchema = tableSchema.dimensions.find((m)=>m.name === dimensionKeyWithoutTable);
+        const aliasKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(dimension);
+        if (!dimensionSchema) {
+            continue;
+        }
+        if (i > 0) {
+            newSelectString += ',';
+        }
+        // since alias key is expected to have been unfurled in the base query, we can just use it as is.
+        newSelectString += `  ${aliasKey}`;
+    }
+    return newSelectString;
+};
+const getSelectReplacedSql = (sql, selectString)=>{
+    /*
+   ** Replaces the select portion of a SQL string with the selectString passed.
+   */ const selectRegex = /SELECT\s\*/;
+    const match = sql.match(selectRegex);
+    if (!match) {
+        return sql;
+    }
+    const selectIndex = match.index;
+    if (selectIndex === undefined) {
+        throw new Error('SELECT * not found in SQL string');
+    }
+    const selectLength = match[0].length;
+    const beforeSelect = sql.substring(0, selectIndex);
+    const afterSelect = sql.substring(selectIndex + selectLength);
+    return `${beforeSelect}${selectString}${afterSelect}`;
+};
+const getAllColumnUsedInMeasures = (measures, tableSchema)=>{
+    let columns = [];
+    measures.forEach((measure)=>{
+        const columnMatch = getColumnsFromSQL(measure.sql, tableSchema.name);
+        if (columnMatch && columnMatch.length > 0) {
+            columns = [
+                ...columns,
+                ...columnMatch
+            ];
+        }
+    });
+    // Remove duplicates
+    return [
+        ...new Set(columns)
+    ];
+};
+const getColumnsFromSQL = (sql, tableName)=>{
+    const regex = new RegExp(`(${tableName}\\.[a-zA-Z0-9_]+)`, 'g');
+    const columnMatch = sql.match(regex);
+    return columnMatch;
+};
+const applyProjectionToSQLQuery = (dimensions, measures, tableSchema, sqlToReplace)=>{
+    let measureSelectString = cubeMeasureToSQLSelectString(measures, tableSchema);
+    if (measures.length > 0 && dimensions.length > 0) {
+        measureSelectString += ', ';
+    }
+    const selectString = addDimensionToSQLProjection(dimensions, measureSelectString, tableSchema);
+    return getSelectReplacedSql(sqlToReplace, selectString);
+};
+
+//# sourceMappingURL=cube-measure-transformer.js.map

package/src/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 { Member } from '../types/cube-types/query';\nimport { Measure, TableSchema } from '../types/cube-types/table';\nimport { meerkatPlaceholderReplacer } from '../utils/meerkat-placeholder-replacer';\nimport { memberKeyToSafeKey } from '../utils/member-key-to-safe-key';\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] = measure.split('.');\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 = measureKey.split('.')[1];\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 = dimension.split('.')[1];\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":["cubeMeasureToSQLSelectString","getSelectReplacedSql","getAllColumnUsedInMeasures","applyProjectionToSQLQuery","measures","tableSchema","base","i","length","measure","name","tableSchemaName","measureKeyWithoutTable","split","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.d.ts

@@ -0,0 +1,21 @@
+import { ExpressionClass, ExpressionType } from '../types/duckdb-serialization-types/serialization/Expression';
+import { OrderType } from '../types/duckdb-serialization-types/serialization/Nodes';
+import { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';
+export declare const cubeOrderByToAST: (order: {
+    [key: string]: "asc" | "desc";
+}) => {
+    type: ResultModifierType;
+    orders: {
+        type: OrderType;
+        null_order: OrderType;
+        expression: {
+            class: ExpressionClass;
+            type: ExpressionType;
+            alias: string;
+            /**
+             * We need to convert the key in the __ format as they are being projected in this format
+             */
+            column_names: string[];
+        };
+    }[];
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "cubeOrderByToAST", {
+    enumerable: true,
+    get: function() {
+        return cubeOrderByToAST;
+    }
+});
+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){
+        const value = order[key];
+        const astOrderBy = value === 'asc' ? _Nodes.OrderType.ASCENDING : _Nodes.OrderType.DESCENDING;
+        const orderByAST = {
+            type: astOrderBy,
+            null_order: _Nodes.OrderType.ORDER_DEFAULT,
+            expression: {
+                class: _Expression.ExpressionClass.COLUMN_REF,
+                type: _Expression.ExpressionType.COLUMN_REF,
+                alias: '',
+                /**
+         * We need to convert the key in the __ format as they are being projected in this format
+         */ column_names: [
+                    (0, _memberkeytosafekey.memberKeyToSafeKey)(key)
+                ]
+            }
+        };
+        orderArr.push(orderByAST);
+    }
+    return {
+        type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
+        orders: orderArr
+    };
+};
+
+//# sourceMappingURL=cube-order-by-transformer.js.map

package/src/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 {\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';\nimport { memberKeyToSafeKey } from '../utils/member-key-to-safe-key';\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;;;4BALN;uBACmB;gCACS;oCACA;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/src/cube-to-duckdb/cube-filter-to-duckdb.d.ts

@@ -0,0 +1,16 @@
+import { QueryFilter } from '../types/cube-types/query';
+import { Dimension, Measure } from '../types/cube-types/table';
+export type QueryOperatorsWithInfo = QueryFilter & {
+    memberInfo: Measure | Dimension;
+};
+export type LogicalAndFilterWithInfo = {
+    and: (QueryOperatorsWithInfo | {
+        or: (QueryOperatorsWithInfo | LogicalAndFilterWithInfo)[];
+    })[];
+};
+export type LogicalOrFilterWithInfo = {
+    or: (QueryOperatorsWithInfo | LogicalAndFilterWithInfo)[];
+};
+export type QueryFilterWithInfo = (QueryOperatorsWithInfo | LogicalAndFilterWithInfo | LogicalOrFilterWithInfo) | (QueryOperatorsWithInfo | LogicalAndFilterWithInfo | LogicalOrFilterWithInfo)[];
+export type QueryFiltersWithInfoSingular = QueryOperatorsWithInfo | LogicalAndFilterWithInfo | LogicalOrFilterWithInfo;
+export type QueryFiltersWithInfo = QueryFiltersWithInfoSingular[];

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

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=cube-filter-to-duckdb.js.map

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

@@ -0,0 +1,33 @@
+import { FilterType, MeerkatQueryFilter, Query, QueryFilter, TableSchema } from '../types/cube-types';
+import { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';
+/**
+ * Get the query filter with only where filterKey matches
+ */
+export declare const traverseAndFilter: (filter: MeerkatQueryFilter, callback: (value: QueryFilter) => boolean) => MeerkatQueryFilter | null;
+export declare const getFilterByMemberKey: (filters: MeerkatQueryFilter[] | undefined, memberKey: string) => MeerkatQueryFilter[];
+/**
+ * Syntax for filter params in SQL:
+ * FILTER_PARAMS.cube_name.member_name.filter(sql_expression)
+ * Example:
+ *  SELECT *
+ *  FROM orders
+ *  WHERE ${FILTER_PARAMS.order_facts.date.filter('date')}
+ * @param sql
+ */
+export declare const detectAllFilterParamsFromSQL: (sql: string) => {
+    memberKey: string;
+    filterExpression: string;
+    matchKey: string;
+}[];
+export declare const getFilterParamsAST: (query: Query, tableSchema: TableSchema, filterType?: FilterType) => {
+    memberKey: string;
+    ast: SelectStatement | null;
+    matchKey: string;
+}[];
+type FilterParamsSQL = {
+    memberKey: string;
+    sql: string;
+    matchKey: string;
+};
+export declare const applyFilterParamsToBaseSQL: (baseSQL: string, filterParamsSQL: FilterParamsSQL[]) => string;
+export {};

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

@@ -0,0 +1,115 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    traverseAndFilter: function() {
+        return traverseAndFilter;
+    },
+    getFilterByMemberKey: function() {
+        return getFilterByMemberKey;
+    },
+    detectAllFilterParamsFromSQL: function() {
+        return detectAllFilterParamsFromSQL;
+    },
+    getFilterParamsAST: function() {
+        return getFilterParamsAST;
+    },
+    applyFilterParamsToBaseSQL: function() {
+        return applyFilterParamsToBaseSQL;
+    }
+});
+const _astbuilder = require("../ast-builder/ast-builder");
+const traverseAndFilter = (filter, callback)=>{
+    if ('member' in filter) {
+        return callback(filter) ? filter : null;
+    }
+    if ('and' in filter) {
+        const filteredAndFilters = filter.and.map((subFilter)=>traverseAndFilter(subFilter, callback)).filter(Boolean);
+        const obj = filteredAndFilters.length > 0 ? {
+            and: filteredAndFilters
+        } : null;
+        return obj;
+    }
+    if ('or' in filter) {
+        const filteredOrFilters = filter.or.map((subFilter)=>traverseAndFilter(subFilter, callback)).filter(Boolean);
+        const obj = filteredOrFilters.length > 0 ? {
+            or: filteredOrFilters
+        } : null;
+        return obj;
+    }
+    return null;
+};
+const getFilterByMemberKey = (filters, memberKey)=>{
+    if (!filters) return [];
+    return filters.map((filter)=>traverseAndFilter(filter, (value)=>value.member === memberKey)).filter(Boolean);
+};
+const detectAllFilterParamsFromSQL = (sql)=>{
+    const regex = /\${FILTER_PARAMS\.(\w+\.\w+)\.filter\('(\w+)'\)}/g;
+    const matches = [];
+    let match;
+    while((match = regex.exec(sql)) !== null){
+        matches.push({
+            memberKey: match[1],
+            filterExpression: match[2],
+            matchKey: match[0]
+        });
+    }
+    return matches;
+};
+const getFilterParamsAST = (query, tableSchema, filterType = 'PROJECTION_FILTER')=>{
+    const filterParamKeys = detectAllFilterParamsFromSQL(tableSchema.sql);
+    const filterParamsAST = [];
+    for (const filterParamKey of filterParamKeys){
+        const filters = getFilterByMemberKey(query.filters, filterParamKey.memberKey);
+        if (filters && filters.length > 0) {
+            filterParamsAST.push({
+                memberKey: filterParamKey.memberKey,
+                matchKey: filterParamKey.matchKey,
+                ast: (0, _astbuilder.cubeToDuckdbAST)({
+                    filters,
+                    measures: [],
+                    dimensions: []
+                }, tableSchema, {
+                    filterType
+                })
+            });
+        }
+    }
+    return filterParamsAST;
+};
+const replaceWhereClauseWithFiltersParamsSQL = (baseSQL, filterParamsSQL)=>{
+    let finalSQL = baseSQL;
+    for (const filterParam of filterParamsSQL){
+        /**
+     * Get SQL expression after WHERE clause
+     */ const whereClause = filterParam.sql.split('WHERE')[1];
+        /**
+     * Replace filter param with SQL expression
+     */ finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);
+    }
+    return finalSQL;
+};
+const applyFilterParamsToBaseSQL = (baseSQL, filterParamsSQL)=>{
+    let finalSQL = replaceWhereClauseWithFiltersParamsSQL(baseSQL, filterParamsSQL);
+    for (const filterParam of filterParamsSQL){
+        /**
+     * Get SQL expression after WHERE clause
+     */ const whereClause = filterParam.sql.split('WHERE')[1];
+        /**
+     * Replace filter param with SQL expression
+     */ finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);
+    }
+    /**
+   * Find all remaining filter params and replace them with TRUE
+   */ const remainingFilterParams = detectAllFilterParamsFromSQL(finalSQL);
+    for (const filterParam of remainingFilterParams){
+        finalSQL = finalSQL.replace(filterParam.matchKey, 'TRUE');
+    }
+    return finalSQL;
+};
+
+//# sourceMappingURL=filter-params-ast.js.map

package/src/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":["traverseAndFilter","getFilterByMemberKey","detectAllFilterParamsFromSQL","getFilterParamsAST","applyFilterParamsToBaseSQL","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/src/get-projection-clause/get-projection-clause.d.ts

@@ -0,0 +1,27 @@
+import { TableSchema } from '../types/cube-types';
+export declare const getFilterMeasureProjection: ({ key, tableSchema, measures, }: {
+    key: string;
+    tableSchema: TableSchema;
+    measures: string[];
+}) => {
+    sql: undefined;
+    foundMember: undefined;
+    aliasKey: undefined;
+} | {
+    sql: string;
+    foundMember: import("../types/cube-types").Measure;
+    aliasKey: string;
+};
+export declare const getDimensionProjection: ({ key, tableSchema, }: {
+    key: string;
+    tableSchema: TableSchema;
+}) => {
+    sql: undefined;
+    foundMember: undefined;
+    aliasKey: undefined;
+} | {
+    sql: string;
+    foundMember: import("../types/cube-types").Dimension;
+    aliasKey: string;
+};
+export declare const getProjectionClause: (measures: string[], dimensions: string[], tableSchema: TableSchema, aliasedColumnSet: Set<string>) => string;

package/src/get-projection-clause/get-projection-clause.js

@@ -0,0 +1,135 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getFilterMeasureProjection: function() {
+        return getFilterMeasureProjection;
+    },
+    getDimensionProjection: function() {
+        return getDimensionProjection;
+    },
+    getProjectionClause: function() {
+        return getProjectionClause;
+    }
+});
+const _cubemeasuretransformer = require("../cube-measure-transformer/cube-measure-transformer");
+const _findintableschema = require("../utils/find-in-table-schema");
+const _memberkeytosafekey = require("../utils/member-key-to-safe-key");
+const getFilterMeasureProjection = ({ key, tableSchema, measures })=>{
+    const tableName = key.split('.')[0];
+    const measureWithoutTable = key.split('.')[1];
+    const foundMember = (0, _findintableschema.findInMeasureSchema)(measureWithoutTable, tableSchema);
+    const isMeasure = measures.includes(key);
+    if (!foundMember || isMeasure || tableName !== tableSchema.name) {
+        // If the selected member is not found in the table schema or if it is already selected, continue.
+        // If the selected member is a measure, don't create an alias. Since measure computation is done in the outermost level of the query
+        // If the selected member is not from the current table, don't create an alias.
+        return {
+            sql: undefined,
+            foundMember: undefined,
+            aliasKey: undefined
+        };
+    }
+    const aliasKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(key);
+    return {
+        sql: `${key} AS ${aliasKey}`,
+        foundMember,
+        aliasKey
+    };
+};
+const getDimensionProjection = ({ key, tableSchema })=>{
+    // Find the table access key
+    const measureWithoutTable = key.split('.')[1];
+    const tableName = key.split('.')[0];
+    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.
+        // If the selected member is not from the current table, don't create an alias.
+        return {
+            sql: undefined,
+            foundMember: undefined,
+            aliasKey: undefined
+        };
+    }
+    const aliasKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(key);
+    // Add the alias key to the set. So we have a reference to all the previously selected members.
+    return {
+        sql: `${foundMember.sql} AS ${aliasKey}`,
+        foundMember,
+        aliasKey
+    };
+};
+const aggregator = ({ member, aliasedColumnSet, acc, sql })=>{
+    if (aliasedColumnSet.has(member) || !sql) {
+        return acc;
+    }
+    aliasedColumnSet.add(member);
+    acc.push(sql);
+    return acc;
+};
+const getProjectionClause = (measures, dimensions, tableSchema, aliasedColumnSet)=>{
+    const filteredDimensions = dimensions.filter((dimension)=>{
+        return dimension.split('.')[0] === tableSchema.name;
+    });
+    const filteredMeasures = measures.filter((measure)=>{
+        return measure.split('.')[0] === tableSchema.name;
+    });
+    const dimensionsProjectionsArr = filteredDimensions.reduce((acc, member, currentIndex, members)=>{
+        const { sql: memberSql } = getDimensionProjection({
+            key: member,
+            tableSchema
+        });
+        return aggregator({
+            member,
+            aliasedColumnSet,
+            acc,
+            currentIndex,
+            members,
+            sql: memberSql
+        });
+    }, []);
+    const dimensionsProjections = dimensionsProjectionsArr.join(', ');
+    const measureProjectionsArr = filteredMeasures.reduce((acc, member, currentIndex, members)=>{
+        const { sql: memberSql } = getFilterMeasureProjection({
+            key: member,
+            tableSchema,
+            measures
+        });
+        return aggregator({
+            member,
+            aliasedColumnSet,
+            acc,
+            currentIndex,
+            members,
+            sql: memberSql
+        });
+    }, []);
+    const measureProjections = measureProjectionsArr.join(', ');
+    const usedMeasureObjects = tableSchema.measures.filter((measure)=>{
+        return measures.findIndex((key)=>{
+            const keyWithoutTable = key.split('.')[1];
+            return keyWithoutTable === measure.name;
+        }) !== -1;
+    });
+    const columnsUsedInMeasures = (0, _cubemeasuretransformer.getAllColumnUsedInMeasures)(usedMeasureObjects, tableSchema);
+    let columnsUsedInMeasuresInProjection = '';
+    columnsUsedInMeasures.forEach((column, index)=>{
+        const safeKey = (0, _memberkeytosafekey.memberKeyToSafeKey)(column);
+        columnsUsedInMeasuresInProjection += `${column} AS ${safeKey}`;
+        if (index !== columnsUsedInMeasures.length - 1) {
+            columnsUsedInMeasuresInProjection += ', ';
+        }
+    });
+    const combinedStr = [
+        dimensionsProjections,
+        measureProjections,
+        columnsUsedInMeasuresInProjection
+    ];
+    return combinedStr.filter((str)=>str.length > 0).join(', ');
+};
+
+//# sourceMappingURL=get-projection-clause.js.map