使用 Knex.js 在 Node.js 项目中构建 SQL 查询

引言

大家好，欢迎来到今天的讲座！今天我们要一起探讨如何在 Node.js 项目中使用 Knex.js 构建 SQL 查询。如果你曾经在编写 SQL 查询时感到头疼，或者对 ORM（对象关系映射）工具感到困惑，那么 Knex.js 可能是你一直在寻找的解决方案。

Knex.js 是一个功能强大且灵活的查询构建器，它可以帮助你在 Node.js 项目中轻松地与数据库进行交互。无论是简单的 CRUD 操作，还是复杂的联表查询，Knex.js 都能为你提供简洁而优雅的 API。最重要的是，它不会像某些 ORM 工具那样强制你遵循特定的模式，而是给你足够的自由度来编写高效的 SQL 查询。

在接下来的时间里，我们将从基础开始，逐步深入到高级用法。我们会通过大量的代码示例和表格来帮助你理解每一个概念。希望你能在这个过程中学到一些新的技巧，并且能够在自己的项目中应用这些知识。

为什么选择 Knex.js？

在开始之前，我们先来聊聊为什么 Knex.js 是一个不错的选择。以下是一些关键原因：

灵活性：Knex.js 不是一个 ORM，而是一个查询构建器。这意味着你可以直接编写 SQL 查询，而不必担心被框架束缚。你可以根据需要选择是否使用链式调用来构建查询，也可以直接写原生 SQL。
支持多种数据库：Knex.js 支持多种主流数据库，包括 PostgreSQL、MySQL、MariaDB、SQLite3 和 Oracle。无论你使用哪种数据库，Knex.js 都能为你提供一致的 API。
易于学习：Knex.js 的 API 设计非常直观，容易上手。即使你是第一次接触查询构建器，也能很快掌握基本用法。
性能优化：由于 Knex.js 直接生成 SQL 查询，而不是通过中间层转换，因此它的性能非常出色。你可以完全控制查询的执行方式，从而确保最佳的性能。
社区支持：Knex.js 拥有一个活跃的开源社区，提供了丰富的文档和插件。如果你遇到问题，可以很容易找到解决方案。

现在，让我们正式进入正题，开始学习如何在 Node.js 项目中使用 Knex.js 构建 SQL 查询吧！

安装 Knex.js

首先，我们需要安装 Knex.js 和相应的数据库驱动程序。假设你已经有一个 Node.js 项目，并且已经初始化了 package.json 文件。如果你还没有项目，可以通过以下命令创建一个新的项目：

npm init -y

接下来，安装 Knex.js 和你所使用的数据库驱动程序。以 PostgreSQL 为例，我们可以使用以下命令安装：

npm install knex pg

如果你使用的是其他数据库，比如 MySQL 或 SQLite3，可以替换 pg 为相应的驱动程序：

MySQL: mysql2
SQLite3: sqlite3
MariaDB: mariadb
Oracle: oracledb

安装完成后，我们还需要初始化 Knex.js。Knex 提供了一个 CLI 工具，可以帮助我们生成配置文件。你可以通过以下命令全局安装 Knex CLI：

npm install -g knex

然后，在项目根目录下运行以下命令来初始化 Knex：

knex init

这将生成一个 knexfile.js 文件，里面包含了数据库连接的配置。打开这个文件，根据你的数据库类型进行修改。例如，如果你使用的是 PostgreSQL，配置可能如下所示：

module.exports = {
  development: {
    client: 'pg',
    connection: {
      host: '127.0.0.1',
      user: 'your_username',
      password: 'your_password',
      database: 'your_database'
    },
    migrations: {
      directory: './migrations'
    },
    seeds: {
      directory: './seeds'
    }
  }
};

配置完成后，我们就可以开始使用 Knex.js 了！接下来，我们将学习如何使用 Knex.js 进行基本的 CRUD 操作。

基本 CRUD 操作

创建表

在开始编写查询之前，我们通常需要先创建数据库表。Knex.js 提供了强大的迁移功能，可以帮助我们管理数据库结构的变化。迁移文件是版本化的 SQL 脚本，用于创建、修改或删除表。

