PostgreSQL

MySQL

SQLite

SingleStore

MSSQL

CockroachDB
v1.0
94%
Benchmarks
Extension
Studio
Studio Package
Gateway
Drizzle Run
Our goodies!
Lokalise
Replit
Sentry
Sevalla
GibsonAI
Clerk
Warp
Vercel
Turso
🚀 Drizzle is giving you 10% off Turso Scaler and Pro for 1 Year 🚀
Payload
Xata
Neon
Nuxt
SQLite Cloud
Upstash
Sponsor

CockroachDB 列类型

WARNING

本页介绍自 drizzle 版本 1.0.0-beta.2 及以上支持的概念。

npm
yarn
pnpm
bun 
npm i drizzle-orm@beta
npm i drizzle-kit@beta -D

我们对所有类型都提供了原生支持，但如果这还不能满足您的需求，欢迎创建 自定义类型。

重要

本部分文档中的所有示例均未使用数据库列名别名，列名均由 TypeScript 的键生成。

如果需要，您可以使用数据库别名作为列名，也可以通过 casing 参数为 Drizzle 定义映射策略。

更多内容请查阅 这里

bigint

int int8 int64 integer

带符号的 8 字节整数

如果预期值在 2^31 以上但低于 2^53，可以使用 mode: 'number'，此时使用 JavaScript 的 number 而非 bigint。

import { bigint, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	bigint: bigint({ mode: 'number' })
});

// 将推断为 `number`
bigint: bigint({ mode: 'number' })

// 将推断为 `bigint`
bigint: bigint({ mode: 'bigint' })
CREATE TABLE "table" (
	"bigint" bigint
);
import { sql } from "drizzle-orm";
import { bigint, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	bigint1: bigint().default(10),
	bigint2: bigint().default(sql`'10'::bigint`)
});
CREATE TABLE "table" (
	"bigint1" bigint DEFAULT 10,
	"bigint2" bigint DEFAULT '10'::bigint
);

smallint

smallint int2
带符号的 2 字节小范围整数

import { smallint, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	smallint: smallint()
});
CREATE TABLE "table" (
	"smallint" smallint
);
import { sql } from "drizzle-orm";
import { smallint, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	smallint1: smallint().default(10),
	smallint2: smallint().default(sql`'10'::smallint`)
});
CREATE TABLE "table" (
	"smallint1" smallint DEFAULT 10,
	"smallint2" smallint DEFAULT '10'::smallint
);

int4

带符号的 4 字节整数

import { int4, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	int4: int4()
});

CREATE TABLE "table" (
	"int4" int4
);
import { sql } from "drizzle-orm";
import { int4, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	int1: int4().default(10),
	int2: int4().default(sql`'10'::int4`)
});
CREATE TABLE "table" (
	"int1" int4 DEFAULT 10,
	"int2" int4 DEFAULT '10'::int4
);

int8

是 bigint 的别名

int2

是 smallint 的别名

---

bool

Cockroach 提供了标准的 SQL 类型 bool。

更多信息请参考官方 Cockroach 文档.

import { bool, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	boolean: bool()
});

CREATE TABLE "table" (
	"boolean" bool
);

---

string

text varchar，char

STRING 数据类型存储 Unicode 字符串。

为兼容 PostgreSQL，CockroachDB 支持以下 STRING 相关类型及其别名：

VARCHAR（及其别名 CHARACTER VARYING）
CHAR（及其别名 CHARACTER）
NAME

更多信息请参考 CockroachDB 官方 文档.

您可以定义 { enum: ["value1", "value2"] } 配置来推断 insert 和 select 类型，但它不会检查运行时的值。

import { string, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
  stringColumn: string(), // 等同于 PostgreSQL 的 `text` 类型
  stringColumn1: string({ length: 256 }), // 等同于 PostgreSQL 的 `varchar(256)` 类型
});

// 将推断为 text: "value1" | "value2" | null
stringColumn: string({ enum: ["value1", "value2"] })
CREATE TABLE "table" (
	"stringColumn" string,
    "stringColumn1" string(256),
);

text

CockroachDB 对 STRING 类型的别名：

更多信息请参考 CockroachDB 官方 文档.

您可以定义 { enum: ["value1", "value2"] } 配置来推断 insert 和 select 类型，但它不会检查运行时的值。

import { text, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
  text: text()
});

// 将推断为 text: "value1" | "value2" | null
text: text({ enum: ["value1", "value2"] })
CREATE TABLE "table" (
	"text" text
);

