add util

Author: egan8888

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

@@ -7,7 +7,10 @@ import {
   QueryFiltersWithInfoSingular,
 } from '../cube-to-duckdb/cube-filter-to-duckdb';
 import { traverseAndFilter } from '../filter-params/filter-params-ast';
-import { constructAlias } from '../member-formatters/get-alias';
+import {
+  constructAlias,
+  shouldUseSafeAlias,
+} from '../member-formatters/get-alias';
 import {
   FilterType,
   MeerkatQueryFilter,
@@ -32,7 +35,13 @@ const formatFilters = (
     : (modifyLeafMeerkatFilter(queryFiltersWithInfo, (item) => {
         return {
           ...item,
-          member: constructAlias(item.member, item.memberInfo.alias),
+          member: constructAlias({
+            name: item.member,
+            alias: item.memberInfo.alias,
+            safe: shouldUseSafeAlias({
+              isAstIdentifier: true,
+            }),
+          }),
         };
       }) as QueryFiltersWithInfo);
 };

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

@@ -1,4 +1,7 @@
-import { getAliasFromSchema } from '../member-formatters/get-alias';
+import {
+  getAliasFromSchema,
+  shouldUseSafeAlias,
+} from '../member-formatters/get-alias';
 import { TableSchema } from '../types/cube-types';
 import { Member } from '../types/cube-types/query';
 import {
@@ -15,7 +18,13 @@ export const cubeDimensionToGroupByAST = (
       class: ExpressionClass.COLUMN_REF,
       type: ExpressionType.COLUMN_REF,
       alias: '',
-      column_names: [getAliasFromSchema({ name: dimension, tableSchema })],
+      column_names: [
+        getAliasFromSchema({
+          name: dimension,
+          tableSchema,
+          safe: shouldUseSafeAlias({ isAstIdentifier: true }),
+        }),
+      ],
     };
 
     return dimensionAST;

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

@@ -1,5 +1,8 @@
-import { getNamespacedKey } from '../member-formatters';
-import { getAliasFromSchema } from '../member-formatters/get-alias';
+import {
+  getAliasFromSchema,
+  getNamespacedKey,
+  shouldUseSafeAlias,
+} 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';
@@ -22,7 +25,9 @@ export const cubeMeasureToSQLSelectString = (
     const aliasKey = getAliasFromSchema({
       name: measure,
       tableSchema,
-      safe: true,
+      safe: shouldUseSafeAlias({
+        isAstIdentifier: false,
+      }),
     });
     const measureSchema = tableSchema.measures.find(
       (m) => m.name === measureKeyWithoutTable
@@ -56,7 +61,9 @@ export const cubeMeasureToSQLSelectString = (
       const columnKey = getAliasFromSchema({
         name: memberKey,
         tableSchema,
-        safe: true,
+        safe: shouldUseSafeAlias({
+          isAstIdentifier: false,
+        }),
       });
       meerkatReplacedSqlString = meerkatReplacedSqlString.replace(
         memberKey,
@@ -88,7 +95,9 @@ const addDimensionToSQLProjection = (
     const aliasKey = getAliasFromSchema({
       name: dimension,
       tableSchema,
-      safe: true,
+      safe: shouldUseSafeAlias({
+        isAstIdentifier: false,
+      }),
     });
 
     if (!dimensionSchema) {

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

@@ -1,4 +1,7 @@
-import { getAliasFromSchema } from '../member-formatters/get-alias';
+import {
+  getAliasFromSchema,
+  shouldUseSafeAlias,
+} from '../member-formatters/get-alias';
 import { TableSchema } from '../types/cube-types';
 import {
   ExpressionClass,
@@ -26,7 +29,13 @@ export const cubeOrderByToAST = (
         /**
          * We need to convert the key in the __ format as they are being projected in this format
          */
-        column_names: [getAliasFromSchema({ name: key, tableSchema })],
+        column_names: [
+          getAliasFromSchema({
+            name: key,
+            tableSchema,
+            safe: shouldUseSafeAlias({ isAstIdentifier: true }),
+          }),
+        ],
       },
     };
     orderArr.push(orderByAST);

meerkat-core/src/get-wrapped-base-query-with-projections/get-aliased-columns-from-filters.ts

@@ -1,4 +1,7 @@
-import { getAliasFromSchema } from '../member-formatters/get-alias';
+import {
+  getAliasFromSchema,
+  shouldUseSafeAlias,
+} from '../member-formatters/get-alias';
 import { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';
 import { MeerkatQueryFilter, Query, TableSchema } from '../types/cube-types';
 import {
@@ -40,7 +43,11 @@ export const getDimensionProjection = ({
     query,
   });
 
-  const aliasKey = getAliasFromSchema({ name: key, tableSchema, safe: true });
+  const aliasKey = getAliasFromSchema({
+    name: key,
+    tableSchema,
+    safe: shouldUseSafeAlias({ isAstIdentifier: false }),
+  });
   // Add the alias key to the set. So we have a reference to all the previously selected members.
   return { sql: `${modifiedSql} AS ${aliasKey}`, foundMember, aliasKey };
 };
@@ -67,7 +74,11 @@ export const getFilterMeasureProjection = ({
       aliasKey: undefined,
     };
   }
-  const aliasKey = getAliasFromSchema({ name: key, tableSchema, safe: true });
+  const aliasKey = getAliasFromSchema({
+    name: key,
+    tableSchema,
+    safe: shouldUseSafeAlias({ isAstIdentifier: false }),
+  });
   return { sql: `${key} AS ${aliasKey}`, foundMember, aliasKey };
 };
 

meerkat-core/src/get-wrapped-base-query-with-projections/get-projection-clause.ts

@@ -1,5 +1,8 @@
 import { getAllColumnUsedInMeasures } from '../cube-measure-transformer/cube-measure-transformer';
-import { getAliasFromSchema } from '../member-formatters/get-alias';
+import {
+  getAliasFromSchema,
+  shouldUseSafeAlias,
+} from '../member-formatters/get-alias';
 import { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';
 import { Query, TableSchema } from '../types/cube-types';
 import {
@@ -52,7 +55,11 @@ export const getProjectionClause = (
         query,
       });
       return memberClauseAggregator({
-        member: getAliasFromSchema({ name: member, tableSchema, safe: true }),
+        member: getAliasFromSchema({
+          name: member,
+          tableSchema,
+          safe: shouldUseSafeAlias({ isAstIdentifier: false }),
+        }),
         aliasedColumnSet,
         acc,
         currentIndex,

meerkat-core/src/member-formatters/get-alias.ts

@@ -3,24 +3,53 @@ import { findInSchema } from '../utils/find-in-table-schema';
 import { memberKeyToSafeKey } from './member-key-to-safe-key';
 import { splitIntoDataSourceAndFields } from './split-into-data-source-and-fields';
 
+export const shouldUseSafeAlias = ({
+  isAstIdentifier,
+  isTableSchemaAlias,
+}: {
+  isAstIdentifier?: boolean;
+  isTableSchemaAlias?: boolean;
+}): boolean => {
+  if (isAstIdentifier) {
+    // Duckdb will automatically quote identifiers that contain special characters or spaces.
+    // when converting the AST to SQL.
+    return false;
+  }
+  if (isTableSchemaAlias) {
+    // No need to wrap alias in quotes as part of table schema
+    return false;
+  }
+  // For other cases such as directly using the alias in SQL queries,
+  // we should make the alias safe to avoid issues with special characters or spaces.
+  return true;
+};
+
 export const getAliasFromSchema = ({
   name,
   tableSchema,
   safe,
 }: {
   name: string;
   tableSchema: TableSchema;
-  safe?: boolean;
+  safe: boolean;
 }): string => {
   const [, field] = splitIntoDataSourceAndFields(name);
-  return constructAlias(name, findInSchema(field, tableSchema)?.alias, safe);
+  return constructAlias({
+    name,
+    alias: findInSchema(field, tableSchema)?.alias,
+    safe,
+  });
 };
 
-export const constructAlias = (
-  name: string,
-  alias?: string,
-  safe?: boolean
-): string => {
+export const constructAlias = ({
+  name,
+  alias,
+  safe,
+}: {
+  name: string;
+  alias?: string;
+  safe: boolean;
+}): string => {
   if (alias) {
     if (safe) {
       // Alias may contain special characters or spaces, so we need to wrap in quotes.

meerkat-core/src/member-formatters/index.ts

@@ -1,5 +1,9 @@
 export { COLUMN_NAME_DELIMITER } from './constants';
-export { constructAlias, getAliasFromSchema } from './get-alias';
+export {
+  constructAlias,
+  getAliasFromSchema,
+  shouldUseSafeAlias,
+} from './get-alias';
 export { getNamespacedKey } from './get-namespaced-key';
 export { memberKeyToSafeKey } from './member-key-to-safe-key';
 export { splitIntoDataSourceAndFields } from './split-into-data-source-and-fields';

meerkat-core/src/resolution/resolution.ts

@@ -1,5 +1,9 @@
-import { getNamespacedKey, memberKeyToSafeKey } from '../member-formatters';
-import { constructAlias } from '../member-formatters/get-alias';
+import {
+  constructAlias,
+  getNamespacedKey,
+  memberKeyToSafeKey,
+  shouldUseSafeAlias,
+} from '../member-formatters';
 import { JoinPath, Member, Query } from '../types/cube-types/query';
 import { Dimension, Measure, TableSchema } from '../types/cube-types/table';
 import {
@@ -11,10 +15,18 @@ import { BASE_DATA_SOURCE_NAME, ResolutionConfig } from './types';
 const constructBaseDimension = (name: string, schema: Measure | Dimension) => {
   return {
     name: memberKeyToSafeKey(name),
-    sql: `${BASE_DATA_SOURCE_NAME}.${constructAlias(name, schema.alias, true)}`,
+    sql: `${BASE_DATA_SOURCE_NAME}.${constructAlias({
+      name,
+      alias: schema.alias,
+      safe: shouldUseSafeAlias({ isAstIdentifier: false }),
+    })}`,
     type: schema.type,
     // Constructs alias to match the name in the base query.
-    alias: constructAlias(name, schema.alias),
+    alias: constructAlias({
+      name,
+      alias: schema.alias,
+      safe: shouldUseSafeAlias({ isTableSchemaAlias: true }),
+    }),
   };
 };
 
@@ -49,11 +61,11 @@ export const createBaseTableSchema = (
       }
     }),
     joins: resolutionConfig.columnConfigs.map((config) => ({
-      sql: `${BASE_DATA_SOURCE_NAME}.${constructAlias(
-        config.name,
-        schemaByName[config.name]?.alias,
-        true
-      )} = ${memberKeyToSafeKey(config.name)}.${config.joinColumn}`,
+      sql: `${BASE_DATA_SOURCE_NAME}.${constructAlias({
+        name: config.name,
+        alias: schemaByName[config.name]?.alias,
+        safe: shouldUseSafeAlias({ isAstIdentifier: false }),
+      })} = ${memberKeyToSafeKey(config.name)}.${config.joinColumn}`,
     })),
   };
 };
@@ -72,10 +84,11 @@ export const generateResolutionSchemas = (
     }
 
     const baseName = memberKeyToSafeKey(colConfig.name);
-    const baseAlias = constructAlias(
-      colConfig.name,
-      findInSchemas(colConfig.name, baseTableSchemas)?.alias
-    );
+    const baseAlias = constructAlias({
+      name: colConfig.name,
+      alias: findInSchemas(colConfig.name, baseTableSchemas)?.alias,
+      safe: shouldUseSafeAlias({ isTableSchemaAlias: true }),
+    });
 
     // For each column that needs to be resolved, create a copy of the relevant table schema.
     // We use the name of the column in the base query as the table schema name
@@ -98,7 +111,11 @@ export const generateResolutionSchemas = (
           name: memberKeyToSafeKey(getNamespacedKey(colConfig.name, col)),
           sql: `${baseName}.${col}`,
           type: dimension.type,
-          alias: `${baseAlias} - ${constructAlias(col, dimension.alias)}`,
+          alias: `${baseAlias} - ${constructAlias({
+            name: col,
+            alias: dimension.alias,
+            safe: shouldUseSafeAlias({ isTableSchemaAlias: true }),
+          })}`,
         };
       }),
     };
@@ -143,11 +160,11 @@ export const generateResolutionJoinPaths = (
     {
       left: BASE_DATA_SOURCE_NAME,
       right: memberKeyToSafeKey(config.name),
-      on: constructAlias(
-        config.name,
-        findInSchemas(config.name, baseTableSchemas)?.alias,
-        true
-      ),
+      on: constructAlias({
+        name: config.name,
+        alias: findInSchemas(config.name, baseTableSchemas)?.alias,
+        safe: shouldUseSafeAlias({ isAstIdentifier: false }),
+      }),
     },
   ]);
 };