const imgs = document.querySelectorAll("img[data-src]");
const config = {
  rootMargin: "0px",
  threshold: 0,
};

const callback = (entries, self) => {
  entries.forEach((entry) => {
    let img = entry.target;
    let src = img.dataset.src;
    if (src) {
      img.src = src;
      img.removeAttribute("data-src");
    }
    // 解除观察
    self.unobserve(entry.target);
  });
};
// 传入回调
let observer = new IntersectionObserver(callback, config);
// 开始观察
imgs.forEach((img) => observer.observe(img));

/*
 * @ use 数据库连接
 */
const mongoose = require("mongoose");
const config = require("../../config/common");

const dbConfig = config[process.env.NODE_ENV || "development"];

mongoose.connect(dbConfig.mongo.url, { useNewUrlParser: true });

mongoose.set("useCreateIndex", true); //加上这个

// 连接成功
mongoose.connection.on("connected", function () {
  //console.log('连接成功 ' + dbConfig.mongo.url);
});

// 连接失败
mongoose.connection.on("error", function (err) {
  console.log("连接失败 " + err);
});

// 断开连接
mongoose.connection.on("disconnected", function () {
  console.log("断开连接");
});

var mongoose = require('mongoose');
var Schema   = mongoose.Schema;

var UserSchema = new Schema({
    name  : { type: String, unique: true },
    posts : [{ type: Schema.Types.ObjectId, ref: 'Post' }]
});
var User = mongoose.model('User', UserSchema);

var PostSchema = new Schema({
    poster   : { type: Schema.Types.ObjectId, ref: 'User' },
    comments : [{ type: Schema.Types.ObjectId, ref: 'Comment' }],
    title    : String,
    content  : String
});
var Post = mongoose.model('Post', PostSchema);

var CommentSchema = new Schema({
    post      : { type: Schema.Types.ObjectId, ref: "Post" },
    commenter : { type: Schema.Types.ObjectId, ref: 'User' },
    content   : {
        main: String,
        label: String
    },
    points: [
        point: [{type: Schema.Types.ObjectId, ref: 'Point'}]
    ]
});
var Comment = mongoose.model('Comment', CommentSchema);

var PointSchema = new mongoose.Schema({
  name: String,
  parent: {type: Schema.Types.ObjectId, ref: 'point'},
  children: [{type: Schema.Types.ObjectId, ref: 'point'}]
})
var Point = mongoose.model('Point', PointSchema);

$or　　　　或关系
$nor　　　 或关系取反
$gt　　　　大于
$gte　　　 大于等于
$lt　　　　 小于
$lte　　　  小于等于
$ne            不等于
$in             在多个值范围内
$nin           不在多个值范围内
$all            匹配数组中多个值
$regex　　正则，用于模糊查询
$size　　　匹配数组大小
$maxDistance　　范围查询，距离（基于LBS）
$mod　　   取模运算
$near　　　邻域查询，查询附近的位置（基于LBS）
$exists　　  字段是否存在
$elemMatch　　匹配内数组内的元素
$within　　范围查询（基于LBS）
$box　　　 范围查询，矩形范围（基于LBS）
$center       范围醒询，圆形范围（基于LBS）
$centerSphere　　范围查询，球形范围（基于LBS）
$slice　　　　查询字段集合中的元素（比如从第几个之后，第N到第M个元素）

{
    name: 4,
    list: [{
        id: "a",
        date: 1504195200000,
        other: "c"
    },{
        id: "b",
        date: 1504195200000,
        other: "c"
    }]
}
// 现在要把other全部更新为"a",方法如下
db.getCollection('test')
  .update({'name': 4}, {$set: {'list.$[].other': 'a'}}, {multi: true})

// router.js
router.get('/admin/:id', controller.admin.index);

// controller
async index(ctx) {
    // 获取路由get传值参数（路由:id）
    ctx.params;
    // 获取url的问号get传值参数
    ctx.query;
}

router.verb('path-match', app.controller.action);
router.verb('router-name', 'path-match', app.controller.action);// 第一个参数可以给name
router.verb('path-match', middleware1, ..., middlewareN, app.controller.action);
router.verb('router-name', 'path-match', middleware1, ..., middlewareN, app.controller.action);

async index() {
    this.ctx.status = 301; // 把重定向改为301
    this.ctx.redirect('/admin/add'); // 默认临时重定向 302
}