varchar

character varying(n) varchar(n)

STRING 别名，用于保持与 PostgreSQL 兼容

更多信息请参考 CockroachDB 官方 文档.

您可以定义 { enum: ["value1", "value2"] } 配置来推断 insert 和 select 类型，但它不会检查运行时的值。

length 参数为可选，依据 PostgreSQL 文档。

import { varchar, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
  varchar1: varchar(),
  varchar2: varchar({ length: 256 }),
});

// 将推断为 text: "value1" | "value2" | null
varchar: varchar({ enum: ["value1", "value2"] }),
CREATE TABLE "table" (
	"varchar1" varchar,
	"varchar2" varchar(256)
);

char

character(n) char(n)

STRING 别名，用于保持与 PostgreSQL 兼容

更多信息请参考 CockroachDB 官方 文档.

您可以定义 { enum: ["value1", "value2"] } 配置来推断 insert 和 select 类型，但它不会检查运行时的值。

length 参数为可选，依据 PostgreSQL 文档。

import { char, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
  char1: char(),
  char2: char({ length: 256 }),
});

// 将推断为 text: "value1" | "value2" | null
char: char({ enum: ["value1", "value2"] }),
CREATE TABLE "table" (
	"char1" char,
	"char2" char(256)
);

---

https://www.cockroachlabs.com/docs/stable/float

decimal

numeric decimal dec
DECIMAL 数据类型存储精确的定点数字。当需要保持精确度（例如货币数据）时使用该类型。

更多信息请参考 CockroachDB 官方 文档.

import { decimal, cockroachTable } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
  decimal1: decimal(),
  decimal2: decimal({ precision: 100 }),
  decimal3: decimal({ precision: 100, scale: 20 }),
  decimalNum: decimal({ mode: 'number' }),
  decimalBig: decimal({ mode: 'bigint' }),
});
CREATE TABLE "table" (
	"decimal1" decimal,
	"decimal2" decimal(100),
	"decimal3" decimal(100, 20),
	"decimalNum" decimal,
	"decimalBig" decimal
);

numeric

是 decimal 的别名

float

float float8 double precision

更多信息请参考 CockroachDB 官方 文档.

import { sql } from "drizzle-orm";
import { float, cockroachTable } from "drizzle-orm/cockroach-core";  

const table = cockroachTable('table', {
	float1: float(),
	float2: float().default(10.10),
	float3: float().default(sql`'10.10'::float`),
});
CREATE TABLE "table" (
	"float1" float,
	"float2" float default 10.10,
	"float3" float default '10.10'::float
);

real

real float4
单精度浮点数（4 字节）

更多信息请参考 CockroachDB 官方 文档.

import { sql } from "drizzle-orm";
import { real, cockroachTable } from "drizzle-orm/cockroach-core";  

const table = cockroachTable('table', {
	real1: real(),
	real2: real().default(10.10),
	real3: real().default(sql`'10.10'::real`),
});
CREATE TABLE "table" (
	"real1" real,
	"real2" real default 10.10,
	"real3" real default '10.10'::real
);

double precision

是 float 的别名

---

jsonb

jsonb

JSONB 数据类型以二进制形式存储 JSON（JavaScript 对象表示法）数据，消除空白符、重复键和键排序。

更多信息请参考 CockroachDB 官方 文档.

import { jsonb, cockroachTable } from "drizzle-orm/cockroach-core";

const table = cockroachTable('table', {
	jsonb1: jsonb(),
	jsonb2: jsonb().default({ foo: "bar" }),
	jsonb3: jsonb().default(sql`'{foo: "bar"}'::jsonb`),
});
CREATE TABLE "table" (
	"jsonb1" jsonb,
	"jsonb2" jsonb default '{"foo": "bar"}'::jsonb,
	"jsonb3" jsonb default '{"foo": "bar"}'::jsonb
);

您可以为 JSON 对象推断指定 .$type<..>() 类型，但它不会检查运行时值。
此方式为默认值、插入及查询 schema 提供了编译时保护。

// 将推断为 { foo: string }
jsonb: jsonb().$type<{ foo: string }>();

// 将推断为 string[]
jsonb: jsonb().$type<string[]>();

// 不会编译通过
jsonb: jsonb().$type<string[]>().default({});

---

bit

bit

BIT 数据类型存储位数组。BIT 类型长度固定。


大小

BIT 的位数根据如下确定：

类型声明逻辑大小
BIT1 位
BIT(N)N 位