要创建一个新的迁移文件，可以使用以下命令：

knex migrate:make create_users_table

这将在 migrations 目录下生成一个新的迁移文件，文件名类似于 xxxxxx_create_users_table.js，其中 xxxxxx 是时间戳。打开这个文件，你会看到两个函数：up 和 down。up 函数用于定义如何创建表，而 down 函数用于定义如何回滚更改。

我们可以在 up 函数中使用 knex.schema.createTable 方法来创建表。例如，假设我们要创建一个 users 表，包含 id、name 和 email 字段：

exports.up = function(knex) {
  return knex.schema.createTable('users', (table) => {
    table.increments('id').primary(); // 自增主键
    table.string('name').notNullable(); // 名字，不允许为空
    table.string('email').unique().notNullable(); // 邮箱，唯一且不允许为空
    table.timestamp('created_at').defaultTo(knex.fn.now()); // 创建时间，默认为当前时间
  });
};

exports.down = function(knex) {
  return knex.schema.dropTable('users'); // 删除表
};

保存文件后，运行以下命令来应用迁移：

knex migrate:latest

这将执行 up 函数中的代码，创建 users 表。如果你想回滚迁移，可以使用以下命令：

knex migrate:rollback

这将执行 down 函数中的代码，删除 users 表。

插入数据

现在我们有了 users 表，接下来可以尝试插入一些数据。Knex.js 提供了 insert 方法，可以轻松地向表中插入新记录。我们可以通过 knex('users') 来获取 users 表的引用，然后调用 insert 方法传递要插入的数据。

const knex = require('knex')(require('./knexfile')['development']);

async function insertUser() {
  const result = await knex('users').insert({
    name: 'Alice',
    email: 'alice@example.com'
  });
  console.log('Inserted user ID:', result[0]);
}

insertUser();

这段代码会向 users 表中插入一条新记录，并返回插入的用户 ID。insert 方法还可以一次插入多条记录，只需传递一个数组即可：

await knex('users').insert([
  { name: 'Bob', email: 'bob@example.com' },
  { name: 'Charlie', email: 'charlie@example.com' }
]);

查询数据

插入数据后，我们可以通过 select 方法查询表中的记录。select 方法可以接受多个参数，用于指定要查询的字段。如果不传递任何参数，则默认查询所有字段。

async function getUsers() {
  const users = await knex('users').select('*');
  console.log(users);
}

getUsers();

如果你想只查询某些字段，可以传递字段名称作为参数：

const users = await knex('users').select('id', 'name');

你还可以使用 where 方法来添加查询条件。例如，查询名为 "Alice" 的用户：

const alice = await knex('users').where({ name: 'Alice' }).first();
console.log(alice);

first() 方法会返回查询结果中的第一条记录。如果没有匹配的记录，则返回 null。

更新数据

更新现有记录也非常简单。我们可以使用 update 方法来修改表中的数据。update 方法接受两个参数：一个是你要更新的字段和值，另一个是查询条件。

async function updateUser() {
  const rowsAffected = await knex('users')
    .where({ id: 1 })
    .update({ email: 'alice.new@example.com' });
  console.log('Rows affected:', rowsAffected);
}

updateUser();

这段代码会将 id 为 1 的用户的邮箱地址更新为 alice.new@example.com，并返回受影响的行数。

删除数据

最后，我们来看看如何删除记录。Knex.js 提供了 del（或 delete）方法来删除表中的数据。你可以通过 where 方法指定要删除的记录。

async function deleteUser() {
  const rowsDeleted = await knex('users')
    .where({ id: 1 })
    .del();
  console.log('Rows deleted:', rowsDeleted);
}

deleteUser();

这段代码会删除 id 为 1 的用户，并返回被删除的行数。

高级查询技巧

掌握了基本的 CRUD 操作后，我们可以进一步探索 Knex.js 的高级查询技巧。这些技巧可以帮助你构建更复杂、更高效的查询。

联表查询