app.router.redirect("/", "/home/index", 302);

// app/router.js
module.exports = (app) => {
  require("./router/news")(app);
  require("./router/admin")(app);
};

// app/router/news.js
module.exports = (app) => {
  app.router.get("/news/list", app.controller.news.list);
  app.router.get("/news/detail", app.controller.news.detail);
};

// app/router/admin.js
module.exports = (app) => {
  app.router.get("/admin/user", app.controller.admin.user);
  app.router.get("/admin/log", app.controller.admin.log);
};

// app/core/base_controller.js
const { Controller } = require("egg");
class BaseController extends Controller {
  get user() {
    return this.ctx.session.user;
  }

  success(data) {
    this.ctx.body = {
      success: true,
      data,
    };
  }

  notFound(msg) {
    msg = msg || "not found";
    this.ctx.throw(404, msg);
  }
}
module.exports = BaseController;

//app/controller/post.js
const Controller = require("../core/base_controller");
class PostController extends Controller {
  async list() {
    const posts = await this.service.listByUser(this.user);
    this.success(posts);
  }
}

module.exports = appInfo => {
    ...

    config.view = {
        mapping: {
            '.html': 'ejs',
        },
    };

	...
};

module.exports = {
  // 配置ejs
  ejs: {
    enable: true,
    package: "egg-view-ejs",
  },
};

async index() {
    const { ctx } = this;
    // 渲染变量
    let msg = "测试内容";
    let list = [1, 2, 3, 4, 5, 6];
    // 渲染模板（render需要加await）
    await ctx.render('index', {
        msg,
        list
    });
}

npm install --save egg-sequelize mysql2

config.sequelize = {
  dialect: "mysql",
  host: "127.0.0.1",
  username: "root",
  password: "root",
  port: 3306,
  database: "friends",
  // 中国时区
  timezone: "+08:00",
  define: {
    // 取消数据表名复数
    freezeTableName: true,
    // 自动写入时间戳 created_at updated_at
    timestamps: true,
    // 字段生成软删除时间戳 deleted_at
    paranoid: true,
    createdAt: "created_at",
    updatedAt: "updated_at",
    deletedAt: "deleted_at",
    // 所有驼峰命名格式化
    underscored: true,
  },
};

npm install --save-dev sequelize-cli

"use strict";

const path = require("path");

module.exports = {
  config: path.join(__dirname, "database/config.json"),
  "migrations-path": path.join(__dirname, "database/migrations"),
  "seeders-path": path.join(__dirname, "database/seeders"),
  "models-path": path.join(__dirname, "app/model"),
};

npx sequelize init:config
npx sequelize init:migrations
// npx sequelize init:models

npx sequelize db:create

npx sequelize migration:generate --name=init-users

"use strict";

module.exports = {
  up: async (queryInterface, Sequelize) => {
    const { INTEGER, STRING, DATE, ENUM } = Sequelize;
    // 创建表
    await queryInterface.createTable(
      "users",
      {
        id: {
          type: INTEGER(20).UNSIGNED,
          primaryKey: true,
          autoIncrement: true,
        },
        username: {
          type: STRING(30),
          allowNull: false,
          defaultValue: "",
          comment: "用户名称",
          unique: true,
        },
        email: {
          type: STRING(160),
          allowNull: false,
          defaultValue: "",
          comment: "用户邮箱",
          unique: true,
        },
        password: { type: STRING(200), allowNull: false, defaultValue: "" },
        avatar_url: { type: STRING(200), allowNull: true, defaultValue: "" },
        mobile: {
          type: STRING(20),
          allowNull: false,
          defaultValue: "",
          comment: "用户手机",
          unique: true,
        },
        prifix: { type: STRING(32), allowNull: false, defaultValue: "" },
        abstract: { type: STRING(255), allowNull: true, defaultValue: "" },
        role_id: {
          type: INTEGER,
          //  定义外键（重要）
          references: {
            model: "users", // 对应表名称（数据表名称）
            key: "id", // 对应表的主键
          },
          onUpdate: "restrict", // 更新时操作
          onDelete: "cascade", // 删除时操作
        },
        gender: {
          type: ENUM,
          values: ["男", "女", "保密"],
          allowNull: true,
          defaultValue: "男",
          comment: "用户性别",
        },
        created_at: DATE,
        updated_at: DATE,
      },
      { engine: "MYISAM" }
    );
    // 添加索引
    queryInterface.addIndex("users", ["gender"]);
    // 添加唯一索引
    queryInterface.addIndex("users", {
      name: "name", // 索引名称
      unique: true, // 唯一索引
      fields: ["name"], // 索引对应字段
    });
  },

  down: async (queryInterface) => {
    await queryInterface.dropTable("users");
  },
};

