egg、sequelize联表查询

最新推荐文章于 2022-08-24 16:22:13 发布
最新推荐文章于 2022-08-24 16:22:13 发布
阅读量1.1w 收藏 7
点赞数 8
分类专栏： nodejs sequelize eggjs 文章标签： egg-sequelize
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30101131/article/details/79474905
版权
nodejs 同时被 3 个专栏收录
9 篇文章 0 订阅
订阅专栏
sequelize
3 篇文章 0 订阅
订阅专栏
eggjs
2 篇文章 0 订阅
订阅专栏

数据库设计

use egg_test;
create table `user`(
    `id` int(10) unsigned auto_increment comment '',
    `username` varchar(20) not null comment '',
    `createdAt` int(10) unsigned comment '',
    `updatedAt` int(10) unsigned comment '',
    primary key(id)
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='用户表';
create table `user_info`(
    `id` int(10) unsigned auto_increment comment '',
    `age` tinyint(4) unsigned default 0 comment '',
    `address` varchar(50) default '' comment '',
    `userId` int(10) unsigned not null comment '',
    `createdAt` int(10) unsigned comment '',
    `updatedAt` int(10) unsigned comment '',
    primary key(id)   
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='用户表信息';
create table `family`(
    `id` int(10) unsigned auto_increment comment '',
    `name` varchar(20) not null comment '',
    `gender` tinyint(1) unsigned comment '0:man,1:woman:',
    `relationship` varchar(10) comment '',
    `createdAt` int(10) unsigned comment '',
    `updatedAt` int(10) unsigned comment '',
    primary key(id)     
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='家庭成员';
create table `teacher_lesson_relation`(
    `id` int(10) unsigned auto_increment comment '',
    `lessonId` int(10) unsigned not null comment '',
    `teacherId` int(10) unsigned not null comment '', 
    `createdAt` int(10) unsigned comment '',
    `updatedAt` int(10) unsigned comment '',
    primary key(id)       
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='课程和老师的关系';
create table `lesson`(
    `id` int(10) unsigned auto_increment comment '',
    `name` varchar(50) not null comment '',
    `createdAt` int(10) unsigned comment '',
    `updatedAt` int(10) unsigned comment '',
    primary key(id)     
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='课程';
create table `teacher`(
    `id` int(10) unsigned auto_increment comment '',
    `name` varchar(50) not null comment '',
    `createdAt` int(10) unsigned comment '',
    `updatedAt` int(10) unsigned comment '',
    primary key(id)  
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='老师';

一对一hasOne

model: user

module.exports = app => {
    const { INTEGER, STRING, TEXT } = app.Sequelize;
    const User = app.model.define('User', {
        id: {
            type: INTEGER.UNSIGNED,
            autoIncrement: true,
            primaryKey: true
        },
        username: {
            type: STRING(20),
            allowNull: false
        }
    }, {
        freezeTableName: true,
        tableName: 'user'
    });
    User.associate = function() {
        app.model.User.hasOne(app.model.Info, { foreignKey: 'userId' });
        app.model.User.hasMany(app.model.Family, { foreignKey: 'userId', targetKey: 'id' });
    }
    return User;
}

用的是：app.model.User.hasOne(app.model.Info, { foreignKey: ‘userId’ });
model: info

module.exports = app => {
    const { INTEGER, STRING, TEXT } = app.Sequelize;
    const Info = app.model.define('Info', {
        id: {
            type: INTEGER.UNSIGNED,
            autoIncrement: true,
            primaryKey: true
        },
        age: {
            type: INTEGER.UNSIGNED
        },
        address: {
            type: STRING(50)
        }
    }, {
        freezeTableName: true,
        tableName: 'user_info'
    });
    Info.associate = function() {
        app.model.Info.belongsTo(app.model.User, { foreignKey: 'userId', targetKey: 'id' });
    }
    return Info;
}

controller

  async getUserListInclueInfo() {
    let result = await this.app.model.User.findAll({
      include: [
        {
          model: this.app.model.Info
        }
      ]
    });
    let result2 = await this.app.model.User.findAll({
      include: [
        {
          model: this.app.model.Info,
          where: {
            age: {
              [this.app.Sequelize.Op.gt]: 15
            }
          }
        }
      ]
    });
    let result3 = await this.app.model.User.findAll({
      include: [
        {
          model: this.app.model.Info,
          where: {
            age: {
              [this.app.Sequelize.Op.gt]: 15
            }
          },
          required: false
        }
      ]
    });    
    this.ctx.body = {
      'no_where': result,
      'has_where': result2,
      'where_has_required_false': result3
    };
  }

结果

{
    "no_where": [
        {
            "id": 1,
            "username": "user1",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": {
                "id": 1,
                "age": 15,
                "address": "address1",
                "createdAt": 0,
                "updatedAt": 0,
                "userId": 1
            }
        },
        {
            "id": 2,
            "username": "user2",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": {
                "id": 2,
                "age": 18,
                "address": "address",
                "createdAt": 0,
                "updatedAt": 0,
                "userId": 2
            }
        },
        {
            "id": 3,
            "username": "user3",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": null
        }
    ],
    "has_where": [
        {
            "id": 2,
            "username": "user2",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": {
                "id": 2,
                "age": 18,
                "address": "address",
                "createdAt": 0,
                "updatedAt": 0,
                "userId": 2
            }
        }
    ],
    "where_has_required_false": [
        {
            "id": 2,
            "username": "user2",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": {
                "id": 2,
                "age": 18,
                "address": "address",
                "createdAt": 0,
                "updatedAt": 0,
                "userId": 2
            }
        },
        {
            "id": 1,
            "username": "user1",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": null
        },
        {
            "id": 3,
            "username": "user3",
            "createdAt": 0,
            "updatedAt": 0,
            "Info": null
        }
    ]
}

中间穿插了include中添加where条件，以及当联的表存在required的影响

一对多 hasMany

在一个model 

module.exports = app => {
    const { INTEGER, STRING, TEXT } = app.Sequelize;
    const Family = app.model.define('Family', {
        id: {
            type: INTEGER.UNSIGNED,
            autoIncrement: true,
            primaryKey: true
        },
        userId: {
            type: INTEGER.UNSIGNED,
            allowNull: false
        },
        name: {
            type: STRING(50),
            allowNull: false
        },
        gender: {
            type: INTEGER.UNSIGNED,
            defaultValue: 0
        },
        relationship: {
            type: STRING(20)
        }
    }, {
        freezeTableName: true,
        tableName: 'family'
    });
    Family.associate = function() {
        app.model.Family.belongsTo(app.model.User, { foreignKey: 'userId', targetKey: 'id' });
    }
    return Family;
}

用到建立关系的是 app.model.User.hasMany(app.model.Family, { foreignKey: ‘userId’, targetKey: ‘id’ });
controller

  async hasMany() {
    let result = await this.app.model.User.findAll({
      include: {
        model: this.app.model.Family
      }
    });
    this.ctx.body = result;
  }

结果

[
    {
        "id": 1,
        "username": "user1",
        "createdAt": 0,
        "updatedAt": 0,
        "Families": [
            {
                "id": 1,
                "userId": 1,
                "name": "tom",
                "gender": 0,
                "relationship": "father",
                "createdAt": 0,
                "updatedAt": 0
            },
            {
                "id": 2,
                "userId": 1,
                "name": "lily",
                "gender": 1,
                "relationship": "mother",
                "createdAt": 0,
                "updatedAt": 0
            }
        ]
    },
    {
        "id": 2,
        "username": "user2",
        "createdAt": 0,
        "updatedAt": 0,
        "Families": []
    },
    {
        "id": 3,
        "username": "user3",
        "createdAt": 0,
        "updatedAt": 0,
        "Families": []
    }
]

一对多 belongsTo

用到是 app.model.Family.belongsTo(app.model.User, { foreignKey: ‘userId’, targetKey: ‘id’ });

controller

  async belongsTo() {
    let result = await this.app.model.Family.findAll({
      include: {
        model: this.app.model.User
      }
    });
    this.ctx.body = result;
  }

结果

[
    {
        "id": 1,
        "userId": 1,
        "name": "tom",
        "gender": 0,
        "relationship": "father",
        "createdAt": 0,
        "updatedAt": 0,
        "User": {
            "id": 1,
            "username": "user1",
            "createdAt": 0,
            "updatedAt": 0
        }
    },
    {
        "id": 2,
        "userId": 1,
        "name": "lily",
        "gender": 1,
        "relationship": "mother",
        "createdAt": 0,
        "updatedAt": 0,
        "User": {
            "id": 1,
            "username": "user1",
            "createdAt": 0,
            "updatedAt": 0
        }
    }
]

多对多belongsToMany

model:lesson

module.exports = app => {
    const { INTEGER, STRING, TEXT } = app.Sequelize;
    const Lesson = app.model.define('Lesson', {
        id: {
            type: INTEGER.UNSIGNED,
            autoIncrement: true,
            primaryKey: true
        },
        name: {
            type: STRING(20)
        }
    }, {
        freezeTableName: true,
        tableName: 'lesson'
    });
    Lesson.associate = function() {
        app.model.Lesson.belongsToMany( app.model.Teacher,{ through: app.model.TeacherLessonRelation, foreignKey: 'lessonId', otherKey: 'teacherId'});
    }
    return Lesson;
}

model: teacher

module.exports = app => {
    const { INTEGER, STRING, TEXT } = app.Sequelize;
    const Teacher = app.model.define('Teacher', {
        id: {
            type: INTEGER.UNSIGNED,
            autoIncrement: true,
            primaryKey: true
        },
        name: {
            type: STRING(20),
            allowNull: false
        }
    }, {
        freezeTableName: true,
        tableName: 'teacher'
    });
    Teacher.associate = function() {

    }
    return Teacher;
}

model: teacher-lesson-relation

module.exports = app => {
    const { INTEGER, STRING, TEXT } = app.Sequelize;
    const TeacherLessonRelation = app.model.define('TeacherLessonRelation', {
        id: {
            type: INTEGER.UNSIGNED,
            autoIncrement: true,
            primaryKey: true
        },
        lessonId: {
            type: INTEGER.UNSIGNED,
            allowNull: false
        },
        teacherId: {
            type: INTEGER.UNSIGNED,
            allowNull: false
        }
    }, {
        freezeTableName: true,
        tableName: 'teacher_lesson_relation'
    });
    TeacherLessonRelation.associate = function() {

    }
    return TeacherLessonRelation;
}

controller

  async belongsToMany() {
    let result = await this.app.model.Lesson.findAll({
      include: {
        model: this.app.model.Teacher
      }
    });
    this.ctx.body = result;
  }

结果

[
    {
        "id": 1,
        "name": "高数",
        "createdAt": null,
        "updatedAt": null,
        "Teachers": [
            {
                "id": 1,
                "name": "zengwe",
                "createdAt": null,
                "updatedAt": null,
                "TeacherLessonRelation": {
                    "id": 1,
                    "lessonId": 1,
                    "teacherId": 1,
                    "createdAt": null,
                    "updatedAt": null
                }
            },
            {
                "id": 2,
                "name": "tom",
                "createdAt": null,
                "updatedAt": null,
                "TeacherLessonRelation": {
                    "id": 2,
                    "lessonId": 1,
                    "teacherId": 2,
                    "createdAt": null,
                    "updatedAt": null
                }
            }
        ]
    },
    {
        "id": 2,
        "name": "地理",
        "createdAt": null,
        "updatedAt": null,
        "Teachers": [
            {
                "id": 3,
                "name": "edward",
                "createdAt": null,
                "updatedAt": null,
                "TeacherLessonRelation": {
                    "id": 3,
                    "lessonId": 2,
                    "teacherId": 3,
                    "createdAt": null,
                    "updatedAt": null
                }
            }
        ]
    },
    {
        "id": 4,
        "name": "政治",
        "createdAt": null,
        "updatedAt": null,
        "Teachers": []
    },
    {
        "id": 5,
        "name": "历史",
        "createdAt": null,
        "updatedAt": null,
        "Teachers": []
    }
]

中间表可以不填写，可以按自动的规则使用，创建符合格式的中间表就可以了

额外

1：在参数中include是可以在里面继续嵌套include的；
2：当一个表中两个字段同时外联同一张表时

如 app.model.User.hasOne(app.model.Info, { as:’userInfo’ foreignKey: ‘userId’ });
app.model.User.hasOne(app.model.Info, { as: ‘moreInfo’ foreignKey: ‘otherId’ });

可以添加as来添加别称，使用时在include中也要使用相同的别称，就可以正常使用了

米斯特尔曾
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
egg mysql 连表查询,使用egg-mysql操作mysql数据库
weixin_42433737的博客
03-19 1355
1、安装mysqlnpm i egg-mysql -S2、在config/plugin.js里声明改插件exports.mysql = {enable: true,package: 'egg-mysql',};3、在config/config.default.js里配置config.mysql = {// 单数据库信息配置client: {// hosthost: 'localhost',// 端...
Eggjs Sequelize 多表关联查询
weixin_39066827的博客
07-03 4348
写服务端的新手，我们项目用nodejs写服务端，框架是egg.js。对于简单的 增、删、改、查 新手的我也是快速上手了，但是当我遇到需要关联其他表查询时，我就懵逼了，不知道怎么关联啊。几经周折，总算搞明白了，特此记录一下~~~ 实现：通过 fdc_vd_user_his 表关联外键，查询 fdc_vd_user_page 表及 fdc_pro_user_project 表 数据模型： fdc_vd_user_page fdc_pro_user_project fdc_vd_user_his
egg实现登录鉴权（八）：sequelize联表查询
Cool的博客
10-28 1075
表之间的关联关系有三种：一对一，一对多，多对多。要进行多表操作，首先要建立表与表之间的关联关系，在sequelize中分别使用hasOne，hasMany和belongsToMany表示以上三中关系。例如我们要建立user表与role表的多对多的关联，可以这样写，首先要建立外键（当然也可以在两张表之间建立中间表） 本文主要完成多表操作简单的部分，熟悉在多表中建立关联关系并且可以完成简单的联表操作，以联表查询为例。 需求 登录成功时返回结果中要包含角色信息，以便展示对应的权限菜单 查询用户时返回...
egg mysql 连表查询_在EggJS中使用Sequelize做联表查询
weixin_36313743的博客
02-05 1056
.联表查询一对一在controller里面如下写// 获取学生信息 通过一对多的联系async info(){const { ctx, app } = this;let result = await app.model.Student.findAll({include: {model: app.model.Info}});ctx.body = result;}获取到的值如下：[// 第一个学生{"...
eggjs与sequelize简单demo
weixin_34239169的博客
01-17 540
2019独角兽企业重金招聘Python工程师标准>>> ...
Egg中使用Sequelize ORM框架操作MySQL--关联查询
Always-Learning
11-12 1092
一、Sequelize自定义表名 只需在定义model的时候，加入tableName字段即可。 module.exports = app => { const { STRING, INTEGER, DATE } = app.Sequelize; const User = app.model.define('user', { id: { type: INTEGER, primaryKey: true, autoIncrement: true }, username: STR
Sequelize中用group by进行分组聚合查询
10-20
在SQL查询中，分组查询...总的来说，Sequelize为开发者提供了灵活的SQL分组和聚合查询接口，使得在Node.js应用中处理数据库查询变得更加简便。通过理解并熟练运用这些方法，可以更高效地操作和分析数据库中的数据。
egg-sequelize:为Egg.js续集
05-27
注意：此插件仅用于将Sequelize集成到Egg.js中，更多文档请访问 。 安装 $ npm i --save egg-sequelize $ npm install --save mysql2 # For both mysql and mariadb dialects # Or use other database backend. $ ...
在egg中使用sequelize进行分表读写
ershing的博客
02-09 2053
关于egg和sequelize 封装框架会解决很多基础问题，同时也会带来很多应用问题 对于前端来说，开发后端服务，最熟悉不过就是 express 和 koa 了，而 egg 是基于 koa 进行封装的应用层框架，做了很多基础功能的封装，开箱即用，十分方便，也提供了插件机制进行扩展。 而 sequelize，是一个 node.js 的 orm 工具，看下 v7 的文档，支持 Postgres, MySQL, MariaDB, SQLite, Microsoft SQL Server, Amazon
node.js使用Sequelize实现多表连接查询
上庸者-不服周
06-08 3037
node访问数据库
nodejs/Sequelize/MySQL——基础、联表及优化
嘿嘿
06-14 596
本文你将看到： MySQL、SQL、ORM、Sequelize 在概念上的关系 Sequelize 的用法 Sequelize 中联表关系的概念、用法、原理、区别 如何优化数据库查询 1 概念 MySQL 大部分人对 MySQL、SQL 是有了解的，毕竟教科书里都写着。 MySQL 是一种典型的关系型数据库嘛，怎么叫关系呢？ 简单说，关系型数据库是由多张能互相联接的二维行列表格组成的数据库。 这里两个点：::二维行列表::（体现在个体表数据结构上）、::互相连接::（体现在表关系和库引擎特点
使用sequelize实现关联查询
u010227042的博客
11-10 1409
关联查询包含一对多和多对一的映射关系，一对多的API为belongsTo，多对一的API为hasMany。使用sequelize进行关联查询时，要根据具体情况选择用哪一个映射关系，因为这其中涉及左右连接、内外连接的性能问题。下面来看一个一对多的例子，当然你可以将这个例子反过来多对一，但是性能会差很多。所以我们要根据数据库表的设计来选择谁关联谁 假设有一个Student表包含id、name、age、address、gender、c_id这几个属性，还有一个Class表包含id、c...
egg-sequelize多对多,belongsToMany
kyyius的博客
04-27 1523
多对多: 学生和老师，一个老师有多个学生，一个学生有多个老师 要确定某条数据需要同时确定学生和老师的关系 一般需要第三张表进行记录，比如把某个学生的id和某个老师的id组合当成一行数据记录，来确定 以下代码进行简写 Student.associate = function (){ // 与Teacher存在多对多关系，使用belongsToMany() app.model.Student.belongsToMany(app.model.Teacher, {
sequelize中的hooks 及association使用及爬坑
weixin_45893488的博客
02-25 834
nodejs的orm模块sequelize功能很强大也很深奥，记录下今天使用hooks 及 association遇到了几个坑。 hooks：顾名思义就是钩子，简单的理解为可以定义相关动作后的关联动作 association： 关联，显式的指定该模型的关联关系。个人觉得 ORM 最大的问题就是关联查询及其复杂，反人类简直。有了 association 就可以显式的指定关联，方便查询。 定义modle 在定义modle的时候还比较容易，只需要在正常的定义后面加上 hooks 和 association 部
egg-sequelize表关联
weixin_45086164的博客
08-24 383
egg-sequelize表关联
egg-sequelize关联查询三种方法
betty_grant的博客
07-21 1980
1. 在Service里定义关联查询 import { Service } from 'egg'; export default class sroceService extends Service { /* * 分页查询 */ public async findSorce(query, page) { let { ctx } = this ctx.model.TSorce.belongsTo(ctx.model.TUser, {
sequelize学习笔记二(关联)
qq_38861711的博客
12-14 1118
Sequelize关联相关知识
egg-sequelize的级联删除
clearlxj的博客
07-04 3304
parent为参照表，children外键关联parent。 const parents = await this.ctx.model.Parent.findAll({ where: { id: parents_id }, include: [{ model: this.ctx.model.Children, as: 'children', ...
使用Sequelize连接数据库
weixin_33895016的博客
08-09 1265
Sequelize.js是一款针对nodejs的ORM框架。 使用nodejs连接过数据库的人肯定对数据库不陌生了。如果是直接链接，需要自己建立并管理连接，还需要手动编写sql语句。简单的项目到是无所谓，可是一旦项目设计的东西比较复杂，表比较多的时候整个sql的编写就非常的消耗精力。 在Java、c#等语言中已经有轻量的数据库框架或者解决方案了。在nodejs中我推荐Sequelize。它是一个很...
sequelize raw参数详解：查询结果的区别
在 Sequelize，一个流行的 Node.js ORM（对象关系映射）库，`raw` 参数是一个关键选项，用于控制查询结果是否以原始形式返回。本篇文章将深入探讨 `raw` 参数在 Sequelize 的 `findOne` 和 `findAll` 方法中的作用...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值