pqb 0.51.6 → 0.52.1

package/dist/index.js

@@ -1274,1507 +1274,1519 @@ const Operators = {
   array
 };
 
-class TextBaseColumn extends ColumnType {
-  constructor(schema, schemaType = schema.stringSchema()) {
-    super(schema, schemaType);
-    this.operators = Operators.text;
-  }
-}
-class LimitedTextBaseColumn extends TextBaseColumn {
-  constructor(schema, limit) {
+const dateTimeEncode = (input) => {
+  return typeof input === "number" ? new Date(input) : input;
+};
+class DateBaseColumn extends ColumnType {
+  constructor(schema) {
     super(
       schema,
-      limit !== void 0 ? schema.stringMax(limit) : schema.stringSchema()
-    );
-    this.data.maxChars = limit;
-  }
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.maxChars !== void 0 && `(${this.data.maxChars})`
+      schema.stringNumberDate(),
+      schema.stringSchema(),
+      schema.stringNumberDate()
     );
+    this.operators = Operators.date;
+    this.asNumber = schema.dateAsNumber;
+    this.asDate = schema.dateAsDate;
+    this.data.encode = dateTimeEncode;
   }
 }
-class VarCharColumn extends LimitedTextBaseColumn {
+class DateColumn extends DateBaseColumn {
   constructor() {
     super(...arguments);
-    this.dataType = "varchar";
+    this.dataType = "date";
   }
   toCode(ctx, key) {
-    const { maxChars } = this.data;
     return columnCode(
       this,
       ctx,
       key,
-      `varchar(${maxChars ?? ""})${orchidCore.stringDataToCode(this.data, ctx.migration)}`
+      `date()${orchidCore.dateDataToCode(this.data, ctx.migration)}`
     );
   }
 }
-class StringColumn extends VarCharColumn {
-  constructor(schema, limit = 255) {
-    super(schema, limit);
+class DateTimeBaseClass extends DateBaseColumn {
+  constructor(schema, dateTimePrecision) {
+    super(schema);
+    this.data.dateTimePrecision = dateTimePrecision;
   }
-  toCode(ctx, key) {
-    let max = this.data.maxChars;
-    if (max === 255) max = void 0;
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`
+    );
+  }
+}
+class DateTimeTzBaseClass extends DateTimeBaseClass {
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.baseDataType,
+      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`,
+      " with time zone"
+    );
+  }
+}
+const timestampToCode = (self, ctx, key) => {
+  const { dateTimePrecision: p } = self.data;
+  const { defaultTimestamp } = self.data;
+  if (defaultTimestamp) {
+    const noTz = self instanceof TimestampColumn ? "NoTZ" : "";
+    const def = self.data.default;
+    const modifyQuery = self.data.modifyQuery;
+    self.data.default = void 0;
+    self.data.modifyQuery = void 0;
+    const code = columnCode(
+      self,
+      ctx,
+      key,
+      `timestamps${noTz}(${p && p !== 6 ? p : ""}).${defaultTimestamp}${orchidCore.dateDataToCode(self.data, ctx.migration)}`
+    );
+    self.data.default = def;
+    self.data.modifyQuery = modifyQuery;
+    return code;
+  } else {
     return columnCode(
-      this,
+      self,
       ctx,
       key,
-      `string(${max ?? ""})${orchidCore.stringDataToCode(this.data, ctx.migration)}`
+      `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data, ctx.migration)}`
     );
   }
-}
-const textColumnToCode = (column, ctx, key) => {
-  const data = { ...column.data };
-  let args = "";
-  const hasMax = data.maxArg !== void 0 && data.max === data.maxArg;
-  if (data.minArg !== void 0 && data.min === data.minArg || hasMax) {
-    if (data.minArg !== 0 || hasMax && data.max !== Infinity) {
-      args += data.minArg;
-    }
-    delete data.min;
-    if (hasMax) {
-      if (data.maxArg !== Infinity) {
-        args += `, ${data.maxArg}`;
-      }
-      delete data.max;
-    }
-  }
-  return columnCode(
-    column,
-    ctx,
-    key,
-    `${column.dataType}(${args})${orchidCore.stringDataToCode(data, ctx.migration)}`
-  );
 };
-class TextColumn extends TextBaseColumn {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "text";
-  }
-  toCode(ctx, key) {
-    return textColumnToCode(this, ctx, key);
-  }
-}
-const byteaParse = (val) => typeof val === "string" ? Buffer.from(val.slice(2), "hex") : val;
-class ByteaColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.buffer());
-    this.dataType = "bytea";
-    this.operators = Operators.text;
-    setColumnDefaultParse(this, byteaParse);
+class TimestampColumn extends DateTimeBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "timestamp";
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `bytea()`);
+    return timestampToCode(this, ctx, key);
   }
 }
-class PointColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "point";
-    this.operators = Operators.text;
+class TimestampTZColumn extends DateTimeTzBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "timestamptz";
+    this.baseDataType = "timestamp";
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `point()`);
+    return timestampToCode(this, ctx, key);
   }
 }