在实际项目中，我们经常需要从多个表中获取数据。Knex.js 提供了 join 方法，可以轻松地进行联表查询。假设我们有两个表：users 和 orders，其中 orders 表包含 user_id 字段，表示订单所属的用户。我们可以使用 join 方法来查询每个用户的订单信息。

async function getOrdersByUser() {
  const orders = await knex('orders')
    .join('users', 'orders.user_id', '=', 'users.id')
    .select('users.name', 'orders.id', 'orders.total');
  console.log(orders);
}

getOrdersByUser();

这段代码会从 orders 表中获取所有订单，并将其与 users 表中的用户信息进行关联。查询结果将包含用户的姓名、订单 ID 和订单总额。

除了 join，Knex.js 还提供了其他类型的联表查询方法，如 leftJoin、rightJoin 和 fullOuterJoin。这些方法可以根据不同的需求选择合适的联表方式。

分页查询

当查询结果集较大时，分页查询是非常有用的。Knex.js 提供了 limit 和 offset 方法来实现分页。limit 用于限制返回的记录数量，而 offset 用于跳过前面的记录。

async function getPaginatedUsers(page, pageSize) {
  const offset = (page - 1) * pageSize;
  const users = await knex('users')
    .select('*')
    .limit(pageSize)
    .offset(offset);
  console.log(users);
}

getPaginatedUsers(2, 10); // 获取第 2 页，每页 10 条记录

这段代码会从 users 表中获取第 2 页的用户，每页 10 条记录。page 参数表示当前页码，pageSize 参数表示每页的记录数。

排序查询

有时我们希望根据某个字段对查询结果进行排序。Knex.js 提供了 orderBy 方法来实现这一点。orderBy 方法接受两个参数：一个是排序字段，另一个是排序方向（asc 表示升序，desc 表示降序）。

async function getUsersOrderByCreatedAt() {
  const users = await knex('users')
    .select('*')
    .orderBy('created_at', 'desc');
  console.log(users);
}

getUsersOrderByCreatedAt();

这段代码会从 users 表中获取所有用户，并按 created_at 字段降序排列。

子查询

Knex.js 还支持子查询，允许你在查询中嵌套其他查询。子查询可以用于各种场景，例如获取某个字段的最大值或最小值，或者基于子查询的结果进行过滤。

假设我们想要查询每个用户的最新订单。我们可以使用子查询来实现这一点：

async function getLatestOrderForEachUser() {
  const latestOrders = await knex('orders')
    .select('users.name', 'orders.id', 'orders.total')
    .join('users', 'orders.user_id', '=', 'users.id')
    .whereIn('orders.id', function() {
      this.select('id')
        .from('orders')
        .groupBy('user_id')
        .orderBy('created_at', 'desc')
        .limit(1);
    });
  console.log(latestOrders);
}

getLatestOrderForEachUser();

这段代码会从 orders 表中获取每个用户的最新订单，并将其与 users 表中的用户信息进行关联。

事务

在处理多个相关操作时，事务可以确保这些操作要么全部成功，要么全部失败。Knex.js 提供了 transaction 方法来管理事务。事务可以防止数据不一致的问题，尤其是在涉及多个表的操作中。

假设我们要同时插入一条用户记录和一条订单记录。我们可以使用事务来确保这两个操作要么都成功，要么都失败：

async function createUserWithOrder() {
  await knex.transaction(async (trx) => {
    const [userId] = await trx('users').insert({
      name: 'David',
      email: 'david@example.com'
    });

    await trx('orders').insert({
      user_id: userId,
      total: 100.00
    });
  });

  console.log('User and order created successfully!');
}

createUserWithOrder();

这段代码会启动一个事务，首先插入一条用户记录，然后插入一条订单记录。如果任何一个操作失败，整个事务将会回滚，确保数据的一致性。

动态查询

在某些情况下，查询条件可能是动态的，取决于用户输入或其他因素。Knex.js 提供了灵活的 API，允许你根据条件动态构建查询。

假设我们有一个搜索功能，用户可以选择按姓名或邮箱进行搜索。我们可以根据用户的输入动态构建查询条件：

