data-finder-ts 0.1.3 → 0.1.5

package/dist/datafinder/typed-attributes.cjs

@@ -33,23 +33,52 @@ __export(typed_attributes_exports, {
 module.exports = __toCommonJS(typed_attributes_exports);
 
 // src/model/relational.ts
+var LIKE_ESCAPE = "!";
+function escapeLike(value) {
+  return value.replaceAll(LIKE_ESCAPE, LIKE_ESCAPE + LIKE_ESCAPE).replaceAll("%", LIKE_ESCAPE + "%").replaceAll("_", LIKE_ESCAPE + "_");
+}
 var RelationalOperationElement = class {
 };
 var Operation = class extends RelationalOperationElement {
-  andOp(other) {
+  /** 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 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 IntegerConstantOperation = class extends ConstantOperation {
+var NumericConstantOperation = class extends ConstantOperation {
+  arithmeticOperand() {
+    return this;
+  }
+};
+var IntegerConstantOperation = class extends NumericConstantOperation {
   constructor(value) {
     super();
     this.value = value;
   }
   value;
 };
-var FloatConstantOperation = class extends ConstantOperation {
+var FloatConstantOperation = class extends NumericConstantOperation {
   constructor(value) {
     super();
     this.value = value;
@@ -63,6 +92,9 @@ var StringConstantOperation = class extends ConstantOperation {
   }
   value;
 };
+var DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+var DateOnly = class extends Date {
+};
 var DateConstantOperation = class extends ConstantOperation {
   constructor(value) {
     super();
@@ -77,7 +109,7 @@ var DateTimeConstantOperation = class extends ConstantOperation {
   }
   value;
 };
-var DecimalConstantOperation = class extends ConstantOperation {
+var DecimalConstantOperation = class extends NumericConstantOperation {
   constructor(value) {
     super();
     this.value = value;
@@ -111,6 +143,20 @@ 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);
@@ -134,21 +180,41 @@ var WindowSpecification = class {
   orderBy;
 };
 var AggregateOperation = class _AggregateOperation extends UnaryOperation {
-  constructor(element, operator, displayName, window) {
+  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 ?? [])
+      new WindowSpecification(partitionBy ?? [], orderBy ?? []),
+      this.separator,
+      this.orderBy
     );
   }
 };
@@ -166,6 +232,14 @@ var WindowFunctionOperation = class _WindowFunctionOperation extends UnaryOperat
   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,
@@ -189,7 +263,38 @@ var ScalarFunctionOperation = class extends UnaryOperation {
   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);
@@ -198,6 +303,34 @@ var DateExtractOperation = class extends UnaryOperation {
   }
   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) {
@@ -211,6 +344,14 @@ var DateArithmeticOperation = class extends UnaryOperation {
   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) {
@@ -222,29 +363,55 @@ var DateDiffOperation = class extends UnaryOperation {
   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) {
+  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 ColumnWithJoin = class extends RelationalOperationElement {
-  constructor(column, parent) {
+  /**
+   * `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) {
@@ -254,18 +421,302 @@ var SortOperation = class {
   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;
+};
+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 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]);
 
 // src/datafinder/attribute.ts
-var Attribute = class {
+var Attribute = class _Attribute {
   _displayName;
   _column;
   _owner;
   _parent;
-  constructor(displayName, columnName, columnDbType, owner, parent) {
+  _embedded;
+  _optional;
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    this._optional = optional;
     this._displayName = displayName;
-    this._column = new Column(columnName, columnDbType, owner);
+    this._column = new Column(columnName, columnDbType, owner, false, nullable);
     this._owner = owner;
     this._parent = parent;
+    this._embedded = embedded;
   }
   column() {
     return this._column;
@@ -279,33 +730,102 @@ var Attribute = class {
   displayName() {
     return this._displayName;
   }
+  /** Alternate attribute on a flat column of the owning table, used in place of this one when its join is elided. */
+  embedded() {
+    return this._embedded;
+  }
+  /** @internal The expression a function of this attribute applies to: its column. */
+  functionInput() {
+    return this.cwj();
+  }
+  /** @internal What a function of this attribute is labelled after: its display name. */
+  functionLabel() {
+    return this._displayName;
+  }
+  /** @internal This attribute as an operand of arithmetic: its column. */
+  arithmeticOperand() {
+    return this.cwj();
+  }
   cwj() {
-    return new ColumnWithJoin(this._column, this._parent);
+    return new ColumnWithJoin(this._column, this._parent, this._embedded?.cwj(), this._optional);
   }
+  /** Count the number of non-null values. Use in a projection with `groupBy` to aggregate per group. */
   count() {
     return new AggregateOperation(
-      new ColumnWithJoin(this._column, this._parent),
+      this.cwj(),
       "COUNT" /* COUNT */,
       this._displayName + " Count"
     );
   }
+  /** Name this column in the result: `f.price().sum().alias('Total')`. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  /** The number of different non-NULL values in the group: `COUNT(DISTINCT column)`. Use with `groupBy` to count per group. */
+  countDistinct() {
+    return new AggregateOperation(this.cwj(), "COUNT_DISTINCT" /* COUNT_DISTINCT */, this._displayName + " Count Distinct");
+  }
+  /** The value, or `defaultValue` when it is NULL: `name().orElse('N/A')`. Like `COALESCE` in SQL. */
+  orElse(defaultValue) {
+    if (!["string", "number", "boolean"].includes(typeof defaultValue)) {
+      throw new TypeError(`An orElse default is a string, number or boolean, not ${defaultValue === null ? "null" : typeof defaultValue}`);
+    }
+    return new ScalarFunctionOperation(this.cwj(), "COALESCE" /* COALESCE */, "Or Else " + this._displayName, void 0, [defaultValue]);
+  }
+  /** Sort this attribute in ascending order. Pass to `orderBy` or a window function's `orderBy`. */
   ascending() {
-    return new SortOperation(new ColumnWithJoin(this._column, this._parent), "ASC" /* ASC */);
+    return new SortOperation(this.cwj(), "ASC" /* ASC */);
   }
+  /** Sort this attribute in descending order. Pass to `orderBy` or a window function's `orderBy`. */
   descending() {
-    return new SortOperation(new ColumnWithJoin(this._column, this._parent), "DESC" /* DESC */);
+    return new SortOperation(this.cwj(), "DESC" /* DESC */);
   }
+  /** Filter to rows where this attribute has no value. */
   isNull() {
-    return new IsNullOperation(new ColumnWithJoin(this._column, this._parent));
+    return new IsNullOperation(this.cwj());
   }
+  /** Filter to rows where this attribute has a value. */
   isNotNull() {
-    return new IsNotNullOperation(new ColumnWithJoin(this._column, this._parent));
+    return new IsNotNullOperation(this.cwj());
+  }
+  /** Wrap a value as a constant of this attribute's type. Overridden by the typed attributes. */
+  toConstant(_value) {
+    throw new TypeError(`${this.constructor.name} does not support isIn / isNotIn`);
+  }
+  _constants(values) {
+    const constants = values.map((v) => this.toConstant(v));
+    if (constants.length === 0) throw new Error("isIn / isNotIn need at least one value");
+    return constants;
+  }
+  /** Filter to rows where this attribute equals any of `values`. */
+  isIn(values) {
+    return new InOperation(this.cwj(), this._constants(values));
+  }
+  /** Filter to rows where this attribute equals none of `values`. Rows with no value are excluded, as in SQL. */
+  isNotIn(values) {
+    return new NotInOperation(this.cwj(), this._constants(values));
   }
   _windowSpec(partitionBy, orderBy) {
-    const pb = partitionBy === void 0 ? [] : Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+    const pbArr = partitionBy === void 0 ? [] : Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+    const pb = pbArr.map((x) => x instanceof _Attribute ? x.cwj() : x);
     const ob = orderBy === void 0 ? [] : Array.isArray(orderBy) ? orderBy : [orderBy];
     return new WindowSpecification(pb, ob);
   }
+  /**
+   * Assign a rank to each row within the ordered window, following pandas `Series.rank` conventions.
+   *
+   * `method` controls tie-breaking (default `'min'`):
+   * - `'min'`   — tied rows share the lowest rank; the next rank skips.
+   * - `'dense'` — like `'min'` but ranks are contiguous (no gaps).
+   * - `'first'` — each row gets a unique sequential integer (no ties).
+   * - `'max'`   — only meaningful with `pct: true` (see below).
+   *
+   * When `pct: true` the result is a relative rank between 0 and 1:
+   * - `method: 'min'` (default) → fraction of values strictly below this row (PERCENT_RANK).
+   * - `method: 'max'` → fraction of values at or below this row (cumulative distribution).
+   *
+   * `partitionBy` restarts the ranking within each group of distinct values.
+   */
   rank(opts = {}) {
     const { method = "min", pct = false, partitionBy, orderBy } = opts;
     let func;
@@ -330,6 +850,11 @@ var Attribute = class {
     }
     return new WindowFunctionOperation(null, func, name, void 0, [], this._windowSpec(partitionBy, orderBy));
   }
+  /**
+   * Split rows into `buckets` equal-sized quantile bins ordered by `orderBy`.
+   * Each row receives a bucket number from 1 (lowest) to `buckets` (highest).
+   * Named after `pandas.qcut`.
+   */
   qcut(buckets, opts = {}) {
     return new WindowFunctionOperation(
       null,
@@ -340,12 +865,17 @@ var Attribute = class {
       this._windowSpec(opts.partitionBy, opts.orderBy)
     );
   }
+  /**
+   * Return the value of this attribute from `periods` rows earlier (positive) or later (negative)
+   * within the ordered window, following `pandas.Series.shift`.
+   * Rows with no neighbour at the given offset return `null` (or `fillValue` if provided).
+   */
   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),
+      this.cwj(),
       func,
       label + " " + this._displayName,
       Math.abs(periods),
@@ -353,9 +883,13 @@ var Attribute = class {
       this._windowSpec(opts.partitionBy, opts.orderBy)
     );
   }
+  /**
+   * Return the first value of this attribute in the window frame.
+   * Use `partitionBy` to restart the frame for each group.
+   */
   first(opts = {}) {
     return new WindowFunctionOperation(
-      new ColumnWithJoin(this._column, this._parent),
+      this.cwj(),
       "FIRST_VALUE" /* FIRST_VALUE */,
       "First " + this._displayName,
       void 0,
@@ -363,9 +897,13 @@ var Attribute = class {
       this._windowSpec(opts.partitionBy, opts.orderBy)
     );
   }
+  /**
+   * Return the last value of this attribute in the window frame.
+   * Use `partitionBy` to restart the frame for each group.
+   */
   last(opts = {}) {
     return new WindowFunctionOperation(
-      new ColumnWithJoin(this._column, this._parent),
+      this.cwj(),
       "LAST_VALUE" /* LAST_VALUE */,
       "Last " + this._displayName,
       void 0,
@@ -375,185 +913,311 @@ var Attribute = class {
   }
 };
 
-// src/datafinder/typed-attributes.ts
-var StringAttribute = class extends Attribute {
-  constructor(displayName, columnName, columnDbType, owner, parent) {
-    super(displayName, columnName, columnDbType, owner, parent);
+// src/datafinder/scalar-functions.ts
+var StringFunctionOperation = class extends ScalarFunctionOperation {
+  functionInput() {
+    return this;
+  }
+  functionLabel() {
+    return labelOf(this);
   }
-  upper() {
-    return new ScalarFunctionOperation(this.cwj(), "UPPER" /* UPPER */, "Upper " + this.displayName());
+};
+var NumericFunctionOperation = class extends ScalarFunctionOperation {
+  functionInput() {
+    return this;
   }
-  lower() {
-    return new ScalarFunctionOperation(this.cwj(), "LOWER" /* LOWER */, "Lower " + this.displayName());
+  functionLabel() {
+    return labelOf(this);
   }
-  strip() {
-    return new ScalarFunctionOperation(this.cwj(), "TRIM" /* TRIM */, "Strip " + this.displayName());
+};
+function labelOf(operation) {
+  return operation.displayName ?? operation.func.charAt(0) + operation.func.slice(1).toLowerCase();
+}
+function stringFunction(element, func, label, secondArg, extraArgs = []) {
+  return new StringFunctionOperation(element, func, label, secondArg, extraArgs);
+}
+function numberFunction(element, func, label, secondArg) {
+  return new NumericFunctionOperation(element, func, label, secondArg);
+}
+var StringFunctions = class {
+  /** Join text on the end: `f.first().concat(' ', f.last())`. A NULL part makes the whole NULL. */
+  concat(...more) {
+    return concat(this, ...more);
   }
-  lstrip() {
-    return new ScalarFunctionOperation(this.cwj(), "LTRIM" /* LTRIM */, "LStrip " + this.displayName());
+  /** Convert every character to uppercase. */
+  toUpperCase() {
+    return stringFunction(this.functionInput(), "UPPER" /* UPPER */, "Upper " + this.functionLabel());
   }
-  rstrip() {
-    return new ScalarFunctionOperation(this.cwj(), "RTRIM" /* RTRIM */, "RStrip " + this.displayName());
+  /** Convert every character to lowercase. */
+  toLowerCase() {
+    return stringFunction(this.functionInput(), "LOWER" /* LOWER */, "Lower " + this.functionLabel());
   }
+  /** Remove leading and trailing whitespace. */
+  trim() {
+    return stringFunction(this.functionInput(), "TRIM" /* TRIM */, "Trim " + this.functionLabel());
+  }
+  /** Remove leading whitespace. */
+  trimStart() {
+    return stringFunction(this.functionInput(), "LTRIM" /* LTRIM */, "Trim Start " + this.functionLabel());
+  }
+  /** Remove trailing whitespace. */
+  trimEnd() {
+    return stringFunction(this.functionInput(), "RTRIM" /* RTRIM */, "Trim End " + this.functionLabel());
+  }
+  /** Return the number of characters in the string. */
   length() {
-    return new ScalarFunctionOperation(this.cwj(), "LENGTH" /* LENGTH */, "Length " + this.displayName());
+    return numberFunction(this.functionInput(), "LENGTH" /* LENGTH */, "Length " + this.functionLabel());
   }
+  /** Return the string with characters in reverse order. */
   reverse() {
-    return new ScalarFunctionOperation(this.cwj(), "REVERSE" /* REVERSE */, "Reverse " + this.displayName());
+    return stringFunction(this.functionInput(), "REVERSE" /* REVERSE */, "Reverse " + this.functionLabel());
   }
+  /** Return the first `n` characters. */
   left(n) {
-    return new ScalarFunctionOperation(this.cwj(), "LEFT" /* LEFT */, "Left " + this.displayName(), n);
+    return stringFunction(this.functionInput(), "LEFT" /* LEFT */, "Left " + this.functionLabel(), n);
   }
+  /** Return the last `n` characters. */
   right(n) {
-    return new ScalarFunctionOperation(this.cwj(), "RIGHT" /* RIGHT */, "Right " + this.displayName(), n);
+    return stringFunction(this.functionInput(), "RIGHT" /* RIGHT */, "Right " + this.functionLabel(), n);
   }
+  /** Return the string repeated `n` times. */
   repeat(n) {
-    return new ScalarFunctionOperation(this.cwj(), "REPEAT" /* REPEAT */, "Repeat " + this.displayName(), n);
+    return stringFunction(this.functionInput(), "REPEAT" /* REPEAT */, "Repeat " + this.functionLabel(), n);
   }
+  /** Replace all occurrences of `fromStr` with `toStr`. */
   replace(fromStr, toStr) {
-    return new ScalarFunctionOperation(this.cwj(), "REPLACE" /* REPLACE */, "Replace " + this.displayName(), void 0, [fromStr, toStr]);
+    return stringFunction(this.functionInput(), "REPLACE" /* REPLACE */, "Replace " + this.functionLabel(), void 0, [fromStr, toStr]);
   }
+  /**
+   * Extract a portion of the string.
+   * `start` is zero-based (following Python convention); `length` is optional.
+   */
   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);
+    return stringFunction(this.functionInput(), "SUBSTRING" /* SUBSTRING */, "Substring " + this.functionLabel(), void 0, args);
+  }
+};
+var NumericFunctions = class {
+  /** Absolute value (distance from zero, always non-negative). */
+  abs() {
+    return numberFunction(this.functionInput(), "ABS" /* ABS */, "Abs " + this.functionLabel());
+  }
+  /** Round up to the nearest integer. */
+  ceil() {
+    return numberFunction(this.functionInput(), "CEILING" /* CEILING */, "Ceil " + this.functionLabel());
+  }
+  /** Round down to the nearest integer. */
+  floor() {
+    return numberFunction(this.functionInput(), "FLOOR" /* FLOOR */, "Floor " + this.functionLabel());
+  }
+  /** Square root. */
+  sqrt() {
+    return numberFunction(this.functionInput(), "SQRT" /* SQRT */, "Sqrt " + this.functionLabel());
+  }
+  /** Remainder after dividing by `n`. */
+  mod(n) {
+    return numberFunction(this.functionInput(), "MOD" /* MOD */, "Mod " + this.functionLabel(), n);
+  }
+  /** Raise to the power of `n`. */
+  power(n) {
+    return numberFunction(this.functionInput(), "POWER" /* POWER */, "Power " + this.functionLabel(), n);
   }
+  /** Round to `d` decimal places, or to the nearest integer when `d` is omitted. */
+  round(d) {
+    return numberFunction(this.functionInput(), "ROUND" /* ROUND */, "Round " + this.functionLabel(), d);
+  }
+};
+applyMixins(StringFunctionOperation, [StringFunctions]);
+applyMixins(NumericFunctionOperation, [NumericFunctions]);
+
+// src/datafinder/typed-attributes.ts
+var MinMax = class {
+  /** Smallest value in the group. */
+  min() {
+    return new AggregateOperation(this.cwj(), "MIN" /* MIN */, "Min " + this.displayName());
+  }
+  /** Largest value in the group. */
+  max() {
+    return new AggregateOperation(this.cwj(), "MAX" /* MAX */, "Max " + this.displayName());
+  }
+};
+var StringAttribute = class extends Attribute {
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
+  }
+  toConstant(value) {
+    return new StringConstantOperation(String(value));
+  }
+  /**
+   * Join the values of a group into one text with `separator` between them. `orderBy` is the order they are
+   * joined in (`[f.name().ascending()]`); without it the order is not defined. Missing values are skipped.
+   */
+  join(separator = "", orderBy = []) {
+    return new AggregateOperation(this.cwj(), "STRING_AGG" /* STRING_AGG */, "Join " + this.displayName(), void 0, separator, orderBy);
+  }
+  /** Filter to rows where this attribute equals `value`. */
   eq(value) {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new StringConstantOperation(value));
   }
+  /** Filter to rows where this attribute does not equal `value`. */
   ne(value) {
     return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new StringConstantOperation(value));
   }
+  /** Filter to rows where this attribute contains `value` as a substring. */
   contains(value) {
-    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${value}%`));
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${escapeLike(value)}%`));
   }
+  /** Filter to rows where this attribute begins with `prefix`. */
   startsWith(prefix) {
-    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`${prefix}%`));
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`${escapeLike(prefix)}%`));
   }
+  /** Filter to rows where this attribute ends with `suffix`. */
   endsWith(suffix) {
-    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${suffix}`));
+    return new ComparisonOperation(this.cwj(), "LIKE" /* LIKE */, new StringConstantOperation(`%${escapeLike(suffix)}`));
   }
+  /** Filter to rows where this attribute does not contain `value` as a substring. */
   notContains(value) {
-    return new ComparisonOperation(this.cwj(), "NOT_LIKE" /* NOT_LIKE */, new StringConstantOperation(`%${value}%`));
+    return new ComparisonOperation(this.cwj(), "NOT_LIKE" /* NOT_LIKE */, new StringConstantOperation(`%${escapeLike(value)}%`));
   }
 };
+applyMixins(StringAttribute, [MinMax, StringFunctions]);
 var NumericAttribute = class extends Attribute {
-  constructor(displayName, columnName, columnDbType, owner, parent) {
-    super(displayName, columnName, columnDbType, owner, parent);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
   }
+  /** Sum of all values in the group. */
   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");
+    return new AggregateOperation(this.cwj(), "SUM" /* SUM */, "Sum " + this.displayName());
   }
+  /** Arithmetic mean of all values in the group. */
   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());
+    return new AggregateOperation(this.cwj(), "AVERAGE" /* AVERAGE */, "Average " + this.displayName());
   }
-  floor() {
-    return new ScalarFunctionOperation(this.cwj(), "FLOOR" /* FLOOR */, "Floor " + this.displayName());
+  /** Standard deviation of the values in the group: the sample one by default, `ddof = 0` for the population one, as `Series.std`. */
+  std(ddof = 1) {
+    const operator = sample(ddof) ? "STDDEV_SAMP" /* STDDEV_SAMP */ : "STDDEV_POP" /* STDDEV_POP */;
+    return new AggregateOperation(this.cwj(), operator, "Std " + 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);
+  /** Variance of the values in the group: the sample one by default, `ddof = 0` for the population one, as `Series.var`. */
+  var(ddof = 1) {
+    const operator = sample(ddof) ? "VAR_SAMP" /* VAR_SAMP */ : "VAR_POP" /* VAR_POP */;
+    return new AggregateOperation(this.cwj(), operator, "Var " + this.displayName());
   }
 };
+applyMixins(NumericAttribute, [MinMax, NumericFunctions, Arithmetic]);
 var DoubleAttribute = class extends NumericAttribute {
-  constructor(displayName, columnName, columnDbType, owner, parent) {
-    super(displayName, columnName, columnDbType, owner, parent);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
   }
+  toConstant(value) {
+    return new FloatConstantOperation(Number(value));
+  }
+  /** Filter to rows where this attribute equals `value`. */
   eq(value) {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new FloatConstantOperation(value));
   }
+  /** Filter to rows where this attribute does not equal `value`. */
   ne(value) {
     return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new FloatConstantOperation(value));
   }
+  /** Filter to rows where this attribute is greater than `value`. */
   gt(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new FloatConstantOperation(value));
   }
+  /** Filter to rows where this attribute is less than `value`. */
   lt(value) {
     return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new FloatConstantOperation(value));
   }
+  /** Filter to rows where this attribute is greater than or equal to `value`. */
   gte(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new FloatConstantOperation(value));
   }
+  /** Filter to rows where this attribute is less than or equal to `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);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
+  }
+  toConstant(value) {
+    return new DecimalConstantOperation(Number(value));
   }
+  /** Filter to rows where this attribute equals `value`. */
   eq(value) {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DecimalConstantOperation(value));
   }