-class LineColumn extends ColumnType {
-  constructor(schema) {
+class TimeColumn extends ColumnType {
+  constructor(schema, dateTimePrecision) {
     super(schema, schema.stringSchema());
-    this.dataType = "line";
-    this.operators = Operators.text;
+    this.dataType = "time";
+    this.operators = Operators.time;
+    this.data.dateTimePrecision = dateTimePrecision;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `line()`);
+    const { dateTimePrecision } = this.data;
+    return columnCode(
+      this,
+      ctx,
+      key,
+      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(
+        this.data,
+        ctx.migration
+      )}`
+    );
   }
 }
-class LsegColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "lseg";
-    this.operators = Operators.text;
+class IntervalColumn extends ColumnType {
+  constructor(schema, fields, precision) {
+    super(schema, schema.timeInterval());
+    this.dataType = "interval";
+    this.operators = Operators.date;
+    this.data.fields = fields;
+    this.data.precision = precision;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `lseg()`);
-  }
-}
-class BoxColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "box";
-    this.operators = Operators.text;
+    const { fields, precision } = this.data;
+    return columnCode(
+      this,
+      ctx,
+      key,
+      `interval(${[fields && `'${fields}'`, precision && String(precision)].filter((part) => part).join(", ")})`
+    );
   }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `box()`);
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.fields && ` ${this.data.fields}`,
+      this.data.precision !== void 0 && ` (${this.data.precision})`
+    );
   }
 }
-class PathColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "path";
-    this.operators = Operators.text;
-  }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `path()`);
+
+class ArrayColumn extends ColumnType {
+  constructor(schema, item, inputType, outputType, queryType) {
+    super(schema, inputType, outputType, queryType);
+    this.dataType = "array";
+    this.operators = Operators.array;
+    item.data.isNullable = true;
+    setColumnDefaultParse(this, (input) => parse$1.call(this, input));
+    this.data.item = item instanceof ArrayColumn ? item.data.item : item;
+    this.data.name = item.data.name;
+    this.data.arrayDims = item instanceof ArrayColumn ? item.data.arrayDims + 1 : 1;
   }
-}
-class PolygonColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "polygon";
-    this.operators = Operators.text;
+  toSQL() {
+    return this.data.item.toSQL() + "[]".repeat(this.data.arrayDims);
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `polygon()`);
+    let open = "array(";
+    let close = ")";
+    for (let i = 1; i < this.data.arrayDims; i++) {
+      open += `${ctx.t}.array(`;
+      close += ")";
+    }
+    const code = [open];
+    const { item } = this.data;
+    const { isNullable } = item.data;
+    delete item.data.isNullable;
+    orchidCore.addCode(code, item.toCode(ctx, key));
+    item.data.isNullable = isNullable;
+    orchidCore.addCode(code, `${close}${orchidCore.arrayDataToCode(this.data, ctx.migration)}`);
+    return columnCode(this, ctx, key, code);
   }
 }
-class CircleColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "circle";
-    this.operators = Operators.text;
+const parse$1 = function(source) {
+  if (typeof source !== "string") return source;
+  const entries = [];
+  parsePostgresArray(source, entries, this.data.item.data.parseItem);
+  return entries;
+};
+const parsePostgresArray = (source, entries, transform) => {
+  let pos = 0;
+  if (source[0] === "[") {
+    pos = source.indexOf("=") + 1;
+    if (!pos) pos = source.length;
   }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `circle()`);
+  if (source[pos] === "{") pos++;
+  let recorded = "";
+  while (pos < source.length) {
+    const character = source[pos++];
+    if (character === "{") {
+      const innerEntries = [];
+      entries.push(innerEntries);
+      pos += parsePostgresArray(source.slice(pos - 1), innerEntries, transform) - 1;
+    } else if (character === "}") {
+      if (recorded) {
+        entries.push(
+          recorded === "NULL" ? null : transform ? transform(recorded) : recorded
+        );
+      }
+      return pos;
+    } else if (character === '"') {
+      let esc = false;
+      let rec = "";
+      while (pos < source.length) {
+        let char;
+        while ((char = source[pos++]) === "\\") {
+          if (!(esc = !esc)) rec += "\\";
+        }
+        if (esc) {
+          esc = false;
+        } else if (char === '"') {
+          break;
+        }
+        rec += char;
+      }
+      entries.push(transform ? transform(rec) : rec);
+      recorded = "";
+    } else if (character === ",") {
+      if (recorded) {
+        entries.push(
+          recorded === "NULL" ? null : transform ? transform(recorded) : recorded
+        );
+        recorded = "";
+      }
+    } else {
+      recorded += character;
+    }
   }
-}
-class MoneyColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.number());
-    this.dataType = "money";
-    this.operators = Operators.number;
-    setColumnDefaultParse(this, moneyParse);
+  return pos;
+};
+
+const encode$1 = (x) => x === null ? x : JSON.stringify(x);
+class JSONColumn extends ColumnType {
+  constructor(schema, inputType) {
+    super(schema, inputType);
+    this.dataType = "jsonb";
+    this.operators = Operators.json;
+    this.data.encode = encode$1;
+    this.data.parseItem = JSON.parse;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `money()`);
+    return columnCode(this, ctx, key, `json()`);
   }
 }
-const moneyParse = Object.assign(
-  function(input) {
-    return input === null ? input : parseFloat(input.replace(/,/g, "").replace(/\$/g, ""));
-  },
-  {
-    hideFromCode: true
-  }
-);
-class CidrColumn extends ColumnType {
+class JSONTextColumn extends ColumnType {
   constructor(schema) {
     super(schema, schema.stringSchema());
-    this.dataType = "cidr";
+    this.dataType = "json";
     this.operators = Operators.text;
   }
+  static get instance() {
+    return this._instance ?? (this._instance = new JSONTextColumn(defaultSchemaConfig));
+  }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `cidr()`);
+    return columnCode(this, ctx, key, `jsonText()`);
   }
 }
-class InetColumn extends ColumnType {
+
+class NumberBaseColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.operators = Operators.number;
+  }
+}
+class IntegerBaseColumn extends NumberBaseColumn {
+  constructor(schema) {
+    super(schema, schema.int());
+    this.data.int = true;
+  }
+}
+class NumberAsStringBaseColumn extends ColumnType {
   constructor(schema) {
     super(schema, schema.stringSchema());
-    this.dataType = "inet";
-    this.operators = Operators.text;
+    this.operators = Operators.number;
+    this.data.jsonCast = "text";
+  }
+}
+class DecimalColumn extends NumberAsStringBaseColumn {
+  constructor(schema, numericPrecision, numericScale) {
+    super(schema);
+    this.operators = Operators.number;
+    this.dataType = "numeric";
+    this.data.numericPrecision = numericPrecision;
+    this.data.numericScale = numericScale;
+    this.data.alias = "decimal";
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `inet()`);
+    const { numericPrecision, numericScale } = this.data;
+    return columnCode(
+      this,
+      ctx,
+      key,
+      `decimal(${numericPrecision || ""}${numericScale ? `, ${numericScale}` : ""})`
+    );
+  }
+  toSQL() {
+    const { numericPrecision, numericScale } = this.data;
+    return orchidCore.joinTruthy(
+      this.dataType,
+      numericPrecision ? numericScale ? `(${numericPrecision}, ${numericScale})` : `(${numericPrecision})` : void 0
+    );
   }
 }
-class MacAddrColumn extends ColumnType {
+const skipNumberMethods = { int: true };
+const intToCode = (column, ctx, key, alias) => {
+  let code;
+  if (column.data.identity) {
+    code = identityToCode(column.data.identity, alias);
+  } else {
+    code = [`${alias}()`];
+  }
+  orchidCore.addCode(
+    code,
+    orchidCore.numberDataToCode(column.data, ctx.migration, skipNumberMethods)
+  );
+  return columnCode(column, ctx, key, code);
+};
+class SmallIntColumn extends IntegerBaseColumn {
   constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "macaddr";
-    this.operators = Operators.text;
+    super(schema);
+    this.dataType = "int2";
+    this.data.alias = "smallint";
+    this.data.parseItem = parseInt;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `macaddr()`);
+    return intToCode(this, ctx, key, "smallint");
+  }
+  identity(options = {}) {
+    return orchidCore.setColumnData(this, "identity", options);
   }
 }
-class MacAddr8Column extends ColumnType {
+class IntegerColumn extends IntegerBaseColumn {
   constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "macaddr8";
-    this.operators = Operators.text;
+    super(schema);
+    this.dataType = "int4";
+    this.data.alias = "integer";
+    this.data.parseItem = parseInt;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `macaddr8()`);
+    return intToCode(this, ctx, key, "integer");
+  }
+  identity(options = {}) {
+    return orchidCore.setColumnData(this, "identity", options);
   }
 }
-class BitColumn extends ColumnType {
-  constructor(schema, length) {
-    super(schema, schema.bit(length));
-    this.dataType = "bit";
-    this.operators = Operators.text;
-    this.data.length = length;
+class BigIntColumn extends NumberAsStringBaseColumn {
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int8";
+    this.data.alias = "bigint";
   }
   toCode(ctx, key) {
-    const { length } = this.data;
-    return columnCode(this, ctx, key, `bit(${length})`);
+    return intToCode(this, ctx, key, "bigint");
   }
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.length !== void 0 && `(${this.data.length})`
+  identity(options = {}) {
+    return orchidCore.setColumnData(this, "identity", options);
+  }
+}
+class RealColumn extends NumberBaseColumn {
+  constructor(schema) {
+    super(schema, schema.number());
+    this.dataType = "float4";
+    this.data.alias = "real";
+    this.data.parseItem = parseFloat;
+  }
+  toCode(ctx, key) {
+    return columnCode(
+      this,
+      ctx,
+      key,
+      `real()${orchidCore.numberDataToCode(this.data, ctx.migration)}`
     );
   }
 }
-class BitVaryingColumn extends ColumnType {
-  constructor(schema, length) {
-    super(schema, schema.bit(length));
-    this.dataType = "varbit";
-    this.operators = Operators.text;
-    this.data.length = length;
-    this.data.alias = "bitVarying";
+class DoublePrecisionColumn extends NumberAsStringBaseColumn {
+  constructor(schema) {
+    super(schema);
+    this.dataType = "float8";
+    this.data.alias = "doublePrecision";
   }
   toCode(ctx, key) {
-    const { length } = this.data;
-    return columnCode(this, ctx, key, `bitVarying(${length ?? ""})`);
+    return columnCode(this, ctx, key, `doublePrecision()`);
+  }
+}
+class SmallSerialColumn extends IntegerBaseColumn {
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int2";
+    this.data.int = true;
+    this.data.alias = "smallSerial";
+    this.data.parseItem = parseInt;
   }
   toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.length !== void 0 && `(${this.data.length})`
+    return "smallserial";
+  }
+  toCode(ctx, key) {
+    return columnCode(
+      this,
+      ctx,
+      key,
+      `smallSerial()${orchidCore.numberDataToCode(
+        this.data,
+        ctx.migration,
+        skipNumberMethods
+      )}`
     );
   }
 }
-class TsVectorColumn extends ColumnType {
-  constructor(schema, defaultLanguage = orchidCore.getDefaultLanguage()) {
-    super(schema, schema.stringSchema());
-    this.defaultLanguage = defaultLanguage;
-    this.dataType = "tsvector";
-    this.operators = Operators.text;
+class SerialColumn extends IntegerBaseColumn {
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int4";
+    this.data.int = true;
+    this.data.alias = "serial";
+    this.data.parseItem = parseInt;
   }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `tsvector()`);
-  }
-  /**
-   * For `tsvector` column type, it can also accept language (optional) and columns:
-   *
-   * ```ts
-   * import { change } from '../dbScript';
-   *
-   * change(async (db) => {
-   *   await db.createTable('post', (t) => ({
-   *     id: t.id(),
-   *     title: t.text(),
-   *     body: t.text(),
-   *     // join title and body into a single ts_vector
-   *     generatedTsVector: t.tsvector().generated(['title', 'body']).searchIndex(),
-   *     // with language:
-   *     spanishTsVector: t
-   *       .tsvector()
-   *       .generated('spanish', ['title', 'body'])
-   *       .searchIndex(),
-   *   }));
-   * });
-   * ```
-   *
-   * @param args
-   */
-  generated(...args) {
-    const arg = args[0];
-    if (typeof arg === "object" && "raw" in arg) {
-      return super.generated(...args);
-    }
-    const toSQL = (ctx) => {
-      const first = args[0];
-      const target = typeof first === "string" ? args[1] : first;
-      const language = typeof first === "string" ? first : this.defaultLanguage;
-      const { snakeCase } = ctx;
-      let sql;
-      if (Array.isArray(target)) {
-        const columns = target.length === 1 ? `"${snakeCase ? orchidCore.toSnakeCase(target[0]) : target[0]}"` : target.map(
-          (column2) => `coalesce("${snakeCase ? orchidCore.toSnakeCase(column2) : column2}", '')`
-        ).join(` || ' ' || `);
-        sql = `to_tsvector('${language}', ${columns})`;
-      } else {
-        for (const key in target) {
-          sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${snakeCase ? orchidCore.toSnakeCase(key) : key}", '')), '${target[key]}')`;
-        }
-        if (sql) {
-          sql += ")";
-        } else {
-          throw new Error("Empty target in the text search generated column");
-        }
-      }
-      return sql;
-    };
-    const toCode = () => {
-      let code = ".generated(";
-      const first = args[0];
-      let target;
-      if (typeof first === "string") {
-        code += `'${first}', `;
-        target = args[1];
-      } else {
-        target = args[0];
-      }
-      if (Array.isArray(target)) {
-        code += `[${target.map((x) => `'${x}'`).join(", ")}]`;
-      } else {
-        const pairs = [];
-        for (const key in target) {
-          pairs.push(
-            `${orchidCore.quoteObjectKey(key)}: '${target[key]}'`
-          );
-        }
-        code += `{ ${pairs.join(", ")} }`;
-      }
-      return code + ")";
-    };
-    const column = orchidCore.setColumnData(this, "generated", {
-      toSQL,
-      toCode
-    });
-    column.data.readonly = true;
-    return column;
-  }
-}
-class TsQueryColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "tsquery";
-    this.operators = Operators.text;
+  toSQL() {
+    return "serial";
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `tsquery()`);
+    return columnCode(
+      this,
+      ctx,
+      key,
+      `serial()${orchidCore.numberDataToCode(
+        this.data,
+        ctx.migration,
+        skipNumberMethods
+      )}`
+    );
   }
 }
-const uuidDefaultSQL = "gen_random_uuid()";
-const uuidDefault = new RawSQL(uuidDefaultSQL);
-class UUIDColumn extends ColumnType {
+class BigSerialColumn extends NumberAsStringBaseColumn {
   constructor(schema) {
-    super(schema, schema.uuid());
-    this.dataType = "uuid";
-    this.operators = Operators.text;
-    this.data.defaultDefault = uuidDefault;
+    super(schema);
+    this.dataType = "int8";
+    this.data.alias = "bigint";
   }
-  /**
-   * see {@link ColumnType.primaryKey}
-   */
-  primaryKey(name) {
-    const column = super.primaryKey(name);
-    if (!column.data.default) column.data.default = uuidDefault;
-    return column;
+  toSQL() {
+    return "bigserial";
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `uuid()`);
+    return columnCode(this, ctx, key, `bigSerial()`);
   }
 }
-class XMLColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "xml";
+
+const parseDateToDate = (value) => new Date(value);
+const defaultSchemaConfig = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse(fn) {
+    return setColumnParse(this, fn);
+  },
+  parseNull(fn) {
+    return setColumnParseNull(this, fn);
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  encode(fn) {
+    return orchidCore.setColumnData(this, "encode", fn);
+  },
+  asType() {
+    return this;
+  },
+  dateAsNumber() {
+    return this.parse(Date.parse);
+  },
+  dateAsDate() {
+    return this.parse(parseDateToDate);
+  },
+  enum(dataType, type) {
+    return new EnumColumn(defaultSchemaConfig, dataType, type, void 0);
+  },
+  array(item) {
+    return new ArrayColumn(defaultSchemaConfig, item, void 0);
+  },
+  boolean: orchidCore.noop,
+  buffer: orchidCore.noop,
+  unknown: orchidCore.noop,
+  never: orchidCore.noop,
+  stringSchema: orchidCore.noop,
+  stringMin: orchidCore.noop,
+  stringMax: orchidCore.noop,
+  stringMinMax: orchidCore.noop,
+  number: orchidCore.noop,
+  int: orchidCore.noop,
+  stringNumberDate: orchidCore.noop,
+  timeInterval: orchidCore.noop,
+  bit: orchidCore.noop,
+  uuid: orchidCore.noop,
+  nullable() {
+    return orchidCore.setColumnData(this, "isNullable", true);
+  },
+  json() {
+    return new JSONColumn(defaultSchemaConfig, void 0);
+  },
+  setErrors: orchidCore.noop,
+  smallint: () => new SmallIntColumn(defaultSchemaConfig),
+  integer: () => new IntegerColumn(defaultSchemaConfig),
+  real: () => new RealColumn(defaultSchemaConfig),
+  smallSerial: () => new SmallSerialColumn(defaultSchemaConfig),
+  serial: () => new SerialColumn(defaultSchemaConfig),
+  bigint: () => new BigIntColumn(defaultSchemaConfig),
+  decimal: (precision, scale) => new DecimalColumn(defaultSchemaConfig, precision, scale),
+  doublePrecision: () => new DoublePrecisionColumn(defaultSchemaConfig),
+  bigSerial: () => new BigSerialColumn(defaultSchemaConfig),
+  money: () => new MoneyColumn(defaultSchemaConfig),
+  varchar: (limit) => new VarCharColumn(defaultSchemaConfig, limit),
+  text: () => new TextColumn(defaultSchemaConfig),
+  string: (limit) => new StringColumn(defaultSchemaConfig, limit),
+  citext: () => new CitextColumn(defaultSchemaConfig),
+  date: () => new DateColumn(defaultSchemaConfig),
+  timestampNoTZ: (precision) => new TimestampColumn(defaultSchemaConfig, precision),
+  timestamp: (precision) => new TimestampTZColumn(defaultSchemaConfig, precision),
+  geographyPointSchema: orchidCore.noop
+};
+
+class TextBaseColumn extends ColumnType {
+  constructor(schema, schemaType = schema.stringSchema()) {
+    super(schema, schemaType);
     this.operators = Operators.text;
   }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `xml()`);
-  }
-}
-class CitextColumn extends TextBaseColumn {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.dataType = "citext";
-    this.data.extension = "citext";
-  }
-  toCode(ctx, key) {
-    return textColumnToCode(this, ctx, key);
-  }
 }
