Function collectSelectedColumns

src/utils/visualQuery.ts:91–145

(
  nodes: QueryNode[],
  aliases: Record<string, string>
)

 * Collects selected columns with their expressions and ordering
 */
export function collectSelectedColumns(
  nodes: QueryNode[],
  aliases: Record<string, string>
): { columns: SelectedColumn[]; hasAggregation: boolean; nonAggregatedCols: string[] } {
  const selectedColsWithOrder: SelectedColumn[] = [];
  const nonAggregatedCols: string[] = [];
  let hasAggregation = false;

  nodes.forEach((node) => {
    const data = node.data;
    const alias = aliases[node.id];

    if (data.selectedColumns) {
      Object.entries(data.selectedColumns).forEach(([col, isChecked]) => {
        if (isChecked) {
          const agg = data.columnAggregations?.[col];
          const colAlias = data.columnAliases?.[col];
          let colExpr = `${alias}.${col}`;
          let order = 999;

          if (agg?.function) {
            hasAggregation = true;
            if (agg.function === 'COUNT_DISTINCT') {
              colExpr = `COUNT(DISTINCT ${alias}.${col})`;
            } else {
              colExpr = `${agg.function}(${alias}.${col})`;
            }

            if (agg?.alias) {
              colExpr += ` AS ${agg.alias}`;
            }

            if (agg?.order !== undefined) {
              order = agg.order;
            }
          } else {
            nonAggregatedCols.push(`${alias}.${col}`);

            if (colAlias?.alias) {
              colExpr += ` AS ${colAlias.alias}`;
            }

            if (colAlias?.order !== undefined) {
              order = colAlias.order;
            }
          }

          selectedColsWithOrder.push({ expr: colExpr, order, colName: col });
        }
      });
    }
  });

  return { columns: selectedColsWithOrder, hasAggregation, nonAggregatedCols };
}

/**
 * Sorts columns by their order property