閱讀(23.4k) 書簽贊(0) 我要糾錯(cuò)

model（模型）

2021-09-17 14:32 更新

屬性

think.model.base繼承自 think.base 類。

使用 ES6 的語(yǔ)法繼承該類

export default class extends think.model.base {
  getList(){

  }
}

使用普通方式繼承該類

module.exports = think.model({
  getList: function(){

  }
})

屬性

model.pk

數(shù)據(jù)表主鍵，默認(rèn)為id。

model.name

模型名，默認(rèn)從當(dāng)前文件名中解析。

當(dāng)前文件路徑為 for/bar/app/home/model/user.js，那么解析的模型名為user。

model.tablePrefix

數(shù)據(jù)表名稱前綴，默認(rèn)為think_。

model.tableName

數(shù)據(jù)表名稱，不包含前綴。默認(rèn)等于模型名。

model.fields

數(shù)據(jù)表字段，默認(rèn)自動(dòng)從數(shù)據(jù)表分析。

model.indexes

數(shù)據(jù)表索引，默認(rèn)自動(dòng)從數(shù)據(jù)表分析。

model.config

配置，實(shí)例化的時(shí)候指定。

model._db

連接數(shù)據(jù)庫(kù)句柄。

model._data

操作的數(shù)據(jù)。

model._options

操作選項(xiàng)。

方法

model.model(name, options, module)

name {String} 模型名稱
options {Object} 配置項(xiàng)
module {String} 模塊名
return {Object}

獲取模型實(shí)例，可以跨模塊獲取。

export default class extends think.model.base {
  * getList(){
    //獲取 user 模型實(shí)例
    let instance = this.model("user");
    let list = yield instance.select();
    let ids = list.map(item => {
      return item.id;
    });
    let data = yield this.where({id: ["IN", ids]}).select();
    return data;
  }
}

model.getTablePrefix()

return {string}

獲取表名前綴。

model.getConfigKey()

return {String}

獲取配置對(duì)應(yīng)的 key，緩存 db 句柄時(shí)使用。

model.db()

return {Object}

根據(jù)當(dāng)前的配置獲取 db 實(shí)例，如果已經(jīng)存在則直接返回。

model.getModelName()

return {String} 模型名稱

如果已經(jīng)配置則直接返回，否則解析當(dāng)前的文件名。

model.getTableName()

return {String} 獲取表名，包含表前綴

獲取表名，包含表前綴。

model.cache(key, timeout)

key {String} 緩存 key
timeout {Number} 緩存有效時(shí)間，單位為秒
return {this}

設(shè)置緩存選項(xiàng)。

設(shè)置緩存 key 和時(shí)間

export default class extends think.model.base {
  getList(){
    return this.cache("getList", 1000).where({id: {">": 100}}).select();
  }
}

只設(shè)置緩存時(shí)間，緩存 key 自動(dòng)生成

export default class extends think.model.base {
  getList(){
    return this.cache(1000).where({id: {">": 100}}).select();
  }
}

設(shè)置更多的緩存信息

export default class extends think.model.base {
  getList(){
    return this.cache({
      key: "getList",
      timeout: 1000,
      type: "file" //使用文件方式緩存
    }).where({id: {">": 100}}).select();
  }
}

model.limit(offset, length)

offset {Number} 設(shè)置查詢的起始位置
length {Number} 設(shè)置查詢的數(shù)據(jù)長(zhǎng)度
return {this}

設(shè)置查詢結(jié)果的限制條件。

限制數(shù)據(jù)長(zhǎng)度

export default class extends think.model.base {
  getList(){
    //查詢20條數(shù)據(jù)
    return this.limit(20).where({id: {">": 100}}).select();
  }
}

限制數(shù)據(jù)起始位置和長(zhǎng)度

export default class extends think.model.base {
  getList(){
    //從起始位置100開始查詢20調(diào)數(shù)據(jù)
    return this.limit(100, 20).where({id: {">": 100}}).select();
  }
}

model.page(page, listRows)

page {Number} 當(dāng)前頁(yè)，從 1 開始
listRows {Number} 每頁(yè)的條數(shù)
return {this}

設(shè)置查詢分頁(yè)數(shù)據(jù)，自動(dòng)轉(zhuǎn)化為 limit 數(shù)據(jù)。

export default class extends think.model.base {
  getList(){
    //查詢第 2 頁(yè)數(shù)據(jù)，每頁(yè) 10 條數(shù)據(jù)
    return this.page(2, 10).where({id: {">": 100}}).select();
  }
}

