model

think.model.base 继承自 think.base 类。

使用 ES6 的语法继承该类
  1. export default class extends think.model.base {
  2.   getList(){
  4.   }
  5. }
使用普通方式继承该类
  1. module.exports = think.model({
  2.   getList: function(){
  4.   }
  5. })

属性

model.pk

数据表主键，默认为 id。

model.name

模型名，默认从当前文件名中解析。

当前文件路径为 for/bar/app/home/model/user.js，那么解析的模型名为 user。

model.tablePrefix

数据表名称前缀，默认为 think_。

model.tableName

数据表名称，不包含前缀。默认等于模型名。

model.schema

数据表字段，关系型数据库默认自动从数据表分析。

model.indexes

数据表索引，关系数据库会自动从数据表分析。

model.config

配置，实例化的时候指定。

model._db

连接数据库句柄。

model._data

操作的数据。

model._options

操作选项。

方法

model.model(name, options, module)

  • name {String} 模型名称
  • options {Object} 配置项
  • module {String} 模块名
  • return {Object}
    获取模型实例，可以跨模块获取。
  1. export default class extends think.model.base {
  2.   async getList(){
  3.     //获取 user 模型实例
  4.     let instance = this.model('user');
  5.     let list = await instance.select();
  6.     let ids = list.map(item => {
  7.       return item.id;
  8.     });
  9.     let data = await this.where({id: ['IN', ids]}).select();
  10.     return data;
  11.   }
  12. }

model.getTablePrefix()

  • return {string}
    获取表名前缀。

model.getConfigKey()

  • return {String}
    获取配置对应的 key，缓存 db 句柄时使用。

model.db()

  • return {Object}
    根据当前的配置获取 db 实例，如果已经存在则直接返回。

model.getModelName()

  • return {String} 模型名称
    如果已经配置则直接返回，否则解析当前的文件名。

model.getTableName()

  • return {String} 获取表名，包含表前缀
    获取表名，包含表前缀。

model.cache(key, timeout)

  • key {String} 缓存 key
  • timeout {Number} 缓存有效时间，单位为秒
  • return {this}
    设置缓存选项。
设置缓存 key 和时间
  1. export default class extends think.model.base {
  2.   getList(){
  3.     return this.cache('getList', 1000).where({id: {'>': 100}}).select();
  4.   }
  5. }
只设置缓存时间，缓存 key 自动生成
  1. export default class extends think.model.base {
  2.   getList(){
  3.     return this.cache(1000).where({id: {'>': 100}}).select();
  4.   }
  5. }
设置更多的缓存信息
  1. export default class extends think.model.base {
  2.   getList(){
  3.     return this.cache({
  4.       key: 'getList',
  5.       timeout: 1000,
  6.       type: 'file' //使用文件方式缓存
  7.     }).where({id: {'>': 100}}).select();
  8.   }
  9. }

model.limit(offset, length)

  • offset {Number} 设置查询的起始位置
  • length {Number} 设置查询的数据长度
  • return {this}
    设置查询结果的限制条件。
限制数据长度
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //查询20条数据
  4.     return this.limit(20).where({id: {'>': 100}}).select();
  5.   }
  6. }
限制数据起始位置和长度
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //从起始位置100开始查询20调数据
  4.     return this.limit(100, 20).where({id: {'>': 100}}).select();
  5.   }
  6. }

也可以直接传入一个数组，如：

  1. export default class extends think.model.base {
  2.   getList(){
  3.     //从起始位置100开始查询20调数据
  4.     return this.limit([100, 20]).where({id: {'>': 100}}).select();
  5.   }
  6. }

model.page(page, listRows)

  • page {Number} 当前页，从 1 开始
  • listRows {Number} 每页的条数
  • return {this}
    设置查询分页数据，自动转化为 limit 数据。
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //查询第 2 页数据，每页 10 条数据
  4.     return this.page(2, 10).where({id: {'>': 100}}).select();
  5.   }
  6. }

也可以直接设置一个参数为数组，关联模型等情况下可能会有用。如：

  1. export default class extends think.model.base {
  2.   getList(){
  3.     //查询第 2 页数据，每页 10 条数据
  4.     return this.page([2, 10]).where({id: {'>': 100}}).select();
  5.   }
  6. }

