• koa使用Sequelize：定义数据结构

    创建连接
    1. const { Sequelize } = require('sequelize');
    2.  
    3. // 第一个参数：连接的数据库名
    4. // 第二个参数：数据库的用户名
    5. // 第三个参数：数据库的密码
    6. const mysql = new Sequelize('mytest', 'root', 'root', {
    7.     dialect: 'mysql',       // 这里可以改成任意一种关系型数据库
    8.     host: 'localhost',      // 数据库服务器
    9.     timezone: '+08:00',     // 这里是东八区，默认为0时区
    10.     pool: {                 // 使用连接池
    11.         max: 5,
    12.         min: 0,
    13.         acquire: 30000,
    14.         idle: 10000,
    15.     },
    16. });
    测试连接
    1. // 测试连接是否成功
    2. (async () => {
    3.     try {
    4.         await mysql.authenticate();
    5.         console.log('Connection has been established successfully.');
    6.     } catch (error) {
    7.         console.error('Unable to connect to the database:', error);
    8.     }
    9. })();   // 多一个括号表示调用方法
    完整db定义类
    1. const AppConfig = {
    2.   environment: "dev",
    3.   database: {
    4.     database: "notes_app", // 库名
    5.     username: "notes_app", // 用户名
    6.     password: "notes_app", // 密码
    7.     options: {
    8.       // 配置
    9.       host: "localhost",
    10.       dialect: "mysql",
    11.       define: {
    12.         // create_time && update_time
    13.         timestamps: true,
    14.         // delete_time
    15.         paranoid: true,
    16.         createdAt: "created_at",
    17.         updatedAt: "updated_at",
    18.         deletedAt: "deleted_at",
    19.         // 把驼峰命名转换为下划线
    20.         underscored: true,
    21.         scopes: {
    22.           bh: {
    23.             attributes: {
    24.               exclude: ["updated_at", "deleted_at", "created_at"]
    25.             }
    26.           },
    27.           iv: {
    28.             attributes: {
    29.               exclude: ["updated_at", "deleted_at"]
    30.             }
    31.           }
    32.         }
    33.       },
    34.       pool: {
    35.         max: 5,
    36.         min: 0,
    37.         acquire: 30000,
    38.         idle: 10000
    39.       },
    40.       timezone: "+08:00" // 东八时区
    41.     }
    42.   },
    43.   security: {
    44.     secretKey: "secretKey",
    45.     // 过期时间 1小时
    46.     expiresIn: 60 * 60
    47.   }
    48. };
    49.  
    50. module.exports = AppConfig;

    1. const { Sequelize } = require("sequelize");
    2.  
    3. const AppConfig = require("../config/config");
    4.  
    5. class DbManager {
    6.   constructor() {
    7.     this.config = AppConfig.database;
    8.     this.sequelize = null;
    9.     this.isConnected = false;
    10.   }
    11.  
    12.   async isConnection() {
    13.     const { database, username, password, options } = this.config;
    14.     this.sequelize = new Sequelize(database, username, password, options);
    15.  
    16.     try {
    17.       await this.sequelize.authenticate();
    18.       // console.log("successfully");
    19.       this.isInitOk = true;
    20.       return true;
    21.     } catch (error) {
    22.       console.error("Unable to connect to the database:", error);
    23.       return false;
    24.     }
    25.   }
    26.  
    27.   start() {
    28.     const isConnected = this.isConnection();
    29.     this.isConnected = isConnected;
    30.     if (isConnected) {
    31.       // console.log("连接ok");
    32.       return true;
    33.     }
    34.   }
    35.  
    36.   stop() {
    37.     if (this.sequelize !== null) {
    38.       this.sequelize.close();
    39.       console.log("连接close");
    40.     }
    41.   }
    42.  
    43.   getSequelize() {
    44.     return this.sequelize;
    45.   }
    46.  
    47.   getIsConnected() {
    48.     return this.isConnected;
    49.   }
    50. }
    51.  
    52. const dbManager = new DbManager();
    53. dbManager.start();
    54.  
    55. const sequelize = dbManager.getSequelize();
    56. // console.log(sequelize);
    57. sequelize.sync({ force: false }); // 初始化模型
    58.  
    59. module.exports = {
    60.   dbManager,
    61.   sequelize
    62. };
    常用DataTypes定义
    1. Sequelize.STRING                      // VARCHAR(255)
    2. Sequelize.STRING(1234)                // VARCHAR(1234)
    3. Sequelize.STRING.BINARY               // VARCHAR BINARY
    4. Sequelize.TEXT                        // TEXT
    5. Sequelize.TEXT('tiny')                // TINYTEXT
    6.  
    7. Sequelize.INTEGER                     // INTEGER
    8. Sequelize.BIGINT                      // BIGINT
    9. Sequelize.BIGINT(11)                  // BIGINT(11)
    10.  
    11. Sequelize.FLOAT                       // FLOAT
    12. Sequelize.FLOAT(11)                   // FLOAT(11)
    13. Sequelize.FLOAT(11, 12)               // FLOAT(11,12)
    14.  
    15. Sequelize.REAL                        // REAL         仅限于PostgreSQL.
    16. Sequelize.REAL(11)                    // REAL(11)     仅限于PostgreSQL.
    17. Sequelize.REAL(11, 12)                // REAL(11,12)  仅限于PostgreSQL.
    18.  
    19. Sequelize.DOUBLE                      // DOUBLE
    20. Sequelize.DOUBLE(11)                  // DOUBLE(11)
    21. Sequelize.DOUBLE(11, 12)              // DOUBLE(11,12)
    22.  
    23. Sequelize.DECIMAL                     // DECIMAL
    24. Sequelize.DECIMAL(10, 2)              // DECIMAL(10,2)
    25.  
    26. Sequelize.DATE                        // DATETIME 针对 mysql / sqlite, TIMESTAMP WITH TIME ZONE 针对 postgres
    27. Sequelize.DATE(6)                     // DATETIME(6) 针对 mysql 5.6.4+. 小数秒支持多达6位精度
    28. Sequelize.DATEONLY                    // DATE 不带时间.
    29. Sequelize.BOOLEAN                     // TINYINT(1)
    30.  
    31. Sequelize.ENUM('value 1', 'value 2')  // 一个允许具有 “value 1” 和 “value 2” 的 ENUM
    32. Sequelize.ARRAY(Sequelize.TEXT)       // 定义一个数组。 仅限于 PostgreSQL。
    33. Sequelize.ARRAY(Sequelize.ENUM)       // 定义一个 ENUM 数组. 仅限于 PostgreSQL。
    添加model
    1. const { Model, DataTypes } = require("sequelize");
    2. const { sequelize } = require("../util/db");
    3.  
    4. class Cate extends Model {}
    5.  
    6. Cate.init(
    7.   {
    8.     id: {
    9.       type: DataTypes.INTEGER,
    10.       primaryKey: true, // 主键
    11.       autoIncrement: true // 自增
    12.     },
    13.     uid: {
    14.       type: DataTypes.UUID,
    15.       defaultValue: DataTypes.UUIDV4,
    16.       unique: true // 唯一
    17.     },
    18.     name: DataTypes.STRING,
    19.     icon: DataTypes.STRING,
    20.     desc: DataTypes.TEXT,
    21.     parentUid: DataTypes.UUID
    22.   },
    23.   {
    24.     sequelize,
    25.     tableName: "cate" // 指定生成的表名
    26.   }
    27. );
    28.  
    29. module.exports = {
    30.   Cate
    31. };
    为model添加初始
    1. Cate.sync({ force: false })
    2.   .then(async () => {
    3.     await Cate.create({
    4.       name: "所有笔记",
    5.       icon: "",
    6.       desc: "所有笔记",
    7.       parentUid: ""
    8.     });
    9.  
    10.     await Cate.create({
    11.       name: "标签",
    12.       icon: "",
    13.       desc: "标签",
    14.       parentUid: ""
    15.     });
    16.  
    17.     await Cate.create({
    18.       name: "回收站",
    19.       icon: "",
    20.       desc: "回收站",
    21.       parentUid: ""
    22.     });
    23.   })
    24.   .catch(err => {
    25.     console.log("err= ", err);
    26.   }); // 初始化模型

    模型关联
    一对一
    文章
    1. class Article extends Model {}
    2.  
    3. Article.init(
    4.   {
    5.     id: {
    6.       type: DataTypes.INTEGER,
    7.       primaryKey: true, // 主键
    8.       autoIncrement: true // 自增
    9.     },
    10.     uid: {
    11.       type: DataTypes.UUID,
    12.       primaryKey: true, // 主键
    13.       defaultValue: DataTypes.UUIDV4
    14.     },
    15.     title: DataTypes.STRING,
    16.     deleteUid: DataTypes.UUID,
    17.     collectUid: DataTypes.UUID,
    18.     publishStatus: {
    19.       type: DataTypes.INTEGER,
    20.       // (0草稿、1公开、2私有)
    21.       defaultValue: 0
    22.     }
    23.   },
    24.   {
    25.     sequelize,
    26.     tableName: "article" // 指定生成的表名
    27.   }
    28. );
    文章内容
    1. class ArticleContent extends Model {}
    2.  
    3. ArticleContent.init(
    4.   {
    5.     id: {
    6.       type: DataTypes.INTEGER,
    7.       primaryKey: true, // 主键
    8.       autoIncrement: true // 自增
    9.     },
    10.     uid: {
    11.       type: DataTypes.UUID,
    12.       primaryKey: true, // 主键
    13.       defaultValue: DataTypes.UUIDV4
    14.     },
    15.     content: DataTypes.TEXT
    16.   },
    17.   {
    18.     sequelize,
    19.     timestamps: false,
    20.     tableName: "article_content" // 指定生成的表名
    21.   }
    22. );

    关联关系定义
    1. // 关联意味着 A 和 B 之间存在一对一的关系,外键在目标模型(B)中定义.
    2. ArticleContent.hasOne(Article, {
    3.   foreignKey: "article_content_uid",
    4.   sourceKey: "uid"
    5. });
    6.  
    7. // A.belongsTo(B)关联意味着 A 和 B 之间存在一对一的关系,外键在源模型中定义(A).
    8. Article.belongsTo(ArticleContent, {
    9.   foreignKey: "article_content_uid",
    10.   sourceKey: "uid"
    11. });
    多对多
    分类
    1. class Cate extends Model {}
    2. Cate.init(
    3.   {
    4.     id: {
    5.       type: DataTypes.INTEGER,
    6.       primaryKey: true, // 主键
    7.       autoIncrement: true // 自增
    8.     },
    9.     uid: {
    10.       type: DataTypes.UUID,
    11.       primaryKey: true, // 主键
    12.       defaultValue: DataTypes.UUIDV4
    13.     },
    14.     name: DataTypes.STRING,
    15.     icon: DataTypes.STRING,
    16.     desc: DataTypes.TEXT,
    17.     parentUid: DataTypes.UUID
    18.   },
    19.   {
    20.     sequelize,
    21.     tableName: "cate" // 指定生成的表名
    22.   }
    23. );
    文章分类关联表定义
    1. class ArticleCates extends Model {}
    2.  
    3. ArticleCates.init(
    4.   {
    5.     id: {
    6.       type: DataTypes.INTEGER,
    7.       primaryKey: true, // 主键
    8.       allowNull: false,
    9.       autoIncrement: true // 自增
    10.     },
    11.     uid: {
    12.       type: DataTypes.UUID,
    13.       primaryKey: true, // 主键
    14.       defaultValue: DataTypes.UUIDV4
    15.     }
    16.   },
    17.   {
    18.     sequelize,
    19.     timestamps: false,
    20.     tableName: "articale_cates" // 指定生成的表名
    21.   }
    22. );

    关联关系定义（采用两个一对多的方式）
    1. Article.hasMany(ArticleCates, {
    2.   foreignKey: "article_uid",
    3.   sourceKey: "uid"
    4. });
    5.  
    6. Cate.hasMany(ArticleCates, {
    7.   foreignKey: "cate_uid",
    8.   sourceKey: "uid"
    9. });
    10.  
    11. ArticleCates.belongsTo(Article, { foreignKey: "article_uid" });
    12. ArticleCates.belongsTo(Cate, { foreignKey: "cate_uid" });
    生成的关联表

    如果采用多对多方式关联，始终都关联不上uid，可以用id关联。

    1. Article.belongsToMany(Cate, {
    2.   through: ArticleCates,
    3.   foreignKey: "article_uid", // ArticleCates 表中表示文章 uid 的字段名
    4.   sourceKey: "uid",
    5.   otherKey: "cate_uid" // ArticleCates 表中表示分类 uid 的字段名
    6. });
    7. Cate.belongsToMany(Article, {
    8.   through: ArticleCates,
    9.   foreignKey: "cate_uid", // ArticleCates 表中表示分类 uid 的字段名
    10.   sourceKey: "uid",
    11.   otherKey: "article_uid" // ArticleCates 表中表示文章 uid 的字段名
    12. });
  • 相关阅读:
    2022年最新Python大数据之Python基础【六】函数与变量
    Python 字典类型拓展(包括 MappingProxyType 只读字典, defaultdict 缺省字典和 ChainMap)
    纳米金颗粒修饰核酸产品|碳纳米管载核酸-DNA/RNA材料|解析说明
    【JAVA】异常
    Spring Boot_1【配置环境&&项目结构&&Spring Security相关】
    nginx静态网站部署
    Python获取jsonp数据
    飞致云及其旗下1Panel项目进入2023年第三季度最具成长性开源初创榜单
    感受帅酷一刻 | Kvaser CAN总线助力瑞典CAKE越野电动摩托车研发、测试与维护
    中国现代农业谋定发展-国稻种芯-万祥军：面临哪些制约因素？
  • 原文地址：https://blog.csdn.net/h1530687053/article/details/132605509