"use strict";

module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.sequelize.transaction((t) => {
      return Promise.all([
        queryInterface.addColumn(
          "user",
          "role_id",
          {
            type: Sequelize.INTEGER,
          },
          { transaction: t }
        ),
        queryInterface.addColumn(
          "user",
          "ceshi",
          {
            type: Sequelize.STRING,
          },
          { transaction: t }
        ),
      ]);
    });
  },

  down: (queryInterface, Sequelize) => {
    return queryInterface.sequelize.transaction((t) => {
      return Promise.all([
        queryInterface.removeColumn("user", "role_id", { transaction: t }),
        queryInterface.removeColumn("user", "ceshi", { transaction: t }),
      ]);
    });
  },
};

// app / model / user.js

"use strict";
module.exports = (app) => {
  const { STRING, INTEGER, DATE } = app.Sequelize;
  // 配置（重要：一定要配置详细，一定要！！！）
  const User = app.model.define(
    "user",
    {
      id: { type: INTEGER, primaryKey: true, autoIncrement: true },
      name: STRING(30),
      age: INTEGER,
      created_at: DATE,
      updated_at: DATE,
    },
    {
      timestamps: true, // 是否自动写入时间戳
      tableName: "users", // 自定义数据表名称
    }
  );

  return User;
};

// app/controller/users.js
const Controller = require("egg").Controller;

function toInt(str) {
  if (typeof str === "number") return str;
  if (!str) return str;
  return parseInt(str, 10) || 0;
}

class UserController extends Controller {
  async index() {
    const ctx = this.ctx;
    const query = {
      limit: toInt(ctx.query.limit),
      offset: toInt(ctx.query.offset),
    };
    ctx.body = await ctx.model.User.findAll(query);
  }

  async show() {
    const ctx = this.ctx;
    ctx.body = await ctx.model.User.findByPk(toInt(ctx.params.id));
  }

  async create() {
    const ctx = this.ctx;
    const { name, age } = ctx.request.body;
    const user = await ctx.model.User.create({ name, age });
    ctx.status = 201;
    ctx.body = user;
  }

  async update() {
    const ctx = this.ctx;
    const id = toInt(ctx.params.id);
    const user = await ctx.model.User.findByPk(id);
    if (!user) {
      ctx.status = 404;
      return;
    }

    const { name, age } = ctx.request.body;
    await user.update({ name, age });
    ctx.body = user;
  }

  async destroy() {
    const ctx = this.ctx;
    const id = toInt(ctx.params.id);
    const user = await ctx.model.User.findByPk(id);
    if (!user) {
      ctx.status = 404;
      return;
    }

    await user.destroy();
    ctx.status = 200;
  }
}

module.exports = UserController;

// app/router.js
module.exports = (app) => {
  const { router, controller } = app;
  router.resources("users", "/users", controller.users);
};

// 配置（重要）
const User = app.model.define(
  "user",
  {
    id: { type: INTEGER, primaryKey: true, autoIncrement: true },
    name: STRING(30),
    age: INTEGER,
    created_at: DATE,
    updated_at: DATE,
  },
  {
    // 自定义表名
    freezeTableName: true,
    tableName: "xyz_users",

    // 是否需要增加createdAt、updatedAt、deletedAt字段
    timestamps: true,

    // 不需要createdAt字段
    createdAt: false,

    // 将updatedAt字段改个名
    updatedAt: "utime",

    // 将deletedAt字段改名
    // 同时需要设置paranoid为true（此种模式下，删除数据时不会进行物理删除，而是设置deletedAt为当前时间
    deletedAt: "dtime",
    paranoid: true,
  }
);

// 迁移文件
queryInterface.addConstraint("tableName", ["user_id"], {
  type: "foreign key",
  name: "user_id",
  references: {
    //Required field
    table: "users",
    field: "id",
  },
  onDelete: "cascade",
  onUpdate: "cascade",
});