model.where(where)

  • where {String | Object} where 条件
  • return {this}
    设置 where 查询条件。可以通过属性 _logic 设置逻辑，默认为 AND。可以通过属性 _complex 设置复合查询。

注：1、以下示例不适合 mongo model，mongo 中设置 where 条件请见 model.mongo 里的 where 条件设定。2、where 条件中的值需要在 Logic 里做数据校验，否则可能会有漏洞。

普通条件
  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user`
  4.     return this.where().select();
  5.   }
  6.   where2(){
  7.     //SELECT * FROM `think_user` WHERE ( `id` = 10 )
  8.     return this.where({id: 10}).select();
  9.   }
  10.   where3(){
  11.     //SELECT * FROM `think_user` WHERE ( id = 10 OR id < 2 )
  12.     return this.where('id = 10 OR id < 2').select();
  13.   }
  14.   where4(){
  15.     //SELECT * FROM `think_user` WHERE ( `id` != 10 )
  16.     return this.where({id: ['!=', 10]}).select();
  17.   }
  18. }
null 条件
  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` where ( title IS NULL );
  4.     return this.where({title: null}).select();
  5.   }
  6.   where2(){
  7.     //SELECT * FROM `think_user` where ( title IS NOT NULL );
  8.     return this.where({title: ['!=', null]}).select();
  9.   }
  10. }
EXP 条件

ThinkJS 默认会对字段和值进行转义，防止安全漏洞。有时候一些特殊的情况不希望被转义，可以使用 EXP 的方式，如：

  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE ( (`name` ='name') )
  4.     return this.where({name: ['EXP', "=\"name\""]}).select();
  5.   }
  6. }
LIKE 条件
  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE ( `title` NOT LIKE 'welefen' )
  4.     return this.where({title: ['NOTLIKE', 'welefen']}).select();
  5.   }
  6.   where2(){
  7.     //SELECT * FROM `think_user` WHERE ( `title` LIKE '%welefen%' )
  8.     return this.where({title: ['like', '%welefen%']}).select();
  9.   }
  10.   //like 多个值
  11.   where3(){
  12.     //SELECT * FROM `think_user` WHERE ( (`title` LIKE 'welefen' OR `title` LIKE 'suredy') )
  13.     return this.where({title: ['like', ['welefen', 'suredy']]}).select();
  14.   }
  15.   //多个字段或的关系 like 一个值
  16.   where4(){
  17.     //SELECT * FROM `think_user` WHERE ( (`title` LIKE '%welefen%') OR (`content` LIKE '%welefen%') )
  18.     return this.where({'title|content': ['like', '%welefen%']}).select();
  19.   }
  20.   //多个字段与的关系 Like 一个值
  21.   where5(){
  22.     //SELECT * FROM `think_user` WHERE ( (`title` LIKE '%welefen%') AND (`content` LIKE '%welefen%') )
  23.     return this.where({'title&content': ['like', '%welefen%']}).select();
  24.   }
  25. }
IN 条件
  1. export default class extens think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE ( `id` IN ('10','20') )
  4.     return this.where({id: ['IN', '10,20']}).select();
  5.   }
  6.   where2(){
  7.     //SELECT * FROM `think_user` WHERE ( `id` IN (10,20) )
  8.     return this.where({id: ['IN', [10, 20]]}).select();
  9.   }
  10.   where3(){
  11.     //SELECT * FROM `think_user` WHERE ( `id` NOT IN (10,20) )
  12.     return this.where({id: ['NOTIN', [10, 20]]}).select();
  13.   }
  14. }
BETWEEN 查询
  1. export default class extens think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE (  (`id` BETWEEN 1 AND 2) )
  4.     return this.where({id: ['BETWEEN', 1, 2]}).select();
  5.   }
  6.   where2(){
  7.     //SELECT * FROM `think_user` WHERE (  (`id` BETWEEN '1' AND '2') )
  8.     return this.where({id: ['between', '1,2']}).select();
  9.   }
  10. }