-
-const dateTimeEncode = (input) => {
-  return typeof input === "number" ? new Date(input) : input;
-};
-class DateBaseColumn extends ColumnType {
-  constructor(schema) {
+class LimitedTextBaseColumn extends TextBaseColumn {
+  constructor(schema, limit) {
     super(
       schema,
-      schema.stringNumberDate(),
-      schema.stringSchema(),
-      schema.stringNumberDate()
+      limit !== void 0 ? schema.stringMax(limit) : schema.stringSchema()
+    );
+    this.data.maxChars = limit;
+  }
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.maxChars !== void 0 && `(${this.data.maxChars})`
     );
-    this.operators = Operators.date;
-    this.asNumber = schema.dateAsNumber;
-    this.asDate = schema.dateAsDate;
-    this.data.encode = dateTimeEncode;
   }
 }
-class DateColumn extends DateBaseColumn {
+class VarCharColumn extends LimitedTextBaseColumn {
   constructor() {
     super(...arguments);
-    this.dataType = "date";
+    this.dataType = "varchar";
   }
   toCode(ctx, key) {
+    const { maxChars } = this.data;
     return columnCode(
       this,
       ctx,
       key,
-      `date()${orchidCore.dateDataToCode(this.data, ctx.migration)}`
+      `varchar(${maxChars ?? ""})${orchidCore.stringDataToCode(this.data, ctx.migration)}`
     );
   }
 }
-class DateTimeBaseClass extends DateBaseColumn {
-  constructor(schema, dateTimePrecision) {
-    super(schema);
-    this.data.dateTimePrecision = dateTimePrecision;
-  }
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`
-    );
+class StringColumn extends VarCharColumn {
+  constructor(schema, limit = 255) {
+    super(schema, limit);
   }
-}
-class DateTimeTzBaseClass extends DateTimeBaseClass {
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.baseDataType,
-      this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`,
-      " with time zone"
-    );
-  }
-}
-const timestampToCode = (self, ctx, key) => {
-  const { dateTimePrecision: p } = self.data;
-  const { defaultTimestamp } = self.data;
-  if (defaultTimestamp) {
-    const noTz = self instanceof TimestampColumn ? "NoTZ" : "";
-    const def = self.data.default;
-    const modifyQuery = self.data.modifyQuery;
-    self.data.default = void 0;
-    self.data.modifyQuery = void 0;
-    const code = columnCode(
-      self,
-      ctx,
-      key,
-      `timestamps${noTz}(${p && p !== 6 ? p : ""}).${defaultTimestamp}${orchidCore.dateDataToCode(self.data, ctx.migration)}`
-    );
-    self.data.default = def;
-    self.data.modifyQuery = modifyQuery;
-    return code;
-  } else {
+  toCode(ctx, key) {
+    let max = this.data.maxChars;
+    if (max === 255) max = void 0;
     return columnCode(
-      self,
+      this,
       ctx,
       key,
-      `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data, ctx.migration)}`
+      `string(${max ?? ""})${orchidCore.stringDataToCode(this.data, ctx.migration)}`
     );
   }
+}
+const textColumnToCode = (column, ctx, key) => {
+  const data = { ...column.data };
+  let args = "";
+  const hasMax = data.maxArg !== void 0 && data.max === data.maxArg;
+  if (data.minArg !== void 0 && data.min === data.minArg || hasMax) {
+    if (data.minArg !== 0 || hasMax && data.max !== Infinity) {
+      args += data.minArg;
+    }
+    delete data.min;
+    if (hasMax) {
+      if (data.maxArg !== Infinity) {
+        args += `, ${data.maxArg}`;
+      }
+      delete data.max;
+    }
+  }
+  return columnCode(
+    column,
+    ctx,
+    key,
+    `${column.dataType}(${args})${orchidCore.stringDataToCode(data, ctx.migration)}`
+  );
 };
-class TimestampColumn extends DateTimeBaseClass {
-  constructor() {
-    super(...arguments);
-    this.dataType = "timestamp";
+class TextColumn extends TextBaseColumn {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "text";
+  }
+  static get instance() {
+    return this._instance ?? (this._instance = new TextColumn(defaultSchemaConfig));
   }
   toCode(ctx, key) {
-    return timestampToCode(this, ctx, key);
+    return textColumnToCode(this, ctx, key);
   }
 }
-class TimestampTZColumn extends DateTimeTzBaseClass {
-  constructor() {
-    super(...arguments);
-    this.dataType = "timestamptz";
-    this.baseDataType = "timestamp";
+const byteaParse = (val) => typeof val === "string" ? Buffer.from(val.slice(2), "hex") : val;
+class ByteaColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.buffer());
+    this.dataType = "bytea";
+    this.operators = Operators.text;
+    setColumnDefaultParse(this, byteaParse);
   }
   toCode(ctx, key) {
-    return timestampToCode(this, ctx, key);
+    return columnCode(this, ctx, key, `bytea()`);
   }
 }
-class TimeColumn extends ColumnType {
-  constructor(schema, dateTimePrecision) {
+class PointColumn extends ColumnType {
+  constructor(schema) {
     super(schema, schema.stringSchema());
-    this.dataType = "time";
-    this.operators = Operators.time;
-    this.data.dateTimePrecision = dateTimePrecision;
+    this.dataType = "point";
+    this.operators = Operators.text;
   }
   toCode(ctx, key) {
-    const { dateTimePrecision } = this.data;
-    return columnCode(
-      this,
-      ctx,
-      key,
-      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(
-        this.data,
-        ctx.migration
-      )}`
-    );
+    return columnCode(this, ctx, key, `point()`);
   }
 }
-class IntervalColumn extends ColumnType {
-  constructor(schema, fields, precision) {
-    super(schema, schema.timeInterval());
-    this.dataType = "interval";
-    this.operators = Operators.date;
-    this.data.fields = fields;
-    this.data.precision = precision;
+class LineColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "line";
+    this.operators = Operators.text;
   }
   toCode(ctx, key) {
-    const { fields, precision } = this.data;
-    return columnCode(
-      this,
-      ctx,
-      key,
-      `interval(${[fields && `'${fields}'`, precision && String(precision)].filter((part) => part).join(", ")})`
-    );
-  }
-  toSQL() {
-    return orchidCore.joinTruthy(
-      this.dataType,
-      this.data.fields && ` ${this.data.fields}`,
-      this.data.precision !== void 0 && ` (${this.data.precision})`
-    );
+    return columnCode(this, ctx, key, `line()`);
   }
 }
-
-class BooleanColumn extends ColumnType {
+class LsegColumn extends ColumnType {
   constructor(schema) {
-    super(schema, schema.boolean());
-    this.dataType = "bool";
-    this.operators = Operators.boolean;
-    this.data.alias = "boolean";
-    this.data.parseItem = parseItem;
+    super(schema, schema.stringSchema());
+    this.dataType = "lseg";
+    this.operators = Operators.text;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, "boolean()");
+    return columnCode(this, ctx, key, `lseg()`);
   }
 }
-const parseItem = (input) => input[0] === "t";
-
-const encode$1 = (x) => x === null ? x : JSON.stringify(x);
-class JSONColumn extends ColumnType {
-  constructor(schema, inputType) {
-    super(schema, inputType);
-    this.dataType = "jsonb";
-    this.operators = Operators.json;
-    this.data.encode = encode$1;
-    this.data.parseItem = JSON.parse;
+class BoxColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "box";
+    this.operators = Operators.text;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `json()`);
+    return columnCode(this, ctx, key, `box()`);
   }
 }
-class JSONTextColumn extends ColumnType {
+class PathColumn extends ColumnType {
   constructor(schema) {
     super(schema, schema.stringSchema());
-    this.dataType = "json";
+    this.dataType = "path";
     this.operators = Operators.text;
   }
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `jsonText()`);
+    return columnCode(this, ctx, key, `path()`);
   }
 }
-
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
-var _query, _query2;
-class OrchidOrmError extends Error {
-}
-class NotFoundError extends OrchidOrmError {
-  constructor(query, message = "Record is not found") {
-    super(message);
-    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
-    __privateAdd(this, _query);
-    __privateSet(this, _query, query);
+class PolygonColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "polygon";
+    this.operators = Operators.text;
   }
-  get query() {
-    return __privateGet(this, _query);
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `polygon()`);
   }
 }
-_query = new WeakMap();
-class OrchidOrmInternalError extends Error {
-  constructor(query, message) {
-    super(message);
-    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
-    __privateAdd(this, _query2);
-    __privateSet(this, _query2, query);
+class CircleColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "circle";
+    this.operators = Operators.text;
   }
-  get query() {
-    return __privateGet(this, _query2);
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `circle()`);
   }
 }
-_query2 = new WeakMap();
-class QueryError extends OrchidOrmInternalError {
-  get isUnique() {
-    return this.code === "23505";
+class MoneyColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.number());
+    this.dataType = "money";
+    this.operators = Operators.number;
+    setColumnDefaultParse(this, moneyParse);
   }
-  get columns() {
-    if (this.columnsCache) return this.columnsCache;
-    const columns = {};
-    if (this.detail) {
-      const list = this.detail.match(/\((.*)\)=/)?.[1];
-      if (list) {
-        list.split(", ").forEach((item) => {
-          const column = item.startsWith('"') ? item.slice(1, -1) : item;
-          const key = this.query.columnNameToKey(column) ?? column;
-          columns[key] = true;
-        });
-      }
-    }
-    return this.columnsCache = columns;
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `money()`);
   }
 }
-class MoreThanOneRowError extends OrchidOrmInternalError {
-  constructor(query, message) {
-    super(query, message);
+const moneyParse = Object.assign(
+  function(input) {
+    return input === null ? input : parseFloat(input.replace(/,/g, "").replace(/\$/g, ""));
+  },
+  {
+    hideFromCode: true
   }
-}
-class UnhandledTypeError extends OrchidOrmInternalError {
-  constructor(query, value) {
-    super(query, `Unhandled type: ${JSON.stringify(value)} received`);
+);
+class CidrColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "cidr";
+    this.operators = Operators.text;
+  }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `cidr()`);
   }
 }
-
-const _clone = (q) => q.clone();
-const pushQueryArrayImmutable = (q, key, value) => {
-  const arr = q.q[key];
-  q.q[key] = arr ? [...arr, ...value] : value;
-  return q;
-};
-const pushQueryValueImmutable = (q, key, value) => {
-  orchidCore.pushOrNewArrayToObjectImmutable(q.q, key, value);
-  return q;
-};
-const setQueryObjectValueImmutable = (q, object, key, value) => {
-  q.q[object] = {
-    ...q.q[object],
-    [key]: value
-  };
-  return q;
-};
-const throwIfNoWhere = (q, method) => {
-  if (!q.q.or && !q.q.and && !q.q.scopes && !q.q.all) {
-    throw new OrchidOrmInternalError(
-      q,
-      `Dangerous ${method} without conditions`
-    );
-  }
-};
-const throwIfJoinLateral = (q, method) => {
-  if (q.q.join?.some(
-    (x) => Array.isArray(x) || "s" in x.args && x.args.s
-  )) {
-    throw new OrchidOrmInternalError(
-      q,
-      `Cannot join a complex query in ${method}`
-    );
+class InetColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "inet";
+    this.operators = Operators.text;
   }
-};
-const saveSearchAlias = (q, as, key) => {
-  const shapes = q.q[key];
-  if (shapes?.[as]) {
-    let suffix = 2;
-    while (shapes[as = `${as}${suffix}`]) {
-      suffix++;
-    }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `inet()`);
   }
-  setQueryObjectValueImmutable(q, key, as, orchidCore.emptyObject);
-  return as;
-};
-const extendQuery = (q, methods) => {
-  const base = Object.create(q.baseQuery);
-  base.baseQuery = base;
-  Object.assign(base, methods);
-  const cloned = Object.create(base);
-  cloned.q = getClonedQueryData(q.q);
-  return cloned;
-};
-const getPrimaryKeys = (q) => {
-  var _a;
-  return (_a = q.internal).primaryKeys ?? (_a.primaryKeys = collectPrimaryKeys(q));
-};
-const collectPrimaryKeys = (q) => {
-  const primaryKeys = [];
-  const { shape } = q.q;
-  for (const key in shape) {
-    if (shape[key].data.primaryKey) {
-      primaryKeys.push(key);
-    }
+}
+class MacAddrColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "macaddr";
+    this.operators = Operators.text;
   }
-  const pkey = q.internal.tableData.primaryKey;
-  if (pkey) {
-    primaryKeys.push(...pkey.columns);
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `macaddr()`);
   }
-  return primaryKeys;
-};
-const _queryAll = (q) => {
-  q.q.returnType = "all";
-  q.q.all = true;
-  return q;
-};
-const _queryTake = (query) => {
-  const q = query.q;
-  switch (q.returnType) {
-    case "valueOrThrow":
-    case "pluck":
-    case "void":
-      break;
-    case "value": {
-      q.returnType = "valueOrThrow";
-      break;
-    }
-    default: {
-      q.returnType = "oneOrThrow";
-    }
+}
+class MacAddr8Column extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "macaddr8";
+    this.operators = Operators.text;
   }
-  return query;
-};
-const _queryTakeOptional = (query) => {
-  const q = query.q;
-  switch (q.returnType) {
-    case "value":
-    case "pluck":
-    case "void":
-      break;
-    case "valueOrThrow": {
-      q.returnType = "value";
-      break;
-    }
-    default: {
-      q.returnType = "one";
-    }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `macaddr8()`);
   }
-  return query;
-};
-const _queryExec = (q) => {
-  q.q.returnType = "void";
-  return q;
-};
-const _queryRows = (q) => {
-  q.q.returnType = "rows";
-  return q;
-};
-const getFullColumnTable = (q, column, index, as) => {
-  const table = column.slice(0, index);
-  return as && table !== as && q.q.aliases?.[table] === as ? as : table;
-};
-
-function simpleColumnToSQL(ctx, key, column, quotedAs) {
-  if (!column) return `"${key}"`;
-  const { data } = column;
-  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
 }
-function simpleExistingColumnToSQL(ctx, key, column, quotedAs) {
-  const { data } = column;
-  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
-}
-const columnToSql = (ctx, data, shape, column, quotedAs, select) => {
-  const index = column.indexOf(".");
-  if (index !== -1) {
-    return columnWithDotToSql(
-      ctx,
-      data,
-      shape,
-      column,
-      index,
-      quotedAs,
-      select
-    );
+class BitColumn extends ColumnType {
+  constructor(schema, length) {
+    super(schema, schema.bit(length));
+    this.dataType = "bit";
+    this.operators = Operators.text;
+    this.data.length = length;
   }
-  if (!select && data.joinedShapes?.[column]) {
-    return `"${column}".r`;
+  toCode(ctx, key) {
+    const { length } = this.data;
+    return columnCode(this, ctx, key, `bit(${length})`);
   }
-  return simpleColumnToSQL(ctx, column, shape[column], quotedAs);
-};
-const maybeSelectedColumnToSql = (ctx, data, column, quotedAs) => {
-  const index = column.indexOf(".");
-  if (index !== -1) {
-    return columnWithDotToSql(ctx, data, data.shape, column, index, quotedAs);
-  } else {
-    if (data.joinedShapes?.[column]) {
-      return `"${column}".r`;
-    }
-    if (data.select) {
-      for (const s of data.select) {
-        if (typeof s === "object" && "selectAs" in s) {
-          if (column in s.selectAs) {
-            return simpleColumnToSQL(ctx, column, data.shape[column]);
-          }
-        }
-      }
-    }
-    return simpleColumnToSQL(ctx, column, data.shape[column], quotedAs);
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.length !== void 0 && `(${this.data.length})`
+    );
   }
-};
-const columnWithDotToSql = (ctx, data, shape, column, index, quotedAs, select) => {
-  const table = column.slice(0, index);
-  const key = column.slice(index + 1);
-  if (key === "*") {
-    const shape2 = data.joinedShapes?.[table];
-    return shape2 ? select ? makeRowToJson(table, shape2, true) : `"${table}".*` : column;
+}
+class BitVaryingColumn extends ColumnType {
+  constructor(schema, length) {
+    super(schema, schema.bit(length));
+    this.dataType = "varbit";
+    this.operators = Operators.text;
+    this.data.length = length;
+    this.data.alias = "bitVarying";
   }
-  const tableName = data.aliases?.[table] || table;
-  const quoted = `"${table}"`;
-  const col = quoted === quotedAs ? shape[key] : data.joinedShapes?.[tableName]?.[key];
-  if (col) {
-    if (col.data.name) {
-      return `"${tableName}"."${col.data.name}"`;
-    }
-    if (col.data.computed) {
-      return col.data.computed.toSQL(ctx, quoted);
-    }
-    return `"${tableName}"."${key}"`;
+  toCode(ctx, key) {
+    const { length } = this.data;
+    return columnCode(this, ctx, key, `bitVarying(${length ?? ""})`);
   }
-  return `"${tableName}"."${key}"`;
-};
-const columnToSqlWithAs = (ctx, data, column, as, quotedAs, select, jsonList) => {
-  const index = column.indexOf(".");
-  return index !== -1 ? tableColumnToSqlWithAs(
-    ctx,
-    data,
-    column,
-    column.slice(0, index),
-    column.slice(index + 1),
-    as,
-    quotedAs,
-    select,
-    jsonList
-  ) : ownColumnToSqlWithAs(ctx, data, column, as, quotedAs, select, jsonList);
-};
-const tableColumnToSqlWithAs = (ctx, data, column, table, key, as, quotedAs, select, jsonList) => {
-  if (key === "*") {
-    if (jsonList) jsonList[as] = void 0;
-    const shape = data.joinedShapes?.[table];
-    if (shape) {
-      {
-        return makeRowToJson(table, shape, true) + ` "${as}"`;
-      }
-    }
-    return column;
+  toSQL() {
+    return orchidCore.joinTruthy(
+      this.dataType,
+      this.data.length !== void 0 && `(${this.data.length})`
+    );
   }
-  const tableName = data.aliases?.[table] || table;
-  const quoted = `"${table}"`;
-  const col = quoted === quotedAs ? data.shape[key] : data.joinedShapes?.[tableName][key];
-  if (jsonList) jsonList[as] = col;
-  if (col) {
-    if (col.data.name && col.data.name !== key) {
-      return `"${tableName}"."${col.data.name}" "${as}"`;
-    }
-    if (col.data.computed) {
-      return `${col.data.computed.toSQL(ctx, quoted)} "${as}"`;
+}
+class TsVectorColumn extends ColumnType {
+  constructor(schema, defaultLanguage = orchidCore.getDefaultLanguage()) {
+    super(schema, schema.stringSchema());
+    this.defaultLanguage = defaultLanguage;
+    this.dataType = "tsvector";
+    this.operators = Operators.text;
+  }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `tsvector()`);
+  }
+  /**
+   * For `tsvector` column type, it can also accept language (optional) and columns:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('post', (t) => ({
+   *     id: t.id(),
+   *     title: t.text(),
+   *     body: t.text(),
+   *     // join title and body into a single ts_vector
+   *     generatedTsVector: t.tsvector().generated(['title', 'body']).searchIndex(),
+   *     // with language:
+   *     spanishTsVector: t
+   *       .tsvector()
+   *       .generated('spanish', ['title', 'body'])
+   *       .searchIndex(),
+   *   }));
+   * });
+   * ```
+   *
+   * @param args
+   */
+  generated(...args) {
+    const arg = args[0];
+    if (typeof arg === "object" && "raw" in arg) {
+      return super.generated(...args);
     }
+    const toSQL = (ctx) => {
+      const first = args[0];
+      const target = typeof first === "string" ? args[1] : first;
+      const language = typeof first === "string" ? first : this.defaultLanguage;
+      const { snakeCase } = ctx;
+      let sql;
+      if (Array.isArray(target)) {
+        const columns = target.length === 1 ? `"${snakeCase ? orchidCore.toSnakeCase(target[0]) : target[0]}"` : target.map(
+          (column2) => `coalesce("${snakeCase ? orchidCore.toSnakeCase(column2) : column2}", '')`
+        ).join(` || ' ' || `);
+        sql = `to_tsvector('${language}', ${columns})`;
+      } else {
+        for (const key in target) {
+          sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${snakeCase ? orchidCore.toSnakeCase(key) : key}", '')), '${target[key]}')`;
+        }
+        if (sql) {
+          sql += ")";
+        } else {
+          throw new Error("Empty target in the text search generated column");
+        }
+      }
+      return sql;
+    };
+    const toCode = () => {
+      let code = ".generated(";
+      const first = args[0];
+      let target;
+      if (typeof first === "string") {
+        code += `'${first}', `;
+        target = args[1];
+      } else {
+        target = args[0];
+      }
+      if (Array.isArray(target)) {
+        code += `[${target.map((x) => `'${x}'`).join(", ")}]`;
+      } else {
+        const pairs = [];
+        for (const key in target) {
+          pairs.push(
+            `${orchidCore.quoteObjectKey(key)}: '${target[key]}'`
+          );
+        }
+        code += `{ ${pairs.join(", ")} }`;
+      }
+      return code + ")";
+    };
+    const column = orchidCore.setColumnData(this, "generated", {
+      toSQL,
+      toCode
+    });
+    column.data.readonly = true;
+    return column;
   }
-  return `"${tableName}"."${key}"${key === as ? "" : ` "${as}"`}`;
+}
+class TsQueryColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "tsquery";
+    this.operators = Operators.text;
+  }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `tsquery()`);
+  }
+}
+const uuidDefaultSQL = "gen_random_uuid()";
+const uuidDefault = new RawSQL(uuidDefaultSQL);
+class UUIDColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.uuid());
+    this.dataType = "uuid";
+    this.operators = Operators.text;
+    this.data.defaultDefault = uuidDefault;
+  }
+  /**
+   * see {@link ColumnType.primaryKey}
+   */
+  primaryKey(name) {
+    const column = super.primaryKey(name);
+    if (!column.data.default) column.data.default = uuidDefault;
+    return column;
+  }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `uuid()`);
+  }
+}
+class XMLColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "xml";
+    this.operators = Operators.text;
+  }
+  static get instance() {
+    return this._instance ?? (this._instance = new XMLColumn(defaultSchemaConfig));
+  }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, `xml()`);
+  }
+}
+class CitextColumn extends TextBaseColumn {
+  constructor(schema) {
+    super(schema, schema.stringSchema());
+    this.dataType = "citext";
+    this.data.extension = "citext";
+  }
+  toCode(ctx, key) {
+    return textColumnToCode(this, ctx, key);
+  }
+}
+
+class BooleanColumn extends ColumnType {
+  constructor(schema) {
+    super(schema, schema.boolean());
+    this.dataType = "bool";
+    this.operators = Operators.boolean;
+    this.data.alias = "boolean";
+    this.data.parseItem = parseItem;
+  }
+  static get instance() {
+    return this._instance ?? (this._instance = new BooleanColumn(defaultSchemaConfig));
+  }
+  toCode(ctx, key) {
+    return columnCode(this, ctx, key, "boolean()");
+  }
+}
+const parseItem = (input) => input[0] === "t";
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
 };