"use strict";

module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.bulkInsert(
      "Users",
      [
        {
          firstName: "John",
          lastName: "Doe",
          email: "demo@demo.com",
          createdAt: new Date(),
          updatedAt: new Date(),
        },
      ],
      {}
    );
  },

  down: (queryInterface, Sequelize) => {
    return queryInterface.bulkDelete("Users", null, {});
  },
};

// 一个用户对应一个用户资料

// app/model/user.js
module.exports = (app) => {
  const { STRING, INTEGER, DATE } = app.Sequelize;

  const User = app.model.define("user", {
    id: { type: INTEGER, primaryKey: true, autoIncrement: true },
    name: STRING(30),
    age: INTEGER,
    created_at: DATE,
    updated_at: DATE,
  });
  // 关联关系
  User.associate = function (models) {
    // 关联用户资料 一对一
    User.hasOne(app.model.Userinfo);
  };
  return User;
};

// app/model/userinfo.js
module.exports = (app) => {
  const { STRING, INTEGER, DATE } = app.Sequelize;
  const userinfo = app.model.define(
    "userinfo",
    {
      nickname: STRING,
      user_id: INTEGER,
    },
    {}
  );
  // 关联用户表
  userinfo.associate = function (models) {
    app.model.Userinfo.belongsTo(app.model.User);
  };
  return userinfo;
};

// app/controller/users.js
// 显示单条
async show() {
    // 根据主键查询 查询一条用findOne
    this.ctx.body = await this.ctx.model.User.findOne({
        // 主表查询字段限制
        attributes:['name'],
        // 关联查询
        include: [{
            // 需要查询的模型
            model: this.app.model.Userinfo,
            // 副表查询的字段
            attributes: ['nickname']
        }],
        // 主表条件
        where: {
            id: 3
        }
    });
}

class City extends Model {}
City.init({ countryCode: Sequelize.STRING }, { sequelize, modelName: "city" });
class Country extends Model {}
Country.init(
  { isoCode: Sequelize.STRING },
  { sequelize, modelName: "country" }
);

// 在这里,我们可以根据国家代码连接国家和城市
Country.hasMany(City, { foreignKey: "countryCode", sourceKey: "isoCode" });
City.belongsTo(Country, { foreignKey: "countryCode", targetKey: "isoCode" });

User.belongsToMany(Project, {
  as: "Tasks",
  through: "worker_tasks",
  foreignKey: "userId",
});
Project.belongsToMany(User, {
  as: "Workers",
  through: "worker_tasks",
  foreignKey: "projectId",
});

// 获取关联模型对象，n对一不需要加s
let userinfo = await user.getUserinfo();
// n对多需要加s
await user.getPosts({
  attributes: ["title"],
  where: {
    id: 3,
  },
});
// 关联操作
// 1：用户创建文章（一对多）
await this.ctx.model.Post.create({
  title: "第一篇文章",
  user_id: user.id,
});

// 2.获取当前用户所有文章
await user.getPosts();
await user.getPosts({
  attributes: ["id"],
  where: {
    title: "测试",
  },
});

// 3：用户删除文章（一对多）
// (1) 获取当前用户的所有文章
let posts = await user.getPosts({
  attributes: ["id"],
});
posts = posts.map((v) => v.id);
await this.ctx.model.Post.destroy({
  where: {
    id: posts,
  },
});

// 场景三：用户关注话题（多对多）
await this.ctx.model.TopicUser.bulkCreate([
  {
    user_id: user.id,
    topic_id: 1,
  },
  {
    user_id: user.id,
    topic_id: 2,
  },
]);

// 用户关注话题（多对多）
await this.ctx.model.TopicUser.destroy({
  where: {
    user_id: user.id,
    topic_id: [1, 2],
  },
});

// app/model/user.js

module.exports = (app) => {
  const { STRING, INTEGER, DATE } = app.Sequelize;

  const User = app.model.define("user", {
    id: { type: INTEGER, primaryKey: true, autoIncrement: true },
    name: {
      type: STRING(30),
      // 单独字段的getter，查询时都会调用
      // this.getDataValue('name') 获取原始值
      get() {
        const age = this.getDataValue("age");
        return this.getDataValue("name") + "年龄：" + age;
      },
    },
    age: {
      type: INTEGER,
      // 单独字段的setter，新增和更新时调用
      // this.setDataValue('name') 设置原始值
      set(val) {
        this.setDataValue("age", val * 10);
      },
    },
    created_at: DATE,
    updated_at: DATE,
  });

  // 关联用户资料
  User.associate = function (models) {
    app.model.User.hasOne(app.model.Userinfo);
  };
  return User;
};

