data-finder-ts 0.1.3 → 0.1.5

package/dist/chunk-BKPWV3OF.js

@@ -0,0 +1,962 @@
+import {
+  BiTemporalColumns,
+  BusinessDateAndProcessingTemporalColumns,
+  MilestonedTable,
+  ProcessingTemporalColumns,
+  SingleBusinessDateColumn
+} from "./chunk-GPHWC533.js";
+import {
+  DateAttribute,
+  DateTimeAttribute
+} from "./chunk-MGEL5RWM.js";
+import {
+  Attribute
+} from "./chunk-BGEX377Q.js";
+import {
+  AggregateOperation,
+  Alias,
+  ArithmeticOperation,
+  BinaryOperation,
+  BooleanConstantOperation,
+  CaseOperation,
+  Column,
+  ColumnWithJoin,
+  ComparisonOperation,
+  ConcatOperation,
+  ConstantOperation,
+  CountAllOperation,
+  DateArithmeticOperation,
+  DateConstantOperation,
+  DateDiffOperation,
+  DateExtractOperation,
+  DateTimeConstantOperation,
+  DateTruncOperation,
+  DecimalConstantOperation,
+  ExistsOperation,
+  FloatConstantOperation,
+  InOperation,
+  IntegerConstantOperation,
+  IsNotNullOperation,
+  IsNullOperation,
+  LIKE_ESCAPE,
+  LogicalOperation,
+  NoOperation,
+  NotExistsOperation,
+  NotInOperation,
+  RelationalOperationElement,
+  ScalarFunctionOperation,
+  SelectOperation,
+  SortOperation,
+  StringConstantOperation,
+  UnaryOperation,
+  WindowFunctionOperation,
+  WindowSpecification,
+  containsAggregate,
+  containsAggregateOrWindow
+} from "./chunk-PF6EJZHB.js";
+
+// src/datafinder/dialect.ts
+var doubleQuoted = (name) => '"' + name.replaceAll('"', '""') + '"';
+var quoted = (value) => "'" + value.replaceAll("'", "''") + "'";
+var SECONDS_PER = { ["HOUR" /* HOUR */]: 3600, ["MINUTE" /* MINUTE */]: 60, ["SECOND" /* SECOND */]: 1 };
+var POSTGRES = {
+  name: "postgres",
+  quoteIdentifier: doubleQuoted,
+  stringLiteral: quoted,
+  orderDirection: (direction) => direction === "ASC" /* ASC */ ? " ASC" : " DESC",
+  doubleType: "DOUBLE PRECISION",
+  dayOfWeek: (expression) => `EXTRACT(DOW FROM ${expression})`,
+  dateDiff(unit, from, to) {
+    const start = `CAST(${from} AS TIMESTAMP)`;
+    const end = `CAST(${to} AS TIMESTAMP)`;
+    switch (unit) {
+      case "DAY" /* DAY */:
+        return `(CAST(${to} AS DATE) - CAST(${from} AS DATE))`;
+      case "MONTH" /* MONTH */:
+        return `CAST(EXTRACT(YEAR FROM AGE(${end}, ${start})) * 12 + EXTRACT(MONTH FROM AGE(${end}, ${start})) AS BIGINT)`;
+      case "YEAR" /* YEAR */:
+        return `CAST(EXTRACT(YEAR FROM AGE(${end}, ${start})) AS BIGINT)`;
+      default: {
+        const seconds = SECONDS_PER[unit];
+        if (seconds === void 0) throw new Error(`Cannot take the difference in ${unit}`);
+        return `CAST(FLOOR(EXTRACT(EPOCH FROM (${end} - ${start})) / ${seconds}) AS BIGINT)`;
+      }
+    }
+  },
+  stringAgg: (expression, separator, orderBy) => `STRING_AGG(${expression}, ${separator}${orderBy.length > 0 ? " ORDER BY " + orderBy.join(", ") : ""})`
+};
+var DUCKDB = {
+  ...POSTGRES,
+  name: "duckdb",
+  // DuckDB sorts nulls last whichever way the sort goes
+  orderDirection: (direction) => direction === "ASC" /* ASC */ ? " ASC" : " DESC NULLS FIRST",
+  doubleType: "DOUBLE",
+  dateDiff: (unit, from, to) => `DATE_DIFF('${unit.toLowerCase()}', ${from}, ${to})`
+};
+var DATABRICKS = {
+  name: "databricks",
+  // a double-quoted token is a string in Databricks; identifiers take backticks
+  quoteIdentifier: (name) => "`" + name.replaceAll("`", "``") + "`",
+  // a backslash starts an escape in a Databricks string literal, and a doubled quote is not one: Spark reads
+  // 'it''s' as the two literals 'it' and 's' and joins them, losing the quote. A quote is escaped with a backslash.
+  stringLiteral: (value) => "'" + value.replaceAll("\\", "\\\\").replaceAll("'", "\\'") + "'",
+  // Databricks sorts nulls first when ascending, last when descending
+  orderDirection: (direction) => direction === "ASC" /* ASC */ ? " ASC NULLS LAST" : " DESC NULLS FIRST",
+  doubleType: "DOUBLE",
+  // DAYOFWEEK is 1 = Sunday through 7 = Saturday
+  dayOfWeek: (expression) => `(DAYOFWEEK(${expression}) - 1)`,
+  dateDiff: (unit, from, to) => `DATEDIFF(${unit}, ${from}, ${to})`,
+  stringAgg: (expression, separator, orderBy) => `LISTAGG(${expression}, ${separator})${orderBy.length > 0 ? " WITHIN GROUP (ORDER BY " + orderBy.join(", ") + ")" : ""}`
+};
+var DIALECTS = { postgres: POSTGRES, duckdb: DUCKDB, databricks: DATABRICKS };
+function dialectOf(dialect) {
+  if (typeof dialect !== "string") return dialect;
+  const found = DIALECTS[dialect];
+  if (found === void 0) throw new Error(`Unknown SQL dialect '${dialect}': one of ${Object.keys(DIALECTS).join(", ")}`);
+  return found;
+}
+
+// src/datafinder/sql-generator.ts
+var TableAlias = class {
+  constructor(table, alias) {
+    this.table = table;
+    this.alias = alias;
+  }
+  table;
+  alias;
+};
+var TableAliasColumn = class extends RelationalOperationElement {
+  constructor(column, tableAlias) {
+    super();
+    this.column = column;
+    this.tableAlias = tableAlias;
+  }
+  column;
+  tableAlias;
+};
+var Join = class {
+  constructor(source, target, filterOp) {
+    this.source = source;
+    this.target = target;
+    this.filterOp = filterOp;
+  }
+  source;
+  target;
+  filterOp;
+  /** `source = target`, written with the key column first as Legend writes a join defined as key = foreign key. */
+  condition() {
+    let [first, second] = [this.source, this.target];
+    if (second.column.primaryKey && !first.column.primaryKey) [first, second] = [second, first];
+    return first.tableAlias.alias + "." + first.column.name + " = " + second.tableAlias.alias + "." + second.column.name;
+  }
+};
+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())}'`;
+}
+function sqlFormatDate(value) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `'${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}'`;
+}
+var LOGICAL_OPERATOR_STR = {
+  ["AND" /* AND */]: " AND ",
+  ["OR" /* OR */]: " OR "
+};
+var COMPARISON_OPERATOR_STR = {
+  ["EQUAL" /* EQUAL */]: " = ",
+  ["NOT_EQUAL" /* NOT_EQUAL */]: " <> ",
+  ["LESS_THAN" /* LESS_THAN */]: " < ",
+  ["GREATER_THAN" /* GREATER_THAN */]: " > ",
+  ["LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */]: " <= ",
+  ["GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */]: " >= ",
+  ["LIKE" /* LIKE */]: " LIKE ",
+  ["NOT_LIKE" /* NOT_LIKE */]: " NOT LIKE "
+};
+var AGGREGATE_SQL_NAMES = {
+  ["AVERAGE" /* AVERAGE */]: "AVG"
+};
+var GUARDED_COMPARISONS = /* @__PURE__ */ new Set([
+  "LESS_THAN" /* LESS_THAN */,
+  "GREATER_THAN" /* GREATER_THAN */,
+  "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */,
+  "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */,
+  "LIKE" /* LIKE */
+]);
+var WINDOW_SQL_NAMES = {
+  ["ROW_NUMBER" /* ROW_NUMBER */]: "ROW_NUMBER",
+  ["RANK" /* RANK */]: "RANK",
+  ["DENSE_RANK" /* DENSE_RANK */]: "DENSE_RANK",
+  ["NTILE" /* NTILE */]: "NTILE",
+  ["LAG" /* LAG */]: "LAG",
+  ["LEAD" /* LEAD */]: "LEAD",
+  ["FIRST_VALUE" /* FIRST_VALUE */]: "FIRST_VALUE",
+  ["LAST_VALUE" /* LAST_VALUE */]: "LAST_VALUE",
+  ["CUME_DIST" /* CUME_DIST */]: "CUME_DIST",
+  ["PERCENT_RANK" /* PERCENT_RANK */]: "PERCENT_RANK"
+};
+var SCALAR_SQL_NAMES = {
+  ["ABS" /* ABS */]: "ABS",
+  ["CEILING" /* CEILING */]: "CEILING",
+  ["FLOOR" /* FLOOR */]: "FLOOR",
+  ["MOD" /* MOD */]: "MOD",
+  ["POWER" /* POWER */]: "POWER",
+  ["SQRT" /* SQRT */]: "SQRT",
+  ["ROUND" /* ROUND */]: "ROUND",
+  ["UPPER" /* UPPER */]: "UPPER",
+  ["LOWER" /* LOWER */]: "LOWER",
+  ["TRIM" /* TRIM */]: "TRIM",
+  ["LTRIM" /* LTRIM */]: "LTRIM",
+  ["RTRIM" /* RTRIM */]: "RTRIM",
+  ["LENGTH" /* LENGTH */]: "LENGTH",
+  ["REVERSE" /* REVERSE */]: "REVERSE",
+  ["LEFT" /* LEFT */]: "LEFT",
+  ["RIGHT" /* RIGHT */]: "RIGHT",
+  ["REPEAT" /* REPEAT */]: "REPEAT",
+  ["REPLACE" /* REPLACE */]: "REPLACE",
+  ["SUBSTRING" /* SUBSTRING */]: "SUBSTRING",
+  ["COALESCE" /* COALESCE */]: "COALESCE"
+};
+function constantValueString(op, d) {
+  if (op instanceof StringConstantOperation) return d.stringLiteral(op.value);
+  if (op instanceof DateConstantOperation) return sqlFormatDate(op.value);
+  if (op instanceof DateTimeConstantOperation) return sqlFormatDatetime(op.value);
+  if (op instanceof IntegerConstantOperation) return String(op.value);
+  if (op instanceof FloatConstantOperation) return Number.isInteger(op.value) && Math.abs(op.value) < 1e21 ? op.value.toFixed(1) : String(op.value);
+  if (op instanceof BooleanConstantOperation) return op.value ? "TRUE" : "FALSE";
+  if (op instanceof DecimalConstantOperation) return String(op.value);
+  throw new Error("Unknown constant operation");
+}
+function selectedConstantString(op, d) {
+  if (op instanceof FloatConstantOperation) return "CAST(" + constantValueString(op, d) + " AS " + d.doubleType + ")";
+  if (op instanceof DateTimeConstantOperation) return "TIMESTAMP " + constantValueString(op, d);
+  if (op instanceof DateConstantOperation) return "DATE " + constantValueString(op, d);
+  return constantValueString(op, d);
+}
+function windowSpecToString(window, d) {
+  const parts = [];
+  if (window.partitionBy.length > 0) {
+    parts.push("PARTITION BY " + window.partitionBy.map((p) => sqlOperationToString(p, d)).join(", "));
+  }
+  if (window.orderBy.length > 0) {
+    parts.push("ORDER BY " + window.orderBy.map(
+      (s) => sqlOperationToString(s.column, d) + d.orderDirection(s.direction)
+    ).join(", "));
+  }
+  return "OVER (" + parts.join(" ") + ")";
+}
+var ARITHMETIC_PRECEDENCE = {
+  ["+" /* ADD */]: 1,
+  ["-" /* SUBTRACT */]: 1,
+  ["*" /* MULTIPLY */]: 2,
+  ["/" /* DIVIDE */]: 2
+};
+function arithmeticNeedsParentheses(parent, child, onRight) {
+  if (!(child instanceof ArithmeticOperation)) return false;
+  const here = ARITHMETIC_PRECEDENCE[parent.operator];
+  const there = ARITHMETIC_PRECEDENCE[child.operator];
+  return there < here || there === here && onRight && (parent.operator === "-" /* SUBTRACT */ || parent.operator === "/" /* DIVIDE */);
+}
+function operandString(operation, d) {
+  return operation instanceof ConstantOperation ? constantValueString(operation, d) : sqlOperationToString(operation, d);
+}
+var RenderedSql = class extends RelationalOperationElement {
+  constructor(sql) {
+    super();
+    this.sql = sql;
+  }
+  sql;
+};
+function isCondition(op) {
+  return op instanceof ComparisonOperation || op instanceof LogicalOperation || op instanceof IsNullOperation || op instanceof IsNotNullOperation || op instanceof InOperation || op instanceof NotInOperation || op instanceof ExistsOperation || op instanceof NotExistsOperation;
+}
+function sqlOperationToString(operation, d) {
+  if (operation instanceof TableAliasColumn) {
+    return operation.tableAlias.alias + "." + operation.column.name;
+  }
+  if (operation instanceof WindowFunctionOperation) {
+    const fn = WINDOW_SQL_NAMES[operation.func];
+    const parts = [];
+    if (operation.element !== null && operation.element !== void 0) {
+      parts.push(sqlOperationToString(operation.element, d));
+    }
+    if (operation.secondArg !== void 0) parts.push(String(operation.secondArg));
+    for (const arg of operation.extraArgs) {
+      parts.push(typeof arg === "string" ? d.stringLiteral(arg) : String(arg));
+    }
+    const sql = fn + "(" + parts.join(", ") + ")";
+    return sql + (operation.window !== void 0 ? " " + windowSpecToString(operation.window, d) : " OVER ()");
+  }
+  if (operation instanceof AggregateOperation && operation.operator === "COUNT_DISTINCT" /* COUNT_DISTINCT */) {
+    return "COUNT(DISTINCT " + sqlOperationToString(operation.element, d) + ")";
+  }
+  if (operation instanceof AggregateOperation && operation.operator === "STRING_AGG" /* STRING_AGG */) {
+    let sql = d.stringAgg(
+      sqlOperationToString(operation.element, d),
+      d.stringLiteral(operation.separator ?? ""),
+      operation.orderBy.map((s) => sqlOperationToString(s.column, d) + d.orderDirection(s.direction))
+    );
+    if (operation.window !== void 0) sql += " " + windowSpecToString(operation.window, d);
+    return sql;
+  }
+  if (operation instanceof AggregateOperation) {
+    const fn = AGGREGATE_SQL_NAMES[operation.operator] ?? operation.operator;
+    let sql = fn + "(" + sqlOperationToString(operation.element, d) + ")";
+    if (operation.window !== void 0) {
+      sql += " " + windowSpecToString(operation.window, d);
+    }
+    return sql;
+  }
+  if (operation instanceof ScalarFunctionOperation) {
+    const fn = SCALAR_SQL_NAMES[operation.func];
+    const parts = [sqlOperationToString(operation.element, d)];
+    if (operation.secondArg !== void 0) parts.push(String(operation.secondArg));
+    for (const arg of operation.extraArgs) {
+      parts.push(typeof arg === "string" ? d.stringLiteral(arg) : String(arg));
+    }
+    return fn + "(" + parts.join(", ") + ")";
+  }
+  if (operation instanceof DateExtractOperation) {
+    const element = sqlOperationToString(operation.element, d);
+    return operation.part === "DOW" /* DOW */ ? d.dayOfWeek(element) : "EXTRACT(" + operation.part + " FROM " + element + ")";
+  }
+  if (operation instanceof DateTruncOperation) {
+    return "CAST(DATE_TRUNC('" + operation.part.toLowerCase() + "', " + sqlOperationToString(operation.element, d) + ") AS DATE)";
+  }
+  if (operation instanceof DateArithmeticOperation) {
+    const op = operation.isAdd ? "+" : "-";
+    return sqlOperationToString(operation.element, d) + " " + op + " INTERVAL '" + operation.n + "' " + operation.unit;
+  }
+  if (operation instanceof DateDiffOperation) {
+    return d.dateDiff(operation.unit, sqlOperationToString(operation.element, d), "TIMESTAMP " + sqlFormatDatetime(operation.other));
+  }
+  if (operation instanceof CountAllOperation) return "COUNT(*)";
+  if (operation instanceof ConstantOperation) return selectedConstantString(operation, d);
+  if (operation instanceof RenderedSql) return operation.sql;
+  if (operation instanceof ConcatOperation) return operation.parts.map((part) => operandString(part, d)).join(" || ");
+  if (operation instanceof ArithmeticOperation) {
+    let left = operandString(operation.left, d);
+    let right = operandString(operation.right, d);
+    if (arithmeticNeedsParentheses(operation, operation.left, false)) left = "(" + left + ")";
+    if (arithmeticNeedsParentheses(operation, operation.right, true)) right = "(" + right + ")";
+    return left + " " + operation.operator + " " + right;
+  }
+  if (operation instanceof Alias) {
+    return sqlOperationToString(operation.element, d) + " AS " + d.quoteIdentifier(operation.name);
+  }
+  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;
+  throw new TypeError("Cannot find ColumnWithJoin in: " + operation.constructor.name);
+}
+function openEndClause(endAttr, value, infiniteDatetime) {
+  const gtOp = endAttr instanceof DateTimeAttribute ? endAttr.gt(value) : endAttr.gt(value);
+  if (infiniteDatetime === void 0) {
+    const colRef = new ColumnWithJoin(endAttr.column(), endAttr.parent());
+    return new LogicalOperation(gtOp, "OR" /* OR */, new IsNullOperation(colRef));
+  }
+  return gtOp;
+}
+function andAll(ops) {
+  const present = ops.filter((op) => op !== null);
+  if (present.length === 0) return null;
+  return present.slice(1).reduce((left, right) => new LogicalOperation(left, "AND" /* AND */, right), present[0]);
+}
+function processingPredicate(mc, processingDatetime, joinNode) {
+  if (!(mc instanceof ProcessingTemporalColumns || mc instanceof BusinessDateAndProcessingTemporalColumns || mc instanceof BiTemporalColumns) || processingDatetime === null) return null;
+  const startAt = new DateTimeAttribute("start_at", mc.startAtColumn.name, mc.startAtColumn.type, mc.startAtColumn.table.qualifiedName, joinNode);
+  const endAt = new DateTimeAttribute("end_at", mc.endAtColumn.name, mc.endAtColumn.type, mc.endAtColumn.table.qualifiedName, joinNode);
+  return new LogicalOperation(startAt.lte(processingDatetime), "AND" /* AND */, openEndClause(endAt, processingDatetime, mc.infiniteDatetime));
+}
+function businessPredicate(mc, businessDate, joinNode) {
+  if (businessDate === null) return null;
+  if (mc instanceof BiTemporalColumns) {
+    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);
+    return new LogicalOperation(dateFrom.lte(businessDate), "AND" /* AND */, openEndClause(dateTo, businessDate, mc.infiniteDatetime));
+  }
+  if (mc instanceof BusinessDateAndProcessingTemporalColumns || mc instanceof SingleBusinessDateColumn) {
+    const businessAtt = new DateAttribute("business_date", mc.businessDateColumn.name, mc.businessDateColumn.type, mc.businessDateColumn.table.qualifiedName, joinNode);
+    return businessAtt.eq(businessDate);
+  }
+  return null;
+}
+function businessRangePredicate(mc, businessDateFrom, businessDateTo, joinNode) {
+  if (businessDateFrom === null || businessDateTo === null) return null;
+  if (mc instanceof BiTemporalColumns) {
+    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);
+    return new LogicalOperation(dateFrom.lte(businessDateTo), "AND" /* AND */, openEndClause(dateTo, businessDateFrom, mc.infiniteDatetime));
+  }
+  if (mc instanceof BusinessDateAndProcessingTemporalColumns || mc instanceof SingleBusinessDateColumn) {
+    const businessAtt = new DateAttribute("business_date", mc.businessDateColumn.name, mc.businessDateColumn.type, mc.businessDateColumn.table.qualifiedName, joinNode);
+    return new LogicalOperation(businessAtt.gte(businessDateFrom), "AND" /* AND */, businessAtt.lte(businessDateTo));
+  }
+  return null;
+}
+function buildMilestoningFilterOperation(businessDate, processingDatetime, table, joinNode) {
+  const mc = table.milestoningColumns;
+  return andAll([processingPredicate(mc, processingDatetime, joinNode), businessPredicate(mc, businessDate, joinNode)]);
+}
+function buildMilestoningFilterOperationForDateRange(businessDateFrom, businessDateTo, processingDatetime, table, joinNode) {
+  const mc = table.milestoningColumns;
+  return andAll([
+    processingPredicate(mc, processingDatetime, joinNode),
+    businessRangePredicate(mc, businessDateFrom, businessDateTo, joinNode)
+  ]);
+}
+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);
+    for (const sort of op.orderBy) walkRefs(sort, 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 DateTruncOperation || op instanceof DateArithmeticOperation || op instanceof DateDiffOperation || op instanceof IsNullOperation || op instanceof IsNotNullOperation || op instanceof InOperation || op instanceof NotInOperation) {
+    walkRefs(op.element, visit, visitExists);
+  } else if (op instanceof Alias) {
+    walkRefs(op.element, visit, visitExists);
+  } else if (op instanceof ConcatOperation) {
+    for (const part of op.parts) walkRefs(part, visit, visitExists);
+  } else if (op instanceof ArithmeticOperation) {
+    walkRefs(op.left, visit, visitExists);
+    walkRefs(op.right, visit, visitExists);
+  } else if (op instanceof CaseOperation) {
+    walkRefs(op.condition, visit, visitExists);
+    walkRefs(op.then, visit, visitExists);
+    walkRefs(op.fallback, 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, distinct = false, offset, having) {
+  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 = milestoningFor(table);
+    if (milestonedOp !== null) {
+      filter = filter instanceof NoOperation ? milestonedOp : new LogicalOperation(filter, "AND" /* AND */, milestonedOp);
+    }
+  }
+  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);
+    }
+    if (node.join.target instanceof MilestonedTable) {
+      const milestonedOp = milestoningFor(node.join.target, node);
+      if (milestonedOp !== null) {
+        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, joinFilters, distinct, offset, having);
+}
+function needsParentheses(parent, child) {
+  return child instanceof LogicalOperation && child.operator !== parent.operator;
+}
+function reachesToMany(op) {
+  if (op instanceof ColumnWithJoin) {
+    for (let node = op.parent; node !== void 0; node = node.parent) if (node.many) return true;
+    return false;
+  }
+  if (op instanceof UnaryOperation || op instanceof Alias) return reachesToMany(op.element);
+  if (op instanceof BinaryOperation) return reachesToMany(op.left) || reachesToMany(op.right);
+  return false;
+}
+function unaliased(op) {
+  return op instanceof Alias ? unaliased(op.element) : op;
+}
+var SQLQueryGenerator = class {
+  constructor(_dialect) {
+    this._dialect = _dialect;
+  }
+  _dialect;
+  _select = [];
+  _from = /* @__PURE__ */ new Set();
+  _join = [];
+  _groupByParts = [];
+  _having = "";
+  _orderByParts = [];
+  _where = "";
+  _limit;
+  _distinct = false;
+  _offset;
+  _tableAliasIncr = 0;
+  _tableAliasesByTable = /* @__PURE__ */ new Map();
+  _addedJoinIds = /* @__PURE__ */ new Set();
+  _rootTable;
+  _elidableNodes = /* @__PURE__ */ new Set();
+  _joinFilters = /* @__PURE__ */ new Map();
+  _guardOptional = true;
+  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));
+    }
+    this.processSelect(select.display);
+    this._where = this.buildFilter(select.filter);
+    const groupByJoins = /* @__PURE__ */ new Map();
+    for (const expr of select.groupBy) {
+      this._collectRequiredJoins(expr, groupByJoins);
+    }
+    for (const node of groupByJoins.values()) {
+      this._addJoin(node);
+    }
+    this._groupByParts = this._groupByPartsFor(select);
+    this._having = "";
+    if (select.having !== void 0) {
+      const havingJoins = /* @__PURE__ */ new Map();
+      this._collectRequiredJoins(select.having, havingJoins);
+      for (const node of havingJoins.values()) this._addJoin(node);
+      this._guardOptional = false;
+      try {
+        this._having = this.buildFilter(select.having);
+      } finally {
+        this._guardOptional = true;
+      }
+    }
+    this._orderByParts = select.orderBy.map(
+      (s) => this._sortExpression(s.column) + this._dialect.orderDirection(s.direction)
+    );
+    this._limit = select.limit;
+    this._distinct = select.distinct;
+    this._offset = select.offset;
+  }
+  /**
+   * The GROUP BY of a query: the grouping it was given, else the grouping its columns imply.
+   *
+   * Columns that are not aggregated are what the aggregates are computed for, so a query that selects both is
+   * grouped by those columns (as a DataFrame's `groupby(columns).agg(...)` does). An aggregate read through a
+   * to-many association is computed for each row of the root table, as Legend does, so the root's primary key
+   * is grouped by too. A query that selects only aggregates over the root's own columns is not grouped: the
+   * aggregate covers every row. A constant needs no grouping: a bare
+   * `GROUP BY 7` would be a column position.
+   */
+  _groupByPartsFor(select) {
+    if (select.groupBy.length > 0) return select.groupBy.map((a) => this._attrToColString(a));
+    const aggregates = select.display.filter(containsAggregate);
+    if (aggregates.length === 0) return [];
+    const perRoot = select.table !== void 0 && aggregates.some(reachesToMany);
+    const keys = perRoot ? select.table.columns.filter((c) => c.primaryKey).map((c) => this._columnToString(c)) : [];
+    const grouped = select.display.map((column, i) => ({ column, shown: this._select[i] })).filter(({ column }) => !containsAggregateOrWindow(column) && !(unaliased(column) instanceof ConstantOperation)).map(({ shown }) => sqlOperationToString(shown.element, this._dialect));
+    return [.../* @__PURE__ */ new Set([...keys, ...grouped])];
+  }
+  /** What a sort orders by: a column, or an expression such as an aggregate. */
+  _sortExpression(expression) {
+    if (expression instanceof ColumnWithJoin || expression instanceof Attribute) return this.buildFilter(expression);
+    return sqlOperationToString(this._rewriteOperation(expression), this._dialect);
+  }
+  _columnToString(column) {
+    return this._tableAliasForTable(column.owner, column.owner).alias + "." + column.name;
+  }
+  _attrToColString(attr) {
+    const { column, parent } = this._resolve(attr);
+    const ta = this._tableAliasForTable(column.owner, parent ?? column.owner);
+    return ta.alias + "." + column.name;
+  }
+  _collectRequiredJoins(op, 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 };
+  }
+  /** Whether the value `op` reads can be missing, in the join or embedded form that is used for it. */
+  _resolveOptional(op) {
+    if (op.parent !== void 0 && this._elidableNodes.has(op.parent) && op.embedded !== void 0) {
+      return this._resolveOptional(op.embedded);
+    }
+    return op.optional;
+  }
+  _rewriteWindowSpec(window) {
+    const partitionBy = window.partitionBy.map((p) => this._rewriteOperation(p));
+    const orderBy = window.orderBy.map((s) => new SortOperation(this._rewriteOperation(s.column), s.direction));
+    return new WindowSpecification(partitionBy, orderBy);
+  }
+  _rewriteOperation(op) {
+    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);
+      return new TableAliasColumn(op, ta);
+    }
+    if (op instanceof AggregateOperation) {
+      return new AggregateOperation(
+        this._rewriteOperation(op.element),
+        op.operator,
+        op.displayName,
+        op.window ? this._rewriteWindowSpec(op.window) : void 0,
+        op.separator,
+        op.orderBy.map((s) => new SortOperation(this._rewriteOperation(s.column), s.direction))
+      );
+    }
+    if (op instanceof CaseOperation) return new RenderedSql(this._caseSql(op));
+    if (isCondition(op)) return new RenderedSql(this.buildFilter(op));
+    if (op instanceof ConcatOperation) return new ConcatOperation(op.parts.map((part) => this._rewriteOperation(part)), op.displayName);
+    if (op instanceof ArithmeticOperation) {
+      return new ArithmeticOperation(this._rewriteOperation(op.left), op.operator, this._rewriteOperation(op.right), op.displayName);
+    }
+    if (op instanceof WindowFunctionOperation) {
+      const el = op.element ? this._rewriteOperation(op.element) : null;
+      return new WindowFunctionOperation(
+        el,
+        op.func,
+        op.displayName,
+        op.secondArg,
+        [...op.extraArgs],
+        op.window ? this._rewriteWindowSpec(op.window) : void 0
+      );
+    }
+    if (op instanceof ScalarFunctionOperation) {
+      return new ScalarFunctionOperation(this._rewriteOperation(op.element), op.func, op.displayName, op.secondArg, op.extraArgs);
+    }
+    if (op instanceof DateExtractOperation) {
+      return new DateExtractOperation(this._rewriteOperation(op.element), op.part, op.displayName);
+    }
+    if (op instanceof DateTruncOperation) {
+      return new DateTruncOperation(this._rewriteOperation(op.element), op.part, op.displayName);
+    }
+    if (op instanceof DateArithmeticOperation) {
+      return new DateArithmeticOperation(this._rewriteOperation(op.element), op.n, op.unit, op.isAdd, op.displayName);
+    }
+    if (op instanceof DateDiffOperation) {
+      return new DateDiffOperation(this._rewriteOperation(op.element), op.other, op.unit, op.displayName);
+    }
+    return op;
+  }
+  /** The CASE written out now: its condition can only be rendered while the query is being built. */
+  _caseSql(op) {
+    const branch = (value) => value instanceof ConstantOperation ? constantValueString(value, this._dialect) : sqlOperationToString(this._rewriteOperation(value), this._dialect);
+    let sql = "CASE WHEN " + this.buildFilter(op.condition) + " THEN " + branch(op.then);
+    if (op.fallback !== void 0) sql += " ELSE " + branch(op.fallback);
+    return sql + " END";
+  }
+  processSelect(cols) {
+    const requiredJoins = /* @__PURE__ */ new Map();
+    for (const col of cols) {
+      this._collectRequiredJoins(col, requiredJoins);
+    }
+    for (const node of requiredJoins.values()) {
+      this._addJoin(node);
+    }
+    for (const col of cols) this._selectColumn(col);
+  }
+  /** Add one column to the select list. An alias reads the column it wraps, then names the entry. */
+  _selectColumn(col) {
+    if (col instanceof Alias) {
+      this._selectColumn(col.element);
+      const read = this._select.pop();
+      this._select.push(new Alias(read.element, col.name));
+    } else if (col instanceof Attribute) {
+      const { column, parent: node } = this._resolve(col);
+      let ta;
+      if (node !== void 0) {
+        ta = this._tableAliasForTable(column.owner, node);
+      } else {
+        ta = this._tableAliasForTable(column.owner, column.owner);
+        this._from.add(ta);
+      }
+      this._select.push(new Alias(new TableAliasColumn(column, ta), col.displayName()));
+    } else if (col instanceof WindowFunctionOperation) {
+      const rewritten = this._rewriteOperation(col);
+      let alias;
+      if (col.displayName) {
+        alias = col.displayName;
+      } else if (["ROW_NUMBER" /* ROW_NUMBER */, "RANK" /* RANK */, "DENSE_RANK" /* DENSE_RANK */].includes(col.func)) {
+        alias = col.func.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+      } else if (col.element) {
+        alias = col.func + " " + findColumn(col).column.name;
+      } else {
+        alias = col.func;
+      }
+      this._select.push(new Alias(rewritten, alias));
+    } else if (col instanceof AggregateOperation && !(col.element instanceof ColumnWithJoin)) {
+      this._select.push(new Alias(this._rewriteOperation(col), col.displayName ?? "Expression"));
+    } else if (col instanceof AggregateOperation) {
+      const colNested = this._resolve(findColumn(col));
+      const node = colNested.parent;
+      let ta;
+      if (node !== void 0) {
+        ta = this._tableAliasForTable(colNested.column.owner, node);
+      } else {
+        ta = this._tableAliasForTable(colNested.column.owner, colNested.column.owner);
+        this._from.add(ta);
+      }
+      const alias = col.displayName ?? col.operator + " " + findColumn(col).column.name;
+      const rewrittenAgg = new AggregateOperation(
+        new TableAliasColumn(colNested.column, ta),
+        col.operator,
+        void 0,
+        col.window ? this._rewriteWindowSpec(col.window) : void 0,
+        col.separator,
+        col.orderBy.map((s) => new SortOperation(this._rewriteOperation(s.column), s.direction))
+      );
+      this._select.push(new Alias(rewrittenAgg, alias));
+    } else if (col instanceof ScalarFunctionOperation) {
+      this._select.push(new Alias(this._rewriteOperation(col), col.displayName ?? col.func + " " + findColumn(col).column.name));
+    } else if (col instanceof DateExtractOperation || col instanceof DateArithmeticOperation || col instanceof DateDiffOperation) {
+      const colNested = this._resolve(findColumn(col));
+      const node = colNested.parent;
+      let ta;
+      if (node !== void 0) {
+        ta = this._tableAliasForTable(colNested.column.owner, node);
+      } else {
+        ta = this._tableAliasForTable(colNested.column.owner, colNested.column.owner);
+        this._from.add(ta);
+      }
+      const alias = col.displayName ?? findColumn(col).column.name;
+      let aliasedOp;
+      if (col instanceof DateExtractOperation) {
+        aliasedOp = new DateExtractOperation(new TableAliasColumn(colNested.column, ta), col.part);
+      } else if (col instanceof DateArithmeticOperation) {
+        aliasedOp = new DateArithmeticOperation(new TableAliasColumn(colNested.column, ta), col.n, col.unit, col.isAdd);
+      } else {
+        aliasedOp = new DateDiffOperation(new TableAliasColumn(colNested.column, ta), col.other, col.unit);
+      }
+      this._select.push(new Alias(aliasedOp, alias));
+    } else if (col instanceof CaseOperation) {
+      this._select.push(new Alias(this._rewriteOperation(col), col.displayName ?? "Expression"));
+    } else if (col instanceof ConcatOperation) {
+      this._select.push(new Alias(this._rewriteOperation(col), col.displayName ?? "Expression"));
+    } else if (col instanceof ArithmeticOperation) {
+      this._select.push(new Alias(this._rewriteOperation(col), col.displayName ?? "Expression"));
+    } else if (col instanceof DateTruncOperation) {
+      this._select.push(new Alias(this._rewriteOperation(col), col.displayName ?? findColumn(col).column.name));
+    } else if (isCondition(col)) {
+      this._select.push(new Alias(new RenderedSql(this.buildFilter(col)), "Expression"));
+    } else if (col instanceof ConstantOperation) {
+      this._select.push(new Alias(col, "Constant"));
+    } else if (col instanceof CountAllOperation) {
+      if (col.table !== "") this._from.add(this._tableAliasForTable(col.table, col.table));
+      this._select.push(new Alias(col, "Count"));
+    }
+  }
+  _addJoin(node) {
+    if (this._addedJoinIds.has(node)) return;
+    if (node.parent !== void 0) this._addJoin(node.parent);
+    this._addedJoinIds.add(node);
+    const join = node.join;
+    const left = join.left;
+    const srcTa = this._tableAliasForTable(left.owner, node.parent ?? left.owner);
+    if (node.parent === void 0) this._from.add(srcTa);
+    const sc = new TableAliasColumn(left, srcTa);
+    const right = join.right;
+    const tc = new TableAliasColumn(right, this._tableAliasForTable(right.owner, node));
+    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 "";
+    if (op instanceof ExistsOperation) {
+      const col = op.node.join.right;
+      return this.buildFilter(new ColumnWithJoin(col, op.node)) + " IS NOT NULL";
+    }
+    if (op instanceof NotExistsOperation) {
+      const col = op.node.join.right;
+      return this.buildFilter(new ColumnWithJoin(col, op.node)) + " IS NULL";
+    }
+    if (op instanceof InOperation) {
+      return this.buildFilter(op.element) + " IN (" + op.values.map((value) => constantValueString(value, this._dialect)).join(", ") + ")";
+    }
+    if (op instanceof NotInOperation) {
+      const column = this.buildFilter(op.element);
+      const sql = column + " NOT IN (" + op.values.map((value) => constantValueString(value, this._dialect)).join(", ") + ")";
+      if (op.element instanceof ColumnWithJoin && this._resolve(op.element).column.nullable) {
+        return "(" + sql + " OR " + column + " IS NULL)";
+      }
+      return sql;
+    }
+    if (op instanceof IsNotNullOperation) return this.buildFilter(op.element) + " IS NOT NULL";
+    if (op instanceof IsNullOperation) return this.buildFilter(op.element) + " IS NULL";
+    if (op instanceof LogicalOperation) {
+      let left = this.buildFilter(op.left);
+      let right = this.buildFilter(op.right);
+      if (needsParentheses(op, op.left)) left = "(" + left + ")";
+      if (needsParentheses(op, op.right)) right = "(" + right + ")";
+      return left + LOGICAL_OPERATOR_STR[op.operator] + right;
+    }
+    if (op instanceof ComparisonOperation) {
+      let sql = this.buildFilter(op.left) + COMPARISON_OPERATOR_STR[op.operator] + this.buildFilter(op.right);
+      if ((op.operator === "LIKE" /* LIKE */ || op.operator === "NOT_LIKE" /* NOT_LIKE */) && op.right instanceof StringConstantOperation && (op.right.value.includes(LIKE_ESCAPE) || op.right.value.includes("\\"))) {
+        sql += " ESCAPE '" + LIKE_ESCAPE + "'";
+      }
+      if (this._guardOptional && GUARDED_COMPARISONS.has(op.operator) && op.left instanceof ColumnWithJoin && this._resolveOptional(op.left)) {
+        sql = "(" + this.buildFilter(op.left) + " IS NOT NULL AND " + sql + ")";
+      }
+      return sql;
+    }
+    if (op instanceof ConstantOperation) return constantValueString(op, this._dialect);
+    if (op instanceof ScalarFunctionOperation || op instanceof ArithmeticOperation || op instanceof ConcatOperation || op instanceof DateTruncOperation || op instanceof AggregateOperation || op instanceof CountAllOperation) {
+      const required = /* @__PURE__ */ new Map();
+      this._collectRequiredJoins(op, required);
+      for (const node of required.values()) this._addJoin(node);
+      return sqlOperationToString(this._rewriteOperation(op), this._dialect);
+    }
+    if (op instanceof ColumnWithJoin) {
+      const { column, parent: node } = this._resolve(op);
+      let ta;
+      if (node !== void 0) {
+        ta = this._tableAliasForTable(column.owner, node);
+        this._addJoin(node);
+      } else {
+        ta = this._tableAliasForTable(column.owner, column.owner);
+      }
+      return ta.alias + "." + column.name;
+    }
+    if (op instanceof Column) {
+      const ta = this._tableAliasForTable(op.owner, op.owner);
+      return ta.alias + "." + op.name;
+    }
+    throw new Error("Unknown operation in buildFilter: " + op.constructor.name);
+  }
+  _tableAliasForTable(table, key) {
+    if (this._tableAliasesByTable.has(key)) {
+      return this._tableAliasesByTable.get(key);
+    }
+    const ta = new TableAlias(table, "t" + this._tableAliasIncr++);
+    this._tableAliasesByTable.set(key, ta);
+    return ta;
+  }
+  buildQueryString() {
+    const joins = this._join.map(
+      (j) => " LEFT OUTER JOIN " + j.target.tableAlias.table + " AS " + j.target.tableAlias.alias + " ON (" + j.condition() + (j.filterOp ? " AND " + this.buildFilter(j.filterOp) : "") + ")"
+    );
+    return (this._distinct ? "SELECT DISTINCT " : "SELECT ") + this._select.map((ca) => sqlOperationToString(ca, this._dialect)).join(",") + " FROM " + Array.from(this._from).map((ta) => ta.table + " AS " + ta.alias).join(",") + joins.join("") + this._buildWhere() + this._buildGroupBy() + this._buildHaving() + this._buildOrderBy() + this._buildLimit() + this._buildOffset();
+  }
+  _buildWhere() {
+    return this._where.length > 0 ? " WHERE " + this._where : "";
+  }
+  _buildGroupBy() {
+    return this._groupByParts.length > 0 ? " GROUP BY " + this._groupByParts.join(", ") : "";
+  }
+  _buildHaving() {
+    return this._having.length > 0 ? " HAVING " + this._having : "";
+  }
+  _buildOrderBy() {
+    return this._orderByParts.length > 0 ? " ORDER BY " + this._orderByParts.join(", ") : "";
+  }
+  _buildOffset() {
+    return this._offset !== void 0 ? " OFFSET " + this._offset : "";
+  }
+  _buildLimit() {
+    return this._limit !== void 0 ? " LIMIT " + this._limit : "";
+  }
+};
+function selectSqlToString(selectOperation, dialect = "postgres") {
+  const qg = new SQLQueryGenerator(dialectOf(dialect));
+  qg.generate(selectOperation);
+  return qg.buildQueryString();
+}
+function toSql(businessDate, processingDatetime, columns, table, op, orderBy = [], groupBy = [], limit, businessDateTo = null, distinct = false, offset, having, dialect = "postgres") {
+  const selectOp = buildQueryOperation(businessDate, processingDatetime, columns, table, op, orderBy, groupBy, limit, businessDateTo, distinct, offset, having);
+  return selectSqlToString(selectOp, dialect);
+}
+
+export {
+  POSTGRES,
+  DUCKDB,
+  DATABRICKS,
+  dialectOf,
+  arithmeticNeedsParentheses,
+  buildQueryOperation,
+  needsParentheses,
+  selectSqlToString,
+  toSql
+};
+//# sourceMappingURL=chunk-BKPWV3OF.js.map