model · ThinkJs2.0開發手冊

[TOC=2,4] `think.model.base`繼承自?[think.base](https://thinkjs.org/zh-CN/doc/2.0/api_think_base.html)?類。 ##### 使用 ES6 的語法繼承該類 ~~~ export default class extends think.model.base { getList(){ } } ~~~ ##### 使用普通方式繼承該類 ~~~ module.exports = think.model({ getList: function(){ } }) ~~~ ### 屬性 #### model.pk 數據表主鍵，默認為`id`。 #### model.name 模型名，默認從當前文件名中解析。當前文件路徑為 for/bar/app/home/model/user.js，那么解析的模型名為`user`。 #### model.tablePrefix 數據表名稱前綴，默認為`think_`。 #### model.tableName 數據表名稱，不包含前綴。默認等于模型名。 #### model.fields 數據表字段，默認自動從數據表分析。 #### model.indexes 數據表索引，默認自動從數據表分析。 #### model.config 配置，實例化的時候指定。 #### model._db 連接數據庫句柄。 #### model._data 操作的數據。 #### model._options 操作選項。 ### 方法 #### model.model(name, options, module) * `name`?{String} 模型名稱 * `options`?{Object} 配置項 * `module`?{String} 模塊名 * `return`?{Object} 獲取模型實例，可以跨模塊獲取。 ~~~ export default class extends think.model.base { * getList(){ //獲取 user 模型實例 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} 獲取配置對應的 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 和時間 ~~~ export default class extends think.model.base { getList(){ return this.cache("getList", 1000).where({id: {">": 100}}).select(); } } ~~~ ##### 只設置緩存時間，緩存 key 自動生成 ~~~ export default class extends think.model.base { getList(){ return this.cache(1000).where({id: {">": 100}}).select(); } } ~~~ ##### 設置更多的緩存信息 ~~~ 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} 設置查詢的起始位置 * `length`?{Number} 設置查詢的數據長度 * `return`?{this} 設置查詢結果的限制條件。 ##### 限制數據長度 ~~~ export default class extends think.model.base { getList(){ //查詢20條數據 return this.limit(20).where({id: {">": 100}}).select(); } } ~~~ ##### 限制數據起始位置和長度 ~~~ export default class extends think.model.base { getList(){ //從起始位置100開始查詢20調數據 return this.limit(100, 20).where({id: {">": 100}}).select(); } } ~~~ #### model.page(page, listRows) * `page`?{Number} 當前頁，從 1 開始 * `listRows`?{Number} 每頁的條數 * `return`?{this} 設置查詢分頁數據，自動轉化為?`limit`?數據。 ~~~ export default class extends think.model.base { getList(){ //查詢第 2 頁數據，每頁 10 條數據 return this.page(2, 10).where({id: {">": 100}}).select(); } } ~~~ #### model.where(where) * `where`?{String | Object} where 條件 * `return`?{this} 設置 where 查詢條件。可以通過屬性?`_logic`?設置邏輯，默認為?`AND`。可以通過屬性?`_complex`?設置復合查詢。 `注：`?1、以下示例不適合 mongo model，mongo 中設置 where 條件請見 model.mongo 里的 where 條件設定。2、where 條件中的值需要在 Logic 里做數據校驗，否則可能會有漏洞。 ##### 普通條件 ~~~ 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 默認會對字段和值進行轉義，防止安全漏洞。有時候一些特殊的情況不希望被轉義，可以使用 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 多個值 where3(){ //SELECT * FROM `think_user` WHERE ( (`title` LIKE "welefen" OR `title` LIKE "suredy") ) return this.where({title: ["like", ["welefen", "suredy"]]}).select(); } //多個字段或的關系 like 一個值 where4(){ //SELECT * FROM `think_user` WHERE ( (`title` LIKE "%welefen%") OR (`content` LIKE "%welefen%") ) return this.where({"title|content": ["like", "%welefen%"]}).select(); } //多個字段與的關系 Like 一個值 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() } } ~~~ ##### 復合查詢 ~~~ 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} 設置要查詢的字段，可以是字符串，也可以是數組 * `return`?{this} 設置要查詢的字段。 ##### 字符串方式 ~~~ export default class extends think.controller.base { async indexAction(){ let model = this.model("user"); //設置要查詢的字符串，字符串方式，多個用逗號隔開 let data = await model.field("name,title").select(); } } ~~~ ##### 調用 SQL 函數 ~~~ export default class extends think.controller.base { //字段里調用 SQL 函數 async listAction(){ let model = this.model("user"); let data = await model.field("id, INSTR(\"30,35,31,\",id + \",\") as d").select(); } } ~~~ ##### 數組方式 ~~~ export default class extends think.controller.base { async indexAction(){ let model = this.model("user"); //設置要查詢的字符串，數組方式 let data = await model.field(["name","title"]).select(); } } ~~~ #### model.fieldReverse(field) * `field`?{String | Array} 反選字段，即查詢的時候不包含這些字段 * `return`?{this} 設置反選字段，查詢的時候會過濾這些字段，支持字符串和數組 2 種方式。 #### model.table(table, hasPrefix) * `table`?{String} 表名 * `hasPrefix`?{Boolean} 是否已經有了表前綴，如果 table 值含有空格，則不在添加表前綴 * `return`?{this} 設置表名，可以將一個 SQL 語句設置為表名。 ##### 設置當前表名 ~~~ export default class extends think.model.base { getList(){ return this.table("test", true).select(); } } ~~~ ##### SQL 語句作為表名 ~~~ 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} 聯合查詢 SQL 或者表名 * `all`?{Boolean} 是否是 UNION ALL 方式 * `return`?{this} 聯合查詢。 ##### SQL 聯合查詢 ~~~ 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(); } } ~~~ ##### 表名聯合查詢 ~~~ 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} 要組合的查詢語句，默認為?`LEFT JOIN` * `return`?{this} 組合查詢，支持字符串、數組和對象等多種方式。 ##### 字符串 ~~~ 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(); } } ~~~ ##### 數組 ~~~ 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(); } } ~~~ ##### 對象：單個表 ~~~ 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(); } } ~~~ ##### 對象：多次 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() } } ~~~ ##### 對象：多個表 ~~~ 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 個值 as: "c", on: ["id", "id"] }, group_tag: { join: "left", as: "d", on: ["id", "group_id"] } }).select() } } ~~~ ##### 對象：ON 條件含有多個字段 ~~~ 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: { // 多個字段的 ON id: "id", title: "name" } } }).select() } } ~~~ ##### 對象：table 值為 SQL 語句 ~~~ 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} 設置排序方式。 ##### 字符串 ~~~ 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(); } } ~~~ ##### 數組 ~~~ 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(); } } ~~~ ##### 對象 ~~~ 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} 設置表別名。 ~~~ 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} 設置 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} 設定分組查詢。 ~~~ 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 執行 * `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} 設置操作選項。如： ~~~ export default class extends think.model.base { getList(){ return this.options({ where: "id = 1", limit: [10, 1] }).select(); } } ~~~ #### model.close() 關于數據庫連接，一般情況下不要直接調用。 #### model.getTableFields(table) * `table`?{String} 表名 * `return`?{Promise} 獲取表的字段信息，自動從數據庫中讀取。 #### 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} 返回影響的行數刪除數據。 #### 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`?方法一起使用。如： ~~~ export default class extends think.controller.base { async listAction(){ let model = this.model("user"); let data = await model.page(this.get("page")).countSelect(); } } ~~~ 返回值數據結構如下： ~~~ { numsPerPage: 10, //每頁顯示的條數 currentPage: 1, //當前頁 count: 100, //總條數 totalPages: 10, //總頁數 data: [{ //當前頁下的數據列表 name: "thinkjs", email: "admin@thinkjs.org" }, ...] } ~~~ #### 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__`?解析為對應的表名。 ~~~ 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} 開啟事務。 #### model.commit() * `return`?{Promise} 提交事務。 #### model.rollback() * `return`?{Promise} 回滾事務。 #### model.transaction(fn) * `fn`?{Function} 要執行的函數 * `return`?{Promise} 使用事務來執行傳遞的函數，函數要返回 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](https://github.com/75team/www.thinkjs.org/tree/master/view/zh-CN/doc/2.0/api_model.md)