+  /** Filter to rows where this attribute does not equal `value`. */
   ne(value) {
     return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DecimalConstantOperation(value));
   }
+  /** Filter to rows where this attribute is greater than `value`. */
   gt(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DecimalConstantOperation(value));
   }
+  /** Filter to rows where this attribute is less than `value`. */
   lt(value) {
     return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DecimalConstantOperation(value));
   }
+  /** Filter to rows where this attribute is greater than or equal to `value`. */
   gte(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DecimalConstantOperation(value));
   }
+  /** Filter to rows where this attribute is less than or equal to `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);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
   }
+  toConstant(value) {
+    return new IntegerConstantOperation(Number(value));
+  }
+  /** Filter to rows where this attribute equals `value`. */
   eq(value) {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new IntegerConstantOperation(value));
   }
+  /** Filter to rows where this attribute does not equal `value`. */
   ne(value) {
     return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new IntegerConstantOperation(value));
   }
+  /** Filter to rows where this attribute is greater than `value`. */
   gt(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new IntegerConstantOperation(value));
   }
+  /** Filter to rows where this attribute is less than `value`. */
   lt(value) {
     return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new IntegerConstantOperation(value));
   }
+  /** Filter to rows where this attribute is greater than or equal to `value`. */
   gte(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new IntegerConstantOperation(value));
   }
