pqb 0.27.6 → 0.28.0

package/dist/index.js

@@ -101,10 +101,23 @@ const countSelect = [new RawSQL("count(*)")];
 function sqlQueryArgsToExpression(args) {
   return Array.isArray(args[0]) ? new RawSQL(args) : args[0];
 }
+const sqlFn = (...args) => {
+  const arg = args[0];
+  if (Array.isArray(arg)) {
+    return new RawSQL(args);
+  }
+  if (typeof args[0] === "string") {
+    return new RawSQL(args[0]);
+  }
+  if (args[1] !== void 0) {
+    return new RawSQL(args[1], arg);
+  }
+  return (...args2) => new RawSQL(args2, arg);
+};
 
 var __defProp$h = Object.defineProperty;
-var __defProps$b = Object.defineProperties;
-var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$i = Object.getOwnPropertySymbols;
 var __hasOwnProp$i = Object.prototype.hasOwnProperty;
 var __propIsEnum$i = Object.prototype.propertyIsEnumerable;
@@ -120,7 +133,7 @@ var __spreadValues$h = (a, b) => {
     }
   return a;
 };
-var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
 class ColumnType extends orchidCore.ColumnTypeBase {
   /**
    * Mark the column as a primary key.
@@ -135,30 +148,90 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    *   readonly table = 'table';
    *   columns = this.setColumns((t) => ({
    *     id: t.uuid().primaryKey(),
+   *     // database-level name can be passed:
+   *     id: t.uuid().primaryKey('primary_key_name'),
    *   }));
    * }
    *
    * // primary key can be used by `find` later:
    * db.table.find('97ba9e78-7510-415a-9c03-23d440aec443');
    * ```
+   *
+   * @param name - to specify a constraint name
    */
-  primaryKey() {
-    return orchidCore.setColumnData(this, "isPrimaryKey", true);
+  primaryKey(name) {
+    return orchidCore.setColumnData(this, "primaryKey", name != null ? name : true);
   }
   foreignKey(fnOrTable, column, options = orchidCore.emptyObject) {
-    const item = typeof fnOrTable === "string" ? __spreadValues$h({ table: fnOrTable, columns: [column] }, options) : __spreadValues$h({ fn: fnOrTable, columns: [column] }, options);
-    return orchidCore.pushColumnData(this, "foreignKeys", item);
+    return orchidCore.pushColumnData(this, "foreignKeys", {
+      fnOrTable,
+      foreignColumns: [column],
+      options
+    });
   }
   toSQL() {
     return this.dataType;
   }
-  index(options = {}) {
-    return orchidCore.pushColumnData(this, "indexes", options);
+  /**
+   * Add an index to the column.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('table', (t) => ({
+   *     // add an index to the name column with default settings:
+   *     name: t.text().index(),
+   *     // options are described below:
+   *     name: t.text().index({ ...options }),
+   *     // with a database-level name:
+   *     name: t.text().index('custom_index_name'),
+   *     // with name and options:
+   *     name: t.text().index('custom_index_name', { ...options }),
+   *   }));
+   * });
+   * ```
+   *
+   * Possible options are:
+   *
+   * ```ts
+   * type IndexOptions = {
+   *   // NULLS NOT DISTINCT: availabe in Postgres 15+, makes sense only for unique index
+   *   nullsNotDistinct?: true;
+   *   // index algorithm to use such as GIST, GIN
+   *   using?: string;
+   *   // specify collation:
+   *   collate?: string;
+   *   // see `opclass` in the Postgres document for creating the index
+   *   opclass?: string;
+   *   // specify index order such as ASC NULLS FIRST, DESC NULLS LAST
+   *   order?: string;
+   *   // include columns to an index to optimize specific queries
+   *   include?: MaybeArray<string>;
+   *   // see "storage parameters" in the Postgres document for creating an index, for example, 'fillfactor = 70'
+   *   with?: string;
+   *   // The tablespace in which to create the index. If not specified, default_tablespace is consulted, or temp_tablespaces for indexes on temporary tables.
+   *   tablespace?: string;
+   *   // WHERE clause to filter records for the index
+   *   where?: string;
+   *   // mode is for dropping the index
+   *   mode?: 'CASCADE' | 'RESTRICT';
+   * };
+   * ```
+   *
+   * @param args
+   */
+  index(...args) {
+    var _a;
+    return orchidCore.pushColumnData(this, "indexes", {
+      options: (_a = typeof args[0] === "string" ? args[1] : args[0]) != null ? _a : orchidCore.emptyObject,
+      name: typeof args[0] === "string" ? args[0] : void 0
+    });
   }
   /**
-   * `searchIndex` is designed for full text search.
+   * `searchIndex` is designed for [full text search](/guide/text-search).
    *
-   * It can accept the same options as a regular `index`, but it is `USING GIN` by default, and it is concatenating columns into a `tsvector`.
+   * It can accept the same options as a regular `index`, but it is `USING GIN` by default, and it is concatenating columns into a `tsvector` database type.
    *
    * ```ts
    * import { change } from '../dbScript';
@@ -166,8 +239,8 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    * change(async (db) => {
    *   await db.createTable('table', (t) => ({
    *     id: t.identity().primaryKey(),
-   *     title: t.string(),
-   *     body: t.string(),
+   *     title: t.text(),
+   *     body: t.text(),
    *     ...t.searchIndex(['title', 'body']),
    *   }));
    * });
@@ -176,10 +249,29 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    * Produces the following index ('english' is a default language, see [full text search](/guide/text-search.html#language) for changing it):
    *
    * ```sql
-   * CREATE INDEX "table_title_body_idx" ON "table" USING GIN (to_tsvector('english', concat_ws(' ', "title", "body")))
+   * CREATE INDEX "table_title_body_idx" ON "table" USING GIN (to_tsvector('english', "title" || ' ' || "body"))
+   * ```
+   *
+   * You can set different search weights (`A` to `D`) on different columns inside the index:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('table', (t) => ({
+   *     id: t.identity().primaryKey(),
+   *     title: t.text(),
+   *     body: t.text(),
+   *     ...t.searchIndex([
+   *       { column: 'title', weight: 'A' },
+   *       { column: 'body', weight: 'B' },
+   *     ]),
+   *   }));
+   * });
    * ```
    *
-   * Also, it works well with a generated `tsvector` column:
+   * When the table has localized columns,
+   * you can define different indexes for different languages by setting the `language` parameter:
    *
    * ```ts
    * import { change } from '../dbScript';
@@ -187,8 +279,44 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    * change(async (db) => {
    *   await db.createTable('table', (t) => ({
    *     id: t.identity().primaryKey(),
-   *     title: t.string(),
-   *     body: t.string(),
+   *     titleEn: t.text(),
+   *     bodyEn: t.text(),
+   *     titleFr: t.text(),
+   *     bodyFr: t.text(),
+   *     ...t.searchIndex(['titleEn', 'bodyEn'], { language: 'english' }),
+   *     ...t.searchIndex(['titleFr', 'bodyFr'], { language: 'french' }),
+   *   }));
+   * });
+   * ```
+   *
+   * Alternatively, different table records may correspond to a single language,
+   * then you can define a search index that relies on a language column by using `languageColumn` parameter:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('table', (t) => ({
+   *     id: t.identity().primaryKey(),
+   *     lang: t.type('regconfig'),
+   *     title: t.text(),
+   *     body: t.text(),
+   *     ...t.searchIndex(['title', 'body'], { languageColumn: 'lang' }),
+   *   }));
+   * });
+   * ```
+   *
+   * It can be more efficient to use a [generated](/guide/migration-column-methods.html#generated-column) column instead of indexing text column in the way described above,
+   * and to set a `searchIndex` on it:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('table', (t) => ({
+   *     id: t.identity().primaryKey(),
+   *     title: t.text(),
+   *     body: t.text(),
    *     generatedTsVector: t.tsvector().generated(['title', 'body']).searchIndex(),
    *   }));
    * });
@@ -202,11 +330,19 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    *
    * @param options - index options
    */
-  searchIndex(options) {
-    return orchidCore.pushColumnData(this, "indexes", __spreadValues$h(__spreadValues$h({}, options), this.dataType === "tsvector" ? { using: "GIN" } : { tsVector: true }));
+  searchIndex(...args) {
+    return orchidCore.pushColumnData(this, "indexes", {
+      options: __spreadValues$h(__spreadValues$h({}, typeof args[0] === "string" ? args[1] : args[0]), this.dataType === "tsvector" ? { using: "GIN" } : { tsVector: true }),
+      name: typeof args[0] === "string" ? args[0] : void 0
+    });
   }
-  unique(options = {}) {
-    return orchidCore.pushColumnData(this, "indexes", __spreadProps$b(__spreadValues$h({}, options), { unique: true }));
+  unique(...args) {
+    return orchidCore.pushColumnData(this, "indexes", {
+      options: __spreadProps$9(__spreadValues$h({}, typeof args[0] === "string" ? args[1] : args[0]), {
+        unique: true
+      }),
+      name: typeof args[0] === "string" ? args[0] : void 0
+    });
   }
   comment(comment) {
     return orchidCore.setColumnData(this, "comment", comment);
@@ -245,8 +381,8 @@ class ColumnType extends orchidCore.ColumnTypeBase {
 }
 
 var __defProp$g = Object.defineProperty;
-var __defProps$a = Object.defineProperties;
-var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
 var __hasOwnProp$h = Object.prototype.hasOwnProperty;
 var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
@@ -262,34 +398,32 @@ var __spreadValues$g = (a, b) => {
     }
   return a;
 };
-var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
 const knownDefaults = {
   current_timestamp: "now()",
   "transaction_timestamp()": "now()"
 };
 const simplifyColumnDefault = (value) => {
   if (typeof value === "string") {
-    const lower = value.toLowerCase();
-    return new RawSQL(knownDefaults[lower] || value);
+    return new RawSQL([
+      [knownDefaults[value.toLowerCase()] || value]
+    ]);
   }
   return;
 };
 const instantiateColumn = (typeFn, params) => {
   const column = typeFn();
-  Object.assign(column.data, __spreadProps$a(__spreadValues$g({}, params), {
+  const { dateTimePrecision } = params;
+  Object.assign(column.data, __spreadProps$8(__spreadValues$g({}, params), {
+    dateTimePrecision: (
+      // 0 is default for date, 6 is default for timestamp
+      dateTimePrecision && dateTimePrecision !== 6 ? dateTimePrecision : void 0
+    ),
+    collate: params.collate,
     default: simplifyColumnDefault(params.default)
   }));
   return column;
 };
-const getConstraintKind = (it) => {
-  let num = 0;
-  for (const key in it) {
-    if ((key === "references" || key === "check") && it[key] !== void 0) {
-      num++;
-    }
-  }
-  return num === 1 ? it.references ? "foreignKey" : "check" : "constraint";
-};
 
 const isDefaultTimeStamp = (item) => {
   if (item.dataType !== "timestamptz")
@@ -317,7 +451,7 @@ const combineCodeElements = (input) => {
   }
   return output;
 };
-const columnsShapeToCode = (shape, tableData, t) => {
+const columnsShapeToCode = (shape, t) => {
   const hasTimestamps = "createdAt" in shape && isDefaultTimeStamp(shape.createdAt) && "updatedAt" in shape && isDefaultTimeStamp(shape.updatedAt);
   const code = [];
   for (const key in shape) {
@@ -334,30 +468,64 @@ const columnsShapeToCode = (shape, tableData, t) => {
   if (hasTimestamps) {
     code.push(`...${t}.timestamps(),`);
   }
-  const { primaryKey, indexes, constraints } = tableData;
-  if (primaryKey) {
-    code.push(primaryKeyToCode(primaryKey, t));
+  return code;
+};
+const pushTableDataCode = (code, ast) => {
+  const lines = [];
+  if (ast.primaryKey) {
+    lines.push([primaryKeyInnerToCode(ast.primaryKey, "t") + ","]);
   }
-  if (indexes) {
-    for (const index of indexes) {
-      code.push(...indexToCode(index, t));
+  if (ast.indexes) {
+    for (const index of ast.indexes) {
+      lines.push(indexToCode(index, "t"));
     }
   }
-  if (constraints) {
-    for (const item of constraints) {
-      code.push(...constraintToCode(item, t));
+  if (ast.constraints) {
+    for (const constraint of ast.constraints) {
+      lines.push(constraintToCode(constraint, "t", true));
     }
   }
+  if (lines.length > 1) {
+    code.push("(t) => [", ...lines, "],");
+  } else if (lines[0].length === 1 && typeof lines[0][0] === "string") {
+    code.push("(t) => " + lines[0][0]);
+  } else {
+    code.push("(t) => ", lines[0]);
+  }
   return code;
 };
-const primaryKeyToCode = (primaryKey, t) => {
-  var _a;
-  const name = (_a = primaryKey.options) == null ? void 0 : _a.name;
-  return `...${t}.primaryKey([${primaryKey.columns.map(orchidCore.singleQuote).join(", ")}]${name ? `, { name: ${orchidCore.singleQuote(name)} }` : ""}),`;
+const primaryKeyInnerToCode = (primaryKey, t) => {
+  const name = primaryKey.name;
+  return `${t}.primaryKey([${primaryKey.columns.map(orchidCore.singleQuote).join(", ")}]${name ? `, ${orchidCore.singleQuote(name)}` : ""})`;
+};
+const indexToCode = (index, t, prefix) => {
+  const code = indexInnerToCode(index, t);
+  if (prefix)
+    code[0] = prefix + code[0];
+  const last = code[code.length - 1];
+  if (typeof last === "string" && !last.endsWith(","))
+    orchidCore.addCode(code, ",");
+  return code;
 };
-const indexToCode = (index, t) => {
+const indexInnerToCode = (index, t) => {
   const code = [];
-  code.push(`...${t}.index(`);
+  code.push(
+    `${t}.${index.options.tsVector ? "searchIndex" : index.options.unique ? "unique" : "index"}(`
+  );
+  const columnOptions = ["collate", "opclass", "order", "weight"];
+  const indexOptionsKeys = [
+    index.options.tsVector ? "unique" : void 0,
+    "using",
+    "nullsNotDistinct",
+    "include",
+    "with",
+    "tablespace",
+    "where",
+    "language",
+    "languageColumn",
+    "dropMode"
+  ];
+  const hasOptions = indexOptionsKeys.some((key) => key && index.options[key]);
   const columnsMultiline = index.columns.some((column) => {
     for (const key in column) {
       if (key !== "column" && column[key] !== void 0)
@@ -371,7 +539,7 @@ const indexToCode = (index, t) => {
       const expr = "column" in column ? column.column : column.expression;
       let hasOptions2 = false;
       for (const key in column) {
-        if (key !== "column" && key !== "expression") {
+        if (key !== "column") {
           hasOptions2 = true;
         }
       }
@@ -383,36 +551,38 @@ const indexToCode = (index, t) => {
             expr
           )},`
         ];
-        if (column.collate !== void 0) {
-          props.push(`collate: ${orchidCore.singleQuote(column.collate)},`);
-        }
-        if (column.opclass !== void 0) {
-          props.push(`opclass: ${orchidCore.singleQuote(column.opclass)},`);
-        }
-        if (column.order !== void 0) {
-          props.push(`order: ${orchidCore.singleQuote(column.order)},`);
+        for (const key of columnOptions) {
+          const value = column[key];
+          if (value !== void 0) {
+            props.push(`${key}: ${orchidCore.singleQuote(value)},`);
+          }
         }
         objects.push("{", props, "},");
       }
     }
-    code.push(["[", objects, "]"]);
+    code.push(["[", objects, hasOptions || index.name ? "]," : "]"]);
+    if (index.name) {
+      orchidCore.addCode(code, `  ${orchidCore.singleQuote(index.name)},`);
+    }
   } else {
     orchidCore.addCode(
       code,
       `[${index.columns.map((it) => orchidCore.singleQuote(it.column)).join(", ")}]`
     );
+    if (index.name) {
+      orchidCore.addCode(code, `, ${orchidCore.singleQuote(index.name)}`);
+    }
   }
-  const hasOptions = orchidCore.objectHasValues(index.options);
   if (hasOptions) {
     if (columnsMultiline) {
-      const columns = code[code.length - 1];
-      columns[columns.length - 1] += ",";
       code.push(["{"]);
     } else {
       orchidCore.addCode(code, ", {");
     }
     const options = [];
-    for (const key in index.options) {
+    for (const key of indexOptionsKeys) {
+      if (!key)
+        continue;
       const value = index.options[key];
       if (value === null || value === void 0)
         continue;
@@ -430,49 +600,43 @@ const indexToCode = (index, t) => {
   if (columnsMultiline) {
     code.push("),");
   } else {
-    orchidCore.addCode(code, "),");
+    orchidCore.addCode(code, ")");
   }
   return code;
 };
-const constraintToCode = (item, t) => {
-  const kind = getConstraintKind(item);
-  if (kind === "foreignKey" && item.references) {
+const constraintToCode = (item, t, m, prefix) => {
+  const code = constraintInnerToCode(item, t, m);
+  if (prefix)
+    code[0] = prefix + code[0];
+  const last = code[code.length - 1];
+  if (typeof last === "string" && !last.endsWith(","))
+    code[code.length - 1] += ",";
+  return code;
+};
+const constraintInnerToCode = (item, t, m) => {
+  if (item.references) {
     return [
-      `...${t}.foreignKey(`,
-      referencesArgsToCode(item.references, item.name),
+      `${t}.foreignKey(`,
+      referencesArgsToCode(item.references, item.name, m),
       "),"
     ];
-  } else if (kind === "check" && item.check) {
-    return [`...${t}.check(${item.check.toCode(t)}),`];
-  } else {
-    return [`...${t}.constraint({`, constraintPropsToCode(t, item), "}),"];
-  }
-};
-const constraintPropsToCode = (t, item) => {
-  const props = [];
-  if (item.name) {
-    props.push(`name: ${orchidCore.singleQuote(item.name)},`);
-  }
-  if (item.references) {
-    props.push(
-      `references: [`,
-      referencesArgsToCode(item.references, false),
-      "],"
-    );
-  }
-  if (item.check) {
-    props.push(`check: ${item.check.toCode(t)},`);
   }
-  return props;
+  return [
+    `${t}.check(${item.check.toCode(t)}${item.name ? `, ${orchidCore.singleQuote(item.name)}` : ""})`
+  ];
 };
 const referencesArgsToCode = ({
   columns,
   fnOrTable,
   foreignColumns,
   options
-}, name = (options == null ? void 0 : options.name) || false) => {
+}, name = (options == null ? void 0 : options.name) || false, m) => {
   const args = [];
   args.push(`${orchidCore.singleQuoteArray(columns)},`);
+  if (m && typeof fnOrTable !== "string") {
+    const { schema, table } = new (fnOrTable())();
+    fnOrTable = schema ? `${schema}.${table}` : table;
+  }
   args.push(
     `${typeof fnOrTable === "string" ? orchidCore.singleQuote(fnOrTable) : fnOrTable.toString()},`
   );
@@ -492,36 +656,42 @@ const referencesArgsToCode = ({
   }
   return args;
 };
-const columnForeignKeysToCode = (foreignKeys) => {
+const columnForeignKeysToCode = (foreignKeys, migration) => {
   const code = [];
   for (const foreignKey of foreignKeys) {
     orchidCore.addCode(code, `.foreignKey(`);
-    for (const part of foreignKeyArgumentToCode(foreignKey)) {
+    for (const part of foreignKeyArgumentToCode(foreignKey, migration)) {
       orchidCore.addCode(code, part);
     }
     orchidCore.addCode(code, ")");
   }
   return code;
 };
-const foreignKeyArgumentToCode = (foreignKey) => {
+const foreignKeyArgumentToCode = ({
+  fnOrTable,
+  foreignColumns,
+  options = orchidCore.emptyObject
+}, migration) => {
   const code = [];
-  if ("fn" in foreignKey) {
-    code.push(foreignKey.fn.toString());
-  } else {
-    code.push(orchidCore.singleQuote(foreignKey.table));
+  if (migration && typeof fnOrTable !== "string") {
+    const { schema, table } = new (fnOrTable())();
+    fnOrTable = schema ? `${schema}.${table}` : table;
   }
-  orchidCore.addCode(code, `, ${orchidCore.singleQuote(foreignKey.columns[0])}`);
-  const hasOptions = foreignKey.name || foreignKey.match || foreignKey.onUpdate || foreignKey.onDelete;
+  code.push(
+    typeof fnOrTable === "string" ? orchidCore.singleQuote(fnOrTable) : fnOrTable.toString()
+  );
+  orchidCore.addCode(code, `, ${orchidCore.singleQuote(foreignColumns[0])}`);
+  const hasOptions = options.name || options.match || options.onUpdate || options.onDelete;
   if (hasOptions) {
     const arr = [];
-    if (foreignKey.name)
-      arr.push(`name: ${orchidCore.singleQuote(foreignKey.name)},`);
-    if (foreignKey.match)
-      arr.push(`match: ${orchidCore.singleQuote(foreignKey.match)},`);
-    if (foreignKey.onUpdate)
-      arr.push(`onUpdate: ${orchidCore.singleQuote(foreignKey.onUpdate)},`);
-    if (foreignKey.onDelete)
-      arr.push(`onDelete: ${orchidCore.singleQuote(foreignKey.onDelete)},`);
+    if (options.name)
+      arr.push(`name: ${orchidCore.singleQuote(options.name)},`);
+    if (options.match)
+      arr.push(`match: ${orchidCore.singleQuote(options.match)},`);
+    if (options.onUpdate)
+      arr.push(`onUpdate: ${orchidCore.singleQuote(options.onUpdate)},`);
+    if (options.onDelete)
+      arr.push(`onDelete: ${orchidCore.singleQuote(options.onDelete)},`);
     orchidCore.addCode(code, ", {");
     code.push(arr);
     orchidCore.addCode(code, "}");
@@ -530,31 +700,31 @@ const foreignKeyArgumentToCode = (foreignKey) => {
 };
 const columnIndexesToCode = (indexes) => {
   const code = [];
-  for (const index of indexes) {
-    orchidCore.addCode(code, `.${index.unique ? "unique" : "index"}(`);
+  for (const { options, name } of indexes) {
+    orchidCore.addCode(code, `.${options.unique ? "unique" : "index"}(`);
     const arr = [];
-    if (index.collate)
-      arr.push(`collate: ${orchidCore.singleQuote(index.collate)},`);
-    if (index.opclass)
-      arr.push(`opclass: ${orchidCore.singleQuote(index.opclass)},`);
-    if (index.order)
-      arr.push(`order: ${orchidCore.singleQuote(index.order)},`);
-    if (index.name)
-      arr.push(`name: ${orchidCore.singleQuote(index.name)},`);
-    if (index.using)
-      arr.push(`using: ${orchidCore.singleQuote(index.using)},`);
-    if (index.include)
+    if (options.collate)
+      arr.push(`collate: ${orchidCore.singleQuote(options.collate)},`);
+    if (options.opclass)
+      arr.push(`opclass: ${orchidCore.singleQuote(options.opclass)},`);
+    if (options.order)
+      arr.push(`order: ${orchidCore.singleQuote(options.order)},`);
+    if (name)
+      arr.push(`name: ${orchidCore.singleQuote(name)},`);
+    if (options.using)
+      arr.push(`using: ${orchidCore.singleQuote(options.using)},`);
+    if (options.include)
       arr.push(
-        `include: ${typeof index.include === "string" ? orchidCore.singleQuote(index.include) : `[${index.include.map(orchidCore.singleQuote).join(", ")}]`},`
+        `include: ${typeof options.include === "string" ? orchidCore.singleQuote(options.include) : `[${options.include.map(orchidCore.singleQuote).join(", ")}]`},`
       );
-    if (index.nullsNotDistinct)
+    if (options.nullsNotDistinct)
       arr.push(`nullsNotDistinct: true,`);
-    if (index.with)
-      arr.push(`with: ${orchidCore.singleQuote(index.with)},`);
-    if (index.tablespace)
-      arr.push(`tablespace: ${orchidCore.singleQuote(index.tablespace)},`);
-    if (index.where)
-      arr.push(`where: ${orchidCore.singleQuote(index.where)},`);
+    if (options.with)
+      arr.push(`with: ${orchidCore.singleQuote(options.with)},`);
+    if (options.tablespace)
+      arr.push(`tablespace: ${orchidCore.singleQuote(options.tablespace)},`);
+    if (options.where)
+      arr.push(`where: ${orchidCore.singleQuote(options.where)},`);
     if (arr.length) {
       orchidCore.addCode(code, "{");
       orchidCore.addCode(code, arr);
@@ -564,8 +734,8 @@ const columnIndexesToCode = (indexes) => {
   }
   return code;
 };
-const columnCheckToCode = (t, check) => {
-  return `.check(${check.toCode(t)})`;
+const columnCheckToCode = (t, { sql, name }) => {
+  return `.check(${sql.toCode(t)}${name ? `, { name: '${name}' }` : ""})`;
 };
 const identityToCode = (identity, dataType) => {
   const code = [];
@@ -577,16 +747,18 @@ const identityToCode = (identity, dataType) => {
   const props = [];
   if (identity.always)
     props.push(`always: true,`);
-  if (identity.incrementBy)
-    props.push(`incrementBy: ${identity.incrementBy},`);
-  if (identity.startWith)
-    props.push(`startWith: ${identity.startWith},`);
+  if (identity.increment && identity.increment !== 1)
+    props.push(`increment: ${identity.increment},`);
+  if (identity.start && identity.start !== 1)
+    props.push(`start: ${identity.start},`);
   if (identity.min)
     props.push(`min: ${identity.min},`);
   if (identity.max)
     props.push(`max: ${identity.max},`);
-  if (identity.cache)
+  if (identity.cache && identity.cache !== 1)
     props.push(`cache: ${identity.cache},`);
+  if (identity.cycle)
+    props.push(`cycle: true,`);
   if (props.length) {
     orchidCore.addCode(code, "{");
     code.push(props, "}");
@@ -594,7 +766,7 @@ const identityToCode = (identity, dataType) => {
   orchidCore.addCode(code, ")");
   return code;
 };
-const columnCode = (type, t, code, data = type.data, skip) => {
+const columnCode = (type, t, code, migration, data = type.data, skip) => {
   code = orchidCore.toArray(code);
   let prepend = `${t}.`;
   if (data.name) {
@@ -605,10 +777,14 @@ const columnCode = (type, t, code, data = type.data, skip) => {
   } else {
     code[0].unshift(prepend);
   }
-  if (data.isPrimaryKey)
-    orchidCore.addCode(code, ".primaryKey()");
+  if (data.primaryKey) {
+    orchidCore.addCode(
+      code,
+      `.primaryKey(${data.primaryKey === true ? "" : orchidCore.singleQuote(data.primaryKey)})`
+    );
+  }
   if (data.foreignKeys) {
-    for (const part of columnForeignKeysToCode(data.foreignKeys)) {
+    for (const part of columnForeignKeysToCode(data.foreignKeys, migration)) {
       orchidCore.addCode(code, part);
     }
   }
@@ -622,7 +798,7 @@ const columnCode = (type, t, code, data = type.data, skip) => {
     orchidCore.addCode(code, `.parse(${type.parseFn.toString()})`);
   if (data.as)
     orchidCore.addCode(code, `.as(${data.as.toCode(t)})`);
-  if (data.default !== void 0) {
+  if (data.default !== void 0 && (!migration || typeof data.default !== "function")) {
     orchidCore.addCode(code, `.default(${orchidCore.columnDefaultArgumentToCode(t, data.default)})`);
   }
   if (data.indexes) {
@@ -824,8 +1000,8 @@ class JSONColumn extends ColumnType {
     this.dataType = "jsonb";
     this.operators = Operators.json;
   }
-  toCode(t) {
-    return columnCode(this, t, `json()`, this.data, toCodeSkip);
+  toCode(t, m) {
+    return columnCode(this, t, `json()`, m, this.data, toCodeSkip);
   }
 }
 JSONColumn.prototype.encodeFn = JSON.stringify;
@@ -835,8 +1011,8 @@ class JSONTextColumn extends ColumnType {
     this.dataType = "json";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `jsonText()`, this.data, toCodeSkip);
+  toCode(t, m) {
+    return columnCode(this, t, `jsonText()`, m, this.data, toCodeSkip);
   }
 }
 
@@ -1092,8 +1268,8 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
 };
 
 var __defProp$f = Object.defineProperty;
-var __defProps$9 = Object.defineProperties;
-var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
 var __hasOwnProp$g = Object.prototype.hasOwnProperty;
 var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
@@ -1109,7 +1285,7 @@ var __spreadValues$f = (a, b) => {
     }
   return a;
 };
-var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
 const processJoinItem = (ctx, table, query, args, quotedAs) => {
   let target;
   let on;
@@ -1171,8 +1347,8 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
       const whereSql = whereToSql(
         ctx,
         q,
-        __spreadProps$9(__spreadValues$f({}, q.q), {
-          joinedShapes: __spreadProps$9(__spreadValues$f(__spreadValues$f({}, query.joinedShapes), q.q.joinedShapes), {
+        __spreadProps$7(__spreadValues$f({}, q.q), {
+          joinedShapes: __spreadProps$7(__spreadValues$f(__spreadValues$f({}, query.joinedShapes), q.q.joinedShapes), {
             [table.q.as || table.table]: table.q.shape
           })
         }),
@@ -1329,8 +1505,8 @@ const getIsJoinSubQuery = (query) => {
 };
 
 var __defProp$e = Object.defineProperty;
-var __defProps$8 = Object.defineProperties;
-var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
 var __hasOwnProp$f = Object.prototype.hasOwnProperty;
 var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
@@ -1346,7 +1522,7 @@ var __spreadValues$e = (a, b) => {
     }
   return a;
 };
-var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
 const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
   var _a;
   if (typeof first === "string") {
@@ -1378,7 +1554,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
         logger: joinToQ.logger
       };
       j.baseQuery = j;
-      const joinedShapes = __spreadProps$8(__spreadValues$e({}, joinToQ.joinedShapes), {
+      const joinedShapes = __spreadProps$6(__spreadValues$e({}, joinToQ.joinedShapes), {
         [joinToQ.as || joinTo.table]: joinTo.shape
       });
       const r = args[0](
@@ -1405,7 +1581,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
         pushQueryArray(q, "or", query.or);
       }
     }
-    const joinedShapes = __spreadProps$8(__spreadValues$e({}, joinTo.q.joinedShapes), {
+    const joinedShapes = __spreadProps$6(__spreadValues$e({}, joinTo.q.joinedShapes), {
       [joinTo.q.as || joinTo.table]: joinTo.shape
     });
     const r = args[0](
@@ -1434,8 +1610,8 @@ const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo) => {
 };
 
 var __defProp$d = Object.defineProperty;
-var __defProps$7 = Object.defineProperties;
-var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
 var __hasOwnProp$e = Object.prototype.hasOwnProperty;
 var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
@@ -1451,7 +1627,7 @@ var __spreadValues$d = (a, b) => {
     }
   return a;
 };
-var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
 const _join = (q, require2, type, first, args) => {
   var _a, _b;
   let joinKey;
@@ -1552,7 +1728,7 @@ const _joinLateral = (self, type, arg, cb, as) => {
         const t = Object.create(q.queryBuilder);
         t.table = arg;
         t.shape = shape;
-        t.q = __spreadProps$7(__spreadValues$d({}, t.q), {
+        t.q = __spreadProps$5(__spreadValues$d({}, t.q), {
           shape
         });
         t.baseQuery = t;
@@ -1606,11 +1782,12 @@ class DateColumn extends DateBaseColumn {
     super(...arguments);
     this.dataType = "date";
   }
-  toCode(t) {
+  toCode(t, m) {
     return columnCode(
       this,
       t,
-      `date()${orchidCore.dateDataToCode(this.data)}`,
+      `date()${orchidCore.dateDataToCode(this.data, m)}`,
+      m,
       this.data,
       skipDateMethodsFromToCode
     );
@@ -1637,7 +1814,7 @@ class DateTimeTzBaseClass extends DateTimeBaseClass {
     );
   }
 }
-const timestampToCode = (self, t) => {
+const timestampToCode = (self, t, m) => {
   const { dateTimePrecision: p } = self.data;
   const { defaultTimestamp } = self.data;
   if (defaultTimestamp) {
@@ -1649,7 +1826,8 @@ const timestampToCode = (self, t) => {
     const code = columnCode(
       self,
       t,
-      `timestamps${noTz}(${p && p !== 6 ? p : ""}).${defaultTimestamp}${orchidCore.dateDataToCode(self.data)}`,
+      `timestamps${noTz}(${p && p !== 6 ? p : ""}).${defaultTimestamp}${orchidCore.dateDataToCode(self.data, m)}`,
+      m,
       self.data,
       skipDateMethodsFromToCode
     );
@@ -1660,7 +1838,8 @@ const timestampToCode = (self, t) => {
     return columnCode(
       self,
       t,
-      `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data)}`,
+      `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data, m)}`,
+      m,
       self.data,
       skipDateMethodsFromToCode
     );
@@ -1671,8 +1850,8 @@ class TimestampColumn extends DateTimeBaseClass {
     super(...arguments);
     this.dataType = "timestamp";
   }
-  toCode(t) {
-    return timestampToCode(this, t);
+  toCode(t, m) {
+    return timestampToCode(this, t, m);
   }
 }
 class TimestampTZColumn extends DateTimeTzBaseClass {
@@ -1681,8 +1860,8 @@ class TimestampTZColumn extends DateTimeTzBaseClass {
     this.dataType = "timestamptz";
     this.baseDataType = "timestamp";
   }
-  toCode(t) {
-    return timestampToCode(this, t);
+  toCode(t, m) {
+    return timestampToCode(this, t, m);
   }
 }
 class TimeColumn extends ColumnType {
@@ -1692,12 +1871,13 @@ class TimeColumn extends ColumnType {
     this.operators = Operators.time;
     this.data.dateTimePrecision = dateTimePrecision;
   }
-  toCode(t) {
+  toCode(t, m) {
     const { dateTimePrecision } = this.data;
     return columnCode(
       this,
       t,
-      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(this.data)}`,
+      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(this.data, m)}`,
+      m,
       this.data,
       skipDateMethodsFromToCode
     );
@@ -1711,12 +1891,13 @@ class IntervalColumn extends ColumnType {
     this.data.fields = fields;
     this.data.precision = precision;
   }
-  toCode(t) {
+  toCode(t, m) {
     const { fields, precision } = this.data;
     return columnCode(
       this,
       t,
       `interval(${[fields && `'${fields}'`, precision && String(precision)].filter((part) => part).join(", ")})`,
+      m,
       this.data,
       skipDateMethodsFromToCode
     );
@@ -1739,9 +1920,9 @@ class EnumColumn extends ColumnType {
     this.dataType = "enum";
     this.inputSchema = this.outputSchema = this.querySchema = schemaType;
   }
-  toCode(t, migration) {
-    const options = migration ? "" : `, [${this.options.map((option) => `'${option}'`).join(", ")}]`;
-    return columnCode(this, t, `enum('${this.enumName}'${options})`);
+  toCode(t, m) {
+    const options = m ? "" : `, [${this.options.map((option) => `'${option}'`).join(", ")}]`;
+    return columnCode(this, t, `enum('${this.enumName}'${options})`, m);
   }
   toSQL() {
     const name = this.enumName;
@@ -1773,15 +1954,16 @@ class ArrayColumn extends ColumnType {
       }
     );
     this.data.item = item;
+    this.data.name = item.data.name;
   }
   toSQL() {
     return `${this.data.item.toSQL()}[]`;
   }
-  toCode(t) {
+  toCode(t, m) {
     const code = ["array("];
     orchidCore.addCode(code, this.data.item.toCode(t));
-    orchidCore.addCode(code, `)${orchidCore.arrayDataToCode(this.data)}`);
-    return columnCode(this, t, code);
+    orchidCore.addCode(code, `)${orchidCore.arrayDataToCode(this.data, m)}`);
+    return columnCode(this, t, code, m);
   }
 }
 const parseArray = (input, pos, len, entries, nested, item) => {
@@ -3197,29 +3379,11 @@ const pushInsertSql = (ctx, q, query, quotedAs) => {
             ""
           )})`
         );
-      } else {
+      } else if ("toSQL" in expr) {
         ctx.sql.push(expr.toSQL(ctx, quotedAs));
+      } else {
+        ctx.sql.push(`ON CONSTRAINT "${expr.constraint}"`);
       }
-    } else if (type === "merge") {
-      const { indexes } = q.internal;
-      const quotedUniques = columns.reduce((arr, key, i) => {
-        var _a2, _b2;
-        const unique = (
-          // check column index
-          ((_b2 = ((_a2 = shape[key]) == null ? void 0 : _a2.data).indexes) == null ? void 0 : _b2.some(
-            (index) => index.unique
-          )) || // check table composite indexes
-          (indexes == null ? void 0 : indexes.some(
-            (index) => index.columns.some(
-              (item) => "column" in item && item.column === key
-            )
-          ))
-        );
-        if (unique)
-          arr.push(quotedColumns[i]);
-        return arr;
-      }, []);
-      ctx.sql.push(`(${quotedUniques.join(", ")})`);
     }
     if (type === "ignore") {
       ctx.sql.push("DO NOTHING");
@@ -3893,10 +4057,27 @@ const extendQuery = (q, methods) => {
   cloned.q = getClonedQueryData(q.q);
   return cloned;
 };
+const getPrimaryKeys = (q) => {
+  var _a, _b;
+  return (_b = (_a = q.internal).primaryKeys) != null ? _b : _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);
+    }
+  }
+  if (q.internal.primaryKeys) {
+    primaryKeys.push(...q.internal.primaryKeys);
+  }
+  return primaryKeys;
+};
 
 var __defProp$a = Object.defineProperty;
-var __defProps$6 = Object.defineProperties;
-var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
 var __hasOwnProp$b = Object.prototype.hasOwnProperty;
 var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
@@ -3912,7 +4093,7 @@ var __spreadValues$a = (a, b) => {
     }
   return a;
 };
-var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
 function setQueryOperators(query, operators) {
   const q = query.q;
   if (q.operators) {
@@ -3971,7 +4152,7 @@ const base = {
     (key, value, ctx, quotedAs) => `NOT ${key} IN ${quoteValue(value, ctx, quotedAs)}`
   )
 };
-const boolean = __spreadProps$6(__spreadValues$a({}, base), {
+const boolean = __spreadProps$4(__spreadValues$a({}, base), {
   and: make(
     (key, value, ctx, quotedAs) => `${key} AND ${value.q.expr.toSQL(ctx, quotedAs)}`
   ),
@@ -3979,7 +4160,7 @@ const boolean = __spreadProps$6(__spreadValues$a({}, base), {
     (key, value, ctx, quotedAs) => `(${key}) OR (${value.q.expr.toSQL(ctx, quotedAs)})`
   )
 });
-const numeric = __spreadProps$6(__spreadValues$a({}, base), {
+const numeric = __spreadProps$4(__spreadValues$a({}, base), {
   lt: make(
     (key, value, ctx, quotedAs) => `${key} < ${quoteValue(value, ctx, quotedAs)}`
   ),
@@ -4000,7 +4181,7 @@ const numeric = __spreadProps$6(__spreadValues$a({}, base), {
     )}`
   )
 });
-const text = __spreadProps$6(__spreadValues$a({}, base), {
+const text = __spreadProps$4(__spreadValues$a({}, base), {
   contains: make(
     (key, value, ctx, quotedAs) => `${key} ILIKE '%' || ${quoteValue(value, ctx, quotedAs)} || '%'`
   ),
@@ -4020,7 +4201,7 @@ const text = __spreadProps$6(__spreadValues$a({}, base), {
     (key, value, ctx, quotedAs) => `${key} LIKE '%' || ${quoteValue(value, ctx, quotedAs)}`
   )
 });
-const json = __spreadProps$6(__spreadValues$a({}, base), {
+const json = __spreadProps$4(__spreadValues$a({}, base), {
   jsonPath: make(
     (key, [path, op, value], ctx, quotedAs) => `jsonb_path_query_first(${key}, '${path}') #>> '{}' ${op} ${value === null ? "null" : quoteValue(value, ctx, quotedAs, true)}`
   ),
@@ -4064,16 +4245,18 @@ class DecimalColumn extends ColumnType {
   constructor(schema, numericPrecision, numericScale) {
     super(schema, schema.stringSchema());
     this.operators = Operators.number;
-    this.dataType = "decimal";
+    this.dataType = "numeric";
     this.data.numericPrecision = numericPrecision;
     this.data.numericScale = numericScale;
+    this.data.alias = "decimal";
   }
-  toCode(t) {
+  toCode(t, m) {
     const { numericPrecision, numericScale } = this.data;
     return columnCode(
       this,
       t,
-      `decimal(${numericPrecision || ""}${numericScale ? `, ${numericScale}` : ""})`
+      `decimal(${numericPrecision || ""}${numericScale ? `, ${numericScale}` : ""})`,
+      m
     );
   }
   toSQL() {
@@ -4085,49 +4268,52 @@ class DecimalColumn extends ColumnType {
   }
 }
 const skipNumberMethods = { int: true };
-const intToCode = (column, t) => {
+const intToCode = (column, t, alias, m) => {
   let code;
   if (column.data.identity) {
-    code = identityToCode(column.data.identity, column.dataType);
+    code = identityToCode(column.data.identity, alias);
   } else {
-    code = [`${column.dataType}()`];
+    code = [`${alias}()`];
   }
-  orchidCore.addCode(code, orchidCore.numberDataToCode(column.data, skipNumberMethods));
-  return columnCode(column, t, code);
+  orchidCore.addCode(code, orchidCore.numberDataToCode(column.data, m, skipNumberMethods));
+  return columnCode(column, t, code, m);
 };
 class SmallIntColumn extends IntegerBaseColumn {
-  constructor() {
-    super(...arguments);
-    this.dataType = "smallint";
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int2";
     this.parseItem = parseInt;
+    this.data.alias = "smallint";
   }
-  toCode(t) {
-    return intToCode(this, t);
+  toCode(t, m) {
+    return intToCode(this, t, "smallint", m);
   }
   identity(options = {}) {
     return orchidCore.setColumnData(this, "identity", options);
   }
 }
 class IntegerColumn extends IntegerBaseColumn {
-  constructor() {
-    super(...arguments);
-    this.dataType = "integer";
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int4";
     this.parseItem = parseInt;
+    this.data.alias = "integer";
   }
-  toCode(t) {
-    return intToCode(this, t);
+  toCode(t, m) {
+    return intToCode(this, t, "integer", m);
   }
   identity(options = {}) {
     return orchidCore.setColumnData(this, "identity", options);
   }
 }
 class BigIntColumn extends NumberAsStringBaseColumn {
-  constructor() {
-    super(...arguments);
-    this.dataType = "bigint";
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int8";
+    this.data.alias = "bigint";
   }
-  toCode(t) {
-    return intToCode(this, t);
+  toCode(t, m) {
+    return intToCode(this, t, "bigint", m);
   }
   identity(options = {}) {
     return orchidCore.setColumnData(this, "identity", options);
@@ -4136,74 +4322,81 @@ class BigIntColumn extends NumberAsStringBaseColumn {
 class RealColumn extends NumberBaseColumn {
   constructor(schema) {
     super(schema, schema.number());
-    this.dataType = "real";
+    this.dataType = "float4";
     this.parseItem = parseFloat;
+    this.data.alias = "real";
   }
-  toCode(t) {
-    return columnCode(this, t, `real()${orchidCore.numberDataToCode(this.data)}`);
+  toCode(t, m) {
+    return columnCode(this, t, `real()${orchidCore.numberDataToCode(this.data, m)}`, m);
   }
 }
 class DoublePrecisionColumn extends NumberAsStringBaseColumn {
-  constructor() {
-    super(...arguments);
-    this.dataType = "double precision";
+  constructor(schema) {
+    super(schema);
+    this.dataType = "float8";
+    this.data.alias = "doublePrecision";
   }
-  toCode(t) {
-    return columnCode(this, t, `doublePrecision()`);
+  toCode(t, m) {
+    return columnCode(this, t, `doublePrecision()`, m);
   }
 }
 class SmallSerialColumn extends IntegerBaseColumn {
   constructor(schema) {
     super(schema);
-    this.dataType = "smallint";
+    this.dataType = "int2";
     this.parseItem = parseInt;
     this.data.int = true;
+    this.data.alias = "smallSerial";
   }
   toSQL() {
     return "smallserial";
   }
-  toCode(t) {
+  toCode(t, m) {
     return columnCode(
       this,
       t,
-      `smallSerial()${orchidCore.numberDataToCode(this.data, skipNumberMethods)}`
+      `smallSerial()${orchidCore.numberDataToCode(this.data, m, skipNumberMethods)}`,
+      m
     );
   }
 }
 class SerialColumn extends IntegerBaseColumn {
   constructor(schema) {
     super(schema);
-    this.dataType = "integer";
+    this.dataType = "int4";
     this.parseItem = parseInt;
     this.data.int = true;
+    this.data.alias = "serial";
   }
   toSQL() {
     return "serial";
   }
-  toCode(t) {
+  toCode(t, m) {
     return columnCode(
       this,
       t,
-      `serial()${orchidCore.numberDataToCode(this.data, skipNumberMethods)}`
+      `serial()${orchidCore.numberDataToCode(this.data, m, skipNumberMethods)}`,
+      m
     );
   }
 }
 class BigSerialColumn extends NumberAsStringBaseColumn {
-  constructor() {
-    super(...arguments);
-    this.dataType = "bigint";
+  constructor(schema) {
+    super(schema);
+    this.dataType = "int8";
+    this.data.alias = "bigint";
   }
   toSQL() {
     return "bigserial";
   }
-  toCode(t) {
-    return columnCode(this, t, `bigSerial()`);
+  toCode(t, m) {
+    return columnCode(this, t, `bigSerial()`, m);
   }
 }
 
 var __defProp$9 = Object.defineProperty;
-var __defProps$5 = Object.defineProperties;
-var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
 var __hasOwnProp$a = Object.prototype.hasOwnProperty;
 var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
@@ -4219,7 +4412,7 @@ var __spreadValues$9 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 class TextBaseColumn extends ColumnType {
   constructor(schema, schemaType = schema.stringSchema()) {
     super(schema, schemaType);
@@ -4246,12 +4439,13 @@ class VarCharColumn extends LimitedTextBaseColumn {
     super(...arguments);
     this.dataType = "varchar";
   }
-  toCode(t) {
+  toCode(t, m) {
     const { maxChars } = this.data;
     return columnCode(
       this,
       t,
-      `varchar(${maxChars != null ? maxChars : ""})${orchidCore.stringDataToCode(this.data)}`
+      `varchar(${maxChars != null ? maxChars : ""})${orchidCore.stringDataToCode(this.data, m)}`,
+      m
     );
   }
 }
@@ -4259,14 +4453,15 @@ class StringColumn extends VarCharColumn {
   constructor(schema, limit = 255) {
     super(schema, limit);
   }
-  toCode(t) {
+  toCode(t, m) {
     let max = this.data.maxChars;
     if (max === 255)
       max = void 0;
     return columnCode(
       this,
       t,
-      `string(${max != null ? max : ""})${orchidCore.stringDataToCode(this.data)}`
+      `string(${max != null ? max : ""})${orchidCore.stringDataToCode(this.data, m)}`,
+      m
     );
   }
 }
@@ -4275,12 +4470,13 @@ class CharColumn extends LimitedTextBaseColumn {
     super(...arguments);
     this.dataType = "char";
   }
-  toCode(t) {
+  toCode(t, m) {
     const { maxChars } = this.data;
     return columnCode(
       this,
       t,
-      `char(${maxChars != null ? maxChars : ""})${orchidCore.stringDataToCode(this.data)}`
+      `char(${maxChars != null ? maxChars : ""})${orchidCore.stringDataToCode(this.data, m)}`,
+      m
     );
   }
 }
@@ -4292,7 +4488,7 @@ const setTextColumnData = (column, minArg, maxArg) => {
     }
   }
 };
-const textColumnToCode = (column, t) => {
+const textColumnToCode = (column, t, m) => {
   const data = __spreadValues$9({}, column.data);
   let args = "";
   const hasMax = data.maxArg !== void 0 && data.max === data.maxArg;
@@ -4311,7 +4507,8 @@ const textColumnToCode = (column, t) => {
   return columnCode(
     column,
     t,
-    `${column.dataType}(${args})${orchidCore.stringDataToCode(data)}`
+    `${column.dataType}(${args})${orchidCore.stringDataToCode(data, m)}`,
+    m
   );
 };
 const minMaxToSchema = (schema, min, max) => min ? max ? schema.stringMinMax(min, max) : schema.stringMin(min) : schema.stringSchema();
@@ -4321,8 +4518,8 @@ class TextColumn extends TextBaseColumn {
     this.dataType = "text";
     setTextColumnData(this, min, max);
   }
-  toCode(t) {
-    return textColumnToCode(this, t);
+  toCode(t, m) {
+    return textColumnToCode(this, t, m);
   }
 }
 class ByteaColumn extends ColumnType {
@@ -4331,8 +4528,8 @@ class ByteaColumn extends ColumnType {
     this.dataType = "bytea";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `bytea()`);
+  toCode(t, m) {
+    return columnCode(this, t, `bytea()`, m);
   }
 }
 class PointColumn extends ColumnType {
@@ -4341,8 +4538,8 @@ class PointColumn extends ColumnType {
     this.dataType = "point";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `point()`);
+  toCode(t, m) {
+    return columnCode(this, t, `point()`, m);
   }
 }
 class LineColumn extends ColumnType {
@@ -4351,8 +4548,8 @@ class LineColumn extends ColumnType {
     this.dataType = "line";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `line()`);
+  toCode(t, m) {
+    return columnCode(this, t, `line()`, m);
   }
 }
 class LsegColumn extends ColumnType {
@@ -4361,8 +4558,8 @@ class LsegColumn extends ColumnType {
     this.dataType = "lseg";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `lseg()`);
+  toCode(t, m) {
+    return columnCode(this, t, `lseg()`, m);
   }
 }
 class BoxColumn extends ColumnType {
@@ -4371,8 +4568,8 @@ class BoxColumn extends ColumnType {
     this.dataType = "box";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `box()`);
+  toCode(t, m) {
+    return columnCode(this, t, `box()`, m);
   }
 }
 class PathColumn extends ColumnType {
@@ -4381,8 +4578,8 @@ class PathColumn extends ColumnType {
     this.dataType = "path";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `path()`);
+  toCode(t, m) {
+    return columnCode(this, t, `path()`, m);
   }
 }
 class PolygonColumn extends ColumnType {
@@ -4391,8 +4588,8 @@ class PolygonColumn extends ColumnType {
     this.dataType = "polygon";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `polygon()`);
+  toCode(t, m) {
+    return columnCode(this, t, `polygon()`, m);
   }
 }
 class CircleColumn extends ColumnType {
@@ -4401,8 +4598,8 @@ class CircleColumn extends ColumnType {
     this.dataType = "circle";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `circle()`);
+  toCode(t, m) {
+    return columnCode(this, t, `circle()`, m);
   }
 }
 class MoneyColumn extends NumberBaseColumn {
@@ -4418,8 +4615,8 @@ class MoneyColumn extends NumberBaseColumn {
       }
     );
   }
-  toCode(t) {
-    return columnCode(this, t, `money()`);
+  toCode(t, m) {
+    return columnCode(this, t, `money()`, m);
   }
 }
 class CidrColumn extends ColumnType {
@@ -4428,8 +4625,8 @@ class CidrColumn extends ColumnType {
     this.dataType = "cidr";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `cidr()`);
+  toCode(t, m) {
+    return columnCode(this, t, `cidr()`, m);
   }
 }
 class InetColumn extends ColumnType {
@@ -4438,8 +4635,8 @@ class InetColumn extends ColumnType {
     this.dataType = "inet";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `inet()`);
+  toCode(t, m) {
+    return columnCode(this, t, `inet()`, m);
   }
 }
 class MacAddrColumn extends ColumnType {
@@ -4448,8 +4645,8 @@ class MacAddrColumn extends ColumnType {
     this.dataType = "macaddr";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `macaddr()`);
+  toCode(t, m) {
+    return columnCode(this, t, `macaddr()`, m);
   }
 }
 class MacAddr8Column extends ColumnType {
@@ -4458,8 +4655,8 @@ class MacAddr8Column extends ColumnType {
     this.dataType = "macaddr8";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `macaddr8()`);
+  toCode(t, m) {
+    return columnCode(this, t, `macaddr8()`, m);
   }
 }
 class BitColumn extends ColumnType {
@@ -4469,9 +4666,9 @@ class BitColumn extends ColumnType {
     this.operators = Operators.text;
     this.data.length = length;
   }
-  toCode(t) {
+  toCode(t, m) {
     const { length } = this.data;
-    return columnCode(this, t, `bit(${length})`);
+    return columnCode(this, t, `bit(${length})`, m);
   }
   toSQL() {
     return orchidCore.joinTruthy(
@@ -4483,13 +4680,14 @@ class BitColumn extends ColumnType {
 class BitVaryingColumn extends ColumnType {
   constructor(schema, length) {
     super(schema, schema.bit(length));
-    this.dataType = "bit varying";
+    this.dataType = "varbit";
     this.operators = Operators.text;
     this.data.length = length;
+    this.data.alias = "bitVarying";
   }
-  toCode(t) {
+  toCode(t, m) {
     const { length } = this.data;
-    return columnCode(this, t, `bitVarying(${length != null ? length : ""})`);
+    return columnCode(this, t, `bitVarying(${length != null ? length : ""})`, m);
   }
   toSQL() {
     return orchidCore.joinTruthy(
@@ -4505,8 +4703,8 @@ class TsVectorColumn extends ColumnType {
     this.dataType = "tsvector";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `tsvector()`);
+  toCode(t, m) {
+    return columnCode(this, t, `tsvector()`, m);
   }
   /**
    * For `tsvector` column type, it can also accept language (optional) and columns:
@@ -4536,14 +4734,17 @@ class TsVectorColumn extends ColumnType {
     const first = args[0];
     if (typeof first === "string" || !("raw" in first)) {
       const target = typeof first === "string" ? args[1] : first;
+      const language = typeof first === "string" ? first : this.defaultLanguage;
       let sql;
       if (Array.isArray(target)) {
         const columns = target.length === 1 ? `"${target[0]}"` : target.map((column) => `coalesce("${column}", '')`).join(` || ' ' || `);
-        sql = `to_tsvector('${typeof first === "string" ? first : this.defaultLanguage}', ${columns})`;
+        sql = `to_tsvector('${language}', ${columns})`;
       } else {
         for (const key in target) {
-          sql = (sql ? sql + " || " : "") + `setweight(to_tsvector(coalesce("${key}", '')), '${target[key]}')`;
+          sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${key}", '')), '${target[key]}')`;
         }
+        if (sql)
+          sql += ")";
       }
       const arr = [sql];
       arr.raw = arr;
@@ -4558,8 +4759,8 @@ class TsQueryColumn extends ColumnType {
     this.dataType = "tsquery";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `tsquery()`);
+  toCode(t, m) {
+    return columnCode(this, t, `tsquery()`, m);
   }
 }
 const uuidDefaultSQL = "gen_random_uuid()";
@@ -4570,20 +4771,24 @@ class UUIDColumn extends ColumnType {
     this.dataType = "uuid";
     this.operators = Operators.text;
   }
-  primaryKey() {
-    const column = super.primaryKey();
+  /**
+   * see {@link ColumnType.primaryKey}
+   */
+  primaryKey(name) {
+    const column = super.primaryKey(name);
     if (!column.data.default)
       column.data.default = uuidDefault;
     return column;
   }
-  toCode(t) {
+  toCode(t, m) {
     const { data } = this;
     return columnCode(
       this,
       t,
       `uuid()`,
+      m,
       // don't output the default default
-      data.default instanceof orchidCore.RawSQLBase && data.default._sql === uuidDefaultSQL ? __spreadProps$5(__spreadValues$9({}, data), { default: void 0 }) : data
+      data.default instanceof orchidCore.RawSQLBase && data.default._sql === uuidDefaultSQL ? __spreadProps$3(__spreadValues$9({}, data), { default: void 0 }) : data
     );
   }
 }
@@ -4593,8 +4798,8 @@ class XMLColumn extends ColumnType {
     this.dataType = "xml";
     this.operators = Operators.text;
   }
-  toCode(t) {
-    return columnCode(this, t, `xml()`);
+  toCode(t, m) {
+    return columnCode(this, t, `xml()`, m);
   }
 }
 class CitextColumn extends TextBaseColumn {
@@ -4603,20 +4808,21 @@ class CitextColumn extends TextBaseColumn {
     this.dataType = "citext";
     setTextColumnData(this, min, max);
   }
-  toCode(t) {
-    return textColumnToCode(this, t);
+  toCode(t, m) {
+    return textColumnToCode(this, t, m);
   }
 }
 
 class BooleanColumn extends ColumnType {
   constructor(schema) {
     super(schema, schema.boolean());
-    this.dataType = "boolean";
+    this.dataType = "bool";
     this.operators = Operators.boolean;
     this.parseItem = (input) => input[0] === "t";
+    this.data.alias = "boolean";
   }
-  toCode(t) {
-    return columnCode(this, t, "boolean()");
+  toCode(t, m) {
+    return columnCode(this, t, "boolean()", m);
   }
 }
 
@@ -4632,8 +4838,8 @@ class CustomTypeColumn extends ColumnType {
     this.operators = Operators.any;
     this.data.isOfCustomType = true;
   }
-  toCode(t) {
-    return columnCode(this, t, `type(${orchidCore.singleQuote(this.dataType)})`);
+  toCode(t, m) {
+    return columnCode(this, t, `type(${orchidCore.singleQuote(this.dataType)})`, m);
   }
   as(column) {
     const c = orchidCore.setColumnData(
@@ -4648,14 +4854,12 @@ class CustomTypeColumn extends ColumnType {
   }
 }
 class DomainColumn extends CustomTypeColumn {
-  toCode(t) {
-    return columnCode(this, t, `domain(${orchidCore.singleQuote(this.dataType)})`);
+  toCode(t, m) {
+    return columnCode(this, t, `domain(${orchidCore.singleQuote(this.dataType)})`, m);
   }
 }
 
 var __defProp$8 = Object.defineProperty;
-var __defProps$4 = Object.defineProperties;
-var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
 var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
 var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
@@ -4671,19 +4875,11 @@ var __spreadValues$8 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
-const newTableData = () => ({});
-let tableData = newTableData();
-const getTableData = () => tableData;
-const resetTableData = (data = newTableData()) => {
-  tableData = data;
-};
-const getColumnTypes = (types, fn, nowSQL, language, data = newTableData()) => {
+const getColumnTypes = (types, fn, nowSQL, language) => {
   if (nowSQL)
     orchidCore.setDefaultNowFn(nowSQL);
   if (language)
     orchidCore.setDefaultLanguage(language);
-  resetTableData(data);
   return fn(types);
 };
 const makeColumnTypes = (schema) => {
@@ -4695,20 +4891,7 @@ const makeColumnTypes = (schema) => {
       orchidCore.setCurrentColumnName(name);
       return this;
     },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    sql(...args) {
-      const arg = args[0];
-      if (Array.isArray(arg)) {
-        return new RawSQL(args);
-      }
-      if (typeof args[0] === "string") {
-        return new RawSQL(args[0]);
-      }
-      if (args[1] !== void 0) {
-        return new RawSQL(args[1], arg);
-      }
-      return (...args2) => new RawSQL(args2, arg);
-    },
+    sql: sqlFn,
     smallint: schema.smallint,
     integer: schema.integer,
     bigint: schema.bigint,
@@ -4805,66 +4988,6 @@ const makeColumnTypes = (schema) => {
     },
     domain(dataType) {
       return new DomainColumn(schema, dataType);
-    },
-    primaryKey(columns, options) {
-      tableData.primaryKey = { columns, options };
-      return orchidCore.emptyObject;
-    },
-    index(columns, options = {}) {
-      var _a;
-      const index = {
-        columns: orchidCore.toArray(columns).map(
-          (column) => typeof column === "string" ? { column } : column
-        ),
-        options
-      };
-      ((_a = tableData.indexes) != null ? _a : tableData.indexes = []).push(index);
-      return orchidCore.emptyObject;
-    },
-    unique(columns, options) {
-      return this.index(columns, __spreadProps$4(__spreadValues$8({}, options), { unique: true }));
-    },
-    /**
-     * See {@link ColumnType.searchIndex}
-     */
-    searchIndex(columns, options) {
-      return this.index(columns, __spreadProps$4(__spreadValues$8({}, options), { tsVector: true }));
-    },
-    constraint({ name, references, check, dropMode }) {
-      var _a;
-      ((_a = tableData.constraints) != null ? _a : tableData.constraints = []).push({
-        name,
-        references: references ? {
-          columns: references[0],
-          fnOrTable: references[1],
-          foreignColumns: references[2],
-          options: references[3]
-        } : void 0,
-        check,
-        dropMode
-      });
-      return orchidCore.emptyObject;
-    },
-    foreignKey(columns, fnOrTable, foreignColumns, options) {
-      var _a;
-      ((_a = tableData.constraints) != null ? _a : tableData.constraints = []).push({
-        name: options == null ? void 0 : options.name,
-        references: {
-          columns,
-          fnOrTable,
-          foreignColumns,
-          options
-        },
-        dropMode: options == null ? void 0 : options.dropMode
-      });
-      return orchidCore.emptyObject;
-    },
-    check(check) {
-      var _a;
-      ((_a = tableData.constraints) != null ? _a : tableData.constraints = []).push({
-        check
-      });
-      return orchidCore.emptyObject;
     }
   }, orchidCore.makeTimestampsHelpers(makeRegexToFindInSql));
 };
@@ -4982,6 +5105,8 @@ for (const key in types.builtins) {
   delete defaultTypeParsers[id];
 });
 const returnArg = (arg) => arg;
+const rollbackSql$1 = { text: "ROLLBACK" };
+const commitSql$1 = { text: "COMMIT" };
 class Adapter {
   constructor(_a) {
     var _b = _a, { types: types2 = defaultTypeParsers } = _b, config = __objRest$1(_b, ["types"]);
@@ -5023,7 +5148,7 @@ class Adapter {
   arrays(query, types2) {
     return performQuery$1(this, query, types2, "array");
   }
-  async transaction(begin, cb) {
+  async transaction(begin, cb, end = commitSql$1) {
     const client = await this.connect();
     try {
       await setSearchPath(client, this.schema);
@@ -5032,10 +5157,10 @@ class Adapter {
       try {
         result = await cb(new TransactionAdapter(this, client, this.types));
       } catch (err) {
-        await performQueryOnClient(client, { text: "ROLLBACK" }, this.types);
+        await performQueryOnClient(client, rollbackSql$1, this.types);
         throw err;
       }
-      await performQueryOnClient(client, { text: "COMMIT" }, this.types);
+      await performQueryOnClient(client, end, this.types);
       return result;
     } finally {
       client.release();
@@ -5109,8 +5234,8 @@ class TransactionAdapter {
 }
 
 var __defProp$7 = Object.defineProperty;
-var __defProps$3 = Object.defineProperties;
-var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
 var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
 var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
@@ -5126,7 +5251,7 @@ var __spreadValues$7 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 class FnExpression extends orchidCore.Expression {
   /**
    * @param q - query object.
@@ -5183,7 +5308,7 @@ class FnExpression extends orchidCore.Expression {
       sql.push(" ");
     if (options.order) {
       pushOrderBySql(
-        __spreadProps$3(__spreadValues$7({}, ctx), { sql }),
+        __spreadProps$2(__spreadValues$7({}, ctx), { sql }),
         this.q.q,
         quotedAs,
         orchidCore.toArray(options.order)
@@ -6114,9 +6239,9 @@ class Create {
    *   password: '1234',
    * });
    *
-   * // When using `.onConflict().ignore()`,
+   * // When using `.onConflictIgnore()`,
    * // the record may be not created and the `createdCount` will be 0.
-   * const createdCount = await db.table.insert(data).onConflict().ignore();
+   * const createdCount = await db.table.insert(data).onConflictIgnore();
    *
    * await db.table.create({
    *   // raw SQL
@@ -6330,32 +6455,44 @@ class Create {
     return _queryDefaults(this.clone(), data);
   }
   /**
-   * A modifier for creating queries that specify alternative behavior in the case of a conflict.
-   * A conflict occurs when a table has a `PRIMARY KEY` or a `UNIQUE` index on a column
-   * (or a composite index on a set of columns) and a row being created has the same value as a row
-   * that already exists in the table in this column(s).
-   * The default behavior in case of conflict is to raise an error and abort the query.
+   * By default, violating unique constraint will cause the creative query to throw,
+   * you can define what to do on a conflict: to ignore it, or to merge the existing record with a new data.
+   *
+   * A conflict occurs when a table has a primary key or a unique index on a column,
+   * or a composite primary key unique index on a set of columns,
+   * and a row being created has the same value as a row that already exists in the table in this column(s).
+   *
+   * Use `onConflictIgnore()` to suppress the error and continue without updating the record,
+   * or `onConflict(['uniqueColumn']).merge()` to update the record with a new data.
    *
-   * Use `onConflict` to either ignore the error by using `.onConflict().ignore()`,
-   * or to update the existing row with new data (perform an "UPSERT") by using `.onConflict().merge()`.
+   * `onConflict` only accepts column names that are defined in `primaryKey` or `unique` in the table definition.
+   * To specify a constraint, its name also must be explicitly set in `primaryKey` or `unique` in the table code.
+   *
+   * Postgres has a limitation that a single `INSERT` query can have only a single `ON CONFLICT` clause that can target only a single unique constraint
+   * for updating the record.
+   *
+   * If your table has multiple potential reasons for unique constraint violation, such as username and email columns in a user table,
+   * consider using [upsert](#upsert) instead.
    *
    * ```ts
    * // leave `onConflict` without argument to ignore or merge on any conflict
-   * db.table.create(data).onConflict().ignore();
+   * db.table.create(data).onConflictIgnore();
    *
    * // single column:
-   * db.table.create(data).onConfict('email');
+   * db.table.create(data).onConfict('email').merge();
    *
    * // array of columns:
-   * db.table.create(data).onConfict(['email', 'name']);
+   * db.table.create(data).onConfict(['email', 'name']).merge();
    *
-   * // raw expression:
-   * db.table.create(data).onConfict(db.table.sql`(email) where condition`);
-   * ```
+   * // constraint name
+   * db.table.create(data).onConfict({ constraint: 'unique_index_name' }).merge();
    *
-   * ::: info
-   * The column(s) given to the `onConflict` must either be the table's PRIMARY KEY or have a UNIQUE index on them, or the query will fail to execute.
-   * When specifying multiple columns, they must be a composite PRIMARY KEY or have a composite UNIQUE index.
+   * // raw SQL expression:
+   * db.table
+   *   .create(data)
+   *   .onConfict(db.table.sql`(email) where condition`)
+   *   .merge();
+   * ```
    *
    * You can use the db.table.sql function in onConflict.
    * It can be useful to specify a condition when you have a partial index:
@@ -6372,29 +6509,17 @@ class Create {
    *   .ignore();
    * ```
    *
-   * :::
-   *
-   * See the documentation on the .ignore() and .merge() methods for more details.
-   *
    * @param arg - optionally provide an array of columns
    */
   onConflict(arg) {
     return new OnConflictQueryBuilder(this, arg);
   }
-}
-class OnConflictQueryBuilder {
-  constructor(query, onConflict) {
-    this.query = query;
-    this.onConflict = onConflict;
-  }
   /**
-   * Available only after `onConflict`.
-   *
-   * `ignore` modifies a create query, and causes it to be silently dropped without an error if a conflict occurs.
+   * Use `onConflictIgnore` to suppress unique constraint violation error when creating a record.
    *
-   * Adds the `ON CONFLICT (columns) DO NOTHING` clause to the insert statement.
+   * Adds `ON CONFLICT (columns) DO NOTHING` clause to the insert statement, columns are optional.
    *
-   * It produces `ON CONFLICT DO NOTHING` when no `onConflict` argument provided.
+   * Can also accept a constraint name.
    *
    * ```ts
    * db.table
@@ -6402,40 +6527,39 @@ class OnConflictQueryBuilder {
    *     email: 'ignore@example.com',
    *     name: 'John Doe',
    *   })
-   *   .onConflict('email')
-   *   .ignore();
+   *   // on any conflict:
+   *   .onConflictIgnore()
+   *   // or, for a specific column:
+   *   .onConflictIgnore('email')
+   *   // or, for a specific constraint:
+   *   .onConflictIgnore({ constraint: 'unique_index_name' });
    * ```
    *
-   *
-   * When there is a conflict, nothing can be returned from the database, that's why `ignore` has to add `| undefined` part to the response type.
-   *
-   * `create` returns a full record by default, it becomes `RecordType | undefined` after applying `ignore`.
+   * When there is a conflict, nothing can be returned from the database, so `onConflictIgnore` adds `| undefined` part to the response type.
    *
    * ```ts
    * const maybeRecord: RecordType | undefined = await db.table
    *   .create(data)
-   *   .onConflict()
-   *   .ignore();
+   *   .onConflictIgnore();
    *
    * const maybeId: number | undefined = await db.table
    *   .get('id')
    *   .create(data)
-   *   .onConflict()
-   *   .ignore();
+   *   .onConflictIgnore();
    * ```
    *
-   * When creating many records, only the created records will be returned. If no records were created, array will be empty:
+   * When creating multiple records, only created records will be returned. If no records were created, array will be empty:
    *
    * ```ts
    * // array can be empty
-   * const arr = await db.table.createMany([data, data, data]).onConflict().ignore();
+   * const arr = await db.table.createMany([data, data, data]).onConflictIgnore();
    * ```
    */
-  ignore() {
-    const q = this.query;
+  onConflictIgnore(arg) {
+    const q = this.clone();
     q.q.onConflict = {
       type: "ignore",
-      expr: this.onConflict
+      expr: arg
     };
     if (q.q.returnType === "oneOrThrow") {
       q.q.returnType = "one";
@@ -6444,23 +6568,27 @@ class OnConflictQueryBuilder {
     }
     return q;
   }
+}
+class OnConflictQueryBuilder {
+  constructor(query, onConflict) {
+    this.query = query;
+    this.onConflict = onConflict;
+  }
   /**
-   * Available only after `onConflict`.
-   *
-   * Modifies a create query, to turn it into an 'upsert' operation.
+   * Available only after [onConflict](#onconflict).
    *
    * Adds an `ON CONFLICT (columns) DO UPDATE` clause to the insert statement.
    *
-   * When no `onConflict` argument provided,
-   * it will automatically collect all table columns that have unique index and use them as a conflict target.
-   *
    * ```ts
    * db.table
    *   .create({
    *     email: 'ignore@example.com',
    *     name: 'John Doe',
    *   })
+   *   // for a specific column:
    *   .onConflict('email')
+   *   // or, for a specific constraint:
+   *   .onConflict({ constraint: 'unique_constraint_name' })
    *   .merge();
    * ```
    *
@@ -6491,15 +6619,15 @@ class OnConflictQueryBuilder {
    *     updatedAt: timestamp,
    *   })
    *   .onConflict('email')
-   *   // string argument for a single column:
+   *   // update only a single column
    *   .merge('email')
-   *   // array of strings for multiple columns:
+   *   // or, update multiple columns
    *   .merge(['email', 'name', 'updatedAt']);
    * ```
    *
-   * It is also possible to specify data to update separately from the data to create.
+   * It's possible to specify data to update separately from the data to create.
    * This is useful if you want to make an update with different data than in creating.
-   * For example, you may want to change a value if the row already exists:
+   * For example, changing a value if the row already exists:
    *
    * ```ts
    * const timestamp = Date.now();
@@ -6517,7 +6645,7 @@ class OnConflictQueryBuilder {
    *   });
    * ```
    *
-   * It is also possible to add a WHERE clause to conditionally update only the matching rows:
+   * You can use `where` to update only the matching rows:
    *
    * ```ts
    * const timestamp = Date.now();
@@ -6537,7 +6665,7 @@ class OnConflictQueryBuilder {
    *   .where({ updatedAt: { lt: timestamp } });
    * ```
    *
-   * `merge` also accepts raw expression:
+   * `merge` can take a raw SQL expression:
    *
    * ```ts
    * db.table
@@ -7773,10 +7901,7 @@ class JsonModifiers {
         options
       ]
     };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
+    return Object.assign(pushQueryValue(q, "select", json), json);
   }
   /**
    * Return a JSON value/object/array where a given value is inserted at the given JSON path. Value can be a single value or JSON object. If a value exists at the given path, the value is not replaced.
@@ -7824,10 +7949,7 @@ class JsonModifiers {
         options
       ]
     };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
+    return Object.assign(pushQueryValue(q, "select", json), json);
   }
   /**
    * Return a JSON value/object/array where a given value is removed at the given JSON path.
@@ -7866,10 +7988,7 @@ class JsonModifiers {
         path
       ]
     };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
+    return Object.assign(pushQueryValue(q, "select", json), json);
   }
   /**
    * Selects a value from JSON data using a JSON path.
@@ -7915,10 +8034,7 @@ class JsonModifiers {
     const json = {
       __json: ["pathQuery", as, type, column, path, options]
     };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
+    return Object.assign(pushQueryValue(q, "select", json), json);
   }
 }
 class JsonMethods {
@@ -7935,10 +8051,7 @@ class JsonMethods {
    * @param coalesce
    */
   json(coalesce) {
-    return queryJson(
-      this.clone(),
-      coalesce
-    );
+    return queryJson(this.clone(), coalesce);
   }
 }
 
@@ -7953,7 +8066,7 @@ const makeMessage = (colors, timeColor, time, sqlColor, sql, valuesColor, values
   const elapsed = process.hrtime(time);
   const formattedTime = `(${elapsed[0] ? `${elapsed[0]}s ` : ""}${(elapsed[1] / 1e6).toFixed(1)}ms)`;
   const result = `${colors ? timeColor(formattedTime) : formattedTime} ${colors ? sqlColor(sql) : sql}`;
-  if (!values.length) {
+  if (!(values == null ? void 0 : values.length)) {
     return result;
   }
   const formattedValues = `[${values.map(quote).join(", ")}]`;
@@ -8065,8 +8178,8 @@ class MergeQueryMethods {
 }
 
 var __defProp$4 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
 var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
 var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
@@ -8082,7 +8195,7 @@ var __spreadValues$4 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 class With {
   /**
    * Add Common Table Expression (CTE) to the query.
@@ -8157,7 +8270,7 @@ class With {
     const query = typeof last === "function" ? last(q.queryBuilder) : last;
     const shape = args.length === 4 ? args[2] : orchidCore.isExpression(query) ? args[1] : query.q.shape;
     if ((options == null ? void 0 : options.columns) === true) {
-      options = __spreadProps$2(__spreadValues$4({}, options), {
+      options = __spreadProps$1(__spreadValues$4({}, options), {
         columns: Object.keys(shape)
       });
     }
@@ -9099,9 +9212,9 @@ const _queryUpdate = (query, arg) => {
   if (queries) {
     q.patchResult = async (_, queryResult) => {
       await Promise.all(queries.map(orchidCore.callWithThis, queryResult));
-      if (ctx.updateData) {
+      if (ctx.collect) {
         const t = query.baseQuery.clone();
-        const keys = query.primaryKeys;
+        const { keys } = ctx.collect;
         _queryWhereIn(
           t,
           keys,
@@ -9109,10 +9222,10 @@ const _queryUpdate = (query, arg) => {
         );
         _queryUpdate(
           t,
-          ctx.updateData
+          ctx.collect.data
         );
         for (const row of queryResult.rows) {
-          Object.assign(row, ctx.updateData);
+          Object.assign(row, ctx.collect.data);
         }
       }
     };
@@ -9545,8 +9658,8 @@ class Transaction {
 }
 
 var __defProp$2 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
 var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
 var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
@@ -9562,7 +9675,7 @@ var __spreadValues$2 = (a, b) => {
     }
   return a;
 };
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 class Headline extends orchidCore.Expression {
   constructor(q, source, params) {
     super();
@@ -9784,7 +9897,7 @@ class SearchMethods {
     const q = this.clone();
     if (!arg.as) {
       const as = saveSearchAlias(q, "@q", "joinedShapes");
-      arg = __spreadProps$1(__spreadValues$2({}, arg), {
+      arg = __spreadProps(__spreadValues$2({}, arg), {
         as
       });
     }
@@ -10373,20 +10486,11 @@ class QueryMethods {
     );
   }
   /**
-   * The `find` method is available only for tables which has exactly one primary key.
-   * And also it can accept raw SQL template literal, then the primary key is not required.
-   *
-   * Finds a record by id, throws {@link NotFoundError} if not found:
+   * Finds a single record by the primary key (id), throws [NotFoundError](/guide/error-handling.html) if not found.
+   * Not available if the table has no or multiple primary keys.
    *
    * ```ts
-   * await db.table.find(1);
-   * ```
-   *
-   * ```ts
-   * await db.user.find`
-   *   age = ${age} AND
-   *   name = ${name}
-   * `;
+   * const result: TableType = await db.table.find(1);
    * ```
    *
    * @param value - primary key value to find by
@@ -10402,7 +10506,7 @@ class QueryMethods {
     return _queryTake(
       _queryWhere(q, [
         {
-          [q.singlePrimaryKey]: value
+          [q.internal.singlePrimaryKey]: value
         }
       ])
     );
@@ -10424,8 +10528,8 @@ class QueryMethods {
     return _queryTake(_queryWhereSql(q, args));
   }
   /**
-   * Find a single record by the primary key (id), adds `LIMIT 1`.
-   * Returns `undefined` when not found.
+   * Finds a single record by the primary key (id), returns `undefined` when not found.
+   * Not available if the table has no or multiple primary keys.
    *
    * ```ts
    * const result: TableType | undefined = await db.table.find(123);
@@ -10455,40 +10559,40 @@ class QueryMethods {
     );
   }
   /**
-   * The same as `where(conditions).take()`, takes the same arguments as {@link Where.where}, it will filter records and add a `LIMIT 1`.
-   * Throws `NotFoundError` if not found.
+   * Finds a single unique record, throws [NotFoundError](/guide/error-handling.html) if not found.
+   * It accepts values of primary keys or unique indexes defined on the table.
+   * `findBy`'s argument type is a union of all possible sets of unique conditions.
+   *
+   * You can use `where(...).take()` for non-unique conditions.
    *
    * ```ts
-   * const result: TableType = await db.table.findBy({ key: 'value' });
-   * // is equivalent to:
-   * db.table.where({ key: 'value' }).take()
+   * await db.table.findBy({ key: 'value' });
    * ```
    *
-   * @param args - `where` conditions
+   * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
    */
-  findBy(...args) {
-    return _queryFindBy(
-      this.clone(),
-      args
-    );
+  findBy(uniqueColumnValues) {
+    return _queryFindBy(this.clone(), [
+      uniqueColumnValues
+    ]);
   }
   /**
-   * The same as `where(conditions).takeOptional()`, it will filter records and add a `LIMIT 1`.
-   * Returns `undefined` when not found.
+   * Finds a single unique record, returns `undefined` if not found.
+   * It accepts values of primary keys or unique indexes defined on the table.
+   * `findBy`'s argument type is a union of all possible sets of unique conditions.
+   *
+   * You can use `where(...).takeOptional()` for non-unique conditions.
    *
    * ```ts
-   * const result: TableType | undefined = await db.table.findByOptional({
-   *   key: 'value',
-   * });
+   * await db.table.findByOptional({ key: 'value' });
    * ```
    *
-   * @param args - `where` conditions
+   * @param uniqueColumnValues - is derived from primary keys and unique indexes in the table
    */
-  findByOptional(...args) {
-    return _queryFindByOptional(
-      this.clone(),
-      args
-    );
+  findByOptional(uniqueColumnValues) {
+    return _queryFindByOptional(this.clone(), [
+      uniqueColumnValues
+    ]);
   }
   /**
    * Specifies the schema to be used as a prefix of a table name.
@@ -10634,9 +10738,9 @@ class QueryMethods {
    * Order by raw SQL expression.
    *
    * ```ts
-   * db.table.order`raw sql`;
+   * db.table.orderSql`raw sql`;
    * // or
-   * db.table.order(db.table.sql`raw sql`);
+   * db.table.orderSql(db.table.sql`raw sql`);
    * ```
    *
    * @param args - SQL expression
@@ -10878,9 +10982,86 @@ orchidCore.applyMixins(QueryMethods, [
   SoftDeleteMethods
 ]);
 
+const makeIndex = (columns, first, second) => {
+  if (typeof first === "string") {
+    const options = second != null ? second : {};
+    return {
+      index: { columns, options, name: first }
+    };
+  } else {
+    const options = first != null ? first : {};
+    return {
+      index: { columns, options }
+    };
+  }
+};
+const tableDataMethods = {
+  primaryKey(columns, name) {
+    return { primaryKey: { columns, name } };
+  },
+  unique(columns, ...[first, second]) {
+    const input = makeIndex(columns, first, second);
+    input.index.options.unique = true;
+    return input;
+  },
+  index: makeIndex,
+  searchIndex(columns, ...[first, second]) {
+    var _a, _b;
+    const input = makeIndex(columns, first, second);
+    (_b = (_a = input.index.options).using) != null ? _b : _a.using = "gin";
+    input.index.options.tsVector = true;
+    return input;
+  },
+  foreignKey(columns, fnOrTable, foreignColumns, options) {
+    return {
+      constraint: {
+        name: options == null ? void 0 : options.name,
+        references: { columns, fnOrTable, foreignColumns, options }
+      }
+    };
+  },
+  check(check, name) {
+    return { constraint: { check, name } };
+  },
+  sql: sqlFn
+};
+const parseTableData = (dataFn) => {
+  const tableData = {};
+  if (dataFn) {
+    const input = dataFn(tableDataMethods);
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        parseTableDataInput(tableData, item);
+      }
+    } else {
+      parseTableDataInput(tableData, input);
+    }
+  }
+  return tableData;
+};
+const parseTableDataInput = (tableData, item) => {
+  var _a, _b, _c, _d;
+  if (item.primaryKey) {
+    tableData.primaryKey = item.primaryKey;
+  } else if (item.index) {
+    const index = item.index;
+    for (let i = index.columns.length - 1; i >= 0; i--) {
+      if (typeof index.columns[i] === "string") {
+        index.columns[i] = {
+          column: index.columns[i]
+        };
+      }
+    }
+    ((_a = tableData.indexes) != null ? _a : tableData.indexes = []).push(item.index);
+  } else if (item.constraint) {
+    ((_b = tableData.constraints) != null ? _b : tableData.constraints = []).push(item.constraint);
+    if ((_d = (_c = item.constraint.references) == null ? void 0 : _c.options) == null ? void 0 : _d.dropMode) {
+      item.constraint.dropMode = item.constraint.references.options.dropMode;
+    }
+  }
+};
+
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -10896,7 +11077,6 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -10911,22 +11091,24 @@ var __objRest = (source, exclude) => {
 };
 const anyShape = {};
 class Db {
-  constructor(adapter, queryBuilder, table = void 0, shape = anyShape, columnTypes, transactionStorage, options) {
+  constructor(adapter, queryBuilder, table = void 0, shape = anyShape, columnTypes, transactionStorage, options, tableData = orchidCore.emptyObject) {
     this.adapter = adapter;
     this.queryBuilder = queryBuilder;
     this.table = table;
     this.shape = shape;
     this.columnTypes = columnTypes;
-    var _a, _b;
+    var _a;
     const self = this;
     const { softDelete } = options;
     const scopes = options.scopes || softDelete ? {} : orchidCore.emptyObject;
-    const tableData = getTableData();
-    this.internal = __spreadProps(__spreadValues({}, tableData), {
+    this.internal = {
       transactionStorage,
       scopes,
-      snakeCase: options.snakeCase
-    });
+      snakeCase: options.snakeCase,
+      noPrimaryKey: options.noPrimaryKey === "ignore",
+      comment: options.comment,
+      tableData
+    };
     this.baseQuery = this;
     const logger = options.logger || console;
     const parsers = {};
@@ -10987,20 +11169,21 @@ class Db {
       log: logParamToLogObject(logger, options.log),
       autoPreparedStatements: (_a = options.autoPreparedStatements) != null ? _a : false,
       parsers: hasParsers ? parsers : void 0,
-      language: options.language
+      language: options.language,
+      schema: options == null ? void 0 : options.schema
     };
-    if (options == null ? void 0 : options.schema) {
-      this.q.schema = options.schema;
+    let shapeHasPrimaryKey;
+    for (const key in shape) {
+      if (shape[key].data.primaryKey) {
+        shapeHasPrimaryKey = true;
+        if (this.internal.singlePrimaryKey) {
+          this.internal.singlePrimaryKey = void 0;
+          break;
+        }
+        this.internal.singlePrimaryKey = key;
+      }
     }
-    this.primaryKeys = Object.keys(shape).filter(
-      (key) => shape[key].data.isPrimaryKey
-    );
-    const primaryKeysFromData = (_b = getTableData().primaryKey) == null ? void 0 : _b.columns;
-    if (primaryKeysFromData)
-      this.primaryKeys.push(...primaryKeysFromData);
-    if (this.primaryKeys.length === 1) {
-      this.singlePrimaryKey = this.primaryKeys[0];
-    } else if (this.primaryKeys.length === 0 && shape !== anyShape && options.noPrimaryKey !== "ignore") {
+    if (!shapeHasPrimaryKey && !tableData.primaryKey && shape !== anyShape && options.noPrimaryKey !== "ignore") {
       const message = `Table ${table} has no primary key`;
       if (options.noPrimaryKey === "error")
         throw new Error(message);
@@ -11189,24 +11372,22 @@ const createDb = (_a) => {
     ct[orchidCore.snakeCaseKey] = true;
   }
   const transactionStorage = new node_async_hooks.AsyncLocalStorage();
-  const qb = new Db(
+  const qb = _initQueryBuilder(
     adapter,
-    void 0,
-    void 0,
-    anyShape,
     ct,
     transactionStorage,
-    commonOptions
+    commonOptions,
+    options
   );
-  qb.queryBuilder = qb;
-  const tableConstructor = (table, shape, options2) => new Db(
+  const tableConstructor = (table, shape, dataFn, options2) => new Db(
     adapter,
     qb,
     table,
     typeof shape === "function" ? getColumnTypes(ct, shape, nowSQL, options2 == null ? void 0 : options2.language) : shape,
     ct,
     transactionStorage,
-    __spreadValues(__spreadValues({}, commonOptions), options2)
+    __spreadValues(__spreadValues({}, commonOptions), options2),
+    parseTableData(dataFn)
   );
   const db = Object.assign(tableConstructor, qb, {
     adapter,
@@ -11217,6 +11398,32 @@ const createDb = (_a) => {
   }
   return db;
 };
+const _initQueryBuilder = (adapter, columnTypes, transactionStorage, commonOptions, options) => {
+  const qb = new Db(
+    adapter,
+    void 0,
+    void 0,
+    anyShape,
+    columnTypes,
+    transactionStorage,
+    commonOptions
+  );
+  if (options.extensions) {
+    const arr = [];
+    for (const x of options.extensions) {
+      if (typeof x === "string") {
+        arr.push({ name: x });
+      } else {
+        for (const key in x) {
+          arr.push({ name: key, version: x[key] });
+        }
+      }
+    }
+    qb.internal.extensions = arr;
+  }
+  qb.internal.domains = options.domains;
+  return qb.queryBuilder = qb;
+};
 
 class Rollback extends Error {
 }
@@ -11449,6 +11656,7 @@ exports.VirtualColumn = VirtualColumn;
 exports.Where = Where;
 exports.With = With;
 exports.XMLColumn = XMLColumn;
+exports._initQueryBuilder = _initQueryBuilder;
 exports._queryAfterSaveCommit = _queryAfterSaveCommit;
 exports._queryAll = _queryAll;
 exports._queryAs = _queryAs;
@@ -11516,7 +11724,7 @@ exports.columnCode = columnCode;
 exports.columnForeignKeysToCode = columnForeignKeysToCode;
 exports.columnIndexesToCode = columnIndexesToCode;
 exports.columnsShapeToCode = columnsShapeToCode;
-exports.constraintPropsToCode = constraintPropsToCode;
+exports.constraintInnerToCode = constraintInnerToCode;
 exports.constraintToCode = constraintToCode;
 exports.copyTableData = copyTableData;
 exports.countSelect = countSelect;
@@ -11527,12 +11735,12 @@ exports.foreignKeyArgumentToCode = foreignKeyArgumentToCode;
 exports.getClonedQueryData = getClonedQueryData;
 exports.getColumnInfo = getColumnInfo;
 exports.getColumnTypes = getColumnTypes;
-exports.getConstraintKind = getConstraintKind;
+exports.getPrimaryKeys = getPrimaryKeys;
 exports.getQueryAs = getQueryAs;
 exports.getShapeFromSelect = getShapeFromSelect;
-exports.getTableData = getTableData;
 exports.handleResult = handleResult;
 exports.identityToCode = identityToCode;
+exports.indexInnerToCode = indexInnerToCode;
 exports.indexToCode = indexToCode;
 exports.instantiateColumn = instantiateColumn;
 exports.isDefaultTimeStamp = isDefaultTimeStamp;
@@ -11547,16 +11755,18 @@ exports.makeExpression = makeExpression;
 exports.makeFnExpression = makeFnExpression;
 exports.makeRegexToFindInSql = makeRegexToFindInSql;
 exports.makeSQL = makeSQL;
-exports.newTableData = newTableData;
 exports.parseRecord = parseRecord;
 exports.parseResult = parseResult;
-exports.primaryKeyToCode = primaryKeyToCode;
+exports.parseTableData = parseTableData;
+exports.parseTableDataInput = parseTableDataInput;
+exports.primaryKeyInnerToCode = primaryKeyInnerToCode;
 exports.processSelectArg = processSelectArg;
 exports.pushLimitSQL = pushLimitSQL;
 exports.pushQueryArray = pushQueryArray;
 exports.pushQueryOn = pushQueryOn;
 exports.pushQueryOrOn = pushQueryOrOn;
 exports.pushQueryValue = pushQueryValue;
+exports.pushTableDataCode = pushTableDataCode;
 exports.queryFrom = queryFrom;
 exports.queryFromSql = queryFromSql;
 exports.queryJson = queryJson;
@@ -11567,14 +11777,15 @@ exports.quote = quote;
 exports.quoteString = quoteString;
 exports.raw = raw;
 exports.referencesArgsToCode = referencesArgsToCode;
-exports.resetTableData = resetTableData;
 exports.resolveSubQueryCallback = resolveSubQueryCallback;
 exports.saveSearchAlias = saveSearchAlias;
 exports.setParserForSelectedString = setParserForSelectedString;
 exports.setQueryObjectValue = setQueryObjectValue;
 exports.setQueryOperators = setQueryOperators;
 exports.simplifyColumnDefault = simplifyColumnDefault;
+exports.sqlFn = sqlFn;
 exports.sqlQueryArgsToExpression = sqlQueryArgsToExpression;
+exports.tableDataMethods = tableDataMethods;
 exports.templateLiteralToSQL = templateLiteralToSQL;
 exports.testTransaction = testTransaction;
 exports.throwIfNoWhere = throwIfNoWhere;