model.where(where)

where {String | Object} where 條件
return {this}

設(shè)置 where 查詢條件?？梢酝ㄟ^屬性 _logic 設(shè)置邏輯，默認(rèn)為 AND?？梢酝ㄟ^屬性 _complex 設(shè)置復(fù)合查詢。

注： 1、以下示例不適合 mongo model，mongo 中設(shè)置 where 條件請(qǐng)見 model.mongo 里的 where 條件設(shè)定。2、where 條件中的值需要在 Logic 里做數(shù)據(jù)校驗(yàn)，否則可能會(huì)有漏洞。

普通條件

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user`
    return this.where().select();
  }
  where2(){
    //SELECT * FROM `think_user` WHERE ( `id` = 10 )
    return this.where({id: 10}).select();
  }
  where3(){
    //SELECT * FROM `think_user` WHERE ( id = 10 OR id < 2 )
    return this.where("id = 10 OR id < 2").select();
  }
  where4(){
    //SELECT * FROM `think_user` WHERE ( `id` != 10 )
    return this.where({id: ["!=", 10]}).select();
  }
}

null 條件

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user` where ( title IS NULL );
    return this.where({title: null}).select();
  }
  where2(){
    //SELECT * FROM `think_user` where ( title IS NOT NULL );
    return this.where({title: ["!=", null]}).select();
  }
}

EXP 條件

ThinkJS 默認(rèn)會(huì)對(duì)字段和值進(jìn)行轉(zhuǎn)義，防止安全漏洞。有時(shí)候一些特殊的情況不希望被轉(zhuǎn)義，可以使用 EXP 的方式，如：

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE ( (`name` ="name") )
    return this.where({name: ["EXP", "=\"name\""]}).select();
  }
}

LIKE 條件

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE ( `title` NOT LIKE "welefen" )
    return this.where({title: ["NOTLIKE", "welefen"]}).select();
  }
  where2(){
    //SELECT * FROM `think_user` WHERE ( `title` LIKE "%welefen%" )
    return this.where({title: ["like", "%welefen%"]}).select();
  }
  //like 多個(gè)值
  where3(){
    //SELECT * FROM `think_user` WHERE ( (`title` LIKE "welefen" OR `title` LIKE "suredy") )
    return this.where({title: ["like", ["welefen", "suredy"]]}).select();
  }
  //多個(gè)字段或的關(guān)系 like 一個(gè)值
  where4(){
    //SELECT * FROM `think_user` WHERE ( (`title` LIKE "%welefen%") OR (`content` LIKE "%welefen%") )
    return this.where({"title|content": ["like", "%welefen%"]}).select();
  }
  //多個(gè)字段與的關(guān)系 Like 一個(gè)值
  where5(){
    //SELECT * FROM `think_user` WHERE ( (`title` LIKE "%welefen%") AND (`content` LIKE "%welefen%") )
    return this.where({"title&content": ["like", "%welefen%"]}).select();
  }
}

IN 條件

export default class extens think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE ( `id` IN ("10","20") )
    return this.where({id: ["IN", "10,20"]}).select();
  }
  where2(){
    //SELECT * FROM `think_user` WHERE ( `id` IN (10,20) )
    return this.where({id: ["IN", [10, 20]]}).select();
  }
  where3(){
    //SELECT * FROM `think_user` WHERE ( `id` NOT IN (10,20) )
    return this.where({id: ["NOTIN", [10, 20]]}).select();
  }
}

BETWEEN 查詢

export default class extens think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE (  (`id` BETWEEN 1 AND 2) )
    return this.where({id: ["BETWEEN", 1, 2]}).select();
  }
  where2(){
    //SELECT * FROM `think_user` WHERE (  (`id` BETWEEN "1" AND "2") )
    return this.where({id: ["between", "1,2"]}).select();
  }
}

多字段查詢

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE ( `id` = 10 ) AND ( `title` = "www" )
    return this.where({id: 10, title: "www"}).select();
  }
  //修改邏輯為 OR
  where2(){
    //SELECT * FROM `think_user` WHERE ( `id` = 10 ) OR ( `title` = "www" )
    return this.where({id: 10, title: "www", _logic: "OR"}).select();
  }
  //修改邏輯為 XOR
  where2(){
    //SELECT * FROM `think_user` WHERE ( `id` = 10 ) XOR ( `title` = "www" )
    return this.where({id: 10, title: "www", _logic: "XOR"}).select();
  }
}