+  /** Filter to rows where this attribute is less than or equal to `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);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
+  }
+  toConstant(value) {
+    return new BooleanConstantOperation(Boolean(value));
   }
+  /** Filter to rows where this attribute equals `value`. */
   eq(value) {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(value));
   }
+  /** Filter to rows where this attribute is true. */
   isTrue() {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(true));
   }
+  /** Filter to rows where this attribute is false. */
   isFalse() {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new BooleanConstantOperation(false));
   }
@@ -564,178 +1228,277 @@ function parseDate(value) {
   if (isNaN(d.getTime())) throw new Error(`Cannot parse date: ${value}`);
   return d;
 }
+function temporalConstant(value) {
+  if (typeof value === "string" && DATE_ONLY_PATTERN.test(value)) return new DateConstantOperation(new DateOnly(value));
+  const date = parseDate(value);
+  return date instanceof DateOnly ? new DateConstantOperation(date) : new DateTimeConstantOperation(date);
+}
 var DateAttribute = class extends Attribute {
-  constructor(displayName, columnName, columnDbType, owner, parent) {
-    super(displayName, columnName, columnDbType, owner, parent);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
+  }
+  toConstant(value) {
+    return new DateConstantOperation(parseDate(value));
   }
+  /** Filter to rows where this date equals `value`. */
   eq(value) {
     return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DateConstantOperation(parseDate(value)));
   }