多字段查询
  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE ( `id` = 10 ) AND ( `title` = 'www' )
  4.     return this.where({id: 10, title: "www"}).select();
  5.   }
  6.   //修改逻辑为 OR
  7.   where2(){
  8.     //SELECT * FROM `think_user` WHERE ( `id` = 10 ) OR ( `title` = 'www' )
  9.     return this.where({id: 10, title: "www", _logic: 'OR'}).select();
  10.   }
  11.   //修改逻辑为 XOR
  12.   where2(){
  13.     //SELECT * FROM `think_user` WHERE ( `id` = 10 ) XOR ( `title` = 'www' )
  14.     return this.where({id: 10, title: "www", _logic: 'XOR'}).select();
  15.   }
  16. }
多条件查询
  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE ( `id` > 10 AND `id` < 20 )
  4.     return this.where({id: {'>': 10, '<': 20}}).select();
  5.   }
  6.   //修改逻辑为 OR 
  7.   where2(){
  8.     //SELECT * FROM `think_user` WHERE ( `id` < 10 OR `id` > 20 )
  9.     return this.where({id: {'<': 10, '>': 20, _logic: 'OR'}}).select()
  10.   }
  11. }
复合查询
  1. export default class extends think.model.base {
  2.   where1(){
  3.     //SELECT * FROM `think_user` WHERE ( `title` = 'test' ) AND (  ( `id` IN (1,2,3) ) OR ( `content` = 'www' ) )
  4.     return this.where({
  5.       title: 'test',
  6.       _complex: {id: ['IN', [1, 2, 3]],
  7.         content: 'www',
  8.         _logic: 'or'
  9.       }
  10.     }).select()
  11.   }
  12. }

model.field(field)

  • field {String | Array} 设置要查询的字段，可以是字符串，也可以是数组
  • return {this}
    设置要查询的字段。
字符串方式
  1. export default class extends think.controller.base {
  2.   async indexAction(){
  3.     let model = this.model('user');
  4.     //设置要查询的字符串，字符串方式，多个用逗号隔开
  5.     let data = await model.field('name,title').select();
  6.   }
  7. }
调用 SQL 函数
  1. export default class extends think.controller.base {
  2.   //字段里调用 SQL 函数
  3.   async listAction(){
  4.     let model = this.model('user');
  5.     let data = await model.field('id, INSTR(\'30,35,31,\',id + \',\') as d').select();
  6.   }
  7. }
数组方式
  1. export default class extends think.controller.base {
  2.   async indexAction(){
  3.     let model = this.model('user');
  4.     //设置要查询的字符串，数组方式
  5.     let data = await model.field(['name','title']).select();
  6.   }
  7. }

model.fieldReverse(field)

  • field {String | Array} 反选字段，即查询的时候不包含这些字段
  • return {this}
    设置反选字段，查询的时候会过滤这些字段，支持字符串和数组 2 种方式。

model.table(table, hasPrefix)

  • table {String} 表名
  • hasPrefix {Boolean} 是否已经有了表前缀，如果 table 值含有空格，则不在添加表前缀
  • return {this}
    设置表名，可以将一个 SQL 语句设置为表名。
设置当前表名
  1. export default class extends think.model.base {
  2.   getList(){
  3.     return this.table('test', true).select();
  4.   }
  5. }
SQL 语句作为表名
  1. export default class extends think.model.base {
  2.   async getList(){
  3.     let sql = await this.model('group').group('name').buildSql();
  4.     let data = await this.table(sql).select();
  5.     return data;
  6.   }
  7. }

model.union(union, all)

  • union {String | Object} 联合查询 SQL 或者表名
  • all {Boolean} 是否是 UNION ALL 方式
  • return {this}
    联合查询。
SQL 联合查询
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` UNION (SELECT * FROM think_pic2)
  4.     return this.union('SELECT * FROM think_pic2').select();
  5.   }
  6. }
表名联合查询
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` UNION ALL (SELECT * FROM `think_pic2`)
  4.     return this.union({table: 'think_pic2'}, true).select();
  5.   }
  6. }

model.join(join)

  • join {String | Object | Array} 要组合的查询语句，默认为 LEFT JOIN
  • return {this}
    组合查询，支持字符串、数组和对象等多种方式。