多條件查詢

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE ( `id` > 10 AND `id` < 20 )
    return this.where({id: {">": 10, "<": 20}}).select();
  }
  //修改邏輯為 OR 
  where2(){
    //SELECT * FROM `think_user` WHERE ( `id` < 10 OR `id` > 20 )
    return this.where({id: {"<": 10, ">": 20, _logic: "OR"}}).select()
  }
}

復(fù)合查詢

export default class extends think.model.base {
  where1(){
    //SELECT * FROM `think_user` WHERE ( `title` = "test" ) AND (  ( `id` IN (1,2,3) ) OR ( `content` = "www" ) )
    return this.where({
      title: "test",
      _complex: {id: ["IN", [1, 2, 3]],
        content: "www",
        _logic: "or"
      }
    }).select()
  }
}

model.field(field)

field {String | Array} 設(shè)置要查詢的字段，可以是字符串，也可以是數(shù)組
return {this}

設(shè)置要查詢的字段。

字符串方式

export default class extends think.controller.base {
  async indexAction(){
    let model = this.model("user");
    //設(shè)置要查詢的字符串，字符串方式，多個(gè)用逗號(hào)隔開
    let data = await model.field("name,title").select();
  }
}

調(diào)用 SQL 函數(shù)

export default class extends think.controller.base {
  //字段里調(diào)用 SQL 函數(shù)
  async listAction(){
    let model = this.model("user");
    let data = await model.field("id, INSTR(\"30,35,31,\",id + \",\") as d").select();
  }
}

數(shù)組方式

export default class extends think.controller.base {
  async indexAction(){
    let model = this.model("user");
    //設(shè)置要查詢的字符串，數(shù)組方式
    let data = await model.field(["name","title"]).select();
  }
}

model.fieldReverse(field)

field {String | Array} 反選字段，即查詢的時(shí)候不包含這些字段
return {this}

設(shè)置反選字段，查詢的時(shí)候會(huì)過濾這些字段，支持字符串和數(shù)組 2 種方式。

model.table(table, hasPrefix)

table {String} 表名
hasPrefix {Boolean} 是否已經(jīng)有了表前綴，如果 table 值含有空格，則不在添加表前綴
return {this}

設(shè)置表名，可以將一個(gè) SQL 語(yǔ)句設(shè)置為表名。

設(shè)置當(dāng)前表名

export default class extends think.model.base {
  getList(){
    return this.table("test", true).select();
  }
}

SQL 語(yǔ)句作為表名

export default class extends think.model.base {
  async getList(){
    let sql = await this.model("group").group("name").buildSql();
    let data = await this.table(sql).select();
    return data;
  }
}

model.union(union, all)

union {String | Object} 聯(lián)合查詢 SQL 或者表名
all {Boolean} 是否是 UNION ALL 方式
return {this}

聯(lián)合查詢。

SQL 聯(lián)合查詢

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` UNION (SELECT * FROM think_pic2)
    return this.union("SELECT * FROM think_pic2").select();
  }
}

表名聯(lián)合查詢

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` UNION ALL (SELECT * FROM `think_pic2`)
    return this.union({table: "think_pic2"}, true).select();
  }
}

model.join(join)

join {String | Object | Array} 要組合的查詢語(yǔ)句，默認(rèn)為 LEFT JOIN
return {this}

組合查詢，支持字符串、數(shù)組和對(duì)象等多種方式。

字符串

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` LEFT JOIN think_cate ON think_group.cate_id=think_cate.id
    return this.join("think_cate ON think_group.cate_id=think_cate.id").select();
  }
}

數(shù)組

export default class extends think.model.base {
  getList(){
    //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
    return this.join([
      "think_cate ON think_group.cate_id=think_cate.id", 
      "RIGHT JOIN think_tag ON think_group.tag_id=think_tag.id"
    ]).select();
  }
}

對(duì)象：?jiǎn)蝹€(gè)表

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` INNER JOIN `think_cate` AS c ON think_user.`cate_id`=c.`id`
    return this.join({
      table: "cate", 
      join: "inner", //join 方式，有 left, right, inner 3 種方式
      as: "c", // 表別名
      on: ["cate_id", "id"] //ON 條件
    }).select();
  }
}

對(duì)象：多次 JOIN

export default class extends think.model.base {
  getList(){
    //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`
    return this.alias("a").join({
      table: "cate",
      join: "left",
      as: "c",
      on: ["cate_id", "id"]
    }).join({
      table: "group_tag",
      join: "left",
      as: "d",
      on: ["id", "group_id"]
    }).select()
  }
}

