v1.0
75%
Benchmarks
Extension
Studio
Studio Package
Drizzle Run
Our goodies!
EdgeDB
Upstash
Turso
🚀 Drizzle is giving you 10% off Turso Scaler and Pro for 1 Year 🚀
Payload
Xata
Neon
Nuxt
Hydra
Deco.cx
Tembo
SQLite Cloud
SingleStore
PrAha
Lokalise
Replit
Mooncake

索引与约束

约束

SQL 约束是对表列施加的规则。它们用于防止无效数据被输入到数据库中。

这确保了数据库中数据的准确性和可靠性。

默认值

DEFAULT 子句指定在执行 INSERT 时，如果用户未提供值，则使用的列的默认值。 如果列定义中没有附加显式的 DEFAULT 子句， 则该列的默认值为 NULL。

显式的 DEFAULT 子句可以指定默认值为 NULL、 字符串常量、BLOB 常量、带符号数字或任何用括号括起来的常量表达式。

PostgreSQL
MySQL
SQLite
SingleStore 
import { sql } from "drizzle-orm";
import { integer, uuid, pgTable } from "drizzle-orm/pg-core";

const table = pgTable('table', {
  integer1: integer('integer1').default(42),
  integer2: integer('integer2').default(sql`'42'::integer`),
  uuid1: uuid('uuid1').defaultRandom(),
  uuid2: uuid('uuid2').default(sql`gen_random_uuid()`),
});
CREATE TABLE IF NOT EXISTS "table" (
  "integer1" integer DEFAULT 42,
  "integer2" integer DEFAULT '42'::integer,
  "uuid1" uuid DEFAULT gen_random_uuid(),
  "uuid2" uuid DEFAULT gen_random_uuid()
);

非空

默认情况下，列可以包含 NULL 值。NOT NULL 约束强制列 不 接受 NULL 值。

这强制字段始终包含一个值，这意味着您不能插入新记录， 或在不向该字段添加值的情况下更新记录。

PostgreSQL
MySQL
SQLite
SingleStore 
import { integer, pgTable } from "drizzle-orm/pg-core";

const table = pgTable('table', {
  integer: integer('integer').notNull(),
});
CREATE TABLE IF NOT EXISTS "table" (
  "integer" integer NOT NULL,
);

唯一

UNIQUE 约束确保列中的所有值都是不同的。

UNIQUE 和 PRIMARY KEY 约束都为列或列集提供了唯一性的保证。

PRIMARY KEY 约束自动具有 UNIQUE 约束。

每个表可以有多个 UNIQUE 约束，但每个表只能有一个 PRIMARY KEY 约束。

PostgreSQL
MySQL
SQLite
SingleStore 
import { integer, text, unique, pgTable } from "drizzle-orm/pg-core";

export const user = pgTable('user', {
  id: integer('id').unique(),
});

export const table = pgTable('table', {
  id: integer('id').unique('custom_name'),
});

export const composite = pgTable('composite_example', {
  id: integer('id'),
  name: text('name'),
}, (t) => [
  unique().on(t.id, t.name),
  unique('custom_name').on(t.id, t.name)
]);

// In Postgres 15.0+ NULLS NOT DISTINCT is available
// This example demonstrates both available usages
export const userNulls = pgTable('user_nulls_example', {
  id: integer('id').unique("custom_name", { nulls: 'not distinct' }),
}, (t) => [
  unique().on(t.id).nullsNotDistinct()
]);
CREATE TABLE IF NOT EXISTS "composite_example" (
  "id" integer,
  "name" text,
  CONSTRAINT "composite_example_id_name_unique" UNIQUE("id","name"),
  CONSTRAINT "custom_name" UNIQUE("id","name")
);

CREATE TABLE IF NOT EXISTS "table" (
	"id" integer,
	CONSTRAINT "custom_name" UNIQUE("id")
);

CREATE TABLE IF NOT EXISTS "user" (
	"id" integer,
	CONSTRAINT "user_id_unique" UNIQUE("id")
);

CREATE TABLE IF NOT EXISTS "user_nulls_example" (
  "id" integer,
  CONSTRAINT "custom_name" UNIQUE NULLS NOT DISTINCT("id"),
  CONSTRAINT "user_nulls_example_id_unique" UNIQUE NULLS NOT DISTINCT("id")
);

检查

CHECK 约束用于限制可以放置在列中的值范围。

如果您在列上定义 CHECK 约束，它将仅允许该列的某些值。

如果您在表上定义 CHECK 约束，它可以根据行中其他列的值限制某些列的值。

PostgreSQL
MySQL
SQLite
SingleStore 
import { sql } from "drizzle-orm";
import { check, integer, pgTable, text, uuid } from "drizzle-orm/pg-core";

export const users = pgTable(
  "users",
  {
    id: uuid().defaultRandom().primaryKey(),
    username: text().notNull(),
    age: integer(),
  },
  (table) => [
    check("age_check1", sql`${table.age} > 21`),
  ]
);
CREATE TABLE IF NOT EXISTS "users" (
    "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
    "username" text NOT NULL,
    "age" integer,
    CONSTRAINT "age_check1" CHECK ("users"."age" > 21)
);

主键

PRIMARY KEY 约束唯一标识表中的每条记录。 主键必须包含 UNIQUE 值，并且不能包含 NULL 值。

一个表只能有 一个 主键；在该表中，这个主键可以由单个或多个列（字段）组成。

PostgreSQL
MySQL
SQLite
SingleStore 
import { serial, text, pgTable } from "drizzle-orm/pg-core";

