Sequelize库的详细知识点讲解及代码演示

Sequelize库的详细知识点讲解及代码演示

1. Sequelize简介

Sequelize 是一个基于 Promise 的 Node.js ORM（对象关系映射）库，它支持多种数据库，包括 MySQL、PostgreSQL、SQLite 和 Microsoft SQL Server。Sequelize 允许开发者使用 JavaScript（或 TypeScript）对象和方法来操作数据库，而不需要编写 SQL 语句。

2. 安装与连接数据库

首先，你需要安装 Sequelize 和对应的数据库驱动程序。以下是使用 npm 安装 Sequelize 和 MySQL 驱动程序的示例：

npm install --save sequelize
npm install --save mysql2

3.连接数据库

连接数据库的方法

// 文件：db/db.js
const { Sequelize } = require('sequelize');
// 方法1: 单独传递参数
const db = new Sequelize(
    //数据库、用户名、密码
    "database","username","password",
    {
        host: "127.0.0.1",
        dialect: "mysql",
        pool: {
            max: 5,
            min: 0,
            acquire:30000,
            idle:10000
        }
    }
)
// 方法2: 传递连接 URI
// const sequelize = new Sequelize('mysql://user:pass@example.com:3306/dbname');
module.exports = db

Sequelize连接数据库详细属性配置解释

Sequelize 提供了丰富的配置选项，以适应不同的数据库环境和需求。以下是一些关键的配置属性及其解释：

1. 数据库类型（dialect）

• 描述：指定使用的数据库类型。
• 支持值：‘mysql’, ‘sqlite’, ‘postgres’, ‘mssql’。
• 示例：

  dialect: 'mysql'
  

2. 主机地址（host）

• 描述：自定义数据库链接地址，可以是 IP 或域名，默认为 ‘localhost’。
• 示例：

  host: 'my.server.tld'
  

3. 端口（port）

• 描述：自定义端口，默认为数据库的默认端口，如 MySQL 的 3306。
• 示例：

  port: 12345
  

4. 日志记录（logging）

• 描述：是否开启日志，默认使用 console.log 输出 SQL 语句。
• 示例：

  logging: true
  

5. 连接池设置（pool）

• 描述：配置连接池的参数。
• 属性：
  • max：最大连接数。
  • min：最小连接数。
  • idle：连接在池中空闲的最大时间，单位为毫秒。
  • acquire：连接池中没有可用连接时，最大等待时间，单位为毫秒。
• 示例：

  pool: {
    max: 5,
    min: 0,
    idle: 10000,
    acquire: 60000
  }
  

6. 数据库选项（dialectOptions）

• 描述：特定数据库的额外选项。
• 属性：
  • socketPath：对于 PostgreSQL，指定 socket 的路径。
  • supportBigNumbers：是否支持大数字。
  • bigNumberStrings：大数字是否以字符串形式返回。
• 示例：

  dialectOptions: {
    socketPath: '/Applications/MAMP/tmp/mysql/mysql.sock',
    supportBigNumbers: true,
    bigNumberStrings: true
  }
  

7. SQLite 存储位置（storage）

• 描述：仅对 SQLite 有效，指定数据库文件的存储路径。
• 默认值：‘:memory:’
• 示例：

  storage: 'path/to/database.sqlite'
  

8. 省略 NULL 值（omitNull）

• 描述：是否将 undefined 转换为 NULL。
• 默认值：false
• 示例：

  omitNull: true
  

9. 定义模型默认参数（define）

• 描述：设置所有模型的默认参数。
• 属性：
  • underscored：是否使用下划线命名法。
  • freezeTableName：是否固定表名。
  • charset：字符集。
  • collate：校对规则。
  • timestamps：是否自动添加时间戳字段。
• 示例：

  define: {
    underscored: false,
    freezeTableName: false,
    charset: 'utf8',
    dialectOptions: {
      collate: 'utf8_general_ci'
    },
    timestamps: true
  }
  

10. 事务隔离级别（isolationLevel）

• 描述：设置事务的隔离级别。

• 示例：

  isolationLevel: Transaction.ISOLATION_LEVELS.REPEATABLE_READ
  

这些配置选项可以帮助你根据具体的应用需求和数据库环境来调整 Sequelize 的行为。更多详细配置，请参考 Sequelize 的官方文档 。

4. 定义模型

在 Sequelize 中，模型是定义数据库表结构的关键。以下是定义一个的用户及评论模型的示例：

这段代码展示了如何使用Sequelize ORM定义两个数据库模型（users和comment），并设置了它们之间的关系。以下是定义模型时的关键知识点：

1). 引入Sequelize和数据库连接

// 文件：model/comment.js
const Sequelize = require('sequelize'); // 引入Sequelize ORM库
const db = require("../db/db2.js"); // 引入数据库连接配置