對(duì)象：多個(gè)表

export default class extends think.model.base {
  getList(){
    //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`
    return this.join({
      cate: {
        on: ["id", "id"]
      },
      group_tag: {
        on: ["id", "group_id"]
      }
    }).select();
  }
}

export default class extends think.model.base {
  getList(){
    //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`
    return this.alias("a").join({
      cate: {
        join: "left", // 有 left,right,inner 3 個(gè)值
        as: "c",
        on: ["id", "id"]
      },
      group_tag: {
        join: "left",
        as: "d",
        on: ["id", "group_id"]
      }
    }).select()
  }
}

對(duì)象：ON 條件含有多個(gè)字段

export default class extends think.model.base {
  getList(){
    //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`)
    return this.join({
      cate: {on: "id, id"},
      group_tag: {on: ["id", "group_id"]},
      tag: {
        on: { // 多個(gè)字段的 ON
          id: "id",
          title: "name"
        }
      }
    }).select()
  }
}

對(duì)象：table 值為 SQL 語(yǔ)句

export default class extends think.model.base {
  async getList(){
    let sql = await this.model("group").buildSql();
    //SELECT * FROM `think_user` LEFT JOIN ( SELECT * FROM `think_group` ) ON think_user.`gid`=( SELECT * FROM `think_group` ).`id`
    return this.join({
      table: sql,
      on: ["gid", "id"]
    }).select();
  }
}

model.order(order)

order {String | Array | Object} 排序方式
return {this}

設(shè)置排序方式。

字符串

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` ORDER BY id DESC, name ASC
    return this.order("id DESC, name ASC").select();
  }
  getList1(){
    //SELECT * FROM `think_user` ORDER BY count(num) DESC
    return this.order("count(num) DESC").select();
  }
}

數(shù)組

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` ORDER BY id DESC,name ASC
    return this.order(["id DESC", "name ASC"]).select();
  }
}

對(duì)象

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` ORDER BY `id` DESC,`name` ASC
    return this.order({
      id: "DESC",
      name: "ASC"
    }).select();
  }
}

model.alias(tableAlias)

tableAlias {String} 表別名
return {this}

設(shè)置表別名。

export default class extends think.model.base {
  getList(){
    //SELECT * FROM think_user AS a;
    return this.alias("a").select();
  }
}

model.having(having)

having {String} having 查詢的字符串
return {this}

設(shè)置 having 查詢。

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` HAVING view_nums > 1000 AND view_nums < 2000
    return this.having("view_nums > 1000 AND view_nums < 2000").select();
  }
}

model.group(group)

group {String} 分組查詢的字段
return {this}

設(shè)定分組查詢。

export default class extends think.model.base {
  getList(){
    //SELECT * FROM `think_user` GROUP BY `name`
    return this.group("name").select();
  }
}

model.distinct(distinct)

distinct {String} 去重的字段
return {this}

去重查詢。

export default class extends think.model.base {
  getList(){
    //SELECT DISTINCT `name` FROM `think_user`
    return this.distinct("name").select();
  }
}

model.explain(explain)

explain {Boolean} 是否添加 explain 執(zhí)行
return {this}

是否在 SQL 之前添加 explain 執(zhí)行，用來查看 SQL 的性能。

model.optionsFilter(options)

操作選項(xiàng)過濾。

model.dataFilter(data)

data {Object | Array} 要操作的數(shù)據(jù)

數(shù)據(jù)過濾。

model.beforeAdd(data)

data {Object} 要添加的數(shù)據(jù)

添加前置操作。

model.afterAdd(data)

data {Object} 要添加的數(shù)據(jù)

添加后置操作。

model.afterDelete(data)

刪除后置操作。

model.beforeUpdate(data)

data {Object} 要更新的數(shù)據(jù)

更新前置操作。

model.afterUpdate(data)

data {Object} 要更新的數(shù)據(jù)

更新后置操作。

model.afterFind(data)

data {Object} 查詢的單條數(shù)據(jù)
return {Object | Promise}

find 查詢后置操作。

model.afterSelect(data)

data [Array] 查詢的數(shù)據(jù)數(shù)據(jù)
return {Array | Promise}

select 查詢后置操作。

model.data(data)

data {Object}

添加和更新操作時(shí)設(shè)置操作的數(shù)據(jù)。

model.options(options)

options {Object}

設(shè)置操作選項(xiàng)。如：