async function searchUsers(query) {
  const users = await knex('users')
    .select('*')
    .where((builder) => {
      if (query.name) {
        builder.where('name', 'like', `%${query.name}%`);
      }
      if (query.email) {
        builder.where('email', 'like', `%${query.email}%`);
      }
    });
  console.log(users);
}

searchUsers({ name: 'A%', email: 'example%' });

这段代码会根据用户输入的 name 和 email 动态构建查询条件。where 方法可以接受一个回调函数，允许我们在回调中动态添加查询条件。

性能优化

在实际项目中，性能优化是非常重要的。Knex.js 提供了一些工具和技巧，可以帮助你优化查询性能。

索引

索引可以显著提高查询速度，特别是在处理大量数据时。你可以通过迁移文件为表中的字段添加索引。例如，假设我们要为 users 表的 email 字段添加索引：

exports.up = function(knex) {
  return knex.schema.alterTable('users', (table) => {
    table.index('email');
  });
};

exports.down = function(knex) {
  return knex.schema.alterTable('users', (table) => {
    table.dropIndex('email');
  });
};

这段代码会在 email 字段上创建一个索引，从而加快基于 email 的查询。

批量插入

当你需要插入大量数据时，批量插入可以显著提高性能。Knex.js 提供了 batchInsert 方法，可以一次性插入多条记录。

async function bulkInsertUsers() {
  const users = Array.from({ length: 1000 }, (_, i) => ({
    name: `User ${i + 1}`,
    email: `user${i + 1}@example.com`
  }));

  await knex('users').batchInsert(users, 100);
  console.log('Bulk insert completed!');
}

bulkInsertUsers();

这段代码会一次性插入 1000 条用户记录，每次插入 100 条。batchInsert 方法可以显著减少数据库连接的开销，提高插入效率。

查询缓存

对于频繁执行的查询，缓存可以显著提高性能。Knex.js 本身不提供内置的缓存机制，但你可以结合 Redis 或其他缓存工具来实现查询缓存。

例如，你可以使用 Redis 缓存查询结果：

const redis = require('redis');
const client = redis.createClient();

async function getCachedUsers() {
  const cacheKey = 'users';
  const cachedData = await client.get(cacheKey);

  if (cachedData) {
    console.log('Returning cached data');
    return JSON.parse(cachedData);
  }

  const users = await knex('users').select('*');
  await client.set(cacheKey, JSON.stringify(users), 'EX', 60); // 缓存 60 秒
  console.log('Returning fresh data');
  return users;
}

getCachedUsers();

这段代码会首先检查 Redis 中是否有缓存的查询结果。如果有，则直接返回缓存的数据；否则，执行查询并将结果缓存 60 秒。

结语

恭喜你，现在已经完成了 Knex.js 的全面学习！通过今天的讲座，我们不仅学会了如何使用 Knex.js 进行基本的 CRUD 操作，还掌握了高级查询技巧、性能优化方法以及事务管理等重要内容。

Knex.js 是一个非常强大且灵活的查询构建器，能够帮助你在 Node.js 项目中高效地与数据库进行交互。无论你是初学者还是有经验的开发者，Knex.js 都能为你提供简洁而优雅的 API，让你轻松应对各种复杂的查询需求。

希望今天的讲座对你有所帮助，如果你有任何问题或想法，欢迎随时交流。祝你在未来的开发中取得更大的成功！😊

附录：常用 API 快速参考

为了方便大家查阅，这里列出了一些常用的 Knex.js API 方法及其简要说明：

方法	说明
`knex(tableName)`	获取表的引用
`insert(data)`	向表中插入新记录
`select(columns)`	查询表中的记录
`where(condition)`	添加查询条件
`update(data)`	更新表中的记录
`del()`	删除表中的记录
`join(table, column1, operator, column2)`	进行联表查询
`limit(number)`	限制返回的记录数量
`offset(number)`	跳过前面的记录
`orderBy(column, direction)`	对查询结果进行排序
`transaction(fn)`	管理事务
`batchInsert(data, batchSize)`	批量插入记录
`index(column)`	为字段添加索引

希望这个快速参考能帮助你在日常开发中更快地上手 Knex.js！🚀