+  /** Filter to rows where this date does not equal `value`. */
   ne(value) {
     return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DateConstantOperation(parseDate(value)));
   }
+  /** Filter to rows where this date is after `value`. */
   gt(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DateConstantOperation(parseDate(value)));
   }
+  /** Filter to rows where this date is before `value`. */
   lt(value) {
     return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DateConstantOperation(parseDate(value)));
   }
+  /** Filter to rows where this date is on or after `value`. */
   gte(value) {
     return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DateConstantOperation(parseDate(value)));
   }
+  /** Filter to rows where this date is on or before `value`. */
   lte(value) {
     return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DateConstantOperation(parseDate(value)));
   }
+  /** Extract the four-digit calendar year. */
   year() {
     return new DateExtractOperation(this.cwj(), "YEAR" /* YEAR */, "Year " + this.displayName());
   }
+  /** Extract the month number (1–12). */
   month() {
     return new DateExtractOperation(this.cwj(), "MONTH" /* MONTH */, "Month " + this.displayName());
   }
+  /** Extract the day of the month (1–31). */
   day() {
     return new DateExtractOperation(this.cwj(), "DAY" /* DAY */, "Day " + this.displayName());
   }
+  /** Extract the quarter (1–4). */
   quarter() {
     return new DateExtractOperation(this.cwj(), "QUARTER" /* QUARTER */, "Quarter " + this.displayName());
   }
