Drizzle ORM 入门教程：轻松上手数据库操作

概述

Drizzle ORM 是一个轻量级且高性能的数据库操作库，专为 JavaScript 和 TypeScript 项目设计。它支持多种数据库类型，如 PostgreSQL、MySQL、MariaDB、SQLite 和 CockroachDB。通过 Drizzle ORM，开发者可以更方便地进行数据库操作，提高代码的可维护性和扩展性。Drizzle ORM 提供了强大的查询构建器和类型安全支持，简化了数据库操作流程。

Drizzle ORM 简介

什么是 Drizzle ORM

Drizzle ORM 是一个轻量级且高性能的数据库操作库，专为 JavaScript 和 TypeScript 项目设计。它支持多种数据库类型，如 PostgreSQL、MySQL、MariaDB、SQLite 和 CockroachDB。通过 Drizzle ORM，开发者可以更方便地进行数据库操作，提高代码的可维护性和扩展性。

Drizzle ORM 的核心特性是提供了一种声明性的语法来操作数据库，这使得即使是复杂的查询也能以简洁的方式编写。同时，Drizzle ORM 能够很好地与 TypeScript 集成，提供了强类型支持，确保代码的安全性和可靠性。

Drizzle ORM 的特点和优势

1. 轻量级
   Drizzle ORM 相对于其他 ORM 工具（如 Sequelize 或 Knex.js），体积更小，启动速度更快。这对于对性能有较高要求的应用来说非常重要。

2. 高性能
   通过减少中间层和优化数据库访问，Drizzle ORM 能够提供接近原生数据库操作的性能。

3. 类型安全
   通过与 TypeScript 的集成，Drizzle ORM 能够提供强类型支持，减少潜在的运行时错误。

4. 灵活的查询构建
   Drizzle ORM 提供了强大的查询构建器，允许开发者构建复杂的查询逻辑，无需担心 SQL 注入等安全问题。

5. 广泛的支持
   支持多种数据库类型，使得开发者可以更灵活地选择适合自己的数据库环境。

安装 Drizzle ORM

要开始使用 Drizzle ORM，首先需要安装它。以下是安装 Drizzle ORM 的步骤：

npm install @vercel/postgres drizzle-orm @types/pg

上面的命令会安装 Drizzle ORM 的主要库以及 PostgreSQL 的类型定义。注意，具体数据库的类型定义可能会有所不同，需根据所使用的数据库进行相应调整。

数据库连接与配置

连接数据库的基本方法

连接数据库是使用 Drizzle ORM 的第一步。Drizzle ORM 使用 drizzle 函数来创建一个数据库连接实例。以下是一个基本的连接示例：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

// 连接到 PostgreSQL 数据库
const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 使用数据库
db.select({ id: sql<number>`1` });

配置数据库连接参数

在创建数据库连接时，可以通过配置参数来定制连接行为。例如，可以通过提供不同的环境变量来适应不同的数据库配置：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: process.env.DB_USER,
  host: process.env.DB_HOST,
  database: process.env.DB_NAME,
  password: process.env.DB_PASSWORD,
  port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : 5432,
});

const db = drizzle(pool);

// 使用数据库
db.select({ id: sql<number>`1` });

处理数据库连接错误

在连接数据库时，可能会遇到各种错误，如网络超时、身份验证失败等。Drizzle ORM 提供了错误处理机制，可以捕获并处理这些异常：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

try {
  const db = drizzle(pool);
  db.select({ id: sql<number>`1` });
} catch (error) {
  console.error('数据库连接失败:', error);
}

基本的数据库操作

创建与删除表

在使用 Drizzle ORM 时，可以通过 SQL 语句来创建和删除表。以下是创建和删除表的基本示例：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 创建表
db.execute(sql`
  create table if not exists users (
  id serial primary key,
  name varchar(255) not null,
  email varchar(255) not null unique
)
`);

// 删除表
db.execute(sql`
  drop table if exists users
`);

插入数据

插入数据是数据库操作中常见的任务。Drizzle ORM 提供了简洁的查询语法来插入数据：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 插入数据
const result = await db.execute(sql`
  insert into users (name, email)
  values ('张三', '[e-mail]'),
         ('李四', '[e-mail]')
`);

