support aliases (#154)

* member formatters

* support aliasing

* update browser and add tests

* update browser

* review comments

* restore unchanged files

* restore more

* update name

* use table schemas

* update version

* use map

* cleanup

* add util

* refactor

---------

Co-authored-by: Eric Gan <[email protected]>

Author: egan8888

meerkat-browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/meerkat-browser",
-  "version": "0.0.98",
+  "version": "0.0.99",
   "dependencies": {
     "tslib": "^2.3.0",
     "@devrev/meerkat-core": "*",

meerkat-browser/src/browser-cube-to-sql-with-resolution/browser-cube-to-sql-with-resolution.ts

@@ -50,15 +50,17 @@ export const cubeQueryToSQLWithResolution = async ({
     query.dimensions
   );
 
-  const resolutionSchemas: TableSchema[] =
-    generateResolutionSchemas(resolutionConfig);
+  const resolutionSchemas: TableSchema[] = generateResolutionSchemas(
+    resolutionConfig,
+    tableSchemas
+  );
 
   const resolveParams: CubeQueryToSQLParams = {
     connection: connection,
     query: {
       measures: [],
       dimensions: generateResolvedDimensions(query, resolutionConfig),
-      joinPaths: generateResolutionJoinPaths(resolutionConfig),
+      joinPaths: generateResolutionJoinPaths(resolutionConfig, tableSchemas),
     },
     tableSchemas: [baseTable, ...resolutionSchemas],
   };

meerkat-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/meerkat-core",
-  "version": "0.0.98",
+  "version": "0.0.99",
   "dependencies": {
     "tslib": "^2.3.0"
   },

meerkat-core/src/ast-builder/ast-builder.spec.ts

@@ -377,4 +377,42 @@ describe('cubeToDuckdbAST', () => {
       type: 'COLUMN_REF',
     });
   });
+
+  it('should handle aliases', () => {
+    const tableSchema: TableSchema = {
+      name: 'test_table',
+      sql: 'test_table',
+      measures: [
+        {
+          name: 'measure',
+          sql: 'test_table.measure',
+          type: 'number',
+          alias: 'measure_with_alias',
+        },
+      ],
+      dimensions: [
+        {
+          name: 'dimension',
+          sql: 'test_table.dimension',
+          type: 'string',
+          alias: 'dimension_with_alias',
+        },
+      ],
+    };
+
+    const query: Query = {
+      measures: ['test_table.measure'],
+      dimensions: ['test_table.dimension'],
+    };
+
+    const result = cubeToDuckdbAST(query, tableSchema);
+    expect(result.node.type).toBe(QueryNodeType.SELECT_NODE);
+    expect(result.node.group_expressions).toHaveLength(1);
+    expect(result.node.group_expressions[0]).toEqual({
+      alias: '',
+      class: 'COLUMN_REF',
+      column_names: ['dimension_with_alias'],
+      type: 'COLUMN_REF',
+    });
+  });
 });

meerkat-core/src/ast-builder/ast-builder.ts

@@ -7,7 +7,7 @@ import {
   QueryFiltersWithInfoSingular,
 } from '../cube-to-duckdb/cube-filter-to-duckdb';
 import { traverseAndFilter } from '../filter-params/filter-params-ast';