+  /** Extract the ISO week number (1–53). */
   week() {
     return new DateExtractOperation(this.cwj(), "WEEK" /* WEEK */, "Week " + this.displayName());
   }
+  /** Extract the day of the week (0 = Sunday through 6 = Saturday). */
   dayOfWeek() {
     return new DateExtractOperation(this.cwj(), "DOW" /* DOW */, "Day Of Week " + this.displayName());
   }
+  /** The date of the first day of the week the date falls in (a Monday). */
+  firstDayOfWeek() {
+    return new DateTruncOperation(this.cwj(), "WEEK" /* WEEK */, "First Day Of Week " + this.displayName());
+  }
+  /** The date of the first day of the month the date falls in. */
+  firstDayOfMonth() {
+    return new DateTruncOperation(this.cwj(), "MONTH" /* MONTH */, "First Day Of Month " + this.displayName());
+  }
+  /** The date of the first day of the quarter the date falls in. */
+  firstDayOfQuarter() {
+    return new DateTruncOperation(this.cwj(), "QUARTER" /* QUARTER */, "First Day Of Quarter " + this.displayName());
+  }
+  /** The date of the first day of the year the date falls in. */
+  firstDayOfYear() {
+    return new DateTruncOperation(this.cwj(), "YEAR" /* YEAR */, "First Day Of Year " + this.displayName());
+  }
+  /** Add `n` days to this date. */
   addDays(n) {
     return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, true, "Add Days " + this.displayName());
   }