export default class extends think.model.base {
  getList(){
    return this.options({
      where: "id = 1",
      limit: [10, 1]
    }).select();
  }
}

model.close()

關(guān)于數(shù)據(jù)庫(kù)連接，一般情況下不要直接調(diào)用。

model.getTableFields(table)

table {String} 表名
return {Promise}

獲取表的字段信息，自動(dòng)從數(shù)據(jù)庫(kù)中讀取。

model.getLastSql()

return {String}

獲取最后執(zhí)行的 SQL 語(yǔ)句。

model.buildSql()

return {Promise}

將當(dāng)前的查詢條件生成一個(gè) SQL 語(yǔ)句。

model.parseOptions(oriOpts, extraOptions)

oriOpts {Object}
extraOptions {Object}
return {Promise}

根據(jù)已經(jīng)設(shè)定的一些條件解析當(dāng)前的操作選項(xiàng)。

model.getPk()

return {Promise}

返回 pk 的值，返回一個(gè) Promise。

model.parseType(field, value)

field {String} 數(shù)據(jù)表中的字段名稱
value {Mixed}
return {Mixed}

根據(jù)數(shù)據(jù)表中的字段類型解析 value。

model.parseData(data)

data {Object} 要解析的數(shù)據(jù)
return {Object}

調(diào)用 parseType 方法解析數(shù)據(jù)。

model.add(data, options, replace)

data {Object} 要添加的數(shù)據(jù)
options {Object} 操作選項(xiàng)
replace {Boolean} 是否是替換操作
return {Promise} 返回插入的 ID

添加一條數(shù)據(jù)。

model.thenAdd(data, where)

data {Object} 要添加的數(shù)據(jù)
where {Object} where 條件
return {Promise}

當(dāng) where 條件未命中到任何數(shù)據(jù)時(shí)才添加數(shù)據(jù)。

model.addMany(dataList, options, replace)

dataList {Array} 要添加的數(shù)據(jù)列表
options {Object} 操作選項(xiàng)
replace {Boolean} 是否是替換操作
return {Promise} 返回插入的 ID

一次添加多條數(shù)據(jù)。

model.delete(options)

options {Object} 操作選項(xiàng)
return {Promise} 返回影響的行數(shù)

刪除數(shù)據(jù)。

model.update(data, options)

data {Object} 要更新的數(shù)據(jù)
options {Object} 操作選項(xiàng)
return {Promise} 返回影響的行數(shù)

更新數(shù)據(jù)。

updateMany(dataList, options)

dataList {Array} 要更新的數(shù)據(jù)列表
options {Object} 操作選項(xiàng)
return {Promise}

更新多條數(shù)據(jù)，dataList 里必須包含主鍵的值，會(huì)自動(dòng)設(shè)置為更新條件。

model.increment(field, step)

field {String} 字段名
step {Number} 增加的值，默認(rèn)為 1
return {Promise}

字段值增加。

model.decrement(field, step)

field {String} 字段名
step {Number} 增加的值，默認(rèn)為 1
return {Promise}

字段值減少。

model.find(options)

options {Object} 操作選項(xiàng)
return {Promise} 返回單條數(shù)據(jù)

查詢單條數(shù)據(jù)，返回的數(shù)據(jù)類型為對(duì)象。如果未查詢到相關(guān)數(shù)據(jù)，返回值為 {}。

model.select(options)

options {Object} 操作選項(xiàng)
return {Promise} 返回多條數(shù)據(jù)

查詢單條數(shù)據(jù)，返回的數(shù)據(jù)類型為數(shù)組。如果未查詢到相關(guān)數(shù)據(jù)，返回值為 []。

model.countSelect(options, pageFlag)

options {Object} 操作選項(xiàng)
pageFlag {Boolean} 當(dāng)頁(yè)數(shù)不合法時(shí)處理，true 為修正到第一頁(yè)，false 為修正到最后一頁(yè)，默認(rèn)不修正
return {Promise}

分頁(yè)查詢，一般需要結(jié)合 page 方法一起使用。如：

export default class extends think.controller.base {
  async listAction(){
    let model = this.model("user");
    let data = await model.page(this.get("page")).countSelect();
  }
}

返回值數(shù)據(jù)結(jié)構(gòu)如下：

{
  numsPerPage: 10, //每頁(yè)顯示的條數(shù)
  currentPage: 1, //當(dāng)前頁(yè)
  count: 100, //總條數(shù)
  totalPages: 10, //總頁(yè)數(shù)
  data: [{ //當(dāng)前頁(yè)下的數(shù)據(jù)列表
    name: "thinkjs",
    email: "admin@thinkjs.org"
  }, ...]
}