console.log(`插入了 ${result?.rowCount || 0} 条数据`);

查询数据

查询数据是数据库操作中最基础的任务之一。Drizzle ORM 提供了多种方法来查询数据，包括简单的选择查询和复杂的条件查询：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 查询数据
const result = await db.select({
  id: sql<number>`1`,
  name: sql`name`,
  email: sql`email`
}).from('users')

console.log('查询结果:', result);

更新数据

更新数据通常涉及修改现有的数据库记录。Drizzle ORM 提供了方便的方法来执行更新操作：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 更新数据
const result = await db.execute(sql`
  update users
  set name = '张三',
  email = '[e-mail]'
  where id = 1
`);

console.log(`更新了 ${result?.rowCount || 0} 条数据`);

删除数据

删除数据操作通常用于从数据库中移除不再需要的记录。Drizzle ORM 提供了简单的方法来执行删除操作：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 删除数据
const result = await db.execute(sql`
  delete from users
  where id = 1
`);

console.log(`删除了 ${result?.rowCount || 0} 条数据`);

使用模型进行数据库操作

定义模型类

为了简化数据库操作，通常会定义一些模型类来表示数据库中的表。这些模型类可以根据数据库表的结构来定义：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';
import { z } from 'zod';

// 数据库表结构定义
const schema = z.object({
  id: z.number().int().optional(),
  name: z.string().min(1),
  email: z.string().email().min(1),
});

type User = z.infer<typeof schema>;

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 使用模型类
const newUser: User = {
  name: '王五',
  email: '[e-mail]',
};

const result = await db.execute(sql`
  insert into users (name, email)
  values (${newUser.name}, ${newUser.email})
`);

console.log(`插入了 ${result?.rowCount || 0} 条数据`);

使用模型进行增删改查

通过定义模型类，可以更方便地进行数据库的增删改查操作。以下是一个通过模型类进行查询的示例：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';
import { z } from 'zod';

const schema = z.object({
  id: z.number().int().optional(),
  name: z.string().min(1),
  email: z.string().email().min(1),
});

type User = z.infer<typeof schema>;

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 查询数据
const users = await db.select().from<User>('users');

console.log('查询结果:', users);

关系映射与关联操作

Drizzle ORM 还支持关系映射，可以处理一对多、多对一等多种关系。以下是一个简单的关联操作示例：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';
import { z } from 'zod';

// 定义用户表
const userSchema = z.object({
  id: z.number().int().optional(),
  name: z.string().min(1),
  email: z.string().email().min(1),
});

type User = z.infer<typeof userSchema>;

// 定义订单表
const orderSchema = z.object({
  id: z.number().int().optional(),
  user_id: z.number().int().min(1),
  product_name: z.string().min(1),
});

type Order = z.infer<typeof orderSchema>;

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

// 关联查询
const usersWithOrders = await db.select({
  user: { id: sql<number>`1`, name: sql`name`, email: sql`email` },
  orders: db.select({ id: sql<number>`1`, product_name: sql`product_name` }).from('orders')
}).from<User & { orders: Order[] }>('users')

console.log('关联查询结果:', usersWithOrders);

进阶功能介绍

事务管理

事务是一种确保数据库操作的原子性、一致性、隔离性、持久性的机制。Drizzle ORM 支持事务操作，可以通过 db.transaction() 方法来启动事务：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

async function runTransaction() {
  try {
    await db.transaction(async (db) => {
      // 插入数据
      const insertResult = await db.execute(sql`
        insert into users (name, email)
        values ('赵六', '[e-mail]')
      `);

      console.log(`插入了 ${insertResult?.rowCount || 0} 条数据`);

      // 更新数据
      const updateResult = await db.execute(sql`
        update users
        set name = '赵六更新'
        where id = ${insertResult?.lastId || 0}
      `);

      console.log(`更新了 ${updateResult?.rowCount || 0} 条数据`);
    });
  } catch (error) {
    console.error('事务失败:', error);
  }
}

runTransaction();

查询构建器

Drizzle ORM 提供了强大的查询构建器，可以构造复杂的查询语句，包括过滤、排序、分页等操作：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