+  /** Add `n` months to this date. */
   addMonths(n) {
     return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, true, "Add Months " + this.displayName());
   }
+  /** Add `n` years to this date. */
   addYears(n) {
     return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, true, "Add Years " + this.displayName());
   }
+  /** Subtract `n` days from this date. */
   subtractDays(n) {
     return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, false, "Subtract Days " + this.displayName());
   }
+  /** Subtract `n` months from this date. */
   subtractMonths(n) {
     return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, false, "Subtract Months " + this.displayName());
   }
+  /** Subtract `n` years from this date. */
   subtractYears(n) {
     return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, false, "Subtract Years " + this.displayName());
   }
+  /** Number of whole days between this date and `other`. */
   diffDays(other) {
     return new DateDiffOperation(this.cwj(), other, "DAY" /* DAY */, "Diff Days " + this.displayName());
   }
+  /** Number of whole months between this date and `other`. */
   diffMonths(other) {
     return new DateDiffOperation(this.cwj(), other, "MONTH" /* MONTH */, "Diff Months " + this.displayName());
   }
+  /** Number of whole years between this date and `other`. */
   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);
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    super(displayName, columnName, columnDbType, owner, parent, embedded, nullable, optional);
   }
+  toConstant(value) {
+    return temporalConstant(value);
+  }
+  /** Filter to rows where this timestamp equals `value`. */
   eq(value) {
-    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, new DateTimeConstantOperation(parseDate(value)));
+    return new ComparisonOperation(this.cwj(), "EQUAL" /* EQUAL */, temporalConstant(value));
   }
