prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/QueryBuilder/getJoinQuery.ts

@@ -1,7 +1,16 @@
 import { isDefined, asName } from "prostgles-types";
 import { ParsedJoinPath, parseJoinPath } from "../ViewHandler/parseJoinPath";
-import { NewQuery, NewQueryJoin, SelectItem, asNameAlias } from "./QueryBuilder";
-import { ROOT_TABLE_ALIAS, ROOT_TABLE_ROW_NUM_ID, indentLines } from "./getSelectQuery";
+import {
+  NewQuery,
+  NewQueryJoin,
+  SelectItem,
+  asNameAlias,
+} from "./QueryBuilder";
+import {
+  ROOT_TABLE_ALIAS,
+  ROOT_TABLE_ROW_NUM_ID,
+  indentLines,
+} from "./getSelectQuery";
 import { ViewHandler } from "../ViewHandler/ViewHandler";
 import { getJoinOnCondition } from "../ViewHandler/getTableJoinQuery";
 import { prepareOrderByQuery } from "../DboBuilder";
@@ -10,7 +19,7 @@ type Args = {
   q1: NewQuery;
   q2: NewQueryJoin;
   selectParamsGroupBy: boolean;
-}
+};
 
 /**
  * Rename all join columns to prevent name clash
@@ -20,8 +29,8 @@ export const getJoinCol = (colName: string) => {
   return {
     alias,
     rootSelect: `${asName(colName)} AS ${alias}`,
-  }
-}
+  };
+};
 
 export const JSON_AGG_FIELD_NAME = "prostgles_json_agg_result_field";
 /**
@@ -29,25 +38,29 @@ export const JSON_AGG_FIELD_NAME = "prostgles_json_agg_result_field";
  */
 export const NESTED_ROWID_FIELD_NAME = "prostgles_rowid_field";
 
-const getJoinTable = (tableName: string, pathIndex: number, isLastTableAlias: string | undefined) => {
-  const rawAlias = isLastTableAlias ?? `p${pathIndex}  ${tableName}`; 
+const getJoinTable = (
+  tableName: string,
+  pathIndex: number,
+  isLastTableAlias: string | undefined,
+) => {
+  const rawAlias = isLastTableAlias ?? `p${pathIndex}  ${tableName}`;
   return {
     // name: asName(tableName), /** table names are already escaped */
     name: tableName,
     alias: asName(rawAlias),
     rawAlias,
-  }
-}
+  };
+};
 
 type GetJoinQueryResult = {
   resultAlias: string;
-  // queryLines: string[]; 
+  // queryLines: string[];
   firstJoinTableJoinFields: string[];
   isOrJoin: boolean;
   type: "cte";
   joinLines: string[];
   cteLines: string[];
-}
+};
 
 /**
   Returns join query. All inner join tables will be prefixed with path index unless it's the final target table which is aliased using the q2 tableAlias
@@ -60,81 +73,109 @@ type GetJoinQueryResult = {
   ) target_table
   ON ...condition
  */