-import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';
+import { constructAlias } from '../member-formatters/get-alias';
 import {
   FilterType,
   MeerkatQueryFilter,
@@ -32,7 +32,13 @@ const formatFilters = (
     : (modifyLeafMeerkatFilter(queryFiltersWithInfo, (item) => {
         return {
           ...item,
-          member: memberKeyToSafeKey(item.member),
+          member: constructAlias({
+            name: item.member,
+            alias: item.memberInfo.alias,
+            aliasContext: {
+              isAstIdentifier: true,
+            },
+          }),
         };
       }) as QueryFiltersWithInfo);
 };
@@ -113,7 +119,10 @@ export const cubeToDuckdbAST = (
     query.dimensions &&
     query.dimensions?.length > 0
   ) {
-    node.group_expressions = cubeDimensionToGroupByAST(query.dimensions);
+    node.group_expressions = cubeDimensionToGroupByAST(
+      query.dimensions,
+      tableSchema
+    );
     const groupSets = [];
     /**
      * We only support one group set for now.
@@ -125,7 +134,7 @@ export const cubeToDuckdbAST = (
   }
   node.modifiers = [];
   if (query.order && Object.keys(query.order).length > 0) {
-    node.modifiers.push(cubeOrderByToAST(query.order));
+    node.modifiers.push(cubeOrderByToAST(query.order, tableSchema));
   }
   if (query.limit || query.offset) {
     // Type assertion is needed here because the AST is not typed correctly.

meerkat-core/src/cube-group-by-transformer/cube-group-by-transformer.ts

@@ -1,17 +1,27 @@
-import { memberKeyToSafeKey } from '../member-formatters';
+import { getAliasFromSchema } from '../member-formatters/get-alias';
+import { TableSchema } from '../types/cube-types';
 import { Member } from '../types/cube-types/query';
 import {
   ExpressionClass,
   ExpressionType,
 } from '../types/duckdb-serialization-types/serialization/Expression';
 
-export const cubeDimensionToGroupByAST = (dimensions: Member[]) => {
+export const cubeDimensionToGroupByAST = (
+  dimensions: Member[],
+  tableSchema: TableSchema
+) => {
   const groupByAST = dimensions.map((dimension) => {
     const dimensionAST = {
       class: ExpressionClass.COLUMN_REF,
       type: ExpressionType.COLUMN_REF,
       alias: '',
-      column_names: [memberKeyToSafeKey(dimension)],
+      column_names: [
+        getAliasFromSchema({
+          name: dimension,
+          tableSchema,
+          aliasContext: { isAstIdentifier: true },
+        }),
+      ],
     };
 
     return dimensionAST;

meerkat-core/src/cube-measure-transformer/cube-measure-transformer.spec.ts

@@ -7,7 +7,7 @@ import {
 } from './cube-measure-transformer';
 
 describe('cubeMeasureToSQLSelectString', () => {
-  let tableSchema: TableSchema;
+  let tableSchema: TableSchema, tableSchemaWithAliases: TableSchema;
   const cube = 'cube_test';
 
   beforeEach(() => {
@@ -27,6 +27,26 @@ describe('cubeMeasureToSQLSelectString', () => {
         },
       ],
     };
+
+    tableSchemaWithAliases = {
+      name: 'test_with_aliases',
+      sql: cube,
+      measures: [
+        {
+          name: 'measure1',
+          sql: 'COUNT(*)',
+          type: 'number',
+          alias: 'alias_measure1',
+        },
+        {
+          name: 'measure2',
+          sql: 'SUM(total)',
+          type: 'number',
+          alias: 'alias_measure2',
+        },
+      ],
+      dimensions: [],
+    };
   });
 
   it('should construct a SQL select string with COUNT(*) when provided with correct measure', () => {
@@ -47,6 +67,17 @@ describe('cubeMeasureToSQLSelectString', () => {
     expect(result).toBe(`SELECT test.*`);
   });
 
+  it('should use alias for measures when provided', () => {
+    const measures: Member[] = ['temp.measure1', 'temp.measure2'];
+    const result = cubeMeasureToSQLSelectString(
+      measures,
+      tableSchemaWithAliases
+    );
+    expect(result).toBe(
+      `SELECT COUNT(*) AS "alias_measure1" ,  SUM(total) AS "alias_measure2" `
+    );
+  });
+
   it('should replace the select portion of a SQL string using replaceSelectWithCubeMeasure 1', () => {
     const measures: Member[] = ['temp.measure1', 'temp.measure2'];
     const sqlToReplace = 'SELECT * FROM my_table';
@@ -89,6 +120,20 @@ describe('cubeMeasureToSQLSelectString', () => {
       `SELECT COUNT(*) AS temp__measure1 ,  SUM(total) AS temp__measure2 ,   temp__dimension1,  temp__dimension2 FROM (SELECT * FROM TABLE_1)`
     );
   });
+
+  it('should use aliases when provided', () => {
+    const measures: Member[] = ['temp.measure1', 'temp.measure2'];
+    const sqlToReplace = 'SELECT * FROM my_table';
+    const result = applyProjectionToSQLQuery(
+      [],
+      measures,
+      tableSchemaWithAliases,
+      sqlToReplace
+    );
+    expect(result).toBe(
+      `SELECT COUNT(*) AS "alias_measure1" ,  SUM(total) AS "alias_measure2"  FROM my_table`
+    );
+  });
 });
 
 describe('getAllColumnUsedInMeasures', () => {

meerkat-core/src/cube-measure-transformer/cube-measure-transformer.ts

@@ -1,4 +1,4 @@
-import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';
+import { getAliasFromSchema, getNamespacedKey } from '../member-formatters';
 import { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';
 import { Member } from '../types/cube-types/query';
 import { Measure, TableSchema } from '../types/cube-types/table';
@@ -18,7 +18,13 @@ export const cubeMeasureToSQLSelectString = (
     const [tableSchemaName, measureKeyWithoutTable] =
       splitIntoDataSourceAndFields(measure);
 
-    const aliasKey = memberKeyToSafeKey(measure);
+    const aliasKey = getAliasFromSchema({
+      name: measure,
+      tableSchema,
+      aliasContext: {
+        isAstIdentifier: false,
+      },
+    });
     const measureSchema = tableSchema.measures.find(
       (m) => m.name === measureKeyWithoutTable
     );
@@ -47,8 +53,14 @@ export const cubeMeasureToSQLSelectString = (
     //Replace all the columnsUsedInMeasure with safeKey
     columnsUsedInMeasure?.forEach((measureKey) => {
       const [_, column] = splitIntoDataSourceAndFields(measureKey);
-      const memberKey = `${tableSchemaName}.${column}`;
-      const columnKey = memberKeyToSafeKey(memberKey);
+      const memberKey = getNamespacedKey(tableSchemaName, column);
+      const columnKey = getAliasFromSchema({
+        name: memberKey,
+        tableSchema,
+        aliasContext: {
+          isAstIdentifier: false,
+        },
+      });
       meerkatReplacedSqlString = meerkatReplacedSqlString.replace(
         memberKey,
         columnKey
@@ -76,7 +88,13 @@ const addDimensionToSQLProjection = (
     const dimensionSchema = tableSchema.dimensions.find(
       (m) => m.name === dimensionKeyWithoutTable
     );
-    const aliasKey = memberKeyToSafeKey(dimension);
+    const aliasKey = getAliasFromSchema({
+      name: dimension,
+      tableSchema,
+      aliasContext: {
+        isAstIdentifier: false,
+      },
+    });
 
     if (!dimensionSchema) {
       continue;

meerkat-core/src/cube-order-by-transformer/cube-order-by-transformer.ts

@@ -1,12 +1,16 @@
-import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';
+import { getAliasFromSchema } from '../member-formatters/get-alias';
+import { TableSchema } from '../types/cube-types';
 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 const cubeOrderByToAST = (order: { [key: string]: 'asc' | 'desc' }) => {
+export const cubeOrderByToAST = (
+  order: { [key: string]: 'asc' | 'desc' },
+  tableSchema: TableSchema
+) => {
   const orderArr = [];
   for (const key in order) {
     const value = order[key];
@@ -22,7 +26,13 @@ export const cubeOrderByToAST = (order: { [key: string]: 'asc' | 'desc' }) => {
         /**
          * We need to convert the key in the __ format as they are being projected in this format
          */
-        column_names: [memberKeyToSafeKey(key)],
+        column_names: [
+          getAliasFromSchema({
+            name: key,
+            tableSchema,
+            aliasContext: { isAstIdentifier: true },
+          }),
+        ],
       },
     };
     orderArr.push(orderByAST);