• 首先，需要引入Sequelize库和数据库连接配置文件。

2). 定义用户表模型（users）

// 文件：model/comment.js
const users = db.define(
    'users',
    {
        id: {
            type: Sequelize.INTEGER, // 数据类型为整数
            primaryKey: true,        // 指定为表的主键
            autoIncrement: true      // 自动增长
        },
        username: {
            type: Sequelize.STRING  // 数据类型为字符串
        }
    },
    {
        tableName: 'users', // 数据库中表的名称
    }
);

• db.define 方法用来定义一个新的模型。
• 第一个参数 'users' 是模型的名称。
• 第二个参数是一个对象，定义了模型的属性和它们的类型。
• id 字段被定义为主键，并且设置为自动增长，通常用于存储唯一标识符。
• username 字段被定义为字符串类型，用于存储用户的名称。
• tableName 选项用来指定数据库中实际的表名。

3). 定义评论表模型（comment）

// 文件：model/comment.js
const comment = db.define(
    'comment', 
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            references: {
                model: users, // 关联到users模型
                key: 'id'     // 关联到users模型的id字段
            },
        },
        content: {
            type: Sequelize.STRING
        },
        user_id: {
            type: Sequelize.INTEGER,
        },
        article_id: {
            type: Sequelize.INTEGER,
        },
        state:{
            type: Sequelize.INTEGER,
        },
        ctime:{
            type: Sequelize.STRING
        }
    },
    {
        tableName: 'comment', // 数据库中表的名称
        timestamps: false // 禁用自动添加的 createdAt 和 updatedAt 字段
    }
);

• comment 模型同样使用 db.define 方法定义。
• id 字段为主键，并且设置为自动增长。这里的 references 属性定义了外键关系，指向 users 模型的 id 字段。
• content 字段用于存储评论内容。
• user_id 和 article_id 字段用于存储与评论相关联的用户ID和文章ID。
• state 和 ctime 字段分别用于存储评论的状态和创建时间。
• tableName 选项指定了数据库中实际的表名。
• timestamps 设置为 false 禁用了Sequelize自动添加的 createdAt 和 updatedAt 时间戳字段。

4). 设置模型关系

// 文件：model/comment.js
users.hasMany(comment, { foreignKey: 'user_id' });
comment.belongsTo(users, { foreignKey: 'user_id' });

• users.hasMany(comment, { foreignKey: 'user_id' }); 表示一个用户可以有多个评论，foreignKey 指定外键字段为 user_id。
• comment.belongsTo(users, { foreignKey: 'user_id' }); 表示评论属于一个用户，foreignKey 同样指定外键字段为 user_id。

5). 导出模型

// 文件：model/comment.js
module.exports = { users, comment };

• 使用 module.exports 导出定义的模型，以便在其他文件中使用。

这段代码展示了如何在Sequelize中定义模型、设置字段、定义外键关系以及导出模型。这些模型可以用于数据库操作，例如创建、查询、更新和删除数据。

5. 模型导入

在你要使用模型的文件中导入

// 导入模型
const { users, comment } = require("../model/comment.js");

6. Sequelize中sql执行语句

在MySQL和Sequelize中，操作数据库的语句可以对应起来，以下是一些基本的MySQL操作语句及其对应的Sequelize执行语句，以及它们的作用：

1. 查询（SELECT）

   • MySQL: SELECT * FROM users;
   • Sequelize: Users.findAll();
   • 作用：从users表中检索所有记录。

2. 插入（INSERT）

   • MySQL: INSERT INTO users (username, password) VALUES ('john', '123456');
   • Sequelize: Users.create({ username: 'john', password: '123456' });
   • 作用：向users表中插入一条新记录。

3. 更新（UPDATE）

   • MySQL: UPDATE users SET username = 'jane' WHERE id = 1;
   • Sequelize: Users.update({ username: 'jane' }, { where: { id: 1 } });
   • 作用：更新users表中id为1的记录的username字段。

4. 删除（DELETE）

   • MySQL: DELETE FROM users WHERE id = 1;
   • Sequelize: Users.destroy({ where: { id: 1 } });
   • 作用：从users表中删除id为1的记录。

5. 条件查询（WHERE）

   • MySQL: SELECT * FROM users WHERE username = 'john';
   • Sequelize: Users.findAll({ where: { username: 'john' } });
   • 作用：查询users表中username为’john’的记录。

6. 逻辑操作符（AND/OR）

   • MySQL: SELECT * FROM users WHERE username = 'john' AND age > 20;
   • Sequelize: Users.findAll({ where: { [Op.and]: [{ username: 'john' }, { age: { [Op.gt]: 20 } }] } });
   • 作用：查询users表中username为’john’且年龄大于20的记录。