async show() {
    // 根据主键查询
    let user = await this.ctx.model.User.findOne({
        where: {
            id: 3
        }
    });
    // 获取原始值 user.getDataValue('name')
    this.ctx.body = user.getDataValue('name')
}

module.exports = app => {

    ...

    // 钩子
    // 查询前
    User.beforeFind((user, option) => {
        console.log('查询前');
    });
    // 查询后
    User.afterFind((user, option) => {
        console.log('查询后');
    });
    // 新增前
    User.beforeCreate((user, option) => {
        console.log('新增前');
    });
    // 新增后
    User.afterCreate((user, option) => {
        console.log('新增后');
    });
    // 修改前
    User.beforeUpdate((user, option) => {
        console.log('修改前');
    });
    // 修改后
    User.afterUpdate((user, option) => {
        console.log('修改后'); // 真正修改才会触发，数据相同不会触发
    });
    // 删除前
    User.beforeDestroy((user, option) => {
        console.log('删除前');
    });
    // 删除后
    User.afterDestroy((user, option) => {
        console.log('删除后');
    });

    // 批量删除前
    User.beforeBulkDestroy((user, option) => {
        console.log('批量删除前');
    });
    // 批量删除后
    User.afterBulkDestroy((user, option) => {
        console.log('批量删除后');
    });

    return User;
};

Model.findByPk(1);

User.findOrCreate({
  where: {
    username: "sdepold",
  },
  defaults: {
    job: "Technical Lead JavaScript",
  },
}).then(([user, created]) => {
  console.log(
    user.get({
      plain: true,
    })
  );
  console.log(created);

  /*
    findOrCreate 返回一个包含已找到或创建的对象的数组,找到或创建的对象和一个布尔值,如果创建一个新对象将为true,否则为false,像这样:

    [ {
        username: 'sdepold',
        job: 'Technical Lead JavaScript',
        id: 1,
        createdAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET),
        updatedAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET)
      },
      true ]

在上面的例子中,第三行的数组将分成2部分,并将它们作为参数传递给回调函数,在这种情况下将它们视为 "user" 和 "created" .(所以“user”将是返回数组的索引0的对象,并且 "created" 将等于 "true".)
    */
});

User.create({ username: "fnord", job: "omnomnom" })
  .then(() =>
    User.findOrCreate({
      where: {
        username: "fnord",
      },
      defaults: {
        job: "something else",
      },
    })
  )
  .then(([user, created]) => {
    console.log(
      user.get({
        plain: true,
      })
    );
    console.log(created);

    /*
    在这个例子中,findOrCreate 返回一个如下的数组:
    [ {
        username: 'fnord',
        job: 'omnomnom',
        id: 2,
        createdAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET),
        updatedAt: Fri Mar 22 2013 21: 28: 34 GMT + 0100(CET)
      },
      false
    ]
    由findOrCreate返回的数组通过第三行的数组扩展为两部分,并且这些部分将作为2个参数传递给回调函数,在这种情况下将其视为 "user" 和 "created" .(所以“user”将是返回数组的索引0的对象,并且 "created" 将等于 "false".)
    */
  });

Project.findAndCountAll({
  where: {
    title: {
      [Op.like]: "foo%",
    },
  },
  offset: 10,
  limit: 2,
}).then((result) => {
  console.log(result.count);
  console.log(result.rows);
});

User.findAndCountAll({
  include: [{ model: Profile, required: true }],
  limit: 3,
});

User.findAndCountAll({
  include: [{ model: Profile, where: { active: true } }],
  limit: 3,
});

// 找到多个条目
Project.findAll().then((projects) => {
  // projects 将是所有 Project 实例的数组
});

// 搜索特定属性 - 使用哈希
Project.findAll({ where: { name: "A Project" } }).then((projects) => {
  // projects将是一个具有指定 name 的 Project 实例数组
});

