dsl-to-sql 1.0.0-fabric-1p-development.1

package/src/epm-query-builder/base/RelationshipResolver.ts

@@ -0,0 +1,207 @@
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { EpmQueryBuilderOptions, Relationship } from '@epm-query-builder/types/query-builder-types';
+import { SOURCE_TYPES } from '@epm-query-builder/constants/Source';
+
+type JoinType = 'LEFT' | 'INNER' | 'FULL OUTER';
+
+export interface JoinStep {
+  leftTable: string;
+  leftColumn: string;
+  rightTable: string;
+  rightColumn: string;
+  joinType: JoinType;
+  dedupeRightOn?: string;
+}
+
+export interface JoinPlan {
+  baseTable: string;
+  joins: JoinStep[];
+}
+
+interface Edge {
+  from: string;
+  to: string;
+  relation: Relationship;
+}
+
+function isActive(rel: Relationship, includeInactive: boolean): boolean {
+  if (includeInactive) return true;
+  return rel.isActive !== false;
+}
+
+function buildEdges(rels: Relationship[], includeInactive: boolean): Edge[] {
+  const edges: Edge[] = [];
+  for (const r of rels) {
+    if (!isActive(r, includeInactive)) continue;
+    const fromIsMany = r.fromColumnMultiplicity === '*';
+    const toIsMany = r.toColumnMultiplicity === '*';
+
+    if (fromIsMany && toIsMany) {
+      edges.push({ from: r.fromTable, to: r.toTable, relation: r });
+      edges.push({ from: r.toTable, to: r.fromTable, relation: r });
+    } else if (!fromIsMany && toIsMany) {
+      edges.push({ from: r.fromTable, to: r.toTable, relation: r });
+    } else if (fromIsMany && !toIsMany) {
+      edges.push({ from: r.toTable, to: r.fromTable, relation: r });
+    } else {
+      edges.push({ from: r.fromTable, to: r.toTable, relation: r });
+      edges.push({ from: r.toTable, to: r.fromTable, relation: r });
+    }
+  }
+  return edges;
+}
+
+function buildGraph(edges: Edge[]): Map<string, Edge[]> {
+  const graph = new Map<string, Edge[]>();
+  for (const e of edges) {
+    if (!graph.has(e.from)) graph.set(e.from, []);
+    graph.get(e.from)!.push(e);
+  }
+  return graph;
+}
+
+function bfsReachable(graph: Map<string, Edge[]>, start: string): Set<string> {
+  const visited = new Set<string>();
+  if (!start) return visited;
+  const q: string[] = [start];
+  visited.add(start);
+  while (q.length) {
+    const u = q.shift() as string;
+    const outs = graph.get(u) || [];
+    for (const e of outs) {
+      if (!visited.has(e.to)) {
+        visited.add(e.to);
+        q.push(e.to);
+      }
+    }
+  }
+  return visited;
+}
+
+function findShortestPath(
+  graph: Map<string, Edge[]>,
+  start: string,
+  target: string,
+): Edge[] | null {
+  if (start === target) return [];
+  const parent = new Map<string, Edge | null>();
+  const q: string[] = [start];
+  parent.set(start, null);
+
+  while (q.length) {
+    const u = q.shift() as string;
+    const outs = graph.get(u) || [];
+    for (const e of outs) {
+      if (!parent.has(e.to)) {
+        parent.set(e.to, e);
+        if (e.to === target) {
+          const path: Edge[] = [];
+          let cur = target;
+          while (cur !== start) {
+            const pe = parent.get(cur);
+            if (!pe) break;
+            path.push(pe);
+            cur = pe.from;
+          }
+          path.reverse();
+          return path;
+        }
+        q.push(e.to);
+      }
+    }
+  }
+  return null;
+}
+
+function selectBaseTable(requiredTables: string[], edges: Edge[], fallbackBase: string): string {
+  const graph = buildGraph(edges);
+  if (fallbackBase) {
+    const reach = bfsReachable(graph, fallbackBase);
+    const allCovered = requiredTables.every((t) => reach.has(t) || t === fallbackBase);
+    if (allCovered) return fallbackBase;
+  }
+
+  let best: { table: string; covered: number } = { table: fallbackBase, covered: -1 };
+  for (const t of requiredTables) {
+    const cover = bfsReachable(graph, t);
+    const cnt = requiredTables.filter((x) => cover.has(x) || x === t).length;
+    if (cnt > best.covered) {
+      best = { table: t, covered: cnt };
+    }
+  }
+  return best.table || fallbackBase;
+}
+
+function isManyToMany(r: Relationship): boolean {
+  return r.fromColumnMultiplicity === '*' && r.toColumnMultiplicity === '*';
+}
+
+function edgeToJoin(leftTable: string, e: Edge, dimensionOnly: boolean): JoinStep {
+  const r = e.relation;
+  const mm = isManyToMany(r);
+  const joinType: JoinType = dimensionOnly ? 'FULL OUTER' : 'LEFT';
+  if (e.from === r.fromTable && e.to === r.toTable) {
+    return {
+      leftTable,
+      leftColumn: r.fromColumn,
+      rightTable: r.toTable,
+      rightColumn: r.toColumn,
+      joinType,
+      dedupeRightOn: dimensionOnly && mm ? r.toColumn : undefined,
+    };
+  }
+  return {
+    leftTable,
+    leftColumn: r.toColumn,
+    rightTable: r.fromTable,
+    rightColumn: r.fromColumn,
+    joinType,
+    dedupeRightOn: dimensionOnly && mm ? r.fromColumn : undefined,
+  };
+}
+
+export function resolveJoinPlan(options: EpmQueryBuilderOptions): JoinPlan {
+  const relationships = options.relationships || [];
+  if (relationships.length === 0) {
+    return { baseTable: BaseUtilities.getDefaultTableName(options), joins: [] };
+  }
+
+  const requiredTables = BaseUtilities.extractUniqueTableNames(options);
+
+  const dimensionOnly = !BaseUtilities.hasMeasuresInOptions(options);
+  const source = BaseUtilities.getSource(options);
+  const includeInactive = source === SOURCE_TYPES.XMLA && dimensionOnly;
+
+  const edges = buildEdges(relationships, includeInactive);
+  if (requiredTables.length <= 1 || edges.length === 0) {
+    return { baseTable: BaseUtilities.getDefaultTableName(options), joins: [] };
+  }
+
+  const base = selectBaseTable(requiredTables, edges, BaseUtilities.getDefaultTableName(options));
+  const graph = buildGraph(edges);
+
+  const usedPairs = new Set<string>();
+  const joins: JoinStep[] = [];
+
+  for (const t of requiredTables) {
+    if (t === base) continue;
+    const path = findShortestPath(graph, base, t);
+    if (!path) {
+      throw new Error(`No relationship path found from ${base} to ${t}`);
+    }
+    let currentLeft = base;
+    for (const edge of path) {
+      const key = `${edge.from}->${edge.to}`;
+      if (usedPairs.has(key)) {
+        currentLeft = edge.to;
+        continue;
+      }
+      const step = edgeToJoin(currentLeft, edge, dimensionOnly);
+      joins.push(step);
+      usedPairs.add(key);
+      currentLeft = edge.to;
+    }
+  }
+
+  return { baseTable: base, joins };
+}