7. 排序（ORDER BY）

   • MySQL: SELECT * FROM users ORDER BY age DESC;
   • Sequelize: Users.findAll({ order: [['age', 'DESC']] });
   • 作用：从users表中检索所有记录，并按年龄降序排序。

8. 分页（LIMIT/OFFSET）

   • MySQL: SELECT * FROM users LIMIT 10 OFFSET 20;
   • Sequelize: Users.findAll({ limit: 10, offset: 20 });
   • 作用：从users表中检索第3页的10条记录（假设每页显示10条）。

这些是一些基本的MySQL操作语句及其在Sequelize中的对应执行语句，Sequelize作为一个ORM（对象关系映射）库，提供了更高级的抽象来操作数据库，使得开发者可以用更接近JavaScript对象操作的方式来处理数据库操作。

7. 查询接口

Sequelize 提供了丰富的查询接口，包括基本的 CRUD 操作和更复杂的查询。以下是一些基本的查询示例：

1). 普通查询

// 查找所有用户
// 使用findAll方法检索数据库中所有用户记录
User.findAll().then(users => {
  console.log(users); // 打印所有用户的信息
});

// 查找一个用户
// 使用findOne方法根据条件（这里是用户名）检索单个用户记录
User.findOne({ where: { username: 'janedoe' } }).then(user => {
  console.log(user); // 如果找到用户，打印该用户的信息
}).catch(error => {
  console.error('Error finding user:', error); // 如果查找过程中出现错误，打印错误信息
});

// 创建一个用户
// 使用create方法创建一个新的用户记录
User.create({ username: 'johndoe', birthday: new Date(1980, 6, 20) }).then(john => {
  console.log(john); // 如果创建成功，打印新创建的用户信息
}).catch(error => {
  console.error('Error creating user:', error); // 如果创建过程中出现错误，打印错误信息
});

// 更新一个用户
// 使用update方法更新符合条件的用户记录
// 注意：这里的代码有误，应该是传递一个包含更新字段的对象和一个where条件对象
User.update({ username: 'newJane' }, { where: { username: 'Jane' } }).then(result => {
  console.log(result); // 打印更新结果，通常是影响的行数
}).catch(error => {
  console.error('Error updating user:', error); // 如果更新过程中出现错误，打印错误信息
});

// 删除一个用户
// 使用destroy方法根据条件删除用户记录
User.destroy({ where: { username: 'johndoe' } }).then(result => {
  console.log(result); // 打印删除结果，通常是影响的行数
}).catch(error => {
  console.error('Error destroying user:', error); // 如果删除过程中出现错误，打印错误信息
});

// 上面定义模型的时候提到的设置模型关系--目的是为了进行多表查询

2). 多表查询

在多表查询的部分，您需要确保comment和users模型之间已经定义了关联关系。以下是完善后的多表查询代码，包括注释和一些可能的改进：

javascript

// 导入Sequelize模型
const { comment, users } = require('../model/comment.js');

// 异步函数，用于获取特定文章的所有评论及其对应的用户信息
async function getCommentsWithUsers(articleId, page_sizeInt, start) {
  try {
    const commentsData = await comment.findAll({
      where: {
        article_id: Number(articleId) // 根据文章ID过滤评论
      },
      include: [ // 包含用户信息
        {
          model: users, // 指定要包含的用户模型
          attributes: ['username'], // 指定要检索的用户字段，这里只获取用户名
        }
      ],
      limit: page_sizeInt, // 每页显示的评论数量
      offset: start // 跳过的评论数量，用于分页
    });

    return commentsData; // 返回查询结果
  } catch (error) {
    console.error('Error fetching comments with users:', error); // 如果查询过程中出现错误，打印错误信息
    throw error; // 抛出错误，以便调用者可以处理
  }
}

// 使用示例
const articleId = 1; // 假设文章ID为1
const page_sizeInt = 10; // 每页显示10条评论
const start = 0; // 从第一条评论开始
getCommentsWithUsers(articleId, page_sizeInt, start).then(commentsData => {
  console.log(commentsData); // 打印评论及其用户信息
});

3). 说明

1. 模型导入：确保在代码中导入了comment和users模型。
2. 异步函数：使用async函数getCommentsWithUsers来处理异步查询，并使用try...catch块来捕获和处理可能的错误。
3. 分页参数：limit和offset参数用于实现分页功能。
4. 返回结果：函数返回查询结果，以便调用者可以进一步处理。

8. 高级特性

Sequelize 还支持事务、钩子、命名策略、作用域、子查询等高级特性。这些特性可以帮助开发者实现更复杂的数据库操作和业务逻辑。

9. 结论

Sequelize 是一个功能强大的 ORM 库，它简化了 Node.js 应用的数据库操作。通过上述的知识点和代码演示，你可以开始使用 Sequelize 来构建你的数据库驱动的应用。更多高级特性和详细用法，请参考 Sequelize 的官方文档。