更多信息请参考 CockroachDB 官方 文档.

import { sql } from "drizzle-orm";
import { cockroachTable, bit } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	bit1: bit(),
	bit2: bit({ length: 15 }),
	bit3: bit({ length: 15 }).default('10011'),
	bit4: bit({ length: 15 }).default(sql`'10011'`)
});
CREATE TABLE "table" (
	"bit1" bit,
	"bit2" bit(15),
	"bit3" bit(15) DEFAULT '10011',
	"bit4" bit(15) DEFAULT '10011'
);

varbit

varbit

VARBIT 数据类型存储位数组。VARBIT 类型长度可变。


大小

VARBIT 的位数根据如下确定：

类型声明逻辑大小
VARBIT变量长度，无最大值
VARBIT(N)变量长度，最大为 N 位

更多信息请参考 CockroachDB 官方 文档.

import { sql } from "drizzle-orm";
import { cockroachTable, bit } from "drizzle-orm/cockroach-core";

export const table = cockroachTable('table', {
	varbit1: varbit(),
	varbit2: varbit({ length: 15 }),
	varbit3: varbit({ length: 15 }).default('10011'),
	varbit4: varbit({ length: 15 }).default(sql`'10011'`)
});
CREATE TABLE "table" (
	"varbit1" varbit,
	"varbit2" varbit(15),
	"varbit3" varbit(15) DEFAULT '10011',
	"varbit4" varbit(15) DEFAULT '10011'
);

---

uuid

uuid

UUID（全局唯一标识符）数据类型存储 128 位值，保证空间和时间上的唯一性。

更多信息请参考 CockroachDB 官方 文档.

import { uuid, cockroachTable } from "drizzle-orm/cockroach-core";

const table = cockroachTable('table', {
  uuid1: uuid(),
  uuid2: uuid().defaultRandom(),
  uuid3: uuid().default('a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11')
});
CREATE TABLE "table" (
	"uuid1" uuid,
	"uuid2" uuid default gen_random_uuid(),
	"uuid3" uuid default 'a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11'
);

---

time

time timetz time with timezone time without timezone

TIME 数据类型存储 UTC 时间（时分秒）。
TIMETZ 数据类型存储带有时区偏差的 UTC 时间。

更多信息请参考 CockroachDB 官方 文档.

import { time, cockroachTable } from "drizzle-orm/cockroach-core";

const table = cockroachTable('table', {
  time1: time(),
  time2: time({ withTimezone: true }),
  time3: time({ precision: 6 }),
  time4: time({ precision: 6, withTimezone: true })
});
CREATE TABLE "table" (
	"time1" time,
	"time2" time with timezone,
	"time3" time(6),
	"time4" time(6) with timezone
);

timestamp

timestamp timestamptz timestamp with time zone timestamp without time zone

TIMESTAMP 和 TIMESTAMPTZ 数据类型存储 UTC 的日期和时间。

更多信息请参考 CockroachDB 官方 文档.

import { sql } from "drizzle-orm";
import { timestamp, cockroachTable } from "drizzle-orm/cockroach-core";

const table = cockroachTable('table', {
  timestamp1: timestamp(),
	timestamp2: timestamp({ precision: 6, withTimezone: true }),
	timestamp3: timestamp().defaultNow(),
	timestamp4: timestamp().default(sql`now()`),
});
CREATE TABLE "table" (
	"timestamp1" timestamp,
	"timestamp2" timestamp (6) with time zone,
	"timestamp3" timestamp default now(),
	"timestamp4" timestamp default now()
);

可指定 date 或 string 推断模式：

// 将推断为 date 类型
timestamp: timestamp({ mode: "date" }),

// 将推断为 string 类型
timestamp: timestamp({ mode: "string" }),

string 模式不会为您进行任何映射。添加此模式是为开发者提供自行处理日期及映射的可能性，
取决于他们的需要。Drizzle 会以字符串形式将日期原样传递给数据库并从数据库接收，
因此行为应尽可能可预测，并且完全符合数据库行为。

date 模式为常规处理日期的方式。Drizzle 会负责数据库与 JS Date 对象间的所有映射。

date

date

DATE 数据类型存储年月日。

更多信息请参考 CockroachDB 官方 文档.

import { date, cockroachTable } from "drizzle-orm/cockroach-core";

const table = cockroachTable('table', {
	date: date(),
});
CREATE TABLE "table" (
	"date" date
);

可指定 date 或 string 推断模式：

// 将推断为 date 类型
date: date({ mode: "date" }),

