data-finder-ts 0.1.0 → 0.1.3

package/dist/index.cjs

@@ -0,0 +1,1822 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AggregateOperation: () => AggregateOperation,
+  AggregateOperator: () => AggregateOperator,
+  Attribute: () => Attribute,
+  BiTemporalColumns: () => BiTemporalColumns,
+  BinaryOperation: () => BinaryOperation,
+  BooleanAttribute: () => BooleanAttribute,
+  BooleanConstantOperation: () => BooleanConstantOperation,
+  BusinessDateAndProcessingTemporalColumns: () => BusinessDateAndProcessingTemporalColumns,
+  Column: () => Column,
+  ColumnWithJoin: () => ColumnWithJoin,
+  ComparisonOperation: () => ComparisonOperation,
+  ComparisonOperator: () => ComparisonOperator,
+  ConstantOperation: () => ConstantOperation,
+  CountAllOperation: () => CountAllOperation,
+  DataCatalog: () => DataCatalog,
+  DataStore: () => DataStore,
+  Database: () => Database,
+  DateArithmeticOperation: () => DateArithmeticOperation,
+  DateAttribute: () => DateAttribute,
+  DateConstantOperation: () => DateConstantOperation,
+  DateDiffOperation: () => DateDiffOperation,
+  DateExtractOperation: () => DateExtractOperation,
+  DatePart: () => DatePart,
+  DateTimeAttribute: () => DateTimeAttribute,
+  DateTimeConstantOperation: () => DateTimeConstantOperation,
+  DecimalAttribute: () => DecimalAttribute,
+  DecimalConstantOperation: () => DecimalConstantOperation,
+  DoubleAttribute: () => DoubleAttribute,
+  ExistsOperation: () => ExistsOperation,
+  FinderResult: () => FinderResult,
+  FloatAttribute: () => FloatAttribute,
+  FloatConstantOperation: () => FloatConstantOperation,
+  ForeignKey: () => ForeignKey,
+  IntegerAttribute: () => IntegerAttribute,
+  IntegerConstantOperation: () => IntegerConstantOperation,
+  IsNotNullOperation: () => IsNotNullOperation,
+  IsNullOperation: () => IsNullOperation,
+  JoinOperation: () => JoinOperation,
+  JoinTreeNodeOperation: () => JoinTreeNodeOperation,
+  LogicalOperation: () => LogicalOperation,
+  LogicalOperator: () => LogicalOperator,
+  MilestonedTable: () => MilestonedTable,
+  MilestoningColumns: () => MilestoningColumns,
+  NoOperation: () => NoOperation,
+  NotExistsOperation: () => NotExistsOperation,
+  NumericAttribute: () => NumericAttribute,
+  Operation: () => Operation,
+  ProcessingTemporalColumns: () => ProcessingTemporalColumns,
+  RelatedFinder: () => RelatedFinder,
+  RelationalOperationElement: () => RelationalOperationElement,
+  ScalarFunction: () => ScalarFunction,
+  ScalarFunctionOperation: () => ScalarFunctionOperation,
+  Schema: () => Schema,
+  SingleBusinessDateColumn: () => SingleBusinessDateColumn,
+  SortDirection: () => SortDirection,
+  SortOperation: () => SortOperation,
+  StringAttribute: () => StringAttribute,
+  StringConstantOperation: () => StringConstantOperation,
+  Table: () => Table,
+  UnaryOperation: () => UnaryOperation,
+  WindowFunction: () => WindowFunction,
+  WindowFunctionOperation: () => WindowFunctionOperation,
+  WindowSpecification: () => WindowSpecification,
+  clearRunner: () => clearRunner,
+  convertInputsAndSelect: () => convertInputsAndSelect,
+  getRelatedFinderClass: () => getRelatedFinderClass,
+  getRunner: () => getRunner,
+  registerRelatedFinderClass: () => registerRelatedFinderClass,
+  registerRunner: () => registerRunner,
+  selectSqlToString: () => selectSqlToString,
+  toSql: () => toSql
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/model/relational.ts
+var ComparisonOperator = /* @__PURE__ */ ((ComparisonOperator2) => {
+  ComparisonOperator2["EQUAL"] = "EQUAL";
+  ComparisonOperator2["NOT_EQUAL"] = "NOT_EQUAL";
+  ComparisonOperator2["LESS_THAN"] = "LESS_THAN";
+  ComparisonOperator2["GREATER_THAN"] = "GREATER_THAN";
+  ComparisonOperator2["LESS_THAN_OR_EQUAL_TO"] = "LESS_THAN_OR_EQUAL_TO";
+  ComparisonOperator2["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
+  ComparisonOperator2["LIKE"] = "LIKE";
+  ComparisonOperator2["NOT_LIKE"] = "NOT_LIKE";
+  return ComparisonOperator2;
+})(ComparisonOperator || {});
+var LogicalOperator = /* @__PURE__ */ ((LogicalOperator2) => {
+  LogicalOperator2["AND"] = "AND";
+  LogicalOperator2["OR"] = "OR";
+  return LogicalOperator2;
+})(LogicalOperator || {});
+var AggregateOperator = /* @__PURE__ */ ((AggregateOperator2) => {
+  AggregateOperator2["COUNT"] = "COUNT";
+  AggregateOperator2["SUM"] = "SUM";
+  AggregateOperator2["MIN"] = "MIN";
+  AggregateOperator2["MAX"] = "MAX";
+  AggregateOperator2["AVERAGE"] = "AVERAGE";
+  return AggregateOperator2;
+})(AggregateOperator || {});
+var ScalarFunction = /* @__PURE__ */ ((ScalarFunction2) => {
+  ScalarFunction2["ABS"] = "ABS";
+  ScalarFunction2["CEILING"] = "CEILING";
+  ScalarFunction2["FLOOR"] = "FLOOR";
+  ScalarFunction2["MOD"] = "MOD";
+  ScalarFunction2["POWER"] = "POWER";
+  ScalarFunction2["SQRT"] = "SQRT";
+  ScalarFunction2["ROUND"] = "ROUND";
+  ScalarFunction2["UPPER"] = "UPPER";
+  ScalarFunction2["LOWER"] = "LOWER";
+  ScalarFunction2["TRIM"] = "TRIM";
+  ScalarFunction2["LTRIM"] = "LTRIM";
+  ScalarFunction2["RTRIM"] = "RTRIM";
+  ScalarFunction2["LENGTH"] = "LENGTH";
+  ScalarFunction2["REVERSE"] = "REVERSE";
+  ScalarFunction2["LEFT"] = "LEFT";
+  ScalarFunction2["RIGHT"] = "RIGHT";
+  ScalarFunction2["REPEAT"] = "REPEAT";
+  ScalarFunction2["REPLACE"] = "REPLACE";
+  ScalarFunction2["SUBSTRING"] = "SUBSTRING";
+  return ScalarFunction2;
+})(ScalarFunction || {});
+var DatePart = /* @__PURE__ */ ((DatePart2) => {
+  DatePart2["YEAR"] = "YEAR";
+  DatePart2["MONTH"] = "MONTH";
+  DatePart2["DAY"] = "DAY";
+  DatePart2["HOUR"] = "HOUR";
+  DatePart2["MINUTE"] = "MINUTE";
+  DatePart2["SECOND"] = "SECOND";
+  DatePart2["QUARTER"] = "QUARTER";
+  DatePart2["WEEK"] = "WEEK";
+  DatePart2["DOW"] = "DOW";
+  return DatePart2;
+})(DatePart || {});
+var SortDirection = /* @__PURE__ */ ((SortDirection2) => {
+  SortDirection2["ASC"] = "ASC";
+  SortDirection2["DESC"] = "DESC";
+  return SortDirection2;
+})(SortDirection || {});
+var RelationalOperationElement = class {
+};
+var Operation = class extends RelationalOperationElement {
+  andOp(other) {
+    return new LogicalOperation(this, "AND" /* AND */, other);
+  }
+};
+var NoOperation = class extends Operation {
+  andOp(other) {
+    return other;
+  }
+};
+var ConstantOperation = class extends RelationalOperationElement {
+};
+var IntegerConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var FloatConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var StringConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DateConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DateTimeConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DecimalConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var BooleanConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var UnaryOperation = class extends Operation {
+  constructor(element) {
+    super();
+    this.element = element;
+  }
+  element;
+};
+var BinaryOperation = class extends Operation {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  left;
+  right;
+};
+var IsNullOperation = class extends UnaryOperation {
+};
+var IsNotNullOperation = class extends UnaryOperation {
+};
+var ComparisonOperation = class extends BinaryOperation {
+  constructor(left, operator, right) {
+    super(left, right);
+    this.operator = operator;
+  }
+  operator;
+};
+var LogicalOperation = class extends BinaryOperation {
+  constructor(left, operator, right) {
+    super(left, right);
+    this.operator = operator;
+  }
+  operator;
+};
+var WindowSpecification = class {
+  constructor(partitionBy = [], orderBy = []) {
+    this.partitionBy = partitionBy;
+    this.orderBy = orderBy;
+  }
+  partitionBy;
+  orderBy;
+};
+var AggregateOperation = class _AggregateOperation extends UnaryOperation {
+  constructor(element, operator, displayName, window) {
+    super(element);
+    this.operator = operator;
+    this.displayName = displayName;
+    this.window = window;
+  }
+  operator;
+  displayName;
+  window;
+  over(partitionBy, orderBy) {
+    return new _AggregateOperation(
+      this.element,
+      this.operator,
+      this.displayName,
+      new WindowSpecification(partitionBy ?? [], orderBy ?? [])
+    );
+  }
+};
+var WindowFunction = /* @__PURE__ */ ((WindowFunction2) => {
+  WindowFunction2["ROW_NUMBER"] = "ROW_NUMBER";
+  WindowFunction2["RANK"] = "RANK";
+  WindowFunction2["DENSE_RANK"] = "DENSE_RANK";
+  WindowFunction2["NTILE"] = "NTILE";
+  WindowFunction2["LAG"] = "LAG";
+  WindowFunction2["LEAD"] = "LEAD";
+  WindowFunction2["FIRST_VALUE"] = "FIRST_VALUE";
+  WindowFunction2["LAST_VALUE"] = "LAST_VALUE";
+  WindowFunction2["CUME_DIST"] = "CUME_DIST";
+  WindowFunction2["PERCENT_RANK"] = "PERCENT_RANK";
+  return WindowFunction2;
+})(WindowFunction || {});
+var WindowFunctionOperation = class _WindowFunctionOperation extends UnaryOperation {
+  constructor(element, func, displayName, secondArg, extraArgs = [], window) {
+    super(element);
+    this.func = func;
+    this.displayName = displayName;
+    this.secondArg = secondArg;
+    this.extraArgs = extraArgs;
+    this.window = window;
+  }
+  func;
+  displayName;
+  secondArg;
+  extraArgs;
+  window;
+  over(partitionBy, orderBy) {
+    return new _WindowFunctionOperation(
+      this.element,
+      this.func,
+      this.displayName,
+      this.secondArg,
+      [...this.extraArgs],
+      new WindowSpecification(partitionBy ?? [], orderBy ?? [])
+    );
+  }
+};
+var ScalarFunctionOperation = class extends UnaryOperation {
+  constructor(element, func, displayName, secondArg, extraArgs = []) {
+    super(element);
+    this.func = func;
+    this.displayName = displayName;
+    this.secondArg = secondArg;
+    this.extraArgs = extraArgs;
+  }
+  func;
+  displayName;
+  secondArg;
+  extraArgs;
+};
+var DateExtractOperation = class extends UnaryOperation {
+  constructor(element, part, displayName) {
+    super(element);
+    this.part = part;
+    this.displayName = displayName;
+  }
+  part;
+  displayName;
+};
+var DateArithmeticOperation = class extends UnaryOperation {
+  constructor(element, n, unit, isAdd = true, displayName) {
+    super(element);
+    this.n = n;
+    this.unit = unit;
+    this.isAdd = isAdd;
+    this.displayName = displayName;
+  }
+  n;
+  unit;
+  isAdd;
+  displayName;
+};
+var DateDiffOperation = class extends UnaryOperation {
+  constructor(element, other, unit, displayName) {
+    super(element);
+    this.other = other;
+    this.unit = unit;
+    this.displayName = displayName;
+  }
+  other;
+  unit;
+  displayName;
+};
+var Column = class extends RelationalOperationElement {
+  constructor(name, type, owner, primaryKey = false) {
+    super();
+    this.name = name;
+    this.type = type;
+    this.owner = owner;
+    this.primaryKey = primaryKey;
+  }
+  name;
+  type;
+  owner;
+  primaryKey;
+  table;
+};
+var ForeignKey = class {
+  constructor(column, references) {
+    this.column = column;
+    this.references = references;
+  }
+  column;
+  references;
+};
+var DataStore = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+  schemas = [];
+};
+var Database = class extends DataStore {
+  constructor(name, location) {
+    super(name);
+    this.location = location;
+  }
+  location;
+  namespace(schemaName) {
+    return schemaName;
+  }
+};
+var DataCatalog = class extends DataStore {
+  constructor(name) {
+    super(name);
+  }
+  namespace(schemaName) {
+    return `${this.name}.${schemaName}`;
+  }
+};
+var Schema = class {
+  constructor(name, datastore) {
+    this.name = name;
+    this.datastore = datastore;
+    datastore?.schemas.push(this);
+  }
+  name;
+  datastore;
+  tables = [];
+};
+var Table = class {
+  constructor(name, columns, schema) {
+    this.name = name;
+    this.schema = schema;
+    for (const col of columns) {
+      if (this._columnsByName.has(col.name)) {
+        throw new Error(`Duplicate column name '${col.name}' in table '${name}'`);
+      }
+      this._columnsByName.set(col.name, col);
+      col.table = this;
+    }
+    schema?.tables.push(this);
+  }
+  name;
+  schema;
+  _columnsByName = /* @__PURE__ */ new Map();
+  foreignKeys = [];
+  get columns() {
+    return Array.from(this._columnsByName.values());
+  }
+  get qualifiedName() {
+    if (!this.schema) return this.name;
+    if (!this.schema.datastore) return `${this.schema.name}.${this.name}`;
+    return `${this.schema.datastore.namespace(this.schema.name)}.${this.name}`;
+  }
+};
+var JoinOperation = class {
+  constructor(name, target, left, right, filter) {
+    this.name = name;
+    this.target = target;
+    this.left = left;
+    this.right = right;
+    this.filter = filter;
+  }
+  name;
+  target;
+  left;
+  right;
+  filter;
+};
+var JoinTreeNodeOperation = class {
+  constructor(join, parent) {
+    this.join = join;
+    this.parent = parent;
+  }
+  join;
+  parent;
+};
+var ColumnWithJoin = class extends RelationalOperationElement {
+  constructor(column, parent) {
+    super();
+    this.column = column;
+    this.parent = parent;
+  }
+  column;
+  parent;
+};
+var SortOperation = class {
+  constructor(column, direction) {
+    this.column = column;
+    this.direction = direction;
+  }
+  column;
+  direction;
+};
+var CountAllOperation = class extends RelationalOperationElement {
+  constructor(table) {
+    super();
+    this.table = table;
+  }
+  table;
+};
+
+// src/datafinder/attribute.ts
+var Attribute = class {
+  _displayName;
+  _column;
+  _owner;
+  _parent;
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    this._displayName = displayName;
+    this._column = new Column(columnName, columnDbType, owner);
+    this._owner = owner;
+    this._parent = parent;
+  }
+  column() {
+    return this._column;
+  }
+  owner() {
+    return this._owner;
+  }
+  parent() {
+    return this._parent;
+  }
+  displayName() {
+    return this._displayName;
+  }
+  cwj() {
+    return new ColumnWithJoin(this._column, this._parent);
+  }
+  count() {
+    return new AggregateOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      "COUNT" /* COUNT */,
+      this._displayName + " Count"
+    );
+  }
+  ascending() {
+    return new SortOperation(new ColumnWithJoin(this._column, this._parent), "ASC" /* ASC */);
+  }
+  descending() {
+    return new SortOperation(new ColumnWithJoin(this._column, this._parent), "DESC" /* DESC */);
+  }
+  isNull() {
+    return new IsNullOperation(new ColumnWithJoin(this._column, this._parent));
+  }
+  isNotNull() {
+    return new IsNotNullOperation(new ColumnWithJoin(this._column, this._parent));
+  }
+  _windowSpec(partitionBy, orderBy) {
+    const pb = partitionBy === void 0 ? [] : Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+    const ob = orderBy === void 0 ? [] : Array.isArray(orderBy) ? orderBy : [orderBy];
+    return new WindowSpecification(pb, ob);
+  }
+  rank(opts = {}) {
+    const { method = "min", pct = false, partitionBy, orderBy } = opts;
+    let func;
+    let name;
+    if (pct) {
+      if (method === "max") {
+        func = "CUME_DIST" /* CUME_DIST */;
+        name = "Cume Dist";
+      } else {
+        func = "PERCENT_RANK" /* PERCENT_RANK */;
+        name = "Percent Rank";
+      }
+    } else if (method === "first") {
+      func = "ROW_NUMBER" /* ROW_NUMBER */;
+      name = "Row Number";
+    } else if (method === "dense") {
+      func = "DENSE_RANK" /* DENSE_RANK */;
+      name = "Dense Rank";
+    } else {
+      func = "RANK" /* RANK */;
+      name = "Rank";
+    }
+    return new WindowFunctionOperation(null, func, name, void 0, [], this._windowSpec(partitionBy, orderBy));
+  }
+  qcut(buckets, opts = {}) {
+    return new WindowFunctionOperation(
+      null,
+      "NTILE" /* NTILE */,
+      "Quantile",
+      buckets,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  shift(periods = 1, opts = {}) {
+    const extraArgs = opts.fillValue !== void 0 ? [opts.fillValue] : [];
+    const func = periods >= 0 ? "LAG" /* LAG */ : "LEAD" /* LEAD */;
+    const label = periods >= 0 ? "Lag" : "Lead";
+    return new WindowFunctionOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      func,
+      label + " " + this._displayName,
+      Math.abs(periods),
+      extraArgs,
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  first(opts = {}) {
+    return new WindowFunctionOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      "FIRST_VALUE" /* FIRST_VALUE */,
+      "First " + this._displayName,
+      void 0,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  last(opts = {}) {
+    return new WindowFunctionOperation(
+      new ColumnWithJoin(this._column, this._parent),
+      "LAST_VALUE" /* LAST_VALUE */,
+      "Last " + this._displayName,
+      void 0,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+};
+
+// src/datafinder/finder-registry.ts
+var _registry = /* @__PURE__ */ new Map();
+function registerRelatedFinderClass(name, cls) {
+  _registry.set(name, cls);
+}
+function getRelatedFinderClass(name) {
+  return _registry.get(name);
+}
+
+// src/datafinder/typed-attributes.ts
+var StringAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  upper() {
+    return new ScalarFunctionOperation(this.cwj(), "UPPER" /* UPPER */, "Upper " + this.displayName());
+  }
+  lower() {
+    return new ScalarFunctionOperation(this.cwj(), "LOWER" /* LOWER */, "Lower " + this.displayName());
+  }
+  strip() {
+    return new ScalarFunctionOperation(this.cwj(), "TRIM" /* TRIM */, "Strip " + this.displayName());
+  }
+  lstrip() {
+    return new ScalarFunctionOperation(this.cwj(), "LTRIM" /* LTRIM */, "LStrip " + this.displayName());
+  }
+  rstrip() {
+    return new ScalarFunctionOperation(this.cwj(), "RTRIM" /* RTRIM */, "RStrip " + this.displayName());
+  }
+  length() {
+    return new ScalarFunctionOperation(this.cwj(), "LENGTH" /* LENGTH */, "Length " + this.displayName());
+  }
+  reverse() {
+    return new ScalarFunctionOperation(this.cwj(), "REVERSE" /* REVERSE */, "Reverse " + this.displayName());
+  }
+  left(n) {
+    return new ScalarFunctionOperation(this.cwj(), "LEFT" /* LEFT */, "Left " + this.displayName(), n);
+  }
+  right(n) {
+    return new ScalarFunctionOperation(this.cwj(), "RIGHT" /* RIGHT */, "Right " + this.displayName(), n);
+  }
+  repeat(n) {
+    return new ScalarFunctionOperation(this.cwj(), "REPEAT" /* REPEAT */, "Repeat " + this.displayName(), n);
+  }
+  replace(fromStr, toStr) {
+    return new ScalarFunctionOperation(this.cwj(), "REPLACE" /* REPLACE */, "Replace " + this.displayName(), void 0, [fromStr, toStr]);
+  }
+  substring(start, length) {
+    const args = length !== void 0 ? [start + 1, length] : [start + 1];
+    return new ScalarFunctionOperation(this.cwj(), "SUBSTRING" /* SUBSTRING */, "Substring " + this.displayName(), void 0, args);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new StringConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new StringConstantOperation(value));
+  }
+  contains(value) {
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${value}%`));
+  }
+  startsWith(prefix) {
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`${prefix}%`));
+  }
+  endsWith(suffix) {
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${suffix}`));
+  }
+  notContains(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_LIKE" /* NOT_LIKE */, new StringConstantOperation(`%${value}%`));
+  }
+};
+var NumericAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  sum() {
+    return new AggregateOperation(this.cwj(), "SUM" /* SUM */, this.displayName() + " Sum");
+  }
+  min() {
+    return new AggregateOperation(this.cwj(), "MIN" /* MIN */, this.displayName() + " Min");
+  }
+  max() {
+    return new AggregateOperation(this.cwj(), "MAX" /* MAX */, this.displayName() + " Max");
+  }
+  average() {
+    return new AggregateOperation(this.cwj(), "AVERAGE" /* AVERAGE */, this.displayName() + " Average");
+  }
+  abs() {
+    return new ScalarFunctionOperation(this.cwj(), "ABS" /* ABS */, "Abs " + this.displayName());
+  }
+  ceil() {
+    return new ScalarFunctionOperation(this.cwj(), "CEILING" /* CEILING */, "Ceil " + this.displayName());
+  }
+  floor() {
+    return new ScalarFunctionOperation(this.cwj(), "FLOOR" /* FLOOR */, "Floor " + this.displayName());
+  }
+  sqrt() {
+    return new ScalarFunctionOperation(this.cwj(), "SQRT" /* SQRT */, "Sqrt " + this.displayName());
+  }
+  mod(n) {
+    return new ScalarFunctionOperation(this.cwj(), "MOD" /* MOD */, "Mod " + this.displayName(), n);
+  }
+  power(n) {
+    return new ScalarFunctionOperation(this.cwj(), "POWER" /* POWER */, "Power " + this.displayName(), n);
+  }
+  round(d) {
+    return new ScalarFunctionOperation(this.cwj(), "ROUND" /* ROUND */, "Round " + this.displayName(), d);
+  }
+};
+var DoubleAttribute = class extends NumericAttribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new FloatConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new FloatConstantOperation(value));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new FloatConstantOperation(value));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new FloatConstantOperation(value));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new FloatConstantOperation(value));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new FloatConstantOperation(value));
+  }
+};
+var FloatAttribute = DoubleAttribute;
+var DecimalAttribute = class extends NumericAttribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DecimalConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DecimalConstantOperation(value));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DecimalConstantOperation(value));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DecimalConstantOperation(value));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DecimalConstantOperation(value));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DecimalConstantOperation(value));
+  }
+};
+var IntegerAttribute = class extends NumericAttribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new IntegerConstantOperation(value));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new IntegerConstantOperation(value));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new IntegerConstantOperation(value));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new IntegerConstantOperation(value));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new IntegerConstantOperation(value));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new IntegerConstantOperation(value));
+  }
+};
+var BooleanAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(value));
+  }
+  isTrue() {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(true));
+  }
+  isFalse() {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(false));
+  }
+};
+function parseDate(value) {
+  if (value instanceof Date) return value;
+  const d = new Date(value);
+  if (isNaN(d.getTime())) throw new Error(`Cannot parse date: ${value}`);
+  return d;
+}
+var DateAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DateConstantOperation(parseDate(value)));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DateConstantOperation(parseDate(value)));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DateConstantOperation(parseDate(value)));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DateConstantOperation(parseDate(value)));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DateConstantOperation(parseDate(value)));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DateConstantOperation(parseDate(value)));
+  }
+  year() {
+    return new DateExtractOperation(this.cwj(), "YEAR" /* YEAR */, "Year " + this.displayName());
+  }
+  month() {
+    return new DateExtractOperation(this.cwj(), "MONTH" /* MONTH */, "Month " + this.displayName());
+  }
+  day() {
+    return new DateExtractOperation(this.cwj(), "DAY" /* DAY */, "Day " + this.displayName());
+  }
+  quarter() {
+    return new DateExtractOperation(this.cwj(), "QUARTER" /* QUARTER */, "Quarter " + this.displayName());
+  }
+  week() {
+    return new DateExtractOperation(this.cwj(), "WEEK" /* WEEK */, "Week " + this.displayName());
+  }
+  dayOfWeek() {
+    return new DateExtractOperation(this.cwj(), "DOW" /* DOW */, "Day Of Week " + this.displayName());
+  }
+  addDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, true, "Add Days " + this.displayName());
+  }
+  addMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, true, "Add Months " + this.displayName());
+  }
+  addYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, true, "Add Years " + this.displayName());
+  }
+  subtractDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, false, "Subtract Days " + this.displayName());
+  }
+  subtractMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, false, "Subtract Months " + this.displayName());
+  }
+  subtractYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, false, "Subtract Years " + this.displayName());
+  }
+  diffDays(other) {
+    return new DateDiffOperation(this.cwj(), other, "DAY" /* DAY */, "Diff Days " + this.displayName());
+  }
+  diffMonths(other) {
+    return new DateDiffOperation(this.cwj(), other, "MONTH" /* MONTH */, "Diff Months " + this.displayName());
+  }
+  diffYears(other) {
+    return new DateDiffOperation(this.cwj(), other, "YEAR" /* YEAR */, "Diff Years " + this.displayName());
+  }
+};
+var DateTimeAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent) {
+    super(displayName, columnName, columnDbType, owner, parent);
+  }
+  eq(value) {
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  ne(value) {
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  gt(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  lt(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  gte(value) {
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  lte(value) {
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DateTimeConstantOperation(parseDate(value)));
+  }
+  year() {
+    return new DateExtractOperation(this.cwj(), "YEAR" /* YEAR */, "Year " + this.displayName());
+  }
+  month() {
+    return new DateExtractOperation(this.cwj(), "MONTH" /* MONTH */, "Month " + this.displayName());
+  }
+  day() {
+    return new DateExtractOperation(this.cwj(), "DAY" /* DAY */, "Day " + this.displayName());
+  }
+  hour() {
+    return new DateExtractOperation(this.cwj(), "HOUR" /* HOUR */, "Hour " + this.displayName());
+  }
+  minute() {
+    return new DateExtractOperation(this.cwj(), "MINUTE" /* MINUTE */, "Minute " + this.displayName());
+  }
+  second() {
+    return new DateExtractOperation(this.cwj(), "SECOND" /* SECOND */, "Second " + this.displayName());
+  }
+  quarter() {
+    return new DateExtractOperation(this.cwj(), "QUARTER" /* QUARTER */, "Quarter " + this.displayName());
+  }
+  week() {
+    return new DateExtractOperation(this.cwj(), "WEEK" /* WEEK */, "Week " + this.displayName());
+  }
+  dayOfWeek() {
+    return new DateExtractOperation(this.cwj(), "DOW" /* DOW */, "Day Of Week " + this.displayName());
+  }
+  addDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, true, "Add Days " + this.displayName());
+  }
+  addMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, true, "Add Months " + this.displayName());
+  }
+  addYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, true, "Add Years " + this.displayName());
+  }
+  addHours(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "HOUR" /* HOUR */, true, "Add Hours " + this.displayName());
+  }
+  addMinutes(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MINUTE" /* MINUTE */, true, "Add Minutes " + this.displayName());
+  }
+  addSeconds(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "SECOND" /* SECOND */, true, "Add Seconds " + this.displayName());
+  }
+  subtractDays(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, false, "Subtract Days " + this.displayName());
+  }
+  subtractMonths(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, false, "Subtract Months " + this.displayName());
+  }
+  subtractYears(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, false, "Subtract Years " + this.displayName());
+  }
+  subtractHours(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "HOUR" /* HOUR */, false, "Subtract Hours " + this.displayName());
+  }
+  subtractMinutes(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "MINUTE" /* MINUTE */, false, "Subtract Minutes " + this.displayName());
+  }
+  subtractSeconds(n) {
+    return new DateArithmeticOperation(this.cwj(), n, "SECOND" /* SECOND */, false, "Subtract Seconds " + this.displayName());
+  }
+  diffDays(other) {
+    return new DateDiffOperation(this.cwj(), other, "DAY" /* DAY */, "Diff Days " + this.displayName());
+  }
+  diffMonths(other) {
+    return new DateDiffOperation(this.cwj(), other, "MONTH" /* MONTH */, "Diff Months " + this.displayName());
+  }
+  diffYears(other) {
+    return new DateDiffOperation(this.cwj(), other, "YEAR" /* YEAR */, "Diff Years " + this.displayName());
+  }
+  diffHours(other) {
+    return new DateDiffOperation(this.cwj(), other, "HOUR" /* HOUR */, "Diff Hours " + this.displayName());
+  }
+  diffMinutes(other) {
+    return new DateDiffOperation(this.cwj(), other, "MINUTE" /* MINUTE */, "Diff Minutes " + this.displayName());
+  }
+  diffSeconds(other) {
+    return new DateDiffOperation(this.cwj(), other, "SECOND" /* SECOND */, "Diff Seconds " + this.displayName());
+  }
+};
+
+// src/model/milestoning.ts
+var MilestoningColumns = class {
+};
+var ProcessingTemporalColumns = class extends MilestoningColumns {
+  constructor(startAtColumn, endAtColumn, infiniteDatetime) {
+    super();
+    this.startAtColumn = startAtColumn;
+    this.endAtColumn = endAtColumn;
+    this.infiniteDatetime = infiniteDatetime;
+  }
+  startAtColumn;
+  endAtColumn;
+  infiniteDatetime;
+  columns() {
+    return [this.startAtColumn, this.endAtColumn];
+  }
+};
+var SingleBusinessDateColumn = class extends MilestoningColumns {
+  constructor(businessDateColumn) {
+    super();
+    this.businessDateColumn = businessDateColumn;
+  }
+  businessDateColumn;
+  columns() {
+    return [this.businessDateColumn];
+  }
+};
+var BusinessDateAndProcessingTemporalColumns = class extends MilestoningColumns {
+  constructor(businessDateColumn, startAtColumn, endAtColumn, infiniteDatetime) {
+    super();
+    this.businessDateColumn = businessDateColumn;
+    this.startAtColumn = startAtColumn;
+    this.endAtColumn = endAtColumn;
+    this.infiniteDatetime = infiniteDatetime;
+  }
+  businessDateColumn;
+  startAtColumn;
+  endAtColumn;
+  infiniteDatetime;
+  columns() {
+    return [this.businessDateColumn, this.startAtColumn, this.endAtColumn];
+  }
+};
+var BiTemporalColumns = class extends MilestoningColumns {
+  constructor(businessDateFromColumn, businessDateToColumn, startAtColumn, endAtColumn, infiniteDatetime) {
+    super();
+    this.businessDateFromColumn = businessDateFromColumn;
+    this.businessDateToColumn = businessDateToColumn;
+    this.startAtColumn = startAtColumn;
+    this.endAtColumn = endAtColumn;
+    this.infiniteDatetime = infiniteDatetime;
+  }
+  businessDateFromColumn;
+  businessDateToColumn;
+  startAtColumn;
+  endAtColumn;
+  infiniteDatetime;
+  columns() {
+    return [
+      this.businessDateFromColumn,
+      this.businessDateToColumn,
+      this.startAtColumn,
+      this.endAtColumn
+    ];
+  }
+};
+var MilestonedTable = class extends Table {
+  constructor(name, columns, milestoningColumns, schema) {
+    super(name, columns, schema);
+    this.milestoningColumns = milestoningColumns;
+    for (const col of milestoningColumns.columns()) {
+      col.table = this;
+    }
+  }
+  milestoningColumns;
+};
+
+// 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);
+  }
+};
+
+// 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;
+    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;
+};
+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())}'`;
+}
+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 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"
+};
+function constantValueString(op) {
+  if (op instanceof StringConstantOperation) return "'" + 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 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 windowSpecToString(window) {
+  const parts = [];
+  if (window.partitionBy.length > 0) {
+    parts.push("PARTITION BY " + window.partitionBy.map((p) => sqlOperationToString(p)).join(", "));
+  }
+  if (window.orderBy.length > 0) {
+    parts.push("ORDER BY " + window.orderBy.map(
+      (s) => sqlOperationToString(s.column) + (s.direction === "ASC" /* ASC */ ? " ASC" : " DESC")
+    ).join(", "));
+  }
+  return "OVER (" + parts.join(" ") + ")";
+}
+function sqlOperationToString(operation) {
+  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));
+    }
+    if (operation.secondArg !== void 0) parts.push(String(operation.secondArg));
+    for (const arg of operation.extraArgs) {
+      parts.push(typeof arg === "string" ? "'" + arg + "'" : String(arg));
+    }
+    const sql = fn + "(" + parts.join(", ") + ")";
+    return sql + (operation.window !== void 0 ? " " + windowSpecToString(operation.window) : " OVER ()");
+  }
+  if (operation instanceof AggregateOperation) {
+    const fn = AGGREGATE_SQL_NAMES[operation.operator] ?? operation.operator;
+    let sql = fn + "(" + sqlOperationToString(operation.element) + ")";
+    if (operation.window !== void 0) {
+      sql += " " + windowSpecToString(operation.window);
+    }
+    return sql;
+  }
+  if (operation instanceof ScalarFunctionOperation) {
+    const fn = SCALAR_SQL_NAMES[operation.func];
+    const parts = [sqlOperationToString(operation.element)];
+    if (operation.secondArg !== void 0) parts.push(String(operation.secondArg));
+    for (const arg of operation.extraArgs) {
+      parts.push(typeof arg === "string" ? "'" + arg + "'" : String(arg));
+    }
+    return fn + "(" + parts.join(", ") + ")";
+  }
+  if (operation instanceof DateExtractOperation) {
+    return "EXTRACT(" + operation.part + " FROM " + sqlOperationToString(operation.element) + ")";
+  }
+  if (operation instanceof DateArithmeticOperation) {
+    const op = operation.isAdd ? "+" : "-";
+    return sqlOperationToString(operation.element) + " " + op + " INTERVAL " + operation.n + " " + operation.unit;
+  }
+  if (operation instanceof DateDiffOperation) {
+    const otherSql = sqlFormatDatetime(operation.other);
+    return "DATE_DIFF('" + operation.unit.toLowerCase() + "', " + sqlOperationToString(operation.element) + ", " + otherSql + ")";
+  }
+  if (operation instanceof CountAllOperation) return "COUNT(*)";
+  if (operation instanceof Alias) {
+    return sqlOperationToString(operation.element) + ' AS "' + operation.name + '"';
+  }
+  throw new TypeError("Unknown operation in sqlOperationToString: " + operation.constructor.name);
+}
+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 buildMilestoningFilterOperation(businessDate, processingDatetime, table, joinNode) {
+  const mc = table.milestoningColumns;
+  const ops = [];
+  if (mc instanceof BiTemporalColumns) {
+    if (businessDate !== null) {
+      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(businessDate), "AND" /* AND */, openEndClause(dateTo, businessDate, mc.infiniteDatetime)));
+    }
+    if (processingDatetime !== 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);
+      ops.push(new LogicalOperation(startAt.lte(processingDatetime), "AND" /* AND */, openEndClause(endAt, processingDatetime, mc.infiniteDatetime)));
+    }
+  } else if (mc instanceof BusinessDateAndProcessingTemporalColumns) {
+    if (businessDate !== null) {
+      const businessAtt = new DateAttribute("business_date", mc.businessDateColumn.name, mc.businessDateColumn.type, mc.businessDateColumn.table.qualifiedName, joinNode);
+      ops.push(businessAtt.eq(businessDate));
+    }
+    if (processingDatetime !== 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);
+      ops.push(new LogicalOperation(startAt.lte(processingDatetime), "AND" /* AND */, openEndClause(endAt, processingDatetime, mc.infiniteDatetime)));
+    }
+  } else if (mc instanceof ProcessingTemporalColumns && processingDatetime !== 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);
+    ops.push(new LogicalOperation(startAt.lte(processingDatetime), "AND" /* AND */, openEndClause(endAt, processingDatetime, mc.infiniteDatetime)));
+  } else if (mc instanceof SingleBusinessDateColumn && businessDate !== null) {
+    const businessAtt = new DateAttribute("business_date", mc.businessDateColumn.name, mc.businessDateColumn.type, mc.businessDateColumn.table.qualifiedName, joinNode);
+    ops.push(businessAtt.eq(businessDate));
+  }
+  if (ops.length === 0) return null;
+  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) {
+  let filter = op;
+  if (table instanceof MilestonedTable) {
+    const milestonedOp = buildMilestoningFilterOperation(businessDate, processingDatetime, 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);
+    }
+  }
+  for (const node of requiredJoins) {
+    if (node.join.target instanceof MilestonedTable) {
+      const milestonedOp = buildMilestoningFilterOperation(businessDate, processingDatetime, node.join.target, node);
+      if (milestonedOp !== null) {
+        node.join.filter = milestonedOp;
+      }
+    }
+  }
+  return new SelectOperation(columns, filter, orderBy, groupBy, limit, table);
+}
+var SQLQueryGenerator = class {
+  _select = [];
+  _from = /* @__PURE__ */ new Set();
+  _join = [];
+  _groupByParts = [];
+  _orderByParts = [];
+  _where = "";
+  _limit;
+  _tableAliasIncr = 0;
+  _tableAliasesByTable = /* @__PURE__ */ new Map();
+  _addedJoinIds = /* @__PURE__ */ new Set();
+  _rootTable;
+  generate(select) {
+    this._rootTable = select.table;
+    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 = select.groupBy.map((a) => this._attrToColString(a));
+    this._orderByParts = select.orderBy.map(
+      (s) => this.buildFilter(s.column) + (s.direction === "ASC" /* ASC */ ? " ASC" : " DESC")
+    );
+    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;
+  }
+  _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);
+    }
+  }
+  _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) {
+      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 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
+      );
+    }
+    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 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;
+  }
+  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) {
+      if (col instanceof Attribute) {
+        const node = col.parent();
+        let ta;
+        if (node !== void 0) {
+          ta = this._tableAliasForTable(col.owner(), node);
+        } else {
+          ta = this._tableAliasForTable(col.owner(), col.owner());
+          this._from.add(ta);
+        }
+        this._select.push(new Alias(new TableAliasColumn(col.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) {
+        const colNested = 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 + " " + colNested.column.name;
+        const rewrittenAgg = new AggregateOperation(
+          new TableAliasColumn(colNested.column, ta),
+          col.operator,
+          void 0,
+          col.window ? this._rewriteWindowSpec(col.window) : void 0
+        );
+        this._select.push(new Alias(rewrittenAgg, alias));
+      } else if (col instanceof ScalarFunctionOperation) {
+        const colNested = 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.func + " " + colNested.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 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 ?? colNested.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 CountAllOperation) {
+        const ta = this._tableAliasForTable(col.table, col.table);
+        this._from.add(ta);
+        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));
+    this._join.push(new Join(sc, tc, join.filter));
+  }
+  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 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 (op.left instanceof LogicalOperation) left = "(" + left + ")";
+      if (op.right instanceof LogicalOperation) right = "(" + right + ")";
+      return left + LOGICAL_OPERATOR_STR[op.operator] + right;
+    }
+    if (op instanceof ComparisonOperation) {
+      return this.buildFilter(op.left) + COMPARISON_OPERATOR_STR[op.operator] + this.buildFilter(op.right);
+    }
+    if (op instanceof ConstantOperation) return constantValueString(op);
+    if (op instanceof ColumnWithJoin) {
+      const node = op.parent;
+      let ta;
+      if (node !== void 0) {
+        ta = this._tableAliasForTable(op.column.owner, node);
+        this._addJoin(node);
+      } else {
+        ta = this._tableAliasForTable(op.column.owner, op.column.owner);
+      }
+      return ta.alias + "." + op.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.source.tableAlias.alias + "." + j.source.column.name + " = " + j.target.tableAlias.alias + "." + j.target.column.name + (j.filterOp ? " AND " + this.buildFilter(j.filterOp) : "")
+    );
+    return "SELECT " + this._select.map((ca) => sqlOperationToString(ca)).join(",") + " FROM " + Array.from(this._from).map((ta) => ta.table + " AS " + ta.alias).join(",") + joins.join("") + this._buildWhere() + this._buildGroupBy() + this._buildOrderBy() + this._buildLimit();
+  }
+  _buildWhere() {
+    return this._where.length > 0 ? " WHERE " + this._where : "";
+  }
+  _buildGroupBy() {
+    return this._groupByParts.length > 0 ? " GROUP BY " + this._groupByParts.join(", ") : "";
+  }
+  _buildOrderBy() {
+    return this._orderByParts.length > 0 ? " ORDER BY " + this._orderByParts.join(", ") : "";
+  }
+  _buildLimit() {
+    return this._limit !== void 0 ? " LIMIT " + this._limit : "";
+  }
+};
+function selectSqlToString(selectOperation) {
+  const qg = new SQLQueryGenerator();
+  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);
+  return selectSqlToString(selectOp);
+}
+
+// src/datafinder/runner.ts
+var _runner = null;
+function registerRunner(runner) {
+  _runner = runner;
+}
+function clearRunner() {
+  _runner = null;
+}
+function getRunner() {
+  if (!_runner) throw new Error("No query runner registered. Call registerRunner() first.");
+  return _runner;
+}
+var FinderResult = class {
+  constructor(_businessDate, _processingDatetime, _columns, _table, _op) {
+    this._businessDate = _businessDate;
+    this._processingDatetime = _processingDatetime;
+    this._columns = _columns;
+    this._table = _table;
+    this._op = _op;
+  }
+  _businessDate;
+  _processingDatetime;
+  _columns;
+  _table;
+  _op;
+  _orderBy = [];
+  _groupBy = [];
+  _limit;
+  orderByOp(...sorts) {
+    this._orderBy = sorts;
+    return this;
+  }
+  groupByOp(...attrs) {
+    this._groupBy = attrs;
+    return this;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  toSql() {
+    return toSql(
+      this._businessDate,
+      this._processingDatetime,
+      this._columns,
+      this._table,
+      this._op,
+      this._orderBy,
+      this._groupBy,
+      this._limit
+    );
+  }
+  async toRows() {
+    return getRunner().select(
+      this._businessDate,
+      this._processingDatetime,
+      this._columns,
+      this._table,
+      this._op,
+      this._orderBy,
+      this._groupBy,
+      this._limit
+    );
+  }
+};
+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;
+  const d = new Date(normalized);
+  if (isNaN(d.getTime())) throw new Error(`Cannot parse date: ${value}`);
+  return d;
+}
+function convertInputsAndSelect(businessDate, processingDatetime, columns, table, op = new NoOperation()) {
+  return new FinderResult(
+    convertDate(businessDate),
+    convertDate(processingDatetime),
+    columns,
+    table,
+    op
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AggregateOperation,
+  AggregateOperator,
+  Attribute,
+  BiTemporalColumns,
+  BinaryOperation,
+  BooleanAttribute,
+  BooleanConstantOperation,
+  BusinessDateAndProcessingTemporalColumns,
+  Column,
+  ColumnWithJoin,
+  ComparisonOperation,
+  ComparisonOperator,
+  ConstantOperation,
+  CountAllOperation,
+  DataCatalog,
+  DataStore,
+  Database,
+  DateArithmeticOperation,
+  DateAttribute,
+  DateConstantOperation,
+  DateDiffOperation,
+  DateExtractOperation,
+  DatePart,
+  DateTimeAttribute,
+  DateTimeConstantOperation,
+  DecimalAttribute,
+  DecimalConstantOperation,
+  DoubleAttribute,
+  ExistsOperation,
+  FinderResult,
+  FloatAttribute,
+  FloatConstantOperation,
+  ForeignKey,
+  IntegerAttribute,
+  IntegerConstantOperation,
+  IsNotNullOperation,
+  IsNullOperation,
+  JoinOperation,
+  JoinTreeNodeOperation,
+  LogicalOperation,
+  LogicalOperator,
+  MilestonedTable,
+  MilestoningColumns,
+  NoOperation,
+  NotExistsOperation,
+  NumericAttribute,
+  Operation,
+  ProcessingTemporalColumns,
+  RelatedFinder,
+  RelationalOperationElement,
+  ScalarFunction,
+  ScalarFunctionOperation,
+  Schema,
+  SingleBusinessDateColumn,
+  SortDirection,
+  SortOperation,
+  StringAttribute,
+  StringConstantOperation,
+  Table,
+  UnaryOperation,
+  WindowFunction,
+  WindowFunctionOperation,
+  WindowSpecification,
+  clearRunner,
+  convertInputsAndSelect,
+  getRelatedFinderClass,
+  getRunner,
+  registerRelatedFinderClass,
+  registerRunner,
+  selectSqlToString,
+  toSql
+});
+//# sourceMappingURL=index.cjs.map