字符串
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` LEFT JOIN think_cate ON think_group.cate_id=think_cate.id
  4.     return this.join('think_cate ON think_group.cate_id=think_cate.id').select();
  5.   }
  6. }
数组
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` LEFT JOIN think_cate ON think_group.cate_id=think_cate.id RIGHT JOIN think_tag ON think_group.tag_id=think_tag.id
  4.     return this.join([
  5.       'think_cate ON think_group.cate_id=think_cate.id', 
  6.       'RIGHT JOIN think_tag ON think_group.tag_id=think_tag.id'
  7.     ]).select();
  8.   }
  9. }
对象：单个表
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` INNER JOIN `think_cate` AS c ON think_user.`cate_id`=c.`id`
  4.     return this.join({
  5.       table: 'cate', 
  6.       join: 'inner', //join 方式，有 left, right, inner 3 种方式
  7.       as: 'c', // 表别名
  8.       on: ['cate_id', 'id'] //ON 条件
  9.     }).select();
  10.   }
  11. }
对象：多次 JOIN
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM think_user AS a LEFT JOIN `think_cate` AS c ON a.`cate_id`=c.`id` LEFT JOIN `think_group_tag` AS d ON a.`id`=d.`group_id`
  4.     return this.alias('a').join({
  5.       table: 'cate',
  6.       join: 'left',
  7.       as: 'c',
  8.       on: ['cate_id', 'id']
  9.     }).join({
  10.       table: 'group_tag',
  11.       join: 'left',
  12.       as: 'd',
  13.       on: ['id', 'group_id']
  14.     }).select()
  15.   }
  16. }
对象：多个表
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` LEFT JOIN `think_cate` ON think_user.`id`=think_cate.`id` LEFT JOIN `think_group_tag` ON think_user.`id`=think_group_tag.`group_id`
  4.     return this.join({
  5.       cate: {
  6.         on: ['id', 'id']
  7.       },
  8.       group_tag: {
  9.         on: ['id', 'group_id']
  10.       }
  11.     }).select();
  12.   }
  13. }
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM think_user AS a LEFT JOIN `think_cate` AS c ON a.`id`=c.`id` LEFT JOIN `think_group_tag` AS d ON a.`id`=d.`group_id`
  4.     return this.alias('a').join({
  5.       cate: {
  6.         join: 'left', // 有 left,right,inner 3 个值
  7.         as: 'c',
  8.         on: ['id', 'id']
  9.       },
  10.       group_tag: {
  11.         join: 'left',
  12.         as: 'd',
  13.         on: ['id', 'group_id']
  14.       }
  15.     }).select()
  16.   }
  17. }
对象：ON 条件含有多个字段
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` LEFT JOIN `think_cate` ON think_user.`id`=think_cate.`id` LEFT JOIN `think_group_tag` ON think_user.`id`=think_group_tag.`group_id` LEFT JOIN `think_tag` ON (think_user.`id`=think_tag.`id` AND think_user.`title`=think_tag.`name`)
  4.     return this.join({
  5.       cate: {on: 'id, id'},
  6.       group_tag: {on: ['id', 'group_id']},
  7.       tag: {
  8.         on: { // 多个字段的 ON
  9.           id: 'id',
  10.           title: 'name'
  11.         }
  12.       }
  13.     }).select()
  14.   }
  15. }
对象：table 值为 SQL 语句
  1. export default class extends think.model.base {
  2.   async getList(){
  3.     let sql = await this.model('group').buildSql();
  4.     //SELECT * FROM `think_user` LEFT JOIN ( SELECT * FROM `think_group` ) ON think_user.`gid`=( SELECT * FROM `think_group` ).`id`
  5.     return this.join({
  6.       table: sql,
  7.       on: ['gid', 'id']
  8.     }).select();
  9.   }
  10. }

model.order(order)

  • order {String | Array | Object} 排序方式
  • return {this}
    设置排序方式。
字符串
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` ORDER BY id DESC, name ASC
  4.     return this.order('id DESC, name ASC').select();
  5.   }
  6.   getList1(){
  7.     //SELECT * FROM `think_user` ORDER BY count(num) DESC
  8.     return this.order('count(num) DESC').select();
  9.   }
  10. }