+  /** Filter to rows where this timestamp does not equal `value`. */
   ne(value) {
-    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, new DateTimeConstantOperation(parseDate(value)));
+    return new ComparisonOperation(this.cwj(), "NOT_EQUAL" /* NOT_EQUAL */, temporalConstant(value));
   }
+  /** Filter to rows where this timestamp is after `value`. */
   gt(value) {
-    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, new DateTimeConstantOperation(parseDate(value)));
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN" /* GREATER_THAN */, temporalConstant(value));
   }
+  /** Filter to rows where this timestamp is before `value`. */
   lt(value) {
-    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, new DateTimeConstantOperation(parseDate(value)));
+    return new ComparisonOperation(this.cwj(), "LESS_THAN" /* LESS_THAN */, temporalConstant(value));
   }
+  /** Filter to rows where this timestamp is on or after `value`. */
   gte(value) {
-    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, new DateTimeConstantOperation(parseDate(value)));
+    return new ComparisonOperation(this.cwj(), "GREATER_THAN_OR_EQUAL_TO" /* GREATER_THAN_OR_EQUAL_TO */, temporalConstant(value));
   }
+  /** Filter to rows where this timestamp is on or before `value`. */
   lte(value) {
-    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, new DateTimeConstantOperation(parseDate(value)));
+    return new ComparisonOperation(this.cwj(), "LESS_THAN_OR_EQUAL_TO" /* LESS_THAN_OR_EQUAL_TO */, temporalConstant(value));
   }
+  /** Extract the four-digit calendar year. */
   year() {
     return new DateExtractOperation(this.cwj(), "YEAR" /* YEAR */, "Year " + this.displayName());
   }
+  /** Extract the month number (1–12). */
   month() {
     return new DateExtractOperation(this.cwj(), "MONTH" /* MONTH */, "Month " + this.displayName());
   }
+  /** Extract the day of the month (1–31). */
   day() {
     return new DateExtractOperation(this.cwj(), "DAY" /* DAY */, "Day " + this.displayName());
   }
+  /** Extract the hour (0–23). */
   hour() {
     return new DateExtractOperation(this.cwj(), "HOUR" /* HOUR */, "Hour " + this.displayName());
   }
+  /** Extract the minute (0–59). */
   minute() {
     return new DateExtractOperation(this.cwj(), "MINUTE" /* MINUTE */, "Minute " + this.displayName());
   }
+  /** Extract the second (0–59). */
   second() {
     return new DateExtractOperation(this.cwj(), "SECOND" /* SECOND */, "Second " + this.displayName());
   }
+  /** Extract the quarter (1–4). */
   quarter() {
     return new DateExtractOperation(this.cwj(), "QUARTER" /* QUARTER */, "Quarter " + this.displayName());
   }
+  /** Extract the ISO week number (1–53). */
   week() {
     return new DateExtractOperation(this.cwj(), "WEEK" /* WEEK */, "Week " + this.displayName());
   }
+  /** Extract the day of the week (0 = Sunday through 6 = Saturday). */
   dayOfWeek() {
     return new DateExtractOperation(this.cwj(), "DOW" /* DOW */, "Day Of Week " + this.displayName());
   }
