data-finder-ts 0.1.3 → 0.1.4

package/dist/{chunk-6QTCGJWX.js → chunk-FJYA2ASS.js}

@@ -1,11 +1,20 @@
 import {
   toSql
-} from "./chunk-DFYZVBII.js";
+} from "./chunk-MH4XMYVB.js";
 import {
   NoOperation
-} from "./chunk-3SSWFES4.js";
+} from "./chunk-UYMOE6YU.js";
 
 // src/datafinder/runner.ts
+var DEFAULT_TIMEOUT_MS = 6e4;
+var QueryTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Query exceeded ${timeoutMs}ms timeout`);
+    this.timeoutMs = timeoutMs;
+    this.name = "QueryTimeoutError";
+  }
+  timeoutMs;
+};
 var _runner = null;
 function registerRunner(runner) {
   _runner = runner;
@@ -18,21 +27,24 @@ function getRunner() {
   return _runner;
 }
 var FinderResult = class {
-  constructor(_businessDate, _processingDatetime, _columns, _table, _op) {
+  constructor(_businessDate, _processingDatetime, _columns, _table, _op, _businessDateTo = null) {
     this._businessDate = _businessDate;
     this._processingDatetime = _processingDatetime;
     this._columns = _columns;
     this._table = _table;
     this._op = _op;
+    this._businessDateTo = _businessDateTo;
   }
   _businessDate;
   _processingDatetime;
   _columns;
   _table;
   _op;
+  _businessDateTo;
   _orderBy = [];
   _groupBy = [];
   _limit;
+  _timeoutMs = DEFAULT_TIMEOUT_MS;
   orderByOp(...sorts) {
     this._orderBy = sorts;
     return this;
@@ -45,6 +57,11 @@ var FinderResult = class {
     this._limit = n;
     return this;
   }
+  /** Abort the query and throw QueryTimeoutError if it runs longer than `milliseconds` (default 60000). */
+  timeout(milliseconds) {
+    this._timeoutMs = milliseconds;
+    return this;
+  }
   toSql() {
     return toSql(
       this._businessDate,
@@ -54,7 +71,8 @@ var FinderResult = class {
       this._op,
       this._orderBy,
       this._groupBy,
-      this._limit
+      this._limit,
+      this._businessDateTo
     );
   }
   async toRows() {
@@ -66,14 +84,18 @@ var FinderResult = class {
       this._op,
       this._orderBy,
       this._groupBy,
-      this._limit
+      this._limit,
+      this._timeoutMs,
+      this._businessDateTo
     );
   }
 };
 function convertDate(value) {
   if (value === null) return null;
   if (value instanceof Date) return value;
-  const normalized = /^\d{4}-\d{2}-\d{2}$/.test(value) ? value + "T00:00:00Z" : value;
+  let normalized = value;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) normalized = value + "T00:00:00Z";
+  else if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/.test(value)) normalized = value.replace(" ", "T") + "Z";
   const d = new Date(normalized);
   if (isNaN(d.getTime())) throw new Error(`Cannot parse date: ${value}`);
   return d;
@@ -87,12 +109,28 @@ function convertInputsAndSelect(businessDate, processingDatetime, columns, table
     op
   );
 }
+function convertInputsAndSelectForDateRange(businessDateFrom, businessDateTo, processingDatetime, columns, table, op = new NoOperation()) {
+  if (businessDateFrom == null) throw new Error("businessDateFrom is required for findForDateRange");
+  if (businessDateTo == null) throw new Error("businessDateTo is required for findForDateRange");
+  if (processingDatetime == null) throw new Error("processingValidAt is required for findForDateRange");
+  return new FinderResult(
+    convertDate(businessDateFrom),
+    convertDate(processingDatetime),
+    columns,
+    table,
+    op,
+    convertDate(businessDateTo)
+  );
+}
 
 export {
+  DEFAULT_TIMEOUT_MS,
+  QueryTimeoutError,
   registerRunner,
   clearRunner,
   getRunner,
   FinderResult,
-  convertInputsAndSelect
+  convertInputsAndSelect,
+  convertInputsAndSelectForDateRange
 };
-//# sourceMappingURL=chunk-6QTCGJWX.js.map
+//# sourceMappingURL=chunk-FJYA2ASS.js.map

package/dist/chunk-FJYA2ASS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/datafinder/runner.ts"],"sourcesContent":["import { Attribute } from './attribute';\nimport { toSql } from './sql-generator';\nimport {\n  Table,\n  Operation,\n  SortOperation,\n  NoOperation,\n  RelationalOperationElement,\n} from '../model/relational';\n\nexport type Row = unknown[];\n\nexport const DEFAULT_TIMEOUT_MS = 60_000;\n\n/** Thrown by a QueryRunner when a query runs longer than the timeout set on its FinderResult. */\nexport class QueryTimeoutError extends Error {\n  constructor(readonly timeoutMs: number) {\n    super(`Query exceeded ${timeoutMs}ms timeout`);\n    this.name = 'QueryTimeoutError';\n  }\n}\n\n/** Minimum interface satisfied by both Table (SQL) and GraphQLQuery (GraphQL). */\nexport interface QueryTarget {\n  readonly name: string;\n}\n\nexport interface QueryRunner {\n  select(\n    businessDate: Date | null,\n    processingDatetime: Date | null,\n    columns: (Attribute | RelationalOperationElement)[],\n    table: QueryTarget,\n    op: RelationalOperationElement,\n    orderBy?: SortOperation[],\n    groupBy?: Attribute[],\n    limit?: number,\n    timeoutMs?: number,\n    businessDateTo?: Date | null,\n  ): Promise<Row[]>;\n}\n\nlet _runner: QueryRunner | null = null;\n\nexport function registerRunner(runner: QueryRunner): void { _runner = runner; }\nexport function clearRunner(): void { _runner = null; }\nexport function getRunner(): QueryRunner {\n  if (!_runner) throw new Error('No query runner registered. Call registerRunner() first.');\n  return _runner;\n}\n\nexport class FinderResult {\n  private _orderBy: SortOperation[] = [];\n  private _groupBy: Attribute[] = [];\n  private _limit?: number;\n  private _timeoutMs: number = DEFAULT_TIMEOUT_MS;\n\n  constructor(\n    private readonly _businessDate: Date | null,\n    private readonly _processingDatetime: Date | null,\n    private readonly _columns: (Attribute | RelationalOperationElement)[],\n    private readonly _table: QueryTarget,\n    private readonly _op: RelationalOperationElement,\n    private readonly _businessDateTo: Date | null = null,\n  ) {}\n\n  orderByOp(...sorts: SortOperation[]): this {\n    this._orderBy = sorts;\n    return this;\n  }\n\n  groupByOp(...attrs: Attribute[]): this {\n    this._groupBy = attrs;\n    return this;\n  }\n\n  limit(n: number): this {\n    this._limit = n;\n    return this;\n  }\n\n  /** Abort the query and throw QueryTimeoutError if it runs longer than `milliseconds` (default 60000). */\n  timeout(milliseconds: number): this {\n    this._timeoutMs = milliseconds;\n    return this;\n  }\n\n  toSql(): string {\n    return toSql(\n      this._businessDate,\n      this._processingDatetime,\n      this._columns,\n      this._table as Table,\n      this._op,\n      this._orderBy,\n      this._groupBy,\n      this._limit,\n      this._businessDateTo,\n    );\n  }\n\n  async toRows(): Promise<Row[]> {\n    return getRunner().select(\n      this._businessDate,\n      this._processingDatetime,\n      this._columns,\n      this._table,\n      this._op,\n      this._orderBy,\n      this._groupBy,\n      this._limit,\n      this._timeoutMs,\n      this._businessDateTo,\n    );\n  }\n}\n\nfunction convertDate(value: Date | string | null): Date | null {\n  if (value === null) return null;\n  if (value instanceof Date) return value;\n  // Zone-less strings (YYYY-MM-DD, or YYYY-MM-DD HH:MM[:SS]) are read as UTC, matching how\n  // dates are formatted into SQL, so the value doesn't shift with the machine's timezone.\n  let normalized = value;\n  if (/^\\d{4}-\\d{2}-\\d{2}$/.test(value)) normalized = value + 'T00:00:00Z';\n  else if (/^\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?$/.test(value)) normalized = value.replace(' ', 'T') + 'Z';\n  const d = new Date(normalized);\n  if (isNaN(d.getTime())) throw new Error(`Cannot parse date: ${value}`);\n  return d;\n}\n\nexport function convertInputsAndSelect(\n  businessDate: Date | string | null,\n  processingDatetime: Date | string | null,\n  columns: (Attribute | RelationalOperationElement)[],\n  table: QueryTarget,\n  op: RelationalOperationElement = new NoOperation(),\n): FinderResult {\n  return new FinderResult(\n    convertDate(businessDate),\n    convertDate(processingDatetime),\n    columns,\n    table,\n    op,\n  );\n}\n\nexport function convertInputsAndSelectForDateRange(\n  businessDateFrom: Date | string,\n  businessDateTo: Date | string,\n  processingDatetime: Date | string,\n  columns: (Attribute | RelationalOperationElement)[],\n  table: QueryTarget,\n  op: RelationalOperationElement = new NoOperation(),\n): FinderResult {\n  if (businessDateFrom == null) throw new Error('businessDateFrom is required for findForDateRange');\n  if (businessDateTo == null) throw new Error('businessDateTo is required for findForDateRange');\n  if (processingDatetime == null) throw new Error('processingValidAt is required for findForDateRange');\n  return new FinderResult(\n    convertDate(businessDateFrom),\n    convertDate(processingDatetime),\n    columns,\n    table,\n    op,\n    convertDate(businessDateTo),\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-DFYZVBII.js → chunk-MH4XMYVB.js}

@@ -4,16 +4,17 @@ import {
   MilestonedTable,
   ProcessingTemporalColumns,
   SingleBusinessDateColumn
-} from "./chunk-EYXBYV2X.js";
+} from "./chunk-PMPLCEWQ.js";
 import {
   DateAttribute,
   DateTimeAttribute
-} from "./chunk-5K2Z3YDY.js";
+} from "./chunk-4LNZV6EN.js";
 import {
   Attribute
-} from "./chunk-V647VNMY.js";
+} from "./chunk-4JVW4TAB.js";
 import {
   AggregateOperation,
+  Alias,
   BooleanConstantOperation,
   Column,
   ColumnWithJoin,
@@ -26,64 +27,25 @@ import {
   DateExtractOperation,
   DateTimeConstantOperation,
   DecimalConstantOperation,
+  ExistsOperation,
   FloatConstantOperation,
   IntegerConstantOperation,
   IsNotNullOperation,
   IsNullOperation,
   LogicalOperation,
   NoOperation,
+  NotExistsOperation,
   RelationalOperationElement,
   ScalarFunctionOperation,
+  SelectOperation,
   SortOperation,
   StringConstantOperation,
   UnaryOperation,
   WindowFunctionOperation,
   WindowSpecification
-} from "./chunk-3SSWFES4.js";
-
-// src/datafinder/finder.ts
-var ExistsOperation = class extends RelationalOperationElement {
-  constructor(node) {
-    super();
-    this.node = node;
-  }
-  node;
-  andOp(other) {
-    return new LogicalOperation(this, "AND" /* AND */, other);
-  }
-};
-var NotExistsOperation = class extends RelationalOperationElement {
-  constructor(node) {
-    super();
-    this.node = node;
-  }
-  node;
-  andOp(other) {
-    return new LogicalOperation(this, "AND" /* AND */, other);
-  }
-};
-var RelatedFinder = class {
-  constructor(_node) {
-    this._node = _node;
-  }
-  _node;
-  exists() {
-    return new ExistsOperation(this._node);
-  }
-  notExists() {
-    return new NotExistsOperation(this._node);
-  }
-};
+} from "./chunk-UYMOE6YU.js";
 
 // src/datafinder/sql-generator.ts
-var Alias = class {
-  constructor(element, name) {
-    this.element = element;
-    this.name = name;
-  }
-  element;
-  name;
-};
 var TableAlias = class {
   constructor(table, alias) {
     this.table = table;
@@ -111,22 +73,6 @@ var Join = class {
   target;
   filterOp;
 };
-var SelectOperation = class {
-  constructor(display, filter, orderBy = [], groupBy = [], limit, table) {
-    this.display = display;
-    this.filter = filter;
-    this.orderBy = orderBy;
-    this.groupBy = groupBy;
-    this.limit = limit;
-    this.table = table;
-  }
-  display;
-  filter;
-  orderBy;
-  groupBy;
-  limit;
-  table;
-};
 function sqlFormatDatetime(value) {
   const pad = (n, w = 2) => String(n).padStart(w, "0");
   return `'${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())} ${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}'`;
@@ -258,6 +204,9 @@ function sqlOperationToString(operation) {
   }
   throw new TypeError("Unknown operation in sqlOperationToString: " + operation.constructor.name);
 }
+function embeddedOf(ref) {
+  return ref instanceof Attribute ? ref.embedded() : ref.embedded;
+}
 function findColumn(operation) {
   if (operation instanceof UnaryOperation) return findColumn(operation.element);
   if (operation instanceof ColumnWithJoin) return operation;
@@ -307,38 +256,125 @@ function buildMilestoningFilterOperation(businessDate, processingDatetime, table
   if (ops.length === 1) return ops[0];
   return new LogicalOperation(ops[0], "AND" /* AND */, ops[1]);
 }
-function buildQueryOperation(businessDate, processingDatetime, columns, table, op, orderBy = [], groupBy = [], limit) {
+function buildMilestoningFilterOperationForDateRange(businessDateFrom, businessDateTo, processingDatetime, table, joinNode) {
+  const mc = table.milestoningColumns;
+  const ops = [];
+  const hasRange = businessDateFrom !== null && businessDateTo !== null;
+  const processingOp = (m) => {
+    const startAt = new DateTimeAttribute("start_at", m.startAtColumn.name, m.startAtColumn.type, m.startAtColumn.table.qualifiedName, joinNode);
+    const endAt = new DateTimeAttribute("end_at", m.endAtColumn.name, m.endAtColumn.type, m.endAtColumn.table.qualifiedName, joinNode);
+    return new LogicalOperation(startAt.lte(processingDatetime), "AND" /* AND */, openEndClause(endAt, processingDatetime, m.infiniteDatetime));
+  };
+  if (mc instanceof BiTemporalColumns) {
+    if (hasRange) {
+      const dateFrom = new DateAttribute("business_date_from", mc.businessDateFromColumn.name, mc.businessDateFromColumn.type, mc.businessDateFromColumn.table.qualifiedName, joinNode);
+      const dateTo = new DateAttribute("business_date_to", mc.businessDateToColumn.name, mc.businessDateToColumn.type, mc.businessDateToColumn.table.qualifiedName, joinNode);
+      ops.push(new LogicalOperation(dateFrom.lte(businessDateTo), "AND" /* AND */, openEndClause(dateTo, businessDateFrom, mc.infiniteDatetime)));
+    }
+    if (processingDatetime !== null) ops.push(processingOp(mc));
+  } else if (mc instanceof BusinessDateAndProcessingTemporalColumns) {
+    if (hasRange) {
+      const businessAtt = new DateAttribute("business_date", mc.businessDateColumn.name, mc.businessDateColumn.type, mc.businessDateColumn.table.qualifiedName, joinNode);
+      ops.push(new LogicalOperation(businessAtt.gte(businessDateFrom), "AND" /* AND */, businessAtt.lte(businessDateTo)));
+    }
+    if (processingDatetime !== null) ops.push(processingOp(mc));
+  } else if (mc instanceof ProcessingTemporalColumns) {
+    if (processingDatetime !== null) ops.push(processingOp(mc));
+  } else if (mc instanceof SingleBusinessDateColumn && hasRange) {
+    const businessAtt = new DateAttribute("business_date", mc.businessDateColumn.name, mc.businessDateColumn.type, mc.businessDateColumn.table.qualifiedName, joinNode);
+    ops.push(new LogicalOperation(businessAtt.gte(businessDateFrom), "AND" /* AND */, businessAtt.lte(businessDateTo)));
+  }
+  if (ops.length === 0) return null;
+  if (ops.length === 1) return ops[0];
+  return new LogicalOperation(ops[0], "AND" /* AND */, ops[1]);
+}
+function walkRefs(op, visit, visitExists) {
+  if (op === null || op === void 0) return;
+  if (op instanceof Attribute || op instanceof ColumnWithJoin) {
+    visit(op);
+  } else if (op instanceof ExistsOperation || op instanceof NotExistsOperation) {
+    visitExists?.(op.node);
+  } else if (op instanceof AggregateOperation) {
+    walkRefs(op.element, visit, visitExists);
+    if (op.window) walkWindowSpec(op.window, visit, visitExists);
+  } else if (op instanceof WindowFunctionOperation) {
+    if (op.element) walkRefs(op.element, visit, visitExists);
+    if (op.window) walkWindowSpec(op.window, visit, visitExists);
+  } else if (op instanceof ScalarFunctionOperation || op instanceof DateExtractOperation || op instanceof DateArithmeticOperation || op instanceof DateDiffOperation || op instanceof IsNullOperation || op instanceof IsNotNullOperation) {
+    walkRefs(op.element, visit, visitExists);
+  } else if (op instanceof SortOperation) {
+    walkRefs(op.column, visit, visitExists);
+  } else if (op instanceof LogicalOperation || op instanceof ComparisonOperation) {
+    walkRefs(op.left, visit, visitExists);
+    walkRefs(op.right, visit, visitExists);
+  }
+}
+function walkWindowSpec(window, visit, visitExists) {
+  for (const p of window.partitionBy) walkRefs(p, visit, visitExists);
+  for (const s of window.orderBy) walkRefs(s.column, visit, visitExists);
+}
+function buildJoinFilterFromProperties(node, filter, columnMap) {
+  const ops = [];
+  for (const [key, value] of Object.entries(filter)) {
+    const entry = columnMap[key];
+    if (entry === void 0) {
+      throw new Error(`Unknown property '${key}' \u2014 valid properties are: ${Object.keys(columnMap).sort().join(", ")}`);
+    }
+    const [name, type, table] = entry;
+    const col = new ColumnWithJoin(new Column(name, type, table), node);
+    let constant;
+    if (typeof value === "boolean") constant = new BooleanConstantOperation(value);
+    else if (typeof value === "number") constant = Number.isInteger(value) ? new IntegerConstantOperation(value) : new FloatConstantOperation(value);
+    else if (value instanceof Date) constant = type.toUpperCase() === "DATE" ? new DateConstantOperation(value) : new DateTimeConstantOperation(value);
+    else constant = new StringConstantOperation(String(value));
+    ops.push(new ComparisonOperation(col, "EQUAL" /* EQUAL */, constant));
+  }
+  return ops.reduce((acc, op) => new LogicalOperation(acc, "AND" /* AND */, op));
+}
+function withAncestors(nodes) {
+  const ordered = /* @__PURE__ */ new Set();
+  const add = (node) => {
+    if (ordered.has(node)) return;
+    if (node.parent !== void 0) add(node.parent);
+    ordered.add(node);
+  };
+  for (const node of nodes) add(node);
+  return [...ordered];
+}
+function buildQueryOperation(businessDate, processingDatetime, columns, table, op, orderBy = [], groupBy = [], limit, businessDateTo = null) {
   let filter = op;
+  const milestoningFor = (t, node) => businessDateTo !== null ? buildMilestoningFilterOperationForDateRange(businessDate, businessDateTo, processingDatetime, t, node) : buildMilestoningFilterOperation(businessDate, processingDatetime, t, node);
   if (table instanceof MilestonedTable) {
-    const milestonedOp = buildMilestoningFilterOperation(businessDate, processingDatetime, table);
+    const milestonedOp = milestoningFor(table);
     if (milestonedOp !== null) {
       filter = filter instanceof NoOperation ? milestonedOp : new LogicalOperation(filter, "AND" /* AND */, milestonedOp);
     }
   }
-  const requiredJoins = [];
-  const requiredJoinIds = /* @__PURE__ */ new Set();
-  for (const col of columns) {
-    if (col instanceof CountAllOperation) continue;
-    let node;
-    if (col instanceof Attribute) {
-      node = col.parent();
-    } else {
-      node = findColumn(col).parent;
-    }
-    if (node !== void 0 && !requiredJoinIds.has(node)) {
-      requiredJoinIds.add(node);
-      requiredJoins.push(node);
+  const requiredJoins = /* @__PURE__ */ new Set();
+  const collect = (ref) => {
+    const parent = ref instanceof Attribute ? ref.parent() : ref.parent;
+    if (parent !== void 0) requiredJoins.add(parent);
+  };
+  const collectNode = (node) => requiredJoins.add(node);
+  for (const col of columns) walkRefs(col, collect, collectNode);
+  for (const expr of groupBy) walkRefs(expr, collect, collectNode);
+  for (const sort of orderBy) walkRefs(sort, collect, collectNode);
+  walkRefs(op, collect, collectNode);
+  const joinFilters = /* @__PURE__ */ new Map();
+  for (const node of withAncestors(requiredJoins)) {
+    let combined;
+    if (Object.keys(node.join.filterKwargs).length > 0) {
+      combined = buildJoinFilterFromProperties(node, node.join.filterKwargs, node.join.filterColumnMap);
     }
-  }
-  for (const node of requiredJoins) {
     if (node.join.target instanceof MilestonedTable) {
-      const milestonedOp = buildMilestoningFilterOperation(businessDate, processingDatetime, node.join.target, node);
+      const milestonedOp = milestoningFor(node.join.target, node);
       if (milestonedOp !== null) {
-        node.join.filter = milestonedOp;
+        combined = combined === void 0 ? milestonedOp : new LogicalOperation(combined, "AND" /* AND */, milestonedOp);
       }
     }
+    if (combined !== void 0) joinFilters.set(node, combined);
   }
-  return new SelectOperation(columns, filter, orderBy, groupBy, limit, table);
+  return new SelectOperation(columns, filter, orderBy, groupBy, limit, table, joinFilters);
 }
 var SQLQueryGenerator = class {
   _select = [];
@@ -352,8 +388,12 @@ var SQLQueryGenerator = class {
   _tableAliasesByTable = /* @__PURE__ */ new Map();
   _addedJoinIds = /* @__PURE__ */ new Set();
   _rootTable;
+  _elidableNodes = /* @__PURE__ */ new Set();
+  _joinFilters = /* @__PURE__ */ new Map();
   generate(select) {
     this._rootTable = select.table;
+    this._elidableNodes = this._computeElidableNodes(select);
+    this._joinFilters = select.joinFilters;
     if (this._rootTable !== void 0) {
       this._from.add(this._tableAliasForTable(this._rootTable.qualifiedName, this._rootTable.qualifiedName));
     }
@@ -373,39 +413,49 @@ var SQLQueryGenerator = class {
     this._limit = select.limit;
   }
   _attrToColString(attr) {
-    const node = attr.parent();
-    const ta = this._tableAliasForTable(attr.owner(), node ?? attr.owner());
-    return ta.alias + "." + attr.column().name;
+    const { column, parent } = this._resolve(attr);
+    const ta = this._tableAliasForTable(column.owner, parent ?? column.owner);
+    return ta.alias + "." + column.name;
   }
   _collectRequiredJoins(op, out) {
-    if (op === null || op === void 0) return;
-    if (op instanceof Attribute) {
-      const p = op.parent();
-      if (p !== void 0) out.set(p, p);
-    } else if (op instanceof ColumnWithJoin) {
-      if (op.parent !== void 0) out.set(op.parent, op.parent);
-    } else if (op instanceof AggregateOperation) {
-      this._collectRequiredJoins(op.element, out);
-      if (op.window) this._collectRequiredJoins(op.window, out);
-    } else if (op instanceof WindowFunctionOperation) {
-      if (op.element) this._collectRequiredJoins(op.element, out);
-      if (op.window) this._collectRequiredJoinsFromWindowSpec(op.window, out);
-    } else if (op instanceof ScalarFunctionOperation || op instanceof DateExtractOperation || op instanceof DateArithmeticOperation || op instanceof DateDiffOperation) {
-      this._collectRequiredJoins(op.element, out);
-    } else if (op instanceof SortOperation) {
-      this._collectRequiredJoins(op.column, out);
-    } else if (op instanceof LogicalOperation || op instanceof ComparisonOperation) {
-      this._collectRequiredJoins(op.left, out);
-      this._collectRequiredJoins(op.right, out);
-    }
-  }
-  _collectRequiredJoinsFromWindowSpec(window, out) {
-    for (const p of window.partitionBy) {
-      this._collectRequiredJoins(p, out);
-    }
-    for (const s of window.orderBy) {
-      this._collectRequiredJoins(s.column, out);
-    }
+    walkRefs(op, (ref) => {
+      const { parent } = this._resolve(ref);
+      if (parent !== void 0) out.set(parent, parent);
+    });
+  }
+  /**
+   * Determine upfront which join nodes can be satisfied entirely by embedded (join-less) alternates:
+   * a node is elidable when every reference to it has an embedded alternate. A reference without one
+   * (e.g. a milestoning column) keeps the join for every reference to that node.
+   */
+  _computeElidableNodes(select) {
+    const refsByNode = /* @__PURE__ */ new Map();
+    const record = (ref) => {
+      const parent = ref instanceof Attribute ? ref.parent() : ref.parent;
+      if (parent === void 0) return;
+      const refs = refsByNode.get(parent);
+      if (refs) refs.push(ref);
+      else refsByNode.set(parent, [ref]);
+    };
+    for (const col of select.display) walkRefs(col, record);
+    for (const expr of select.groupBy) walkRefs(expr, record);
+    for (const sort of select.orderBy) walkRefs(sort, record);
+    walkRefs(select.filter, record);
+    const elidable = /* @__PURE__ */ new Set();
+    for (const [node, refs] of refsByNode) {
+      if (refs.every((ref) => embeddedOf(ref) !== void 0)) elidable.add(node);
+    }
+    return elidable;
+  }
+  /** The (column, parent) a reference should resolve to, substituting its embedded alternate when its join is elided. */
+  _resolve(ref) {
+    const column = ref instanceof Attribute ? ref.column() : ref.column;
+    const parent = ref instanceof Attribute ? ref.parent() : ref.parent;
+    if (parent !== void 0 && this._elidableNodes.has(parent)) {
+      const embedded = embeddedOf(ref);
+      if (embedded !== void 0) return this._resolve(embedded);
+    }
+    return { column, parent };
   }
   _rewriteWindowSpec(window) {
     const partitionBy = window.partitionBy.map((p) => this._rewriteOperation(p));
@@ -413,13 +463,9 @@ var SQLQueryGenerator = class {
     return new WindowSpecification(partitionBy, orderBy);
   }
   _rewriteOperation(op) {
-    if (op instanceof Attribute) {
-      const ta = this._tableAliasForTable(op.owner(), op.parent() ?? op.owner());
-      return new TableAliasColumn(op.column(), ta);
-    }
-    if (op instanceof ColumnWithJoin) {
-      const ta = op.parent !== void 0 ? this._tableAliasForTable(op.column.owner, op.parent) : this._tableAliasForTable(op.column.owner, op.column.owner);
-      return new TableAliasColumn(op.column, ta);
+    if (op instanceof Attribute || op instanceof ColumnWithJoin) {
+      const { column, parent } = this._resolve(op);
+      return new TableAliasColumn(column, this._tableAliasForTable(column.owner, parent ?? column.owner));
     }
     if (op instanceof Column) {
       const ta = this._tableAliasForTable(op.owner, op.owner);
@@ -468,15 +514,15 @@ var SQLQueryGenerator = class {
     }
     for (const col of cols) {
       if (col instanceof Attribute) {
-        const node = col.parent();
+        const { column, parent: node } = this._resolve(col);
         let ta;
         if (node !== void 0) {
-          ta = this._tableAliasForTable(col.owner(), node);
+          ta = this._tableAliasForTable(column.owner, node);
         } else {
-          ta = this._tableAliasForTable(col.owner(), col.owner());
+          ta = this._tableAliasForTable(column.owner, column.owner);
           this._from.add(ta);
         }
-        this._select.push(new Alias(new TableAliasColumn(col.column(), ta), col.displayName()));
+        this._select.push(new Alias(new TableAliasColumn(column, ta), col.displayName()));
       } else if (col instanceof WindowFunctionOperation) {
         const rewritten = this._rewriteOperation(col);
         let alias;
@@ -491,7 +537,7 @@ var SQLQueryGenerator = class {
         }
         this._select.push(new Alias(rewritten, alias));
       } else if (col instanceof AggregateOperation) {
-        const colNested = findColumn(col);
+        const colNested = this._resolve(findColumn(col));
         const node = colNested.parent;
         let ta;
         if (node !== void 0) {
@@ -500,7 +546,7 @@ var SQLQueryGenerator = class {
           ta = this._tableAliasForTable(colNested.column.owner, colNested.column.owner);
           this._from.add(ta);
         }
-        const alias = col.displayName ?? col.operator + " " + colNested.column.name;
+        const alias = col.displayName ?? col.operator + " " + findColumn(col).column.name;
         const rewrittenAgg = new AggregateOperation(
           new TableAliasColumn(colNested.column, ta),
           col.operator,
@@ -509,7 +555,7 @@ var SQLQueryGenerator = class {
         );
         this._select.push(new Alias(rewrittenAgg, alias));
       } else if (col instanceof ScalarFunctionOperation) {
-        const colNested = findColumn(col);
+        const colNested = this._resolve(findColumn(col));
         const node = colNested.parent;
         let ta;
         if (node !== void 0) {
@@ -518,13 +564,13 @@ var SQLQueryGenerator = class {
           ta = this._tableAliasForTable(colNested.column.owner, colNested.column.owner);
           this._from.add(ta);
         }
-        const alias = col.displayName ?? col.func + " " + colNested.column.name;
+        const alias = col.displayName ?? col.func + " " + findColumn(col).column.name;
         this._select.push(new Alias(
           new ScalarFunctionOperation(new TableAliasColumn(colNested.column, ta), col.func, void 0, col.secondArg, col.extraArgs),
           alias
         ));
       } else if (col instanceof DateExtractOperation || col instanceof DateArithmeticOperation || col instanceof DateDiffOperation) {
-        const colNested = findColumn(col);
+        const colNested = this._resolve(findColumn(col));
         const node = colNested.parent;
         let ta;
         if (node !== void 0) {
@@ -533,7 +579,7 @@ var SQLQueryGenerator = class {
           ta = this._tableAliasForTable(colNested.column.owner, colNested.column.owner);
           this._from.add(ta);
         }
-        const alias = col.displayName ?? colNested.column.name;
+        const alias = col.displayName ?? findColumn(col).column.name;
         let aliasedOp;
         if (col instanceof DateExtractOperation) {
           aliasedOp = new DateExtractOperation(new TableAliasColumn(colNested.column, ta), col.part);
@@ -561,7 +607,9 @@ var SQLQueryGenerator = class {
     const sc = new TableAliasColumn(left, srcTa);
     const right = join.right;
     const tc = new TableAliasColumn(right, this._tableAliasForTable(right.owner, node));
-    this._join.push(new Join(sc, tc, join.filter));
+    const queryFilter = this._joinFilters.get(node);
+    const filterOp = join.filter !== void 0 && queryFilter !== void 0 ? new LogicalOperation(join.filter, "AND" /* AND */, queryFilter) : join.filter ?? queryFilter;
+    this._join.push(new Join(sc, tc, filterOp));
   }
   buildFilter(op) {
     if (op instanceof NoOperation) return "";
@@ -587,15 +635,15 @@ var SQLQueryGenerator = class {
     }
     if (op instanceof ConstantOperation) return constantValueString(op);
     if (op instanceof ColumnWithJoin) {
-      const node = op.parent;
+      const { column, parent: node } = this._resolve(op);
       let ta;
       if (node !== void 0) {
-        ta = this._tableAliasForTable(op.column.owner, node);
+        ta = this._tableAliasForTable(column.owner, node);
         this._addJoin(node);
       } else {
-        ta = this._tableAliasForTable(op.column.owner, op.column.owner);
+        ta = this._tableAliasForTable(column.owner, column.owner);
       }
-      return ta.alias + "." + op.column.name;
+      return ta.alias + "." + column.name;
     }
     if (op instanceof Column) {
       const ta = this._tableAliasForTable(op.owner, op.owner);
@@ -635,18 +683,14 @@ function selectSqlToString(selectOperation) {
   qg.generate(selectOperation);
   return qg.buildQueryString();
 }
-function toSql(businessDate, processingDatetime, columns, table, op, orderBy = [], groupBy = [], limit) {
-  const selectOp = buildQueryOperation(businessDate, processingDatetime, columns, table, op, orderBy, groupBy, limit);
+function toSql(businessDate, processingDatetime, columns, table, op, orderBy = [], groupBy = [], limit, businessDateTo = null) {
+  const selectOp = buildQueryOperation(businessDate, processingDatetime, columns, table, op, orderBy, groupBy, limit, businessDateTo);
   return selectSqlToString(selectOp);
 }
 
 export {
-  ExistsOperation,
-  NotExistsOperation,
-  RelatedFinder,
-  SelectOperation,
   buildQueryOperation,
   selectSqlToString,
   toSql
 };
-//# sourceMappingURL=chunk-DFYZVBII.js.map
+//# sourceMappingURL=chunk-MH4XMYVB.js.map