-export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoinQueryResult => {
-  const paths = parseJoinPath({ 
-    rootTable: q1.table, 
-    rawPath: q2.joinPath, 
-    viewHandler: viewHandler, 
-    allowMultiOrJoin: true, 
-    addShortestJoinIfMissing: true, 
+export const getJoinQuery = (
+  viewHandler: ViewHandler,
+  { q1, q2 }: Args,
+): GetJoinQueryResult => {
+  const paths = parseJoinPath({
+    rootTable: q1.table,
+    rawPath: q2.joinPath,
+    viewHandler: viewHandler,
+    allowMultiOrJoin: true,
+    addShortestJoinIfMissing: true,
   });
 
   const targetTableAliasRaw = q2.tableAlias || q2.table;
   const targetTableAlias = asName(targetTableAliasRaw);
-  
+
   const firstJoinTablePath = paths[0]!;
-  const firstJoinTableJoinFields = firstJoinTablePath.on.flatMap(condObj => Object.entries(condObj).map(([source, target]) => target));
-  const { rootSelectItems, jsonAggLimit } = getNestedSelectFields({ 
-    q: q2, 
-    firstJoinTableAlias: getJoinTable(firstJoinTablePath.table, 0, paths.length === 1? targetTableAliasRaw : undefined).rawAlias, 
-    _joinFields: firstJoinTableJoinFields 
+  const firstJoinTableJoinFields = firstJoinTablePath.on.flatMap((condObj) =>
+    Object.entries(condObj).map(([source, target]) => target),
+  );
+  const { rootSelectItems, jsonAggLimit } = getNestedSelectFields({
+    q: q2,
+    firstJoinTableAlias: getJoinTable(
+      firstJoinTablePath.table,
+      0,
+      paths.length === 1 ? targetTableAliasRaw : undefined,
+    ).rawAlias,
+    _joinFields: firstJoinTableJoinFields,
   });
 
-  const joinType = q2.isLeftJoin? "LEFT" : "INNER";
+  const joinType = q2.isLeftJoin ? "LEFT" : "INNER";
 
   const isOrJoin = firstJoinTablePath.on.length > 1;
-  const joinCondition = getJoinOnCondition({ 
-    on: firstJoinTablePath.on, 
-    leftAlias: asName(q1.tableAlias || q1.table), 
-    rightAlias: targetTableAlias, 
-    getRightColName: (col) => getJoinCol(col).alias
+  const joinCondition = getJoinOnCondition({
+    on: firstJoinTablePath.on,
+    leftAlias: asName(q1.tableAlias || q1.table),
+    rightAlias: targetTableAlias,
+    getRightColName: (col) => getJoinCol(col).alias,
   });
 
-  const joinFields = rootSelectItems.filter(s => s.isJoinCol).map(s => s.alias);
-  const selectedFields = rootSelectItems.filter(s => s.selected).map(s => asNameAlias(s.alias, targetTableAliasRaw));
-  const rootNestedSort = q1.orderByItems.filter(d => d.nested?.joinAlias === q2.joinAlias);
-  const jsonAggSort = prepareOrderByQuery(q2.orderByItems, targetTableAliasRaw).join(", ");
+  const joinFields = rootSelectItems
+    .filter((s) => s.isJoinCol)
+    .map((s) => s.alias);
+  const selectedFields = rootSelectItems
+    .filter((s) => s.selected)
+    .map((s) => asNameAlias(s.alias, targetTableAliasRaw));
+  const rootNestedSort = q1.orderByItems.filter(
+    (d) => d.nested?.joinAlias === q2.joinAlias,
+  );
+  const jsonAggSort = prepareOrderByQuery(
+    q2.orderByItems,
+    targetTableAliasRaw,
+  ).join(", ");
   const jsonAgg = `json_agg((SELECT x FROM (SELECT ${selectedFields}) as x )${jsonAggSort}) ${jsonAggLimit} as ${JSON_AGG_FIELD_NAME}`;
-  
-  const { innerQuery } = getInnerJoinQuery({ paths, q1, q2, rootSelectItems, targetTableAliasRaw });
 
-  const requiredJoinFields = joinFields.map(field => getJoinCol(field).alias);
+  const { innerQuery } = getInnerJoinQuery({
+    paths,
+    q1,
+    q2,
+    rootSelectItems,
+    targetTableAliasRaw,
+  });
+
+  const requiredJoinFields = joinFields.map((field) => getJoinCol(field).alias);
   /**
    * Used to prevent duplicates in case of OR filters
    */
   const rootTableIdField = `${ROOT_TABLE_ALIAS}.${ROOT_TABLE_ROW_NUM_ID}`;
   const wrappingQuery = [
     `SELECT `,
-      ...indentLines([
-        ...(isOrJoin? [rootTableIdField]: requiredJoinFields), 
-        jsonAgg, 
-        ...rootNestedSort.map(d => d.nested!.wrapperQuerySortItem)
-      ], { appendCommas: true }),
+    ...indentLines(
+      [
+        ...(isOrJoin ? [rootTableIdField] : requiredJoinFields),
+        jsonAgg,
+        ...rootNestedSort.map((d) => d.nested!.wrapperQuerySortItem),
+      ],
+      { appendCommas: true },
+    ),
     `FROM (`,
     ...indentLines(innerQuery),
     `) ${targetTableAlias}`,
-    ...(isOrJoin? [
-    `LEFT JOIN ${q1.table} ${ROOT_TABLE_ALIAS}`,
-    `ON ${joinCondition}`
-    ] : []),
-    `GROUP BY ${isOrJoin? rootTableIdField : requiredJoinFields}`,
-  ]; 
-  
+    ...(isOrJoin
+      ? [`LEFT JOIN ${q1.table} ${ROOT_TABLE_ALIAS}`, `ON ${joinCondition}`]
+      : []),
+    `GROUP BY ${isOrJoin ? rootTableIdField : requiredJoinFields}`,
+  ];
+
   /**
    * This is done to prevent join cte names clashing with actual table names
    */
-  const targetTableAliasTempRename = asName(`${targetTableAlias}_prostgles_join_temp_rename`)
+  const targetTableAliasTempRename = asName(
+    `${targetTableAlias}_prostgles_join_temp_rename`,
+  );
   const cteLines = [
     `${targetTableAliasTempRename} AS (`,
     ...indentLines(wrappingQuery),
-    `)`
+    `)`,
   ];
 
   const joinLines = [
     `${joinType} JOIN ( SELECT * FROM ${targetTableAliasTempRename} ) as ${targetTableAlias}`,
-    isOrJoin? 
-      `ON ${targetTableAlias}.${ROOT_TABLE_ROW_NUM_ID} = ${rootTableIdField}` :
-      `ON ${joinCondition}`
+    isOrJoin
+      ? `ON ${targetTableAlias}.${ROOT_TABLE_ROW_NUM_ID} = ${rootTableIdField}`
+      : `ON ${joinCondition}`,
   ];
 
   return {
@@ -145,119 +186,153 @@ export const getJoinQuery = (viewHandler: ViewHandler, { q1, q2 }: Args): GetJoi
     cteLines,
     isOrJoin,
     firstJoinTableJoinFields,
-  }
-}
-
+  };
+};
 
 /**
- * prepares the 
+ * prepares the
  */
-const getInnerJoinQuery = ({ paths, q1, q2, targetTableAliasRaw, rootSelectItems }: {
+const getInnerJoinQuery = ({
+  paths,
+  q1,
+  q2,
+  targetTableAliasRaw,
+  rootSelectItems,
+}: {
   paths: ParsedJoinPath[];
   q1: NewQuery;
   q2: NewQueryJoin;
   targetTableAliasRaw: string;
   rootSelectItems: SelectItemNested[];
 }) => {
-
   const innerQuery = paths.flatMap((path, i) => {
-    
     const isLast = i === paths.length - 1;
     const targetQueryExtraQueries: string[] = [];
 
-    const prevTable = getJoinTable(!i? (q1.tableAlias? asName(q1.tableAlias) : q1.table) : paths[i-1]!.table, i-1, undefined);
-    
-    const table = getJoinTable(path.table, i, isLast? targetTableAliasRaw : undefined);
+    const prevTable = getJoinTable(
+      !i
+        ? q1.tableAlias
+          ? asName(q1.tableAlias)
+          : q1.table
+        : paths[i - 1]!.table,
+      i - 1,
+      undefined,
+    );
 
-    if(isLast){
-      if(q2.where){
+    const table = getJoinTable(
+      path.table,
+      i,
+      isLast ? targetTableAliasRaw : undefined,
+    );
+
+    if (isLast) {
+      if (q2.where) {
         targetQueryExtraQueries.push(q2.where);
       }
 
       /* If aggs exist need to set groupBy add joinFields into select */
-      const aggs = q2.select.filter(s => s.type === "aggregation")
+      const aggs = q2.select.filter((s) => s.type === "aggregation");
       if (aggs.length) {
-        const groupByFields = rootSelectItems.map((c, i) => (c.isJoinCol || c.selected && c.type !== "aggregation")? `${i+1}` : undefined ).filter(isDefined);
-        if(groupByFields.length){
-          targetQueryExtraQueries.push(`GROUP BY ${groupByFields}`)
+        const groupByFields = rootSelectItems
+          .map((c, i) =>
+            c.isJoinCol || (c.selected && c.type !== "aggregation")
+              ? `${i + 1}`
+              : undefined,
+          )
+          .filter(isDefined);
+        if (groupByFields.length) {
+          targetQueryExtraQueries.push(`GROUP BY ${groupByFields}`);
         }
-        if(q2.having){
-          targetQueryExtraQueries.push(`HAVING ${q2.having}`)
+        if (q2.having) {
+          targetQueryExtraQueries.push(`HAVING ${q2.having}`);
         }
       }
     }
 
     const isFirst = !i;
-    if(isFirst){
+    if (isFirst) {
       return [
         `SELECT `,
-        `  /* Join fields + select */`, 
-        ...indentLines(rootSelectItems.map(s => s.query), { appendCommas: true }),
+        `  /* Join fields + select */`,
+        ...indentLines(
+          rootSelectItems.map((s) => s.query),
+          { appendCommas: true },
+        ),
         `FROM ${table.name} ${table.alias}`,
-        ...targetQueryExtraQueries
-      ]
+        ...targetQueryExtraQueries,
+      ];
     }
 
     return [
       `INNER JOIN ${table.name} ${table.alias}`,
-      `ON ${getJoinOnCondition({ 
-        on: path.on, 
-        leftAlias: prevTable.alias, 
+      `ON ${getJoinOnCondition({
+        on: path.on,
+        leftAlias: prevTable.alias,
         rightAlias: table.alias,
       })}`,
-      ...targetQueryExtraQueries
-    ]
+      ...targetQueryExtraQueries,
+    ];
   });
 
-  return { innerQuery }
-}
-
+  return { innerQuery };
+};
 
 type GetSelectFieldsArgs = {
   q: NewQueryJoin;
   firstJoinTableAlias: string;
   _joinFields: string[];
-}
+};
+
+export type SelectItemNested = SelectItem & {
+  query: string;
+  isJoinCol: boolean;
+};
+const getNestedSelectFields = ({
+  q,
+  firstJoinTableAlias,
+  _joinFields,
+}: GetSelectFieldsArgs) => {
+  const targetTableAlias = q.tableAlias || q.table;
 
-export type SelectItemNested = SelectItem & { query: string; isJoinCol: boolean; };
-const getNestedSelectFields = ({ q, firstJoinTableAlias, _joinFields }: GetSelectFieldsArgs) => {
-  const targetTableAlias = (q.tableAlias || q.table);
-  
-  const requiredJoinFields = Array.from(new Set(_joinFields))
-  const selectedFields = q.select.filter(s => s.selected);
-  const rootSelectItems: SelectItemNested[] = selectedFields 
-    .map(s => ({ 
+  const requiredJoinFields = Array.from(new Set(_joinFields));
+  const selectedFields = q.select.filter((s) => s.selected);
+  const rootSelectItems: SelectItemNested[] = selectedFields
+    .map((s) => ({
       ...s,
       isJoinCol: false,
-      query: s.getQuery(targetTableAlias) + " AS " + asName(s.alias)
+      query: s.getQuery(targetTableAlias) + " AS " + asName(s.alias),
     }))
-    .concat(requiredJoinFields.map(f => ({
-      type: "column",
-      columnName: f,
-      alias: f,
-      getFields: () => [f],
-      getQuery: (tableAlias) => asNameAlias(f, tableAlias),
-      selected: false,
-      isJoinCol: true,
-      query: `${asName(firstJoinTableAlias)}.${getJoinCol(f).rootSelect}`,
-    })));
-  
-    const getQuery = (tableAlias?: string) => {
-      const partitionBy = `PARTITION BY ${requiredJoinFields.map(f => asNameAlias(f, tableAlias))}`;
-      return `ROW_NUMBER() OVER(${partitionBy}) AS ${NESTED_ROWID_FIELD_NAME}`
-    };
-    rootSelectItems.push({
-      type: "computed",
-      selected: false,
-      alias: NESTED_ROWID_FIELD_NAME,
-      getFields: () => [],
-      getQuery,
-      query: getQuery(firstJoinTableAlias),
-      isJoinCol: false,
-    })
-  
-  return { 
-    rootSelectItems, 
-    jsonAggLimit: q.limit? `FILTER (WHERE ${NESTED_ROWID_FIELD_NAME} <= ${q.limit})` : ""
+    .concat(
+      requiredJoinFields.map((f) => ({
+        type: "column",
+        columnName: f,
+        alias: f,
+        getFields: () => [f],
+        getQuery: (tableAlias) => asNameAlias(f, tableAlias),
+        selected: false,
+        isJoinCol: true,
+        query: `${asName(firstJoinTableAlias)}.${getJoinCol(f).rootSelect}`,
+      })),
+    );
+
+  const getQuery = (tableAlias?: string) => {
+    const partitionBy = `PARTITION BY ${requiredJoinFields.map((f) => asNameAlias(f, tableAlias))}`;
+    return `ROW_NUMBER() OVER(${partitionBy}) AS ${NESTED_ROWID_FIELD_NAME}`;
+  };
+  rootSelectItems.push({
+    type: "computed",
+    selected: false,
+    alias: NESTED_ROWID_FIELD_NAME,
+    getFields: () => [],
+    getQuery,
+    query: getQuery(firstJoinTableAlias),
+    isJoinCol: false,
+  });
+
+  return {
+    rootSelectItems,
+    jsonAggLimit: q.limit
+      ? `FILTER (WHERE ${NESTED_ROWID_FIELD_NAME} <= ${q.limit})`
+      : "",
   };
-}
+};