-const ownColumnToSqlWithAs = (ctx, data, column, as, quotedAs, select, jsonList) => {
-  const col = data.shape[column];
-  if (jsonList) jsonList[as] = col;
-  if (col) {
-    if (col.data.name && col.data.name !== column) {
-      return `${quotedAs ? `${quotedAs}.` : ""}"${col.data.name}"${col.data.name === as ? "" : ` "${as}"`}`;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _query, _query2;
+class OrchidOrmError extends Error {
+}
+class NotFoundError extends OrchidOrmError {
+  constructor(query, message = "Record is not found") {
+    super(message);
+    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
+    __privateAdd(this, _query);
+    __privateSet(this, _query, query);
+  }
+  get query() {
+    return __privateGet(this, _query);
+  }
+}
+_query = new WeakMap();
+class OrchidOrmInternalError extends Error {
+  constructor(query, message) {
+    super(message);
+    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
+    __privateAdd(this, _query2);
+    __privateSet(this, _query2, query);
+  }
+  get query() {
+    return __privateGet(this, _query2);
+  }
+}
+_query2 = new WeakMap();
+class QueryError extends OrchidOrmInternalError {
+  get isUnique() {
+    return this.code === "23505";
+  }
+  get columns() {
+    if (this.columnsCache) return this.columnsCache;
+    const columns = {};
+    if (this.detail) {
+      const list = this.detail.match(/\((.*)\)=/)?.[1];
+      if (list) {
+        list.split(", ").forEach((item) => {
+          const column = item.startsWith('"') ? item.slice(1, -1) : item;
+          const key = this.query.columnNameToKey(column) ?? column;
+          columns[key] = true;
+        });
+      }
     }
-    if (col.data.computed) {
-      return `${col.data.computed.toSQL(ctx, quotedAs)} "${as}"`;
+    return this.columnsCache = columns;
+  }
+}
+class MoreThanOneRowError extends OrchidOrmInternalError {
+  constructor(query, message) {
+    super(query, message);
+  }
+}
+class UnhandledTypeError extends OrchidOrmInternalError {
+  constructor(query, value) {
+    super(query, `Unhandled type: ${JSON.stringify(value)} received`);
+  }
+}
+
+const _clone = (q) => q.clone();
+const pushQueryArrayImmutable = (q, key, value) => {
+  const arr = q.q[key];
+  q.q[key] = arr ? [...arr, ...value] : value;
+  return q;
+};
+const pushQueryValueImmutable = (q, key, value) => {
+  orchidCore.pushOrNewArrayToObjectImmutable(q.q, key, value);
+  return q;
+};
+const setQueryObjectValueImmutable = (q, object, key, value) => {
+  q.q[object] = {
+    ...q.q[object],
+    [key]: value
+  };
+  return q;
+};
+const throwIfNoWhere = (q, method) => {
+  if (!q.q.or && !q.q.and && !q.q.scopes && !q.q.all) {
+    throw new OrchidOrmInternalError(
+      q,
+      `Dangerous ${method} without conditions`
+    );
+  }
+};
+const throwIfJoinLateral = (q, method) => {
+  if (q.q.join?.some(
+    (x) => Array.isArray(x) || "s" in x.args && x.args.s
+  )) {
+    throw new OrchidOrmInternalError(
+      q,
+      `Cannot join a complex query in ${method}`
+    );
+  }
+};
+const saveSearchAlias = (q, as, key) => {
+  const shapes = q.q[key];
+  if (shapes?.[as]) {
+    let suffix = 2;
+    while (shapes[as = `${as}${suffix}`]) {
+      suffix++;
     }
   }
-  return `${quotedAs ? `${quotedAs}.` : ""}"${column}"${column === as ? "" : ` "${as}"`}`;
+  setQueryObjectValueImmutable(q, key, as, orchidCore.emptyObject);
+  return as;
 };
-const rawOrColumnToSql = (ctx, data, expr, quotedAs, shape = data.shape, select) => {
-  return typeof expr === "string" ? columnToSql(ctx, data, shape, expr, quotedAs, select) : expr.toSQL(ctx, quotedAs);
+const extendQuery = (q, methods) => {
+  const base = Object.create(q.baseQuery);
+  base.baseQuery = base;
+  Object.assign(base, methods);
+  const cloned = Object.create(base);
+  cloned.q = getClonedQueryData(q.q);
+  return cloned;
 };
-const quoteSchemaAndTable = (schema, table) => {
-  return schema ? `"${schema}"."${table}"` : `"${table}"`;
+const getPrimaryKeys = (q) => {
+  var _a;
+  return (_a = q.internal).primaryKeys ?? (_a.primaryKeys = collectPrimaryKeys(q));
 };
-const makeRowToJson = (table, shape, aliasName) => {
-  let isSimple = true;
-  const list = [];
+const collectPrimaryKeys = (q) => {
+  const primaryKeys = [];
+  const { shape } = q.q;
   for (const key in shape) {
-    const column = shape[key];
-    if (column.data.explicitSelect) {
-      continue;
-    }
-    if (aliasName && column.data.name || column.data.jsonCast) {
-      isSimple = false;
+    if (shape[key].data.primaryKey) {
+      primaryKeys.push(key);
     }
-    list.push(
-      `'${key}', "${table}"."${aliasName && column.data.name || key}"${column.data.jsonCast ? `::${column.data.jsonCast}` : ""}`
-    );
   }
-  return isSimple ? `row_to_json("${table}".*)` : `CASE WHEN "${table}".* IS NULL THEN NULL ELSE json_build_object(` + list.join(", ") + ") END";
+  const pkey = q.internal.tableData.primaryKey;
+  if (pkey) {
+    primaryKeys.push(...pkey.columns);
+  }
+  return primaryKeys;
 };
-
-const queryTypeWithLimitOne = {
-  one: true,
-  oneOrThrow: true,
-  value: true,
-  valueOrThrow: true
+const _queryAll = (q) => {
+  q.q.returnType = "all";
+  q.q.all = true;
+  return q;
 };
-const isQueryReturnsAll = (q) => !q.q.returnType || q.q.returnType === "all";
-
-const pushDistinctSql = (ctx, table, distinct, quotedAs) => {
-  ctx.sql.push("DISTINCT");
-  if (distinct.length) {
-    const columns = distinct?.map(
-      (item) => rawOrColumnToSql(ctx, table.q, item, quotedAs)
-    );
-    ctx.sql.push(`ON (${columns?.join(", ") || ""})`);
+const _queryTake = (query) => {
+  const q = query.q;
+  switch (q.returnType) {
+    case "valueOrThrow":
+    case "pluck":
+    case "void":
+      break;
+    case "value": {
+      q.returnType = "valueOrThrow";
+      break;
+    }
+    default: {
+      q.returnType = "oneOrThrow";
+    }
   }
+  return query;
 };
-
-const noneResult = (q, queryData, type) => {
-  if (!type || type === "all" || type === "rows" || type === "pluck") {
-    return [];
-  } else if (type === "one" || type === "value" || type === "void") {
-    return queryData.notFoundDefault;
-  } else if (type === "valueOrThrow" && queryData.returning) {
-    return 0;
-  } else {
-    throw new NotFoundError(q);
+const _queryTakeOptional = (query) => {
+  const q = query.q;
+  switch (q.returnType) {
+    case "value":
+    case "pluck":
+    case "void":
+      break;
+    case "valueOrThrow": {
+      q.returnType = "value";
+      break;
+    }
+    default: {
+      q.returnType = "one";
+    }
   }
+  return query;
 };
-const noneMethods = {
-  // `then` resolves or rejects based on a return type of the query.
-  // It is `async` so it returns a chainable Promise.
-  async then(resolve, reject) {
-    try {
-      const result = noneResult(this, this.q, this.q.returnType);
-      resolve?.(result);
-    } catch (err) {
-      reject?.(err);
-    }
-  },
-  // `catch` returns a Promise, so it is chainable with then/catch.
-  catch: () => new Promise(orchidCore.noop)
+const _queryExec = (q) => {
+  q.q.returnType = "void";
+  return q;
 };
-const _queryNone = (q) => {
-  if (isQueryNone(q)) return q;
-  q = extendQuery(q, noneMethods);
-  pushQueryValueImmutable(q, "and", new RawSQL("false"));
-  pushQueryValueImmutable(
-    q,
-    "transform",
-    (_, queryData) => noneResult(q, queryData, queryData.returnType)
-  );
+const _queryRows = (q) => {
+  q.q.returnType = "rows";
   return q;
 };
-const isQueryNone = (q) => q.then === noneMethods.then;
+const getFullColumnTable = (q, column, index, as) => {
+  const table = column.slice(0, index);
+  return as && table !== as && q.q.aliases?.[table] === as ? as : table;
+};
 
-const _join = (query, require, type, first, args) => {
-  let joinKey;
-  let shape;
-  let parsers;
-  let batchParsers;
-  let computeds;
-  let joinSubQuery = false;
-  first = preprocessJoinArg(query, first);
-  if (typeof first === "object") {
-    let isInternalJoin;
-    if ("_internalJoin" in first) {
-      isInternalJoin = true;
-      first = first._internalJoin;
-    }
-    if (require && isQueryNone(first)) {
-      return _queryNone(query);
-    }
-    const q = first;
-    if (!isInternalJoin) {
-      joinSubQuery = getIsJoinSubQuery(q);
-    }
-    joinKey = q.q.as || q.table;
-    if (joinKey) {
-      shape = getShapeFromSelect(q, joinSubQuery && !!q.q.select);
-      parsers = q.q.parsers;
-      batchParsers = q.q.batchParsers;
-      computeds = q.q.computeds;
-      if (joinSubQuery) {
-        first = q.clone();
-        first.shape = shape;
-      }
-    }
-  } else {
-    joinKey = first;
-    const relation = query.relations[joinKey];
-    if (relation) {
-      shape = getShapeFromSelect(relation.relationConfig.query);
-      const r = relation.relationConfig.query;
-      parsers = r.q.parsers;
-      batchParsers = r.q.batchParsers;
-      computeds = r.q.computeds;
-    } else {
-      const w = query.q.withShapes?.[joinKey];
-      shape = w?.shape;
-      computeds = w?.computeds;
-      if (shape) {
-        if (!require) shape = { ...shape };
-        const arg = { parsers: {} };
-        for (const key in shape) {
-          addColumnParserToQuery(arg, key, shape[key]);
-        }
-      }
-    }
-  }
-  const joinArgs = processJoinArgs(
-    query,
-    first,
-    args,
-    joinSubQuery
-  );
-  if (require && "r" in joinArgs && isQueryNone(joinArgs.r)) {
-    return _queryNone(query);
-  } else if (joinKey && "s" in joinArgs && joinArgs.s) {
-    const j = "j" in joinArgs ? joinArgs.r ?? joinArgs.j : "r" in joinArgs ? joinArgs.r : joinArgs.q;
-    const jq = j.q;
-    if (jq.select || !jq.selectAllColumns) {
-      const { q } = query;
-      const shape2 = getShapeFromSelect(j, true);
-      orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape2);
-      orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, jq.parsers);
-      if (jq.batchParsers) {
-        orchidCore.setObjectValueImmutable(
-          jq,
-          "joinedBatchParsers",
-          joinKey,
-          jq.batchParsers
-        );
-      }
-      orchidCore.setObjectValueImmutable(q, "joinedComputeds", joinKey, jq.computeds);
-    } else {
-      addAllShapesAndParsers(
-        query,
-        joinKey,
-        shape,
-        parsers,
-        batchParsers,
-        computeds
-      );
-    }
-  } else {
-    addAllShapesAndParsers(
-      query,
-      joinKey,
-      shape,
-      parsers,
-      batchParsers,
-      computeds
-    );
-  }
-  pushQueryValueImmutable(query, "join", {
-    type,
-    args: joinArgs
-  });
-  if (query.q.type === "delete") {
-    throwIfJoinLateral(
-      query,
-      query.q.type
+function simpleColumnToSQL(ctx, key, column, quotedAs) {
+  if (!column) return `"${key}"`;
+  const { data } = column;
+  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
+}
+function simpleExistingColumnToSQL(ctx, key, column, quotedAs) {
+  const { data } = column;
+  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
+}
+const columnToSql = (ctx, data, shape, column, quotedAs, select) => {
+  const index = column.indexOf(".");
+  if (index !== -1) {
+    return columnWithDotToSql(
+      ctx,
+      data,
+      shape,
+      column,
+      index,
+      quotedAs,
+      select
     );
   }
-  return query;
-};
-const addAllShapesAndParsers = (query, joinKey, shape, parsers, batchParsers, computeds) => {
-  if (!joinKey) return;
-  const { q } = query;
-  orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
-  orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, parsers);
-  if (batchParsers) {
-    orchidCore.setObjectValueImmutable(q, "joinedBatchParsers", joinKey, batchParsers);
+  if (!select && data.joinedShapes?.[column]) {
+    return `"${column}".r`;
   }
-  orchidCore.setObjectValueImmutable(q, "joinedComputeds", joinKey, computeds);
+  return simpleColumnToSQL(ctx, column, shape[column], quotedAs);
 };
-const _joinLateralProcessArg = (q, arg, cb) => {
-  let relation;
-  if (typeof arg === "string") {
-    relation = q.relations[arg];
-    if (relation) {
-      arg = _clone(relation.relationConfig.query);
-    } else {
-      const w = q.q.withShapes?.[arg];
-      if (w) {
-        const t = Object.create(q.queryBuilder);
-        t.table = arg;
-        t.shape = w.shape;
-        t.computeds = w.computeds;
-        t.q = {
-          ...t.q,
-          shape: w.shape
-        };
-        t.baseQuery = t;
-        arg = t;
+const maybeSelectedColumnToSql = (ctx, data, column, quotedAs) => {
+  const index = column.indexOf(".");
+  if (index !== -1) {
+    return columnWithDotToSql(ctx, data, data.shape, column, index, quotedAs);
+  } else {
+    if (data.joinedShapes?.[column]) {
+      return `"${column}".r`;
+    }
+    if (data.select) {
+      for (const s of data.select) {
+        if (typeof s === "object" && "selectAs" in s) {
+          if (column in s.selectAs) {
+            return simpleColumnToSQL(ctx, column, data.shape[column]);
+          }
+        }
       }
     }
+    return simpleColumnToSQL(ctx, column, data.shape[column], quotedAs);
   }
-  let result = resolveSubQueryCallbackV2(
-    arg,
-    cb
-  );
-  if (relation) {
-    result = relation.relationConfig.joinQuery(
-      result,
-      q
-    );
-  }
-  return result;
 };
-const _joinLateral = (self, type, arg, as) => {
-  const q = self;
-  arg.q.joinTo = q;
-  const joinedAs = getQueryAs(q);
-  orchidCore.setObjectValueImmutable(arg.q, "joinedShapes", joinedAs, q.q.shape);
-  const joinKey = as || arg.q.as || arg.table;
-  if (joinKey) {
-    const shape = getShapeFromSelect(arg, true);
-    orchidCore.setObjectValueImmutable(q.q, "joinedShapes", joinKey, shape);
-    orchidCore.setObjectValueImmutable(q.q, "joinedParsers", joinKey, arg.q.parsers);
-    if (arg.q.batchParsers) {
-      orchidCore.setObjectValueImmutable(
-        q.q,
-        "joinedBatchParsers",
-        joinKey,
-        arg.q.batchParsers
-      );
+const columnWithDotToSql = (ctx, data, shape, column, index, quotedAs, select) => {
+  const table = column.slice(0, index);
+  const key = column.slice(index + 1);
+  if (key === "*") {
+    const shape2 = data.joinedShapes?.[table];
+    return shape2 ? select ? makeRowToJson(table, shape2, true) : `"${table}".*` : column;
+  }
+  const tableName = data.aliases?.[table] || table;
+  const quoted = `"${table}"`;
+  const col = quoted === quotedAs ? shape[key] : data.joinedShapes?.[tableName]?.[key];
+  if (col) {
+    if (col.data.name) {
+      return `"${tableName}"."${col.data.name}"`;
+    }
+    if (col.data.computed) {
+      return col.data.computed.toSQL(ctx, quoted);
     }
+    return `"${tableName}"."${key}"`;
   }
-  as || (as = getQueryAs(arg));
-  orchidCore.setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.computeds);
-  pushQueryValueImmutable(q, "join", [type, arg, as]);
-  return q;
+  return `"${tableName}"."${key}"`;
 };
-
-class ArrayColumn extends ColumnType {
-  constructor(schema, item, inputType, outputType, queryType) {
-    super(schema, inputType, outputType, queryType);
-    this.dataType = "array";
-    this.operators = Operators.array;
-    item.data.isNullable = true;
-    setColumnDefaultParse(this, (input) => parse$1.call(this, input));
-    this.data.item = item instanceof ArrayColumn ? item.data.item : item;
-    this.data.name = item.data.name;
-    this.data.arrayDims = item instanceof ArrayColumn ? item.data.arrayDims + 1 : 1;
-  }
-  toSQL() {
-    return this.data.item.toSQL() + "[]".repeat(this.data.arrayDims);
+const columnToSqlWithAs = (ctx, data, column, as, quotedAs, select, jsonList) => {
+  const index = column.indexOf(".");
+  return index !== -1 ? tableColumnToSqlWithAs(
+    ctx,
+    data,
+    column,
+    column.slice(0, index),
+    column.slice(index + 1),
+    as,
+    quotedAs,
+    select,
+    jsonList
+  ) : ownColumnToSqlWithAs(ctx, data, column, as, quotedAs, select, jsonList);
+};
+const tableColumnToSqlWithAs = (ctx, data, column, table, key, as, quotedAs, select, jsonList) => {
+  if (key === "*") {
+    if (jsonList) jsonList[as] = void 0;
+    const shape = data.joinedShapes?.[table];
+    if (shape) {
+      {
+        return makeRowToJson(table, shape, true) + ` "${as}"`;
+      }
+    }
+    return column;
   }
-  toCode(ctx, key) {
-    let open = "array(";
-    let close = ")";
-    for (let i = 1; i < this.data.arrayDims; i++) {
-      open += `${ctx.t}.array(`;
-      close += ")";
+  const tableName = data.aliases?.[table] || table;
+  const quoted = `"${table}"`;
+  const col = quoted === quotedAs ? data.shape[key] : data.joinedShapes?.[tableName][key];
+  if (jsonList) jsonList[as] = col;
+  if (col) {
+    if (col.data.name && col.data.name !== key) {
+      return `"${tableName}"."${col.data.name}" "${as}"`;
+    }
+    if (col.data.computed) {
+      return `${col.data.computed.toSQL(ctx, quoted)} "${as}"`;
     }
-    const code = [open];
-    const { item } = this.data;
-    const { isNullable } = item.data;
-    delete item.data.isNullable;
-    orchidCore.addCode(code, item.toCode(ctx, key));
-    item.data.isNullable = isNullable;
-    orchidCore.addCode(code, `${close}${orchidCore.arrayDataToCode(this.data, ctx.migration)}`);
-    return columnCode(this, ctx, key, code);
   }
-}
-const parse$1 = function(source) {
-  if (typeof source !== "string") return source;
-  const entries = [];
-  parsePostgresArray(source, entries, this.data.item.data.parseItem);
-  return entries;
+  return `"${tableName}"."${key}"${key === as ? "" : ` "${as}"`}`;
 };
-const parsePostgresArray = (source, entries, transform) => {
-  let pos = 0;
-  if (source[0] === "[") {
-    pos = source.indexOf("=") + 1;
-    if (!pos) pos = source.length;
+const ownColumnToSqlWithAs = (ctx, data, column, as, quotedAs, select, jsonList) => {
+  const col = data.shape[column];
+  if (jsonList) jsonList[as] = col;
+  if (col) {
+    if (col.data.name && col.data.name !== column) {
+      return `${quotedAs ? `${quotedAs}.` : ""}"${col.data.name}"${col.data.name === as ? "" : ` "${as}"`}`;
+    }
+    if (col.data.computed) {
+      return `${col.data.computed.toSQL(ctx, quotedAs)} "${as}"`;
+    }
   }
-  if (source[pos] === "{") pos++;
-  let recorded = "";
-  while (pos < source.length) {
-    const character = source[pos++];
-    if (character === "{") {
-      const innerEntries = [];
-      entries.push(innerEntries);
-      pos += parsePostgresArray(source.slice(pos - 1), innerEntries, transform) - 1;
-    } else if (character === "}") {
-      if (recorded) {
-        entries.push(
-          recorded === "NULL" ? null : transform ? transform(recorded) : recorded
-        );
-      }
-      return pos;
-    } else if (character === '"') {
-      let esc = false;
-      let rec = "";
-      while (pos < source.length) {
-        let char;
-        while ((char = source[pos++]) === "\\") {
-          if (!(esc = !esc)) rec += "\\";
-        }
-        if (esc) {
-          esc = false;
-        } else if (char === '"') {
-          break;
-        }
-        rec += char;
-      }
-      entries.push(transform ? transform(rec) : rec);
-      recorded = "";
-    } else if (character === ",") {
-      if (recorded) {
-        entries.push(
-          recorded === "NULL" ? null : transform ? transform(recorded) : recorded
-        );
-        recorded = "";
-      }
-    } else {
-      recorded += character;
+  return `${quotedAs ? `${quotedAs}.` : ""}"${column}"${column === as ? "" : ` "${as}"`}`;
+};
+const rawOrColumnToSql = (ctx, data, expr, quotedAs, shape = data.shape, select) => {
+  return typeof expr === "string" ? columnToSql(ctx, data, shape, expr, quotedAs, select) : expr.toSQL(ctx, quotedAs);
+};
+const quoteSchemaAndTable = (schema, table) => {
+  return schema ? `"${schema}"."${table}"` : `"${table}"`;
+};
+const makeRowToJson = (table, shape, aliasName) => {
+  let isSimple = true;
+  const list = [];
+  for (const key in shape) {
+    const column = shape[key];
+    if (column.data.explicitSelect) {
+      continue;
+    }
+    if (aliasName && column.data.name || column.data.jsonCast) {
+      isSimple = false;
     }
+    list.push(
+      `'${key}', "${table}"."${aliasName && column.data.name || key}"${column.data.jsonCast ? `::${column.data.jsonCast}` : ""}`
+    );
   }
-  return pos;
+  return isSimple ? `row_to_json("${table}".*)` : `CASE WHEN "${table}".* IS NULL THEN NULL ELSE json_build_object(` + list.join(", ") + ") END";
 };
 
-class NumberBaseColumn extends ColumnType {
-  constructor() {
-    super(...arguments);
-    this.operators = Operators.number;
-  }
-}
-class IntegerBaseColumn extends NumberBaseColumn {
-  constructor(schema) {
-    super(schema, schema.int());
-    this.data.int = true;
-  }
-}
-class NumberAsStringBaseColumn extends ColumnType {
-  constructor(schema) {
-    super(schema, schema.stringSchema());
-    this.operators = Operators.number;
-    this.data.jsonCast = "text";
-  }
-}
-class DecimalColumn extends NumberAsStringBaseColumn {
-  constructor(schema, numericPrecision, numericScale) {
-    super(schema);
-    this.operators = Operators.number;
-    this.dataType = "numeric";
-    this.data.numericPrecision = numericPrecision;
-    this.data.numericScale = numericScale;
-    this.data.alias = "decimal";
-  }
-  toCode(ctx, key) {
-    const { numericPrecision, numericScale } = this.data;
-    return columnCode(
-      this,
-      ctx,
-      key,
-      `decimal(${numericPrecision || ""}${numericScale ? `, ${numericScale}` : ""})`
-    );
-  }
-  toSQL() {
-    const { numericPrecision, numericScale } = this.data;
-    return orchidCore.joinTruthy(
-      this.dataType,
-      numericPrecision ? numericScale ? `(${numericPrecision}, ${numericScale})` : `(${numericPrecision})` : void 0
+const queryTypeWithLimitOne = {
+  one: true,
+  oneOrThrow: true,
+  value: true,
+  valueOrThrow: true
+};
+const isQueryReturnsAll = (q) => !q.q.returnType || q.q.returnType === "all";
+
+const pushDistinctSql = (ctx, table, distinct, quotedAs) => {
+  ctx.sql.push("DISTINCT");
+  if (distinct.length) {
+    const columns = distinct?.map(
+      (item) => rawOrColumnToSql(ctx, table.q, item, quotedAs)
     );
+    ctx.sql.push(`ON (${columns?.join(", ") || ""})`);
   }
-}
-const skipNumberMethods = { int: true };
-const intToCode = (column, ctx, key, alias) => {
-  let code;
-  if (column.data.identity) {
-    code = identityToCode(column.data.identity, alias);
+};
+
+const noneResult = (q, queryData, type) => {
+  if (!type || type === "all" || type === "rows" || type === "pluck") {
+    return [];
+  } else if (type === "one" || type === "value" || type === "void") {
+    return queryData.notFoundDefault;
+  } else if (type === "valueOrThrow" && queryData.returning) {
+    return 0;
   } else {
-    code = [`${alias}()`];
+    throw new NotFoundError(q);
   }
-  orchidCore.addCode(
-    code,
-    orchidCore.numberDataToCode(column.data, ctx.migration, skipNumberMethods)
+};
+const noneMethods = {
+  // `then` resolves or rejects based on a return type of the query.
+  // It is `async` so it returns a chainable Promise.
+  async then(resolve, reject) {
+    try {
+      const result = noneResult(this, this.q, this.q.returnType);
+      resolve?.(result);
+    } catch (err) {
+      reject?.(err);
+    }
+  },
+  // `catch` returns a Promise, so it is chainable with then/catch.
+  catch: () => new Promise(orchidCore.noop)
+};
+const _queryNone = (q) => {
+  if (isQueryNone(q)) return q;
+  q = extendQuery(q, noneMethods);
+  pushQueryValueImmutable(q, "and", new RawSQL("false"));
+  pushQueryValueImmutable(
+    q,
+    "transform",
+    (_, queryData) => noneResult(q, queryData, queryData.returnType)
   );
-  return columnCode(column, ctx, key, code);
+  return q;
 };
-class SmallIntColumn extends IntegerBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "int2";
-    this.data.alias = "smallint";
-    this.data.parseItem = parseInt;
-  }
-  toCode(ctx, key) {
-    return intToCode(this, ctx, key, "smallint");
-  }
-  identity(options = {}) {
-    return orchidCore.setColumnData(this, "identity", options);
-  }
-}
-class IntegerColumn extends IntegerBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "int4";
-    this.data.alias = "integer";
-    this.data.parseItem = parseInt;
-  }
-  toCode(ctx, key) {
-    return intToCode(this, ctx, key, "integer");
-  }
-  identity(options = {}) {
-    return orchidCore.setColumnData(this, "identity", options);
-  }
-}
-class BigIntColumn extends NumberAsStringBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "int8";
-    this.data.alias = "bigint";
-  }
-  toCode(ctx, key) {
-    return intToCode(this, ctx, key, "bigint");
-  }
-  identity(options = {}) {
-    return orchidCore.setColumnData(this, "identity", options);
-  }
-}
-class RealColumn extends NumberBaseColumn {
-  constructor(schema) {
-    super(schema, schema.number());
-    this.dataType = "float4";
-    this.data.alias = "real";
-    this.data.parseItem = parseFloat;
+const isQueryNone = (q) => q.then === noneMethods.then;
+
+const _join = (query, require, type, first, args) => {
+  let joinKey;
+  let shape;
+  let parsers;
+  let batchParsers;
+  let computeds;
+  let joinSubQuery = false;
+  first = preprocessJoinArg(query, first);
+  if (typeof first === "object") {
+    let isInternalJoin;
+    if ("_internalJoin" in first) {
+      isInternalJoin = true;
+      first = first._internalJoin;
+    }
+    if (require && isQueryNone(first)) {
+      return _queryNone(query);
+    }
+    const q = first;
+    if (!isInternalJoin) {
+      joinSubQuery = getIsJoinSubQuery(q);
+    }
+    joinKey = q.q.as || q.table;
+    if (joinKey) {
+      shape = getShapeFromSelect(q, joinSubQuery && !!q.q.select);
+      parsers = q.q.parsers;
+      batchParsers = q.q.batchParsers;
+      computeds = q.q.computeds;
+      if (joinSubQuery) {
+        first = q.clone();
+        first.shape = shape;
+      }
+    }
+  } else {
+    joinKey = first;
+    const relation = query.relations[joinKey];
+    if (relation) {
+      shape = getShapeFromSelect(relation.relationConfig.query);
+      const r = relation.relationConfig.query;
+      parsers = r.q.parsers;
+      batchParsers = r.q.batchParsers;
+      computeds = r.q.computeds;
+    } else {
+      const w = query.q.withShapes?.[joinKey];
+      shape = w?.shape;
+      computeds = w?.computeds;
+      if (shape) {
+        if (!require) shape = { ...shape };
+        const arg = { parsers: {} };
+        for (const key in shape) {
+          addColumnParserToQuery(arg, key, shape[key]);
+        }
+      }
+    }
   }
-  toCode(ctx, key) {
-    return columnCode(
-      this,
-      ctx,
-      key,
-      `real()${orchidCore.numberDataToCode(this.data, ctx.migration)}`
+  const joinArgs = processJoinArgs(
+    query,
+    first,
+    args,
+    joinSubQuery
+  );
+  if (require && "r" in joinArgs && isQueryNone(joinArgs.r)) {
+    return _queryNone(query);
+  } else if (joinKey && "s" in joinArgs && joinArgs.s) {
+    const j = "j" in joinArgs ? joinArgs.r ?? joinArgs.j : "r" in joinArgs ? joinArgs.r : joinArgs.q;
+    const jq = j.q;
+    if (jq.select || !jq.selectAllColumns) {
+      const { q } = query;
+      const shape2 = getShapeFromSelect(j, true);
+      orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape2);
+      orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, jq.parsers);
+      if (jq.batchParsers) {
+        orchidCore.setObjectValueImmutable(
+          jq,
+          "joinedBatchParsers",
+          joinKey,
+          jq.batchParsers
+        );
+      }
+      orchidCore.setObjectValueImmutable(q, "joinedComputeds", joinKey, jq.computeds);
+    } else {
+      addAllShapesAndParsers(
+        query,
+        joinKey,
+        shape,
+        parsers,
+        batchParsers,
+        computeds
+      );
+    }
+  } else {
+    addAllShapesAndParsers(
+      query,
+      joinKey,
+      shape,
+      parsers,
+      batchParsers,
+      computeds
     );
   }
-}
-class DoublePrecisionColumn extends NumberAsStringBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "float8";
-    this.data.alias = "doublePrecision";
-  }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `doublePrecision()`);
-  }
-}
-class SmallSerialColumn extends IntegerBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "int2";
-    this.data.int = true;
-    this.data.alias = "smallSerial";
-    this.data.parseItem = parseInt;
-  }
-  toSQL() {
-    return "smallserial";
-  }
-  toCode(ctx, key) {
-    return columnCode(
-      this,
-      ctx,
-      key,
-      `smallSerial()${orchidCore.numberDataToCode(
-        this.data,
-        ctx.migration,
-        skipNumberMethods
-      )}`
+  pushQueryValueImmutable(query, "join", {
+    type,
+    args: joinArgs
+  });
+  if (query.q.type === "delete") {
+    throwIfJoinLateral(
+      query,
+      query.q.type
     );
   }
-}
-class SerialColumn extends IntegerBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "int4";
-    this.data.int = true;
-    this.data.alias = "serial";
-    this.data.parseItem = parseInt;
+  return query;
+};
+const addAllShapesAndParsers = (query, joinKey, shape, parsers, batchParsers, computeds) => {
+  if (!joinKey) return;
+  const { q } = query;
+  orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
+  orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, parsers);
+  if (batchParsers) {
+    orchidCore.setObjectValueImmutable(q, "joinedBatchParsers", joinKey, batchParsers);
   }
-  toSQL() {
-    return "serial";
+  orchidCore.setObjectValueImmutable(q, "joinedComputeds", joinKey, computeds);
+};
+const _joinLateralProcessArg = (q, arg, cb) => {
+  let relation;
+  if (typeof arg === "string") {
+    relation = q.relations[arg];
+    if (relation) {
+      arg = _clone(relation.relationConfig.query);
+    } else {
+      const w = q.q.withShapes?.[arg];
+      if (w) {
+        const t = Object.create(q.queryBuilder);
+        t.table = arg;
+        t.shape = w.shape;
+        t.computeds = w.computeds;
+        t.q = {
+          ...t.q,
+          shape: w.shape
+        };
+        t.baseQuery = t;
+        arg = t;
+      }
+    }
   }
-  toCode(ctx, key) {
-    return columnCode(
-      this,
-      ctx,
-      key,
-      `serial()${orchidCore.numberDataToCode(
-        this.data,
-        ctx.migration,
-        skipNumberMethods
-      )}`
+  let result = resolveSubQueryCallbackV2(
+    arg,
+    cb
+  );
+  if (relation) {
+    result = relation.relationConfig.joinQuery(
+      result,
+      q
     );
   }
-}
-class BigSerialColumn extends NumberAsStringBaseColumn {
-  constructor(schema) {
-    super(schema);
-    this.dataType = "int8";
-    this.data.alias = "bigint";
-  }
-  toSQL() {
-    return "bigserial";
-  }
-  toCode(ctx, key) {
-    return columnCode(this, ctx, key, `bigSerial()`);
+  return result;
+};
+const _joinLateral = (self, type, arg, as) => {
+  const q = self;
+  arg.q.joinTo = q;
+  const joinedAs = getQueryAs(q);
+  orchidCore.setObjectValueImmutable(arg.q, "joinedShapes", joinedAs, q.q.shape);
+  const joinKey = as || arg.q.as || arg.table;
+  if (joinKey) {
+    const shape = getShapeFromSelect(arg, true);
+    orchidCore.setObjectValueImmutable(q.q, "joinedShapes", joinKey, shape);
+    orchidCore.setObjectValueImmutable(q.q, "joinedParsers", joinKey, arg.q.parsers);
+    if (arg.q.batchParsers) {
+      orchidCore.setObjectValueImmutable(
+        q.q,
+        "joinedBatchParsers",
+        joinKey,
+        arg.q.batchParsers
+      );
+    }
   }
-}
-
-const parseDateToDate = (value) => new Date(value);
-const defaultSchemaConfig = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  parse(fn) {
-    return setColumnParse(this, fn);
-  },
-  parseNull(fn) {
-    return setColumnParseNull(this, fn);
-  },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  encode(fn) {
-    return orchidCore.setColumnData(this, "encode", fn);
-  },
-  asType() {
-    return this;
-  },
-  dateAsNumber() {
-    return this.parse(Date.parse);
-  },
-  dateAsDate() {
-    return this.parse(parseDateToDate);
-  },
-  enum(dataType, type) {
-    return new EnumColumn(defaultSchemaConfig, dataType, type, void 0);
-  },
-  array(item) {
-    return new ArrayColumn(defaultSchemaConfig, item, void 0);
-  },
-  boolean: orchidCore.noop,
-  buffer: orchidCore.noop,
-  unknown: orchidCore.noop,
-  never: orchidCore.noop,
-  stringSchema: orchidCore.noop,
-  stringMin: orchidCore.noop,
-  stringMax: orchidCore.noop,
-  stringMinMax: orchidCore.noop,
-  number: orchidCore.noop,
-  int: orchidCore.noop,
-  stringNumberDate: orchidCore.noop,
-  timeInterval: orchidCore.noop,
-  bit: orchidCore.noop,
-  uuid: orchidCore.noop,
-  nullable() {
-    return orchidCore.setColumnData(this, "isNullable", true);
-  },
-  json() {
-    return new JSONColumn(defaultSchemaConfig, void 0);
-  },
-  setErrors: orchidCore.noop,
-  smallint: () => new SmallIntColumn(defaultSchemaConfig),
-  integer: () => new IntegerColumn(defaultSchemaConfig),
-  real: () => new RealColumn(defaultSchemaConfig),
-  smallSerial: () => new SmallSerialColumn(defaultSchemaConfig),
-  serial: () => new SerialColumn(defaultSchemaConfig),
-  bigint: () => new BigIntColumn(defaultSchemaConfig),
-  decimal: (precision, scale) => new DecimalColumn(defaultSchemaConfig, precision, scale),
-  doublePrecision: () => new DoublePrecisionColumn(defaultSchemaConfig),
-  bigSerial: () => new BigSerialColumn(defaultSchemaConfig),
-  money: () => new MoneyColumn(defaultSchemaConfig),
-  varchar: (limit) => new VarCharColumn(defaultSchemaConfig, limit),
-  text: () => new TextColumn(defaultSchemaConfig),
-  string: (limit) => new StringColumn(defaultSchemaConfig, limit),
-  citext: () => new CitextColumn(defaultSchemaConfig),
-  date: () => new DateColumn(defaultSchemaConfig),
-  timestampNoTZ: (precision) => new TimestampColumn(defaultSchemaConfig, precision),
-  timestamp: (precision) => new TimestampTZColumn(defaultSchemaConfig, precision),
-  geographyPointSchema: orchidCore.noop
+  as || (as = getQueryAs(arg));
+  orchidCore.setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.computeds);
+  pushQueryValueImmutable(q, "join", [type, arg, as]);
+  return q;
 };
 
 const escape = (value, migration, nested) => {
@@ -2864,14 +2876,25 @@ class AfterCommitError extends OrchidOrmError {
     this.hookResults = hookResults;
   }
 }
-const _afterCommitError = (result, hookResults, catchAfterCommitError) => {
-  const err = new AfterCommitError(result, hookResults);
-  if (catchAfterCommitError) {
-    catchAfterCommitError(err);
-  } else {
-    throw err;
+const _runAfterCommitHooks = async (result, promises, getHookNames, catchAfterCommitErrors) => {
+  const hookResults = await Promise.allSettled(promises);
+  if (hookResults.some((result2) => result2.status === "rejected")) {
+    const hookNames = getHookNames();
+    for (const [i, r] of hookResults.entries()) {
+      r.name = hookNames[i];
+    }
+    const err = new AfterCommitError(result, hookResults);
+    if (!catchAfterCommitErrors) throw err;
+    for (const fn of catchAfterCommitErrors) {
+      try {
+        fn(err);
+      } catch {
+      }
+    }
   }
 };
+const isInUserTransaction = (trx) => !!(trx && // when inside test transactions, compare transaction counts to ensure there is a user transaction.
+(!trx.testTransactionCount || trx.transactionId >= trx.testTransactionCount));
 class Transaction {
   async transaction(cbOrOptions, cb) {
     let options;
@@ -2914,10 +2937,7 @@ class Transaction {
         throw err;
       });
       if (log) log.afterQuery(commitSql$1, logData);
-      await runAfterCommit(
-        trx.afterCommit,
-        result
-      );
+      runAfterCommit(trx.afterCommit, result);
       return result;
     } else {
       try {
@@ -2942,7 +2962,7 @@ class Transaction {
         if (transactionId === trx.testTransactionCount) {
           const { afterCommit } = trx;
           trx.afterCommit = void 0;
-          await runAfterCommit(afterCommit, result);
+          runAfterCommit(afterCommit, result);
         }
         return result;
       } finally {
@@ -2977,42 +2997,95 @@ class Transaction {
   }
   isInTransaction() {
     const trx = this.internal.transactionStorage.getStore();
-    return !!(trx && (!trx.testTransactionCount || trx.transactionId >= trx.testTransactionCount));
+    return isInUserTransaction(trx);
   }
-}
-const runAfterCommit = async (afterCommit, result) => {
-  if (afterCommit) {
-    const promises = [];
-    let catchAfterCommitError;
-    for (let i = 0, len = afterCommit.length; i < len; i += 3) {
-      const result2 = afterCommit[i];
-      const q = afterCommit[i + 1];
-      if (q.q.catchAfterCommitError) {
-        catchAfterCommitError = q.q.catchAfterCommitError;
-      }
-      for (const fn of afterCommit[i + 2]) {
-        try {
-          promises.push(fn(result2, q));
-        } catch (err) {
-          promises.push(Promise.reject(err));
+  /**
+   * Schedules a hook to run after the outermost transaction commits:
+   *
+   * ```ts
+   * await db.$transaction(async () => {
+   *   await db.table.create(data)
+   *   await db.table.where({ ...conditions }).update({ key: 'value' })
+   *
+   *   db.$afterCommit(() => { // can be sync or async
+   *     console.log('after commit')
+   *   })
+   * })
+   * ```
+   *
+   * If used outside the transaction, the hook will be executed almost immediately, on the next microtask:
+   *
+   * ```ts
+   * db.$afterCommit(async () => { // can be sync or async
+   *   console.log('after commit')
+   * })
+   * ```
+   *
+   * If the callback has no `try/catch` and throws an error,
+   * this will cause `uncaughtException` if the callback is sync and `unhandledRejection` if it is async.
+   */
+  afterCommit(hook) {
+    const trx = this.internal.transactionStorage.getStore();
+    if (isInUserTransaction(trx)) {
+      (trx.afterCommit ?? (trx.afterCommit = [])).push(hook);
+    } else {
+      queueMicrotask(hook);
+    }
+  }
+}
+const runAfterCommit = (afterCommit, result) => {
+  queueMicrotask(async () => {
+    if (afterCommit) {
+      const promises = [];
+      let catchAfterCommitErrors;
+      for (let i = 0, len = afterCommit.length; i < len; ) {
+        const first = afterCommit[i];
+        if (typeof first === "function") {
+          try {
+            promises.push(first());
+          } catch (err) {
+            promises.push(Promise.reject(err));
+          }
+          i++;
+        } else {
+          const q = afterCommit[i + 1];
+          if (q.q.catchAfterCommitErrors) {
+            (catchAfterCommitErrors ?? (catchAfterCommitErrors = [])).push(...q.q.catchAfterCommitErrors);
+          }
+          for (const fn of afterCommit[i + 2]) {
+            try {
+              promises.push(fn(first, q));
+            } catch (err) {
+              promises.push(Promise.reject(err));
+            }
+          }
+          i += 3;
         }
       }
-    }
-    const hookResults = await Promise.allSettled(promises);
-    if (hookResults.some((result2) => result2.status === "rejected")) {
-      const resultsWithNames = [];
-      let r = 0;
-      for (let i = 0, len = afterCommit.length; i < len; i += 3) {
-        for (const fn of afterCommit[i + 2]) {
-          resultsWithNames.push({
-            ...hookResults[r++],
-            name: fn.name
-          });
+      const getHookNames = () => {
+        const hookNames = [];
+        for (let i = 0, len = afterCommit.length; i < len; ) {
+          const first = afterCommit[i];
+          if (typeof first === "function") {
+            hookNames.push(first.name);
+            i++;
+          } else {
+            for (const fn of afterCommit[i + 2]) {
+              hookNames.push(fn.name);
+            }
+            i += 3;
+          }
         }
-      }
-      _afterCommitError(result, resultsWithNames, catchAfterCommitError);
+        return hookNames;
+      };
+      await _runAfterCommitHooks(
+        result,
+        promises,
+        getHookNames,
+        catchAfterCommitErrors
+      );
     }
-  }
+  });
 };
 
 const applyBatchTransforms = (q, batches) => {
@@ -3430,35 +3503,32 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
           );
         }
         if (afterCommitHooks) {
-          if (trx && // when inside test transactions, push to a transaction only unless it's the outer user transaction.
-          (!trx.testTransactionCount || trx.transactionId + 1 > trx.testTransactionCount)) {
+          if (isInUserTransaction(trx)) {
             (trx.afterCommit ?? (trx.afterCommit = [])).push(
               result,
               q,
               afterCommitHooks
             );
           } else {
-            const promises = [];
-            for (const fn of afterCommitHooks) {
-              try {
-                promises.push(
-                  fn(result, q)
-                );
-              } catch (err) {
-                promises.push(Promise.reject(err));
+            const localResult = result;
+            queueMicrotask(async () => {
+              const promises = [];
+              for (const fn of afterCommitHooks) {
+                try {
+                  promises.push(
+                    fn(localResult, q)
+                  );
+                } catch (err) {
+                  promises.push(Promise.reject(err));
+                }
               }
-            }
-            const hookResults = await Promise.allSettled(promises);
-            if (hookResults.some((result2) => result2.status === "rejected")) {
-              _afterCommitError(
-                result,
-                hookResults.map((result2, i) => ({
-                  ...result2,
-                  name: afterCommitHooks[i].name
-                })),
-                q.q.catchAfterCommitError
+              await _runAfterCommitHooks(
+                localResult,
+                promises,
+                () => afterCommitHooks.map((h) => h.name),
+                q.q.catchAfterCommitErrors
               );
-            }
+            });
           }
         }
       } else if (query.after) {
@@ -4327,7 +4397,7 @@ const getShapeFromSelect = (q, isSubQuery) => {
             const { returnType } = it.q;
             if (returnType === "value" || returnType === "valueOrThrow") {
               const type = it.q.getColumn;
-              if (type) result[key] = type;
+              result[key] = type || UnknownColumn.instance;
             } else {
               result[key] = new JSONTextColumn(defaultSchemaConfig);
             }
@@ -7976,7 +8046,7 @@ class AggregateMethods {
   boolAnd(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      BooleanColumn.instance,
       "bool_and",
       [arg],
       options
@@ -8005,7 +8075,7 @@ class AggregateMethods {
   boolOr(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      BooleanColumn.instance,
       "bool_or",
       [arg],
       options
@@ -8017,7 +8087,7 @@ class AggregateMethods {
   every(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      BooleanColumn.instance,
       "every",
       [arg],
       options
@@ -8050,7 +8120,7 @@ class AggregateMethods {
   jsonAgg(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      JSONTextColumn.instance,
       "json_agg",
       [arg],
       options
@@ -8062,7 +8132,7 @@ class AggregateMethods {
   jsonbAgg(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      JSONTextColumn.instance,
       "jsonb_agg",
       [arg],
       options
@@ -8103,7 +8173,7 @@ class AggregateMethods {
   jsonObjectAgg(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      JSONTextColumn.instance,
       "json_object_agg",
       [{ pairs: arg }],
       options
@@ -8115,7 +8185,7 @@ class AggregateMethods {
   jsonbObjectAgg(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      JSONTextColumn.instance,
       "jsonb_object_agg",
       [{ pairs: arg }],
       options
@@ -8146,7 +8216,7 @@ class AggregateMethods {
   stringAgg(arg, delimiter, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      TextColumn.instance,
       "string_agg",
       [arg, { value: delimiter }],
       options
@@ -8172,7 +8242,7 @@ class AggregateMethods {
   xmlAgg(arg, options) {
     return makeFnExpression(
       this,
-      orchidCore.emptyObject,
+      XMLColumn.instance,
       "xmlagg",
       [arg],
       options
@@ -9506,7 +9576,9 @@ class QueryHooks {
    *   })
    *   .catchAfterCommitError((err) => {
    *     // err is instance of AfterCommitError (see below)
-   *   });
+   *   })
+   *   // can be added multiple times, all catchers will be executed
+   *   .catchAfterCommitError((err) => {});
    *
    * // result is available even if an after commit hook has failed
    * result.id;
@@ -9514,7 +9586,7 @@ class QueryHooks {
    */
   catchAfterCommitError(fn) {
     const q = _clone(this);
-    q.q.catchAfterCommitError = fn;
+    pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
     return q;
   }
 }
@@ -13296,7 +13368,6 @@ exports.VirtualColumn = VirtualColumn;
 exports.Where = Where;
 exports.WithMethods = WithMethods;
 exports.XMLColumn = XMLColumn;
-exports._afterCommitError = _afterCommitError;
 exports._clone = _clone;
 exports._getSelectableColumn = _getSelectableColumn;
 exports._initQueryBuilder = _initQueryBuilder;
@@ -13358,6 +13429,7 @@ exports._queryWhereNotOneOf = _queryWhereNotOneOf;
 exports._queryWhereNotSql = _queryWhereNotSql;
 exports._queryWhereOneOf = _queryWhereOneOf;
 exports._queryWhereSql = _queryWhereSql;
+exports._runAfterCommitHooks = _runAfterCommitHooks;
 exports.addColumnParserToQuery = addColumnParserToQuery;
 exports.addParserForRawExpression = addParserForRawExpression;
 exports.addParserForSelectItem = addParserForSelectItem;
@@ -13402,6 +13474,7 @@ exports.identityToCode = identityToCode;
 exports.indexInnerToCode = indexInnerToCode;
 exports.indexToCode = indexToCode;
 exports.isDefaultTimeStamp = isDefaultTimeStamp;
+exports.isInUserTransaction = isInUserTransaction;
 exports.isQueryReturnsAll = isQueryReturnsAll;
 exports.isSelectingCount = isSelectingCount;
 exports.joinSubQuery = joinSubQuery;