数组
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` ORDER BY id DESC,name ASC
  4.     return this.order(['id DESC', 'name ASC']).select();
  5.   }
  6. }
对象
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` ORDER BY `id` DESC,`name` ASC
  4.     return this.order({
  5.       id: 'DESC',
  6.       name: 'ASC'
  7.     }).select();
  8.   }
  9. }

model.alias(tableAlias)

  • tableAlias {String} 表别名
  • return {this}
    设置表别名。
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM think_user AS a;
  4.     return this.alias('a').select();
  5.   }
  6. }

model.having(having)

  • having {String} having 查询的字符串
  • return {this}
    设置 having 查询。
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` HAVING view_nums > 1000 AND view_nums < 2000
  4.     return this.having('view_nums > 1000 AND view_nums < 2000').select();
  5.   }
  6. }

model.group(group)

  • group {String} 分组查询的字段
  • return {this}
    设定分组查询。
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT * FROM `think_user` GROUP BY `name`
  4.     return this.group('name').select();
  5.   }
  6. }

model.distinct(distinct)

  • distinct {String} 去重的字段
  • return {this}
    去重查询。
  1. export default class extends think.model.base {
  2.   getList(){
  3.     //SELECT DISTINCT `name` FROM `think_user`
  4.     return this.distinct('name').select();
  5.   }
  6. }

model.explain(explain)

  • explain {Boolean} 是否添加 explain 执行
  • return {this}
    是否在 SQL 之前添加 explain 执行，用来查看 SQL 的性能。

model.optionsFilter(options)

操作选项过滤。

model.dataFilter(data)

  • data {Object | Array} 要操作的数据
    数据过滤。

model.beforeAdd(data)

  • data {Object} 要添加的数据
    添加前置操作。

model.afterAdd(data)

  • data {Object} 要添加的数据
    添加后置操作。

model.afterDelete(data)

删除后置操作。

model.beforeUpdate(data)

  • data {Object} 要更新的数据
    更新前置操作。

model.afterUpdate(data)

  • data {Object} 要更新的数据
    更新后置操作。

model.afterFind(data)

  • data {Object} 查询的单条数据
  • return {Object | Promise}
    find 查询后置操作。

model.afterSelect(data)

  • data [Array] 查询的数据数据
  • return {Array | Promise}
    select 查询后置操作。

model.data(data)

  • data {Object}
    添加和更新操作时设置操作的数据。

model.options(options)

  • options {Object}
    设置操作选项。如：
  1. export default class extends think.model.base {
  2.   getList(){
  3.     return this.options({
  4.       where: 'id = 1',
  5.       limit: [10, 1]
  6.     }).select();
  7.   }
  8. }

model.close()

关闭数据库连接，一般情况下不要直接调用。

model.getSchema(table)

  • table {String} 表名
  • return {Promise}
    获取表的字段信息，自动从数据库中读取。

model.getTableFields(table)

已废弃，使用 model.getSchema 方法替代。

model.getLastSql()

  • return {String}
    获取最后执行的 SQL 语句。

model.buildSql()

  • return {Promise}
    将当前的查询条件生成一个 SQL 语句。

model.parseOptions(oriOpts, extraOptions)

  • oriOpts {Object}
  • extraOptions {Object}
  • return {Promise}
    根据已经设定的一些条件解析当前的操作选项。

model.getPk()

  • return {Promise}
    返回 pk 的值，返回一个 Promise。

model.parseType(field, value)

  • field {String} 数据表中的字段名称
  • value {Mixed}
  • return {Mixed}
    根据数据表中的字段类型解析 value。

model.parseData(data)

  • data {Object} 要解析的数据
  • return {Object}
    调用 parseType 方法解析数据。

model.add(data, options, replace)

  • data {Object} 要添加的数据
  • options {Object} 操作选项
  • replace {Boolean} 是否是替换操作
  • return {Promise} 返回插入的 ID
    添加一条数据。

model.thenAdd(data, where)

  • data {Object} 要添加的数据
  • where {Object} where 条件
  • return {Promise}
    当 where 条件未命中到任何数据时才添加数据。

model.addMany(dataList, options, replace)

  • dataList {Array} 要添加的数据列表
  • options {Object} 操作选项
  • replace {Boolean} 是否是替换操作
  • return {Promise} 返回插入的 ID
    一次添加多条数据。

model.delete(options)

  • options {Object} 操作选项
  • return {Promise} 返回影响的行数
    删除数据。

删除 id 为 7 的数据。

  1. model.delete({
  2.   where: {id: 7}
  3. });

model.update(data, options)

  • data {Object} 要更新的数据
  • options {Object} 操作选项
  • return {Promise} 返回影响的行数
    更新数据。

updateMany(dataList, options)

  • dataList {Array} 要更新的数据列表
  • options {Object} 操作选项
  • return {Promise}
    更新多条数据，dataList 里必须包含主键的值，会自动设置为更新条件。

model.increment(field, step)

  • field {String} 字段名
  • step {Number} 增加的值，默认为 1
  • return {Promise}
    字段值增加。

model.decrement(field, step)

  • field {String} 字段名
  • step {Number} 增加的值，默认为 1
  • return {Promise}
    字段值减少。

model.find(options)

  • options {Object} 操作选项
  • return {Promise} 返回单条数据
    查询单条数据，返回的数据类型为对象。如果未查询到相关数据，返回值为 {}。

model.select(options)

  • options {Object} 操作选项
  • return {Promise} 返回多条数据
    查询多条数据，返回的数据类型为数组。如果未查询到相关数据，返回值为 []。

model.countSelect(options, pageFlag)

  • options {Object} 操作选项
  • pageFlag {Boolean} 当页数不合法时处理，true 为修正到第一页，false 为修正到最后一页，默认不修正
  • return {Promise}
    分页查询，一般需要结合 page 方法一起使用。如：
  1. export default class extends think.controller.base {
  2.   async listAction(){
  3.     let model = this.model('user');
  4.     let data = await model.page(this.get('page')).countSelect();
  5.   }
  6. }

返回值数据结构如下：

  1. {
  2.   numsPerPage: 10, //每页显示的条数
  3.   currentPage: 1, //当前页
  4.   count: 100, //总条数
  5.   totalPages: 10, //总页数
  6.   data: [{ //当前页下的数据列表
  7.     name: "thinkjs",
  8.     email: "admin@thinkjs.org"
  9.   }, ...]
  10. }

model.getField(field, one)

  • field {String} 字段名，多个字段用逗号隔开
  • one {Boolean | Number} 获取的条数
  • return {Promise}
    获取特定字段的值。

model.count(field)

  • field {String} 字段名
  • return {Promise} 返回总条数
    获取总条数。

model.sum(field)

  • field {String} 字段名
  • return {Promise}
    对字段值进行求和。

model.min(field)

  • field {String} 字段名
  • return {Promise}
    求字段的最小值。

model.max(field)

  • field {String} 字段名
  • return {Promise}
    求字段的最大值。

model.avg(field)

  • field {String} 字段名
  • return {Promise}
    求字段的平均值。

model.query(…args)

  • return {Promise}
    指定 SQL 语句执行查询。

model.execute(…args)

  • return {Promise}
    执行 SQL 语句。

model.parseSql(sql, …args)

  • sql {String} 要解析的 SQL 语句
  • return {String}
    解析 SQL 语句，调用 util.format 方法解析 SQL 语句，并将 SQL 语句中的 TABLENAME 解析为对应的表名。
  1. export default class extends think.model.base {
  2.   getSql(){
  3.     let sql = 'SELECT * FROM __GROUP__ WHERE id=%d';
  4.     sql = this.parseSql(sql, 10);
  5.     //sql is SELECT * FROM think_group WHERE id=10
  6.   }
  7. }

model.startTrans()

  • return {Promise}
    开启事务。

model.commit()

  • return {Promise}
    提交事务。

model.rollback()

  • return {Promise}
    回滚事务。

model.transaction(fn)

  • fn {Function} 要执行的函数
  • return {Promise}
    使用事务来执行传递的函数，函数要返回 Promise。
  1. export default class extends think.model.base {
  2.   updateData(data){
  3.     return this.transaction(async () => {
  4.       let insertId = await this.add(data);
  5.       let result = await this.model('user_cate').add({user_id: insertId, cate_id: 100});
  6.       return result;
  7.     })
  8.   }
  9. }

原文: https://thinkjs.org/zh-cn/doc/2.2/api_model.html