data-finder-ts 0.1.4 → 0.1.5

package/dist/chunk-PF6EJZHB.js

@@ -0,0 +1,1015 @@
+// 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 LIKE_ESCAPE = "!";
+function escapeLike(value) {
+  return value.replaceAll(LIKE_ESCAPE, LIKE_ESCAPE + LIKE_ESCAPE).replaceAll("%", LIKE_ESCAPE + "%").replaceAll("_", LIKE_ESCAPE + "_");
+}
+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";
+  AggregateOperator2["STRING_AGG"] = "STRING_AGG";
+  AggregateOperator2["COUNT_DISTINCT"] = "COUNT_DISTINCT";
+  AggregateOperator2["STDDEV_SAMP"] = "STDDEV_SAMP";
+  AggregateOperator2["STDDEV_POP"] = "STDDEV_POP";
+  AggregateOperator2["VAR_SAMP"] = "VAR_SAMP";
+  AggregateOperator2["VAR_POP"] = "VAR_POP";
+  AggregateOperator2["BOOL_AND"] = "BOOL_AND";
+  AggregateOperator2["BOOL_OR"] = "BOOL_OR";
+  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";
+  ScalarFunction2["COALESCE"] = "COALESCE";
+  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 {
+  /** Name this column in the result: `f.price().sum().alias('Total')`, `f.age().gt(30).alias('Adult')`. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  and(other) {
+    return new LogicalOperation(this, "AND" /* AND */, other);
+  }
+  /** Combine with `other` using OR. A chain reads left to right: `a.or(b).and(c)` is `(a OR b) AND c`. */
+  or(other) {
+    return new LogicalOperation(this, "OR" /* OR */, other);
+  }
+};
+var NoOperation = class extends Operation {
+  and(other) {
+    return other;
+  }
+  /** No filter matches every row, so OR-ing anything with it still matches every row. */
+  or(_other) {
+    return this;
+  }
+};
+var ConstantOperation = class extends RelationalOperationElement {
+  /** Name this column in the result. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+};
+var NumericConstantOperation = class extends ConstantOperation {
+  arithmeticOperand() {
+    return this;
+  }
+};
+var IntegerConstantOperation = class extends NumericConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var FloatConstantOperation = class extends NumericConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var StringConstantOperation = class extends ConstantOperation {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  value;
+};
+var DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+var DateOnly = class extends Date {
+};
+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 NumericConstantOperation {
+  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 InOperation = class extends UnaryOperation {
+  constructor(element, values) {
+    super(element);
+    this.values = values;
+  }
+  values;
+};
+var NotInOperation = class extends UnaryOperation {
+  constructor(element, values) {
+    super(element);
+    this.values = values;
+  }
+  values;
+};
+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, separator, orderBy = []) {
+    super(element);
+    this.operator = operator;
+    this.displayName = displayName;
+    this.window = window;
+    this.separator = separator;
+    this.orderBy = orderBy;
+  }
+  operator;
+  displayName;
+  window;
+  separator;
+  orderBy;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  arithmeticOperand() {
+    return this;
+  }
+  comparisonOperand() {
+    return this;
+  }
+  over(partitionBy, orderBy) {
+    return new _AggregateOperation(
+      this.element,
+      this.operator,
+      this.displayName,
+      new WindowSpecification(partitionBy ?? [], orderBy ?? []),
+      this.separator,
+      this.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;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  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;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  /** This expression as an operand of a comparison. */
+  comparisonOperand() {
+    return this;
+  }
+  arithmeticOperand() {
+    return this;
+  }
+  /** Only a function that gives a number can be used in arithmetic. */
+  assertNumeric() {
+    if (!NUMERIC_FUNCTIONS.has(this.func)) {
+      throw new TypeError(`${this.func} does not give a number, so it cannot be used in arithmetic`);
+    }
+  }
+};
+var NUMERIC_FUNCTIONS = /* @__PURE__ */ new Set([
+  "ABS" /* ABS */,
+  "CEILING" /* CEILING */,
+  "FLOOR" /* FLOOR */,
+  "MOD" /* MOD */,
+  "POWER" /* POWER */,
+  "SQRT" /* SQRT */,
+  "ROUND" /* ROUND */,
+  "LENGTH" /* LENGTH */
+]);
+var DateExtractOperation = class extends UnaryOperation {
+  constructor(element, part, displayName) {
+    super(element);
+    this.part = part;
+    this.displayName = displayName;
+  }
+  part;
+  displayName;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+};
+var DateTruncOperation = class extends UnaryOperation {
+  constructor(element, part, displayName) {
+    super(element);
+    this.part = part;
+    this.displayName = displayName;
+  }
+  part;
+  displayName;
+  /** Sort by this expression, earliest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, latest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  comparisonOperand() {
+    return this;
+  }
+};
+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;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+};
+var DateDiffOperation = class extends UnaryOperation {
+  constructor(element, other, unit, displayName) {
+    super(element);
+    this.other = other;
+    this.unit = unit;
+    this.displayName = displayName;
+  }
+  other;
+  unit;
+  displayName;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+};
+var Column = class extends RelationalOperationElement {
+  constructor(name, type, owner, primaryKey = false, nullable = true) {
+    super();
+    this.name = name;
+    this.type = type;
+    this.owner = owner;
+    this.primaryKey = primaryKey;
+    this.nullable = nullable && !primaryKey;
+  }
+  name;
+  type;
+  owner;
+  primaryKey;
+  table;
+  /** Whether the column may hold NULL. As in Legend, a primary key is never null. */
+  nullable;
+};
+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;
+  /** Property-equality filters on the join target (property id -> value), set by a related finder given a filter. */
+  filterKwargs = {};
+  /** Maps property ids to [column, type, table] for `filterKwargs`. */
+  filterColumnMap = {};
+};
+var JoinTreeNodeOperation = class {
+  constructor(join, parent, many = false, optional = false) {
+    this.join = join;
+    this.parent = parent;
+    this.many = many;
+    this.optional = optional;
+  }
+  join;
+  parent;
+  many;
+  optional;
+};
+var ColumnWithJoin = class extends RelationalOperationElement {
+  /**
+   * `embedded` is an alternate reference to a flat (denormalized) column on the owning table that
+   * holds the same value without the join; the SQL generator uses it when the join can be elided.
+   */
+  constructor(column, parent, embedded, _optional = false) {
+    super();
+    this.column = column;
+    this.parent = parent;
+    this.embedded = embedded;
+    this._optional = _optional;
+  }
+  column;
+  parent;
+  embedded;
+  _optional;
+  /** Whether the value can be missing: its property is optional, or a navigation on the way to it is. */
+  get optional() {
+    for (let node = this.parent; node !== void 0; node = node.parent) {
+      if (node.optional) return true;
+    }
+    return this._optional;
+  }
+};
+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;
+  /** Name this column in the result. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  comparisonOperand() {
+    return this;
+  }
+};
+var Alias = class _Alias extends RelationalOperationElement {
+  constructor(element, name) {
+    super();
+    this.element = element;
+    this.name = name;
+  }
+  element;
+  name;
+  alias(name) {
+    return new _Alias(this.element, name);
+  }
+  /** Sorts by the column the alias names. */
+  ascending() {
+    return new SortOperation(this.element, "ASC" /* ASC */);
+  }
+  /** Sorts by the column the alias names. */
+  descending() {
+    return new SortOperation(this.element, "DESC" /* DESC */);
+  }
+};
+var CaseOperation = class extends Operation {
+  constructor(condition, then, fallback, displayName) {
+    super();
+    this.condition = condition;
+    this.then = then;
+    this.fallback = fallback;
+    this.displayName = displayName;
+  }
+  condition;
+  then;
+  fallback;
+  displayName;
+};
+var ExistsOperation = class extends RelationalOperationElement {
+  constructor(node) {
+    super();
+    this.node = node;
+  }
+  node;
+  /** Name this column in the result. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  and(other) {
+    return new LogicalOperation(this, "AND" /* AND */, other);
+  }
+  or(other) {
+    return new LogicalOperation(this, "OR" /* OR */, other);
+  }
+};
+var NotExistsOperation = class extends RelationalOperationElement {
+  constructor(node) {
+    super();
+    this.node = node;
+  }
+  node;
+  /** Name this column in the result. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  and(other) {
+    return new LogicalOperation(this, "AND" /* AND */, other);
+  }
+  or(other) {
+    return new LogicalOperation(this, "OR" /* OR */, other);
+  }
+};
+var SelectOperation = class {
+  constructor(display, filter, orderBy = [], groupBy = [], limit, table, joinFilters = /* @__PURE__ */ new Map(), distinct = false, offset, having) {
+    this.display = display;
+    this.filter = filter;
+    this.orderBy = orderBy;
+    this.groupBy = groupBy;
+    this.limit = limit;
+    this.table = table;
+    this.joinFilters = joinFilters;
+    this.distinct = distinct;
+    this.offset = offset;
+    this.having = having;
+  }
+  display;
+  filter;
+  orderBy;
+  groupBy;
+  limit;
+  table;
+  joinFilters;
+  distinct;
+  offset;
+  having;
+};
+function containsAggregateOrWindow(op) {
+  if (op instanceof AggregateOperation || op instanceof WindowFunctionOperation || op instanceof CountAllOperation) return true;
+  if (op instanceof BinaryOperation) return containsAggregateOrWindow(op.left) || containsAggregateOrWindow(op.right);
+  if (op instanceof UnaryOperation || op instanceof Alias) return containsAggregateOrWindow(op.element);
+  return false;
+}
+function containsAggregate(op) {
+  if (op instanceof AggregateOperation || op instanceof CountAllOperation) return true;
+  if (op instanceof BinaryOperation) return containsAggregate(op.left) || containsAggregate(op.right);
+  if (op instanceof UnaryOperation || op instanceof Alias) return containsAggregate(op.element);
+  return false;
+}
+function valueOperand(value) {
+  if (typeof value === "boolean") return new BooleanConstantOperation(value);
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Number.isInteger(value) ? new IntegerConstantOperation(value) : new FloatConstantOperation(value);
+  }
+  if (typeof value === "string") return new StringConstantOperation(value);
+  if (value instanceof DateOnly) return new DateConstantOperation(value);
+  if (value instanceof Date) return new DateTimeConstantOperation(value);
+  throw new TypeError(`A value to compare with is a boolean, a finite number, a string or a date, not ${value === null ? "null" : typeof value}`);
+}
+function operandOf(other) {
+  if (other instanceof RelationalOperationElement) return other;
+  if (typeof other?.cwj === "function") return other.cwj();
+  return valueOperand(other);
+}
+var Comparable = class {
+  _compared(operator, other) {
+    return new ComparisonOperation(this.comparisonOperand(), operator, operandOf(other));
+  }
+  /** Filter to rows where this expression equals `other`. */
+  eq(other) {
+    return this._compared("EQUAL" /* EQUAL */, other);
+  }
+  /** Filter to rows where this expression does not equal `other`. */
+  ne(other) {
+    return this._compared("NOT_EQUAL" /* NOT_EQUAL */, other);
+  }
+  /** Filter to rows where this expression is less than `other`. */
+  lt(other) {
+    return this._compared("LESS_THAN" /* LESS_THAN */, other);
+  }
+  /** Filter to rows where this expression is at most `other`. */
+  lte(other) {
+    return this._compared("LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, other);
+  }
+  /** Filter to rows where this expression is greater than `other`. */
+  gt(other) {
+    return this._compared("GREATER_THAN" /* GREATER_THAN */, other);
+  }
+  /** Filter to rows where this expression is at least `other`. */
+  gte(other) {
+    return this._compared("GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, other);
+  }
+};
+function sample(ddof) {
+  if (ddof !== 0 && ddof !== 1) throw new RangeError(`ddof is 0 (population) or 1 (sample), not ${ddof}`);
+  return ddof === 1;
+}
+var StringPredicates = class {
+  _like(pattern) {
+    return new ComparisonOperation(this.comparisonOperand(), "LIKE" /* LIKE */, new StringConstantOperation(pattern));
+  }
+  /** Filter to rows where this text contains `value`. */
+  contains(value) {
+    return this._like(`%${escapeLike(value)}%`);
+  }
+  /** Filter to rows where this text starts with `prefix`. */
+  startsWith(prefix) {
+    return this._like(`${escapeLike(prefix)}%`);
+  }
+  /** Filter to rows where this text ends with `suffix`. */
+  endsWith(suffix) {
+    return this._like(`%${escapeLike(suffix)}`);
+  }
+};
+var Aggregates = class {
+  _aggregate(operator, label) {
+    return new AggregateOperation(this, operator, label + " Expression");
+  }
+  /** Sum of the values in the group. */
+  sum() {
+    return this._aggregate("SUM" /* SUM */, "Sum");
+  }
+  /** Smallest value in the group. */
+  min() {
+    return this._aggregate("MIN" /* MIN */, "Min");
+  }
+  /** Largest value in the group. */
+  max() {
+    return this._aggregate("MAX" /* MAX */, "Max");
+  }
+  /** Arithmetic mean of the values in the group. */
+  average() {
+    return this._aggregate("AVERAGE" /* AVERAGE */, "Average");
+  }
+  /** Number of non-null values in the group. */
+  count() {
+    return this._aggregate("COUNT" /* COUNT */, "Count");
+  }
+  /** Standard deviation of the values in the group: the sample one by default, `ddof = 0` for the population one. */
+  std(ddof = 1) {
+    return this._aggregate(sample(ddof) ? "STDDEV_SAMP" /* STDDEV_SAMP */ : "STDDEV_POP" /* STDDEV_POP */, "Std");
+  }
+  /** Variance of the values in the group: the sample one by default, `ddof = 0` for the population one. */
+  var(ddof = 1) {
+    return this._aggregate(sample(ddof) ? "VAR_SAMP" /* VAR_SAMP */ : "VAR_POP" /* VAR_POP */, "Var");
+  }
+};
+var BooleanAggregates = class {
+  /** True for a group where every row satisfies the condition. */
+  all() {
+    return new AggregateOperation(this, "BOOL_AND" /* BOOL_AND */, "All Expression");
+  }
+  /** True for a group where at least one row satisfies the condition. */
+  any() {
+    return new AggregateOperation(this, "BOOL_OR" /* BOOL_OR */, "Any Expression");
+  }
+};
+function applyMixins(derived, bases) {
+  for (const base of bases) {
+    for (const name of Object.getOwnPropertyNames(base.prototype)) {
+      if (name === "constructor" || Object.prototype.hasOwnProperty.call(derived.prototype, name)) continue;
+      Object.defineProperty(derived.prototype, name, Object.getOwnPropertyDescriptor(base.prototype, name));
+    }
+  }
+}
+var ArithmeticOperator = /* @__PURE__ */ ((ArithmeticOperator2) => {
+  ArithmeticOperator2["ADD"] = "+";
+  ArithmeticOperator2["SUBTRACT"] = "-";
+  ArithmeticOperator2["MULTIPLY"] = "*";
+  ArithmeticOperator2["DIVIDE"] = "/";
+  return ArithmeticOperator2;
+})(ArithmeticOperator || {});
+var Arithmetic = class {
+  /** Raises if this expression is not a number. */
+  assertNumeric() {
+  }
+  _arithmetic(operator, other) {
+    this.assertNumeric();
+    let operand;
+    if (typeof other === "number") {
+      if (!Number.isFinite(other)) throw new TypeError("Arithmetic is between numbers and numeric columns, not a non-finite number");
+      operand = valueOperand(other);
+    } else if (other !== null && typeof other === "object" && typeof other.arithmeticOperand === "function") {
+      other.assertNumeric?.();
+      operand = other.arithmeticOperand();
+    } else {
+      throw new TypeError(`Arithmetic is between numbers and numeric columns, not ${other === null ? "null" : typeof other}`);
+    }
+    return new ArithmeticOperation(this.arithmeticOperand(), operator, operand);
+  }
+  /** `this + other`. */
+  plus(other) {
+    return this._arithmetic("+" /* ADD */, other);
+  }
+  /** `this - other`. */
+  minus(other) {
+    return this._arithmetic("-" /* SUBTRACT */, other);
+  }
+  /** `this * other`. */
+  times(other) {
+    return this._arithmetic("*" /* MULTIPLY */, other);
+  }
+  /** `this / other`. */
+  dividedBy(other) {
+    return this._arithmetic("/" /* DIVIDE */, other);
+  }
+};
+var ArithmeticOperation = class extends BinaryOperation {
+  constructor(left, operator, right, displayName) {
+    super(left, right);
+    this.operator = operator;
+    this.displayName = displayName;
+  }
+  operator;
+  displayName;
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  arithmeticOperand() {
+    return this;
+  }
+  comparisonOperand() {
+    return this;
+  }
+};
+var ConcatOperation = class extends Operation {
+  constructor(parts, displayName) {
+    super();
+    this.parts = parts;
+    this.displayName = displayName;
+  }
+  parts;
+  displayName;
+  /** Join more text on the end: `f.first().concat(' ', f.last())`. A concatenation joins into one. */
+  concat(...more) {
+    return concat(this, ...more);
+  }
+  /** Sort by this expression, smallest first. */
+  ascending() {
+    return new SortOperation(this, "ASC" /* ASC */);
+  }
+  /** Sort by this expression, largest first. */
+  descending() {
+    return new SortOperation(this, "DESC" /* DESC */);
+  }
+  comparisonOperand() {
+    return this;
+  }
+};
+function concat(...parts) {
+  const partsOf = (part) => {
+    if (part instanceof ConcatOperation) return part.parts;
+    if (typeof part === "string") return [new StringConstantOperation(part)];
+    if (part instanceof RelationalOperationElement) return [part];
+    if (part !== null && typeof part === "object" && typeof part.functionInput === "function") return [part.functionInput()];
+    throw new TypeError(`Text is joined with text, not ${part === null ? "null" : typeof part}`);
+  };
+  return new ConcatOperation(parts.flatMap(partsOf));
+}
+applyMixins(ConcatOperation, [Comparable, StringPredicates]);
+applyMixins(DateTruncOperation, [Comparable]);
+applyMixins(ArithmeticOperation, [Arithmetic, Comparable]);
+applyMixins(ScalarFunctionOperation, [Comparable, Arithmetic, StringPredicates]);
+applyMixins(AggregateOperation, [Arithmetic, Comparable, StringPredicates]);
+applyMixins(CountAllOperation, [Comparable]);
+applyMixins(NumericConstantOperation, [Arithmetic]);
+applyMixins(ConstantOperation, [Aggregates]);
+applyMixins(ArithmeticOperation, [Aggregates]);
+applyMixins(ScalarFunctionOperation, [Aggregates]);
+applyMixins(CaseOperation, [Aggregates]);
+applyMixins(IsNullOperation, [BooleanAggregates]);
+applyMixins(IsNotNullOperation, [BooleanAggregates]);
+applyMixins(InOperation, [BooleanAggregates]);
+applyMixins(NotInOperation, [BooleanAggregates]);
+applyMixins(ComparisonOperation, [BooleanAggregates]);
+applyMixins(LogicalOperation, [BooleanAggregates]);
+
+export {
+  ComparisonOperator,
+  LIKE_ESCAPE,
+  escapeLike,
+  LogicalOperator,
+  AggregateOperator,
+  ScalarFunction,
+  DatePart,
+  SortDirection,
+  RelationalOperationElement,
+  Operation,
+  NoOperation,
+  ConstantOperation,
+  NumericConstantOperation,
+  IntegerConstantOperation,
+  FloatConstantOperation,
+  StringConstantOperation,
+  DATE_ONLY_PATTERN,
+  DateOnly,
+  DateConstantOperation,
+  DateTimeConstantOperation,
+  DecimalConstantOperation,
+  BooleanConstantOperation,
+  UnaryOperation,
+  BinaryOperation,
+  IsNullOperation,
+  IsNotNullOperation,
+  InOperation,
+  NotInOperation,
+  ComparisonOperation,
+  LogicalOperation,
+  WindowSpecification,
+  AggregateOperation,
+  WindowFunction,
+  WindowFunctionOperation,
+  ScalarFunctionOperation,
+  NUMERIC_FUNCTIONS,
+  DateExtractOperation,
+  DateTruncOperation,
+  DateArithmeticOperation,
+  DateDiffOperation,
+  Column,
+  ForeignKey,
+  DataStore,
+  Database,
+  DataCatalog,
+  Schema,
+  Table,
+  JoinOperation,
+  JoinTreeNodeOperation,
+  ColumnWithJoin,
+  SortOperation,
+  CountAllOperation,
+  Alias,
+  CaseOperation,
+  ExistsOperation,
+  NotExistsOperation,
+  SelectOperation,
+  containsAggregateOrWindow,
+  containsAggregate,
+  valueOperand,
+  operandOf,
+  Comparable,
+  sample,
+  StringPredicates,
+  Aggregates,
+  BooleanAggregates,
+  applyMixins,
+  ArithmeticOperator,
+  Arithmetic,
+  ArithmeticOperation,
+  ConcatOperation,
+  concat
+};
+//# sourceMappingURL=chunk-PF6EJZHB.js.map