async function advancedQuery() {
  // 查询并过滤
  const usersWithOrders = await db.select({
    user: { id: sql<number>`1`, name: sql`name`, email: sql`email` },
    orders: db.select({ id: sql<number>`1`, product_name: sql`product_name` }).from('orders')
  }).from<User & { orders: Order[] }>('users')
  .where(sql`name = '张三'`);

  console.log('过滤查询结果:', usersWithOrders);
}

advancedQuery();

过滤和排序

通过查询构建器，可以轻松地添加过滤和排序条件来定制查询结果：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

async function filterAndSort() {
  // 过滤并排序
  const users = await db.select().from<User>('users')
  .where(sql`email like '%example.com'`)
  .orderBy(sql`name`);

  console.log('过滤并排序结果:', users);
}

filterAndSort();

分页与聚合

分页和聚合是数据库操作中常见的任务。通过查询构建器，可以轻松实现这些功能：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

async function paginationAndAggregation() {
  // 分页查询
  const users = await db.select().from<User>('users')
  .limit(10)
  .offset(0);

  console.log('分页查询结果:', users);

  // 聚合查询
  const aggregatedData = await db.select({
    totalUsers: db.count().from('users')
  });

  console.log('聚合查询结果:', aggregatedData);
}

paginationAndAggregation();

常见问题与解决

常见错误及解决方案

1. 连接超时

   • 确保数据库服务器正在运行并且可以访问。
   • 检查网络配置是否正确。
   • 调整连接超时时间。

2. 权限不足

   • 确认数据库用户具有访问数据库的权限。
   • 检查数据库用户角色设置。
3. SQL 错误
   • 检查 SQL 语句是否有语法错误。
   • 通过日志查看具体的错误信息。

性能优化技巧

1. 索引优化

   • 为经常查询的字段添加索引。
   • 考虑复合索引以提高性能。

2. 查询优化

   • 避免不必要的查询，尽量减少查询次数。
   • 使用正确的查询构建器方法，如 select、where、orderBy 等。
3. 缓存数据
   • 使用缓存技术减少对数据库的访问。
   • 缓存经常访问的数据。

代码示例与实战演练

通过上述示例，可以看到 Drizzle ORM 提供了许多功能来简化数据库操作。以下是一个完整的实战演练，展示如何使用 Drizzle ORM 进行一个完整的数据库操作流程：

import { drizzle } from 'drizzle-orm/node-postgres';
import { sql } from '@vercel/postgres';
import { Client, Pool, PoolClient } from 'pg';
import { z } from 'zod';

// 定义用户表结构
const userSchema = z.object({
  id: z.number().int().optional(),
  name: z.string().min(1),
  email: z.string().email().min(1),
});

type User = z.infer<typeof userSchema>;

const pool = new Pool({
  user: 'your_username',
  host: 'localhost',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

const db = drizzle(pool);

async function main() {
  try {
    // 创建表
    await db.execute(sql`
      create table if not exists users (
        id serial primary key,
        name varchar(255) not null,
        email varchar(255) not null unique
      )
    `);

    // 插入数据
    const newUser: User = {
      name: '张三',
      email: '[e-mail]',
    };
    const insertResult = await db.execute(sql`
      insert into users (name, email)
      values (${newUser.name}, ${newUser.email})
    `);

    console.log(`插入了 ${insertResult?.rowCount || 0} 条数据`);

    // 查询数据
    const users = await db.select().from<User>('users');
    console.log('查询结果:', users);

    // 更新数据
    const updateResult = await db.execute(sql`
      update users
      set name = '张三更新'
      where id = ${insertResult?.lastId || 0}
    `);
    console.log(`更新了 ${updateResult?.rowCount || 0} 条数据`);

    // 删除数据
    const deleteResult = await db.execute(sql`
      delete from users
      where id = ${insertResult?.lastId || 0}
    `);
    console.log(`删除了 ${deleteResult?.rowCount || 0} 条数据`);

    // 关闭数据库连接
    await pool.end();
  } catch (error) {
    console.error('数据库操作失败:', error);
  }
}

main();

通过以上代码，可以看到一个完整的数据库操作流程，包括创建表、插入数据、查询数据、更新数据和删除数据。这些操作是数据库应用开发中最常见的任务，通过 Drizzle ORM 可以简化这些操作，提高开发效率。