const user = pgTable('user', {
  id: serial('id').primaryKey(),
});

const table = pgTable('table', {
  id: text('cuid').primaryKey(),
});
CREATE TABLE IF NOT EXISTS "user" (
  "id" serial PRIMARY KEY,
);

CREATE TABLE IF NOT EXISTS "table" (
  "cuid" text PRIMARY KEY,
);

复合主键

就像 PRIMARY KEY，复合主键通过多个字段唯一标识表中的每条记录。

Drizzle ORM 提供了一个独立的 primaryKey 操作符来实现这一点：

PostgreSQL
MySQL
SQLite
SingleStore 
import { serial, text, integer, primaryKey, pgTable } from "drizzle-orm/pg-core";

export const user = pgTable("user", {
  id: serial("id").primaryKey(),
  name: text("name"),
});

export const book = pgTable("book", {
  id: serial("id").primaryKey(),
  name: text("name"),
});

export const booksToAuthors = pgTable("books_to_authors", {
  authorId: integer("author_id"),
  bookId: integer("book_id"),
}, (table) => [
  primaryKey({ columns: [table.bookId, table.authorId] }),
  // Or PK with custom name
  primaryKey({ name: 'custom_name', columns: [table.bookId, table.authorId] }),
]);
...

CREATE TABLE IF NOT EXISTS "books_to_authors" (
  "author_id" integer,
  "book_id" integer,
  PRIMARY KEY("book_id","author_id"),
);

ALTER TABLE "books_to_authors" ADD CONSTRAINT "custom_name" PRIMARY KEY("book_id","author_id");

外键

FOREIGN KEY 约束用于防止破坏表之间链接的操作。 FOREIGN KEY 是一个字段（或字段集合），在一个表中引用另一个表的 PRIMARY KEY。 包含外键的表称为子表，包含主键的表称为引用表或父表。

Drizzle ORM 提供了几种声明外键的方法。 您可以在列声明语句中声明它们：

PostgreSQL
MySQL
SQLite
SingleStore 
import { serial, text, integer, pgTable } from "drizzle-orm/pg-core";

export const user = pgTable("user", {
  id: serial("id"),
  name: text("name"),
});

export const book = pgTable("book", {
  id: serial("id"),
  name: text("name"),
  authorId: integer("author_id").references(() => user.id)
});

如果您想进行自引用，由于 TypeScript 的限制，您必须显式设置引用回调的返回类型或使用独立的 foreignKey 操作符。

PostgreSQL
MySQL
SQLite
SingleStore 
import { serial, text, integer, foreignKey, pgTable, AnyPgColumn } from "drizzle-orm/pg-core";

export const user = pgTable("user", {
  id: serial("id"),
  name: text("name"),
  parentId: integer("parent_id").references((): AnyPgColumn => user.id)
});

// or
export const user = pgTable("user", {
  id: serial("id"),
  name: text("name"),
  parentId: integer("parent_id"),
}, (table) => [
  foreignKey({
    columns: [table.parentId],
    foreignColumns: [table.id],
    name: "custom_fk"
  })
]);

要声明多列外键，可以使用专用的 foreignKey 操作符：

PostgreSQL
MySQL
SQLite
SingleStore 
import { serial, text, foreignKey, pgTable, AnyPgColumn } from "drizzle-orm/pg-core";

export const user = pgTable("user", {
  firstName: text("firstName"),
  lastName: text("lastName"),
}, (table) => [
  primaryKey({ columns: [table.firstName, table.lastName]})
]);

export const profile = pgTable("profile", {
  id: serial("id").primaryKey(),
  userFirstName: text("user_first_name"),
  userLastName: text("user_last_name"),
}, (table) => [
  foreignKey({
    columns: [table.userFirstName, table.userLastName],
    foreignColumns: [user.firstName, user.lastName],
    name: "custom_fk"
  })
])

索引

Drizzle ORM 提供了 index 和 unique index 声明的 API：

PostgreSQL
MySQL
SQLite
SingleStore 
import { serial, text, index, uniqueIndex, pgTable } from "drizzle-orm/pg-core";

export const user = pgTable("user", {
  id: serial("id").primaryKey(),
  name: text("name"),
  email: text("email"),
}, (table) => [
  index("name_idx").on(table.name),
  uniqueIndex("email_idx").on(table.email)
]);
CREATE TABLE "user" (
  ...
);

CREATE INDEX "name_idx" ON "user" ("name");
CREATE UNIQUE INDEX "email_idx" ON "user" ("email");
IMPORTANT

对于 drizzle-kit@0.22.0 和 drizzle-orm@0.31.0 之前的版本，drizzle-kit 仅支持索引 name 和 on() 参数。

在 drizzle-kit@0.22.0 和 drizzle-orm@0.31.0 之后的版本中，drizzle-kit 支持所有字段！

从 0.31.0 开始，Drizzle ORM 的新索引 API 提供了用于索引创建的所有参数的集合：

// First example, with `.on()`
index('name')
  .on(table.column1.asc(), table.column2.nullsFirst(), ...) or .onOnly(table.column1.desc().nullsLast(), table.column2, ...)
  .concurrently()
  .where(sql``)
  .with({ fillfactor: '70' })

// Second Example, with `.using()`
index('name')
  .using('btree', table.column1.asc(), sql`lower(${table.column2})`, table.column1.op('text_ops'))
  .where(sql``) // sql expression
  .with({ fillfactor: '70' })