// 在特定范围内进行搜索
Project.findAll({ where: { id: [1, 2, 3] } }).then((projects) => {
  // projects将是一系列具有 id 1,2 或 3 的项目
  // 这实际上是在做一个 IN 查询
});

Project.findAll({
  where: {
    id: {
      [Op.and]: { a: 5 }, // 且 (a = 5)
      [Op.or]: [{ a: 5 }, { a: 6 }], // (a = 5 或 a = 6)
      [Op.gt]: 6, // id > 6
      [Op.gte]: 6, // id >= 6
      [Op.lt]: 10, // id < 10
      [Op.lte]: 10, // id <= 10
      [Op.ne]: 20, // id != 20
      [Op.between]: [6, 10], // 在 6 和 10 之间
      [Op.notBetween]: [11, 15], // 不在 11 和 15 之间
      [Op.in]: [1, 2], // 在 [1, 2] 之中
      [Op.notIn]: [1, 2], // 不在 [1, 2] 之中
      [Op.like]: "%hat", // 包含 '%hat'
      [Op.notLike]: "%hat", // 不包含 '%hat'
      [Op.iLike]: "%hat", // 包含 '%hat' (不区分大小写)  (仅限 PG)
      [Op.notILike]: "%hat", // 不包含 '%hat'  (仅限 PG)
      [Op.overlap]: [1, 2], // && [1, 2] (PG数组重叠运算符)
      [Op.contains]: [1, 2], // @> [1, 2] (PG数组包含运算符)
      [Op.contained]: [1, 2], // <@ [1, 2] (PG数组包含于运算符)
      [Op.any]: [2, 3], // 任何数组[2, 3]::INTEGER (仅限 PG)
    },
    status: {
      [Op.not]: false, // status 不为 FALSE
    },
  },
});

Project.findOne({
  where: {
    name: "a project",
    [Op.or]: [{ id: [1, 2, 3] }, { id: { [Op.gt]: 10 } }],
  },
});

Project.findOne({
  where: {
    name: "a project",
    id: {
      [Op.or]: [[1, 2, 3], { [Op.gt]: 10 }],
    },
  },
});

SELECT *
FROM `Projects`
WHERE (
  `Projects`.`name` = 'a project'
   AND (`Projects`.`id` IN (1,2,3) OR `Projects`.`id` > 10)
)
LIMIT 1;

Project.findOne({
  where: {
    name: "a project",
    [Op.not]: [{ id: [1, 2, 3] }, { array: { [Op.contains]: [3, 4, 5] } }],
  },
});

SELECT *
FROM `Projects`
WHERE (
  `Projects`.`name` = 'a project'
   AND NOT (`Projects`.`id` IN (1,2,3) OR `Projects`.`array` @> ARRAY[3,4,5]::INTEGER[])
)
LIMIT 1;

// 限制查询的结果
Project.findAll({ limit: 10 });

// 跳过前10个元素
Project.findAll({ offset: 10 });

// 跳过前10个元素,并获取2个
Project.findAll({ offset: 10, limit: 2 });

Project.findAll({ order: [["title", "DESC"]] });
// 生成 ORDER BY title DESC

Project.findAll({ group: "name" });
// 生成 GROUP BY name

something.findOne({
  order: [
    // 将返回 `name`
    ["name"],
    // 将返回 `username` DESC
    ["username", "DESC"],
    // 将返回 max(`age`)
    sequelize.fn("max", sequelize.col("age")),
    // 将返回 max(`age`) DESC
    [sequelize.fn("max", sequelize.col("age")), "DESC"],
    // 将返回 otherfunction(`col1`, 12, 'lalala') DESC
    [
      sequelize.fn("otherfunction", sequelize.col("col1"), 12, "lalala"),
      "DESC",
    ],
    // 将返回 otherfunction(awesomefunction(`col`)) DESC,这个嵌套是可以无限的！
    [
      sequelize.fn(
        "otherfunction",
        sequelize.fn("awesomefunction", sequelize.col("col"))
      ),
      "DESC",
    ],
  ],
});

Model.findAll({
  attributes: ["foo", "bar"],
});

Model.findAll({
  attributes: ["foo", ["bar", "baz"]],
});

Model.findAll({
  attributes: [[sequelize.fn("COUNT", sequelize.col("hats")), "no_hats"]],
});