+  /** The date of the first day of the week the date falls in (a Monday). */
+  firstDayOfWeek() {
+    return new DateTruncOperation(this.cwj(), "WEEK" /* WEEK */, "First Day Of Week " + this.displayName());
+  }
+  /** The date of the first day of the month the date falls in. */
+  firstDayOfMonth() {
+    return new DateTruncOperation(this.cwj(), "MONTH" /* MONTH */, "First Day Of Month " + this.displayName());
+  }
+  /** The date of the first day of the quarter the date falls in. */
+  firstDayOfQuarter() {
+    return new DateTruncOperation(this.cwj(), "QUARTER" /* QUARTER */, "First Day Of Quarter " + this.displayName());
+  }
+  /** The date of the first day of the year the date falls in. */
+  firstDayOfYear() {
+    return new DateTruncOperation(this.cwj(), "YEAR" /* YEAR */, "First Day Of Year " + this.displayName());
+  }
+  /** Add `n` days to this timestamp. */
   addDays(n) {
     return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, true, "Add Days " + this.displayName());
   }
+  /** Add `n` months to this timestamp. */
   addMonths(n) {
     return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, true, "Add Months " + this.displayName());
   }
+  /** Add `n` years to this timestamp. */
   addYears(n) {
     return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, true, "Add Years " + this.displayName());
   }
+  /** Add `n` hours to this timestamp. */
   addHours(n) {
     return new DateArithmeticOperation(this.cwj(), n, "HOUR" /* HOUR */, true, "Add Hours " + this.displayName());
   }
+  /** Add `n` minutes to this timestamp. */
   addMinutes(n) {
     return new DateArithmeticOperation(this.cwj(), n, "MINUTE" /* MINUTE */, true, "Add Minutes " + this.displayName());
   }
+  /** Add `n` seconds to this timestamp. */
   addSeconds(n) {
     return new DateArithmeticOperation(this.cwj(), n, "SECOND" /* SECOND */, true, "Add Seconds " + this.displayName());
   }
+  /** Subtract `n` days from this timestamp. */
   subtractDays(n) {
     return new DateArithmeticOperation(this.cwj(), n, "DAY" /* DAY */, false, "Subtract Days " + this.displayName());
   }
+  /** Subtract `n` months from this timestamp. */
   subtractMonths(n) {
     return new DateArithmeticOperation(this.cwj(), n, "MONTH" /* MONTH */, false, "Subtract Months " + this.displayName());
   }
+  /** Subtract `n` years from this timestamp. */
   subtractYears(n) {
     return new DateArithmeticOperation(this.cwj(), n, "YEAR" /* YEAR */, false, "Subtract Years " + this.displayName());
   }
+  /** Subtract `n` hours from this timestamp. */
   subtractHours(n) {
     return new DateArithmeticOperation(this.cwj(), n, "HOUR" /* HOUR */, false, "Subtract Hours " + this.displayName());
   }
+  /** Subtract `n` minutes from this timestamp. */
   subtractMinutes(n) {
     return new DateArithmeticOperation(this.cwj(), n, "MINUTE" /* MINUTE */, false, "Subtract Minutes " + this.displayName());
   }
+  /** Subtract `n` seconds from this timestamp. */
   subtractSeconds(n) {
     return new DateArithmeticOperation(this.cwj(), n, "SECOND" /* SECOND */, false, "Subtract Seconds " + this.displayName());
   }
+  /** Number of whole days between this timestamp and `other`. */
   diffDays(other) {
     return new DateDiffOperation(this.cwj(), other, "DAY" /* DAY */, "Diff Days " + this.displayName());
   }
+  /** Number of whole months between this timestamp and `other`. */
   diffMonths(other) {
     return new DateDiffOperation(this.cwj(), other, "MONTH" /* MONTH */, "Diff Months " + this.displayName());
   }
+  /** Number of whole years between this timestamp and `other`. */
   diffYears(other) {
     return new DateDiffOperation(this.cwj(), other, "YEAR" /* YEAR */, "Diff Years " + this.displayName());
   }
+  /** Number of whole hours between this timestamp and `other`. */
   diffHours(other) {
     return new DateDiffOperation(this.cwj(), other, "HOUR" /* HOUR */, "Diff Hours " + this.displayName());
   }
+  /** Number of whole minutes between this timestamp and `other`. */
   diffMinutes(other) {
     return new DateDiffOperation(this.cwj(), other, "MINUTE" /* MINUTE */, "Diff Minutes " + this.displayName());
   }
+  /** Number of whole seconds between this timestamp and `other`. */
   diffSeconds(other) {
     return new DateDiffOperation(this.cwj(), other, "SECOND" /* SECOND */, "Diff Seconds " + this.displayName());
   }
 };
+applyMixins(DateAttribute, [MinMax]);
+applyMixins(DateTimeAttribute, [MinMax]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BooleanAttribute,