model.getField(field, one)

field {String} 字段名，多個(gè)字段用逗號(hào)隔開
one {Boolean | Number} 獲取的條數(shù)
return {Promise}

獲取特定字段的值。

model.count(field)

field {String} 字段名
return {Promise} 返回總條數(shù)

獲取總條數(shù)。

model.sum(field)

field {String} 字段名
return {Promise}

對(duì)字段值進(jìn)行求和。

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 語(yǔ)句執(zhí)行查詢。

model.execute(...args)

return {Promise}

執(zhí)行 SQL 語(yǔ)句。

model.parseSql(sql, ...args)

sql {String} 要解析的 SQL 語(yǔ)句
return {String}

解析 SQL 語(yǔ)句，調(diào)用 util.format 方法解析 SQL 語(yǔ)句，并將 SQL 語(yǔ)句中的 __TABLENAME__ 解析為對(duì)應(yīng)的表名。

export default class extends think.model.base {
  getSql(){
    let sql = "SELECT * FROM __GROUP__ WHERE id=%d";
    sql = this.parseSql(sql, 10);
    //sql is SELECT * FROM think_group WHERE id=10
  }
}

model.startTrans()

return {Promise}

開啟事務(wù)。

model.commit()

return {Promise}

提交事務(wù)。

model.rollback()

return {Promise}

回滾事務(wù)。

model.transaction(fn)

fn {Function} 要執(zhí)行的函數(shù)
return {Promise}

使用事務(wù)來執(zhí)行傳遞的函數(shù)，函數(shù)要返回 Promise。

export default class extends think.model.base {
  updateData(data){
    return this.transaction(async () => {
      let insertId = await this.add(data);
      let result = await this.model("user_cate").add({user_id: insertId, cate_id: 100});
      return result;
    })
  }
}

文檔地址：https://github.com/75team/www.thinkjs.org/tree/master/view/zh-CN/doc/2.0/api_model.md

以上內(nèi)容是否對(duì)您有幫助：

← rest controller（Rest 接口處理）

model.mongo（Mongo數(shù)據(jù)庫(kù)模型） →

寫筆記

我要補(bǔ)充

model（模型）

使用 ES6 的語(yǔ)法繼承該類

使用普通方式繼承該類

屬性

model.pk

model.name

model.tablePrefix

model.tableName

model.fields

model.indexes

model.config

model._db

model._data

model._options

方法

model.model(name, options, module)

model.getTablePrefix()

model.getConfigKey()

model.db()

model.getModelName()

model.getTableName()

model.cache(key, timeout)

設(shè)置緩存 key 和時(shí)間

只設(shè)置緩存時(shí)間，緩存 key 自動(dòng)生成

設(shè)置更多的緩存信息

model.limit(offset, length)

限制數(shù)據(jù)長(zhǎng)度

限制數(shù)據(jù)起始位置和長(zhǎng)度

model.page(page, listRows)

model.where(where)

普通條件

null 條件

EXP 條件

LIKE 條件

IN 條件

BETWEEN 查詢

多字段查詢

多條件查詢

復(fù)合查詢

model.field(field)

字符串方式

調(diào)用 SQL 函數(shù)

數(shù)組方式

model.fieldReverse(field)

model.table(table, hasPrefix)

設(shè)置當(dāng)前表名

SQL 語(yǔ)句作為表名

model.union(union, all)

SQL 聯(lián)合查詢

表名聯(lián)合查詢

model.join(join)

字符串

數(shù)組

對(duì)象：?jiǎn)蝹€(gè)表

對(duì)象：多次 JOIN

對(duì)象：多個(gè)表

對(duì)象：ON 條件含有多個(gè)字段

對(duì)象：table 值為 SQL 語(yǔ)句

model.order(order)

字符串

數(shù)組

對(duì)象

model.alias(tableAlias)

model.having(having)

model.group(group)

model.distinct(distinct)

model.explain(explain)

model.optionsFilter(options)

model.dataFilter(data)

model.beforeAdd(data)

model.afterAdd(data)

model.afterDelete(data)

model.beforeUpdate(data)

model.afterUpdate(data)

model.afterFind(data)

model.afterSelect(data)

model.data(data)

model.options(options)

model.close()

model.getTableFields(table)

只設(shè)置緩存時(shí)間，緩存 key 自動(dòng)生成