// 将推断为 string 类型
date: date({ mode: "string" }),

interval

interval

存储表示一段时间跨度的值。

更多信息请参考 CockroachDB 官方 文档.

import { interval, cockroachTable } from "drizzle-orm/cockroach-core";

const table = cockroachTable('table', {
	interval1: interval(),
  interval2: interval({ fields: 'day' }),
  interval3: interval({ fields: 'month' , precision: 6 }),
});

CREATE TABLE "table" (
	"interval1" interval,
	"interval2" interval day,
	"interval3" interval(6) month
);

---

enum

enum enumerated types
枚举（enum）类型是包含静态、有序值集合的数据类型。
它们等同于多种编程语言支持的枚举类型。
示例包括一周的星期几，或某项数据的一组状态值。

更多信息请参考 CockroachDB 官方 文档.

import { cockroachEnum, cockroachTable } from "drizzle-orm/cockroach-core";

export const moodEnum = cockroachEnum('mood', ['sad', 'ok', 'happy']);

export const table = cockroachTable('table', {
  mood: moodEnum(),
});
CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');

CREATE TABLE "table" (
	"mood" mood
);

---

自定义数据类型

每个列构建器都有一个 .$type() 方法，可用于自定义列的数据类型。

例如，对于未知或带品牌的类型非常有用：

type UserId = number & { __brand: 'user_id' };
type Data = {
	foo: string;
	bar: number;
};

const users = cockroachTable('users', {
  id: int().$type<UserId>().primaryKey(),
  jsonField: json().$type<Data>(),
});

身份列

使用此功能需要 drizzle-orm@0.32.0 及以上版本和 drizzle-kit@0.23.0 及以上版本

PostgreSQL 和 CockroachDB 支持身份列，作为自动生成列唯一整数值的方式。这些值使用序列生成，并可通过 GENERATED AS IDENTITY 子句定义。

身份列类型

示例

import { pgTable, integer, text } from 'drizzle-orm/pg-core' 

export const ingredients = pgTable("ingredients", {
  id: integer().primaryKey().generatedAlwaysAsIdentity({ startWith: 1000 }),
  name: text().notNull(),
  description: text(),
});

您可以在 .generatedAlwaysAsIdentity() 函数中指定序列的所有属性，也可以为序列指定自定义名称。

PostgreSQL 文档 参考。

默认值

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

显式的 DEFAULT 子句可指定默认值为 NULL、字符串常量、二进制常量、带符号数字，或括号内的任何常量表达式。

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

const table = pgTable('table', {
	integer1: integer().default(42),
	integer2: integer().default(sql`'42'::integer`),
	uuid1: uuid().defaultRandom(),
	uuid2: uuid().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()
);

使用 $default() 或 $defaultFn()（两者是同一函数的不同别名）时，
可在运行时生成默认值，并在所有插入查询中使用这些值。

这些函数可以帮助您利用各种实现，如 uuid、cuid、cuid2 等。

注意：该默认值不影响 drizzle-kit 的行为，仅用于 drizzle-orm 的运行时

import { text, pgTable } from "drizzle-orm/pg-core";
import { createId } from '@paralleldrive/cuid2';

const table = pgTable('table', {
	id: text().$defaultFn(() => createId()),
});

使用 $onUpdate() 或 $onUpdateFn()（两者是同一函数不同别名）时，
可在运行时生成默认值，并在所有更新查询中使用这些值。

为列添加动态更新值。当行被更新时调用该函数，若没有提供新值，则使用函数返回值作为列值。
若未提供默认值（或 $defaultFn），则该函数在插入行时也会被调用，返回值用作列值。

注意：该值不影响 drizzle-kit 的行为，仅用于 drizzle-orm 的运行时

import { integer, timestamp, text, pgTable } from "drizzle-orm/pg-core";

const table = pgTable('table', {
	updateCounter: integer().default(sql`1`).$onUpdateFn((): SQL => sql`${table.update_counter} + 1`),
	updatedAt: timestamp({ mode: 'date', precision: 3 }).$onUpdate(() => new Date()),
    	alwaysNull: text().$type<string | null>().$onUpdate(() => null),
});

非空

NOT NULL 约束表示对应列不能包含 NULL 值。

import { integer, pgTable } from "drizzle-orm/pg-core";

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

主键

主键约束表示一列或多列可作为表中行的唯一标识符，
要求这些值既唯一且非空。

import { serial, pgTable } from "drizzle-orm/pg-core";

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