ORM框架
认识ORM框架
- ORM框架就是为了避免直接编写sql语句带来的繁琐，而把关系型数据表数据直接映射为js对象进行查询，同时也能把js对象转为关系型数据表的数据进行增加，修改或者删除
sequelize
- swquelize 是一个基于promise的node.js ORM 目前支持Postgres,mysql,mariaDB,SQLite以及MicrosoftSQL Server
Sequelize主要特点
- 支持事务
- 支持一对一，一对多，多对一，多对多，关联表的映射
如何使用sequelize完成CRUD
第一步 sequelize 链接数据库
import {where, op,ModelAttributes,DataTypes} from 'sequelize'
import {Sequelize,ModelStatic,Model} from 'sequelize-typescript'
//
import dbconfig from "./dbconfig";
import { Dialect } from "sequelize";
import { Sequelize } from "sequelize-typescript";
class BaseDaoDefine {
static baseDaoOrm: BaseDaoDefine = new BaseDaoDefine();
mySquelize!: Sequelize;
constructor() {
this.initSquelize("mysql");
}
initSquelize(dialect: Dialect) {
//创建sequelize对象，参数分别为：数据库名称、数据库类型、密码、配置
let { host, user, password, database, port } = dbconfig.getConf();
this.mySquelize = new Sequelize(database, user, password, {
host,
port,
dialect, //何种数据库
define: {
timestamps: false, //ture表示给模型加上时间戳属性（createAt、updateAt),fasle表示不带时间戳属性
freezeTableName: true //true 表示使用给定的表名，fasle表示模型的表名后加s
},
});
}
}
export const {mySquelize}=BaseDaoDefine.baseDaoOrm //导出创建的Sequelize对象
同步数据表
import { DataTypes } from "sequelize";
import { mySquelize } from "../common/BaseDao";
class Userinfo {
static createModel() {
const model= mySquelize.define("userinfo", {
userid: {
type: DataTypes.INTEGER,
field: "userid", //数据表中的字段，不填默认取key值，推荐写上
primaryKey: true,
autoIncrement: true,
},
username: {
type: DataTypes.STRING(30),
field: "username",
allowNull: false,
},
password: {
type: DataTypes.STRING(30),
field: "password",
allowNull: false,
},
age: {
type: DataTypes.INTEGER,
field: "age",
allowNull: false,
},
type: {
type: DataTypes.INTEGER,
field: "type",
allowNull: false,
},
});
model.sync({force:false}) //同步数据库，froce的值为true 表示若存在先删除在创建，froce为false表示不纯在才创建
return model
}
}
export const mode=Userinfo.createModel();
第二步：执行查询（有三个方案）
方案一：使用sequelize的define方法定义一个模型来实现
适合对单表进行的各种查询
适合单表添加更新
适合多表级联添加，更新
不适合多表级联查询，和前端取出数据相差甚远
//模型页面
import { DataTypes } from "sequelize";
import { mySquelize } from "../common/BaseDao";
class Userinfo {
static createModel() {
const model = mySquelize.define("userinfo", {
userid: {
type: DataTypes.INTEGER,
field: "userid", //数据表中的字段，不填默认取key值，推荐写上
primaryKey: true,
autoIncrement: true,
},
username: {
type: DataTypes.STRING(30),
field: "username",
allowNull: false,
},
password: {
type: DataTypes.STRING(30),
field: "password",
allowNull: false,
},
address: {
type: DataTypes.STRING,
field: "address",
allowNull: false,
},
age: {
type: DataTypes.INTEGER,
field: "age",
allowNull: false,
},
type: {
type: DataTypes.INTEGER,
field: "type",
allowNull: false,
},
});
model.sync({ force: false }); //同步数据库，froce的值为true 表示若存在先删除在创建，froce为false表示不纯在才创建
return model;
}
}
export const model = Userinfo.createModel();
// model
import { model } from "./user";
import { Op, Sequelize } from "sequelize";
class UserDaoDefine {
// 新增用户
static addUser(userinfo: Userinfo) {
return model.create(userinfo);
}
// 查询所有用户
static findAllUser() {
return model.findAll({
raw: true, //只看数据库的原值
});
}
// 查询指定的属性
static findByProps() {
return model.findAll({
raw: true,
attributes: ["username", "password"],
});
}
// 条件查询只查一个
static findByUsrAndPsw(username: string, password: string) {
return model.findOne({
raw: true,
where: {
[Op.or]: [{ username }, { password }],
},
});
}
// 模糊查询
static findBylike(key: string) {
return model.findAll({
raw: true,
where: {
username: {
[Op.like]: `%${key}%`,
},
},
});
}
// or查询
static findByuserAndAddr(username: string, age: number | string) {
return model.findAll({
raw: true,
where: {
[Op.or]: [
{
username: {
[Op.like]: `%${username}%`,
},
},
{
age,
},
],
},
});
}
// and查询
static findeByusernameAndpwd(username: string, password: string | number) {
return model.findOne({
raw: true,
where: {
[Op.and]: [
{
username,
},
{
password,
},
],
},
});
}
// 聚合查询
static coutUserifo() {
return model.findAll({
raw: true,
where: {
type: 1,
},
group: "address",
attributes: [
"address",
[Sequelize.fn("count", Sequelize.col("type")), "totalCount"],
],
});
}
// 分页查询
static findUserWithPager(limit:number =5,size:number =1){
return model.findAll({
raw:true,
limit,
offset:(size-1)*limit
})
}
}
export type Userinfo = {
userid?: number;
username: string;
password: string;
type: number;
age: number;
address: string;
};
export const {
addUser,
findAllUser,
findByProps,
findByUsrAndPsw,
findBylike,
findByuserAndAddr,
findeByusernameAndpwd,
coutUserifo,
findUserWithPager
} = UserDaoDefine;
方案2：使用sequelize的原生操作
适合场景：适合所有的增删改查
方案3：使用模型类来实现
应用场景：最适合对单表进行各种查询
//BaseDaoOrm.ts
import { Dialect } from "sequelize";
import { Sequelize } from "sequelize-typescript";
import dbconfig from "../common/dbconfig";
import path from 'path'
class BaseDaoOrm {
static baseDaoOrm: BaseDaoOrm = new BaseDaoOrm();
sequelize!: Sequelize;
constructor() {
this.initSequeConf('mysql');
}
initSequeConf(dialect: Dialect) {
// 创建sequelize对象，参数分别为：数据库名，数据库类型，密码，配置
let { host, user, password, database, port } = dbconfig.getConf();
this.sequelize = new Sequelize(database, user, password, {
host,
port,
dialect, //表示何种数据库
define: { timestamps: false, freezeTableName: true }, //freezeTableName true 表示使用给定的表名，fasle表示模型的表名后加s
//// timestamps ture表示给模型加上时间戳属性（createAt、updateAt),fasle表示不带时间戳属性
});
this.addModels() //只能在创建链接之后去调用
}
addModels(){
const modelPath=path.join(process.cwd(),"/src/ormmodel")
this.sequelize.addModels([modelPath])
}
}
export default BaseDaoOrm.baseDaoOrm
//UserDaoOrm.ts
import './BaseDaoOrm'
import { Op, Sequelize } from "sequelize";
import UserinfoModel from '../ormmodel/userinfo';
class UserDaoOrm {
static userDaoOrm:UserDaoOrm=new UserDaoOrm()
findByLike(key:string) {
const searchkey=`%${key}%`
return UserinfoModel.findAll({
raw:true,
where:{
username:{
[Op.like]:searchkey
}
}
})
}
findAllUser () {
return UserinfoModel.findAll()
}
}
export default UserDaoOrm.userDaoOrm