// This is a tiresome way of getting the number of hats...
Model.findAll({
  attributes: ['id', 'foo', 'bar', 'baz', 'quz', [sequelize.fn('COUNT', sequelize.col('hats')), 'no_hats']]
});

// This is shorter, and less error prone because it still works if you add / remove attributes
Model.findAll({
  attributes: { include: [[sequelize.fn('COUNT', sequelize.col('hats')), 'no_hats']] }
});
SELECT id, foo, bar, baz, quz, COUNT(hats) AS no_hats ...

Model.findAll({
  attributes: { exclude: ['baz'] }
});
SELECT id, foo, bar, quz ...

const Op = Sequelize.Op;

Post.findAll({
  where: {
    authorId: 2,
  },
});
// SELECT * FROM post WHERE authorId = 2

Post.findAll({
  where: {
    authorId: 12,
    status: "active",
  },
});
// SELECT * FROM post WHERE authorId = 12 AND status = 'active';

Post.findAll({
  where: {
    [Op.or]: [{ authorId: 12 }, { authorId: 13 }],
  },
});
// SELECT * FROM post WHERE authorId = 12 OR authorId = 13;

Post.findAll({
  where: {
    authorId: {
      [Op.or]: [12, 13],
    },
  },
});
// SELECT * FROM post WHERE authorId = 12 OR authorId = 13;

Post.destroy({
  where: {
    status: "inactive",
  },
});
// DELETE FROM post WHERE status = 'inactive';

Post.update(
  {
    updatedAt: null,
  },
  {
    where: {
      deletedAt: {
        [Op.ne]: null,
      },
    },
  }
);
// UPDATE post SET updatedAt = null WHERE deletedAt NOT NULL;

Post.findAll({
  where: sequelize.where(
    sequelize.fn("char_length", sequelize.col("status")),
    6
  ),
});
// SELECT * FROM post WHERE char_length(status) = 6;

const Op = Sequelize.Op

[Op.and]: {a: 5}           // 且 (a = 5)
[Op.or]: [{a: 5}, {a: 6}]  // (a = 5 或 a = 6)
[Op.gt]: 6,                // id > 6
[Op.gte]: 6,               // id >= 6
[Op.lt]: 10,               // id < 10
[Op.lte]: 10,              // id <= 10
[Op.ne]: 20,               // id != 20
[Op.eq]: 3,                // = 3
[Op.not]: true,            // 不是 TRUE
[Op.between]: [6, 10],     // 在 6 和 10 之间
[Op.notBetween]: [11, 15], // 不在 11 和 15 之间
[Op.in]: [1, 2],           // 在 [1, 2] 之中
[Op.notIn]: [1, 2],        // 不在 [1, 2] 之中
[Op.like]: '%hat',         // 包含 '%hat'
[Op.notLike]: '%hat'       // 不包含 '%hat'
[Op.iLike]: '%hat'         // 包含 '%hat' (不区分大小写)  (仅限 PG)
[Op.notILike]: '%hat'      // 不包含 '%hat'  (仅限 PG)
[Op.startsWith]: 'hat'     // 类似 'hat%'
[Op.endsWith]: 'hat'       // 类似 '%hat'
[Op.substring]: 'hat'      // 类似 '%hat%'
[Op.regexp]: '^[h|a|t]'    // 匹配正则表达式/~ '^[h|a|t]' (仅限 MySQL/PG)
[Op.notRegexp]: '^[h|a|t]' // 不匹配正则表达式/!~ '^[h|a|t]' (仅限 MySQL/PG)
[Op.iRegexp]: '^[h|a|t]'    // ~* '^[h|a|t]' (仅限 PG)
[Op.notIRegexp]: '^[h|a|t]' // !~* '^[h|a|t]' (仅限 PG)
[Op.like]: { [Op.any]: ['cat', 'hat']} // 包含任何数组['cat', 'hat'] - 同样适用于 iLike 和 notLike
[Op.overlap]: [1, 2]       // && [1, 2] (PG数组重叠运算符)
[Op.contains]: [1, 2]      // @> [1, 2] (PG数组包含运算符)
[Op.contained]: [1, 2]     // <@ [1, 2] (PG数组包含于运算符)
[Op.any]: [2,3]            // 任何数组[2, 3]::INTEGER (仅限PG)

[Op.col]: 'user.organization_id' // = 'user'.'organization_id', 使用数据库语言特定的列标识符, 本例使用 PG