w-orm-lmdb 1.0.12 → 1.0.14

package/src/WOrmLmdb.mjs

@@ -1,765 +1,813 @@
-import { open } from 'lmdb'
-// import mingo from 'mingo' //mingo內未更新import寫法, 會導致ERR_UNSUPPORTED_DIR_IMPORT, 故須改用require引入使用
-import mingo from './reqMingo.js'
-import size from 'lodash-es/size.js'
-import get from 'lodash-es/get.js'
-import each from 'lodash-es/each.js'
-import map from 'lodash-es/map.js'
-import merge from 'lodash-es/merge.js'
-import isEqual from 'lodash-es/isEqual.js'
-import cloneDeep from 'lodash-es/cloneDeep.js'
-import isestr from 'wsemi/src/isestr.mjs'
-import isarr from 'wsemi/src/isarr.mjs'
-import isearr from 'wsemi/src/isearr.mjs'
-import iseobj from 'wsemi/src/iseobj.mjs'
-import isbol from 'wsemi/src/isbol.mjs'
-import haskey from 'wsemi/src/haskey.mjs'
-import evem from 'wsemi/src/evem.mjs'
-import genIDSeq from 'wsemi/src/genIDSeq.mjs'
-import pmSeries from 'wsemi/src/pmSeries.mjs'
-import waitFun from 'wsemi/src/waitFun.mjs'
-
-
-/**
- * 操作資料庫(LMDB)
- *
- * @class
- * @param {Object} [opt={}] 輸入設定物件，預設{}
- * @param {String} [opt.url='_db'] 輸入資料庫用資料夾字串，預設'_db'
- * @param {String} [opt.db='worm'] 輸入使用資料庫名稱字串，預設'worm'
- * @param {String} [opt.cl='test'] 輸入使用資料表名稱字串，預設'test'
- * @param {Boolean} [opt.useCache=false] 輸入是否使用select快取，適用於單程序操作，預設false
- * @returns {Object} 回傳操作資料庫物件，各事件功能詳見說明
- */
-function WOrmLmdb(opt = {}) {
-
-    //_cache
-    let _cache = null
-
-    //url
-    let url = get(opt, 'url')
-    if (!isestr(url)) {
-        url = './_db'
-    }
-
-    //db
-    let db = get(opt, 'db')
-    if (!isestr(db)) {
-        db = 'worm'
-    }
-
-    //cl
-    let cl = get(opt, 'cl')
-    if (!isestr(cl)) {
-        cl = 'test'
-    }
-
-    //useCache
-    let useCache = get(opt, 'useCache')
-    if (!isbol(useCache)) {
-        useCache = false
-    }
-
-    //storage
-    let storage = `${url}/${db}/${cl}`
-    // console.log('storage',storage)
-
-    // client
-    let client = open({
-        path: storage,
-        compression: true,
-        useVersions: true,
-    })
-
-    //ee
-    let ee = evem()
-
-    //getData
-    let getData = async() => {
-
-        //check
-        if (useCache && isarr(_cache)) {
-            return cloneDeep(_cache) //與外部使用數據脫勾
-        }
-
-        //waitOpen
-        await waitOpen()
-        // console.log('client.status',client.status)
-
-        //ltdt
-        let ltdt = []
-        for await (let { value: dt } of client.getRange()) {
-            // console.log('dt',dt)
-            ltdt.push(dt)
-        }
-
-        if (useCache) {
-            _cache = ltdt
-            return cloneDeep(ltdt) //與外部使用數據脫勾
-        }
-        return ltdt
-    }
-
-    //waitOpen, 等待client開啟, 因getRange與get於client關閉時會拋錯
-    let waitOpen = async () => {
-        await waitFun(() => {
-            if (client.status === 'closed') {
-                console.log(`client.status[${client.status}], level is closed`)
-            }
-            return client.status === 'open'
-        })
-    }
-
-    //getValue
-    let getValue = async (key) => {
-        let value = null
-        try {
-            value = await client.get(key)
-        }
-        catch (err) {
-            // if (err.notFound) {
-            //     console.log('資料不存在')
-            // }
-            // else {
-            //     console.log('其他錯誤:', err)
-            // }
-        }
-        return value
-    }
-
-    /**
-     * 查詢數據
-     *
-     * @memberOf WOrmLmdb
-     * @param {Object} [find={}] 輸入查詢條件物件
-     * @returns {Promise} 回傳Promise，resolve回傳數據，reject回傳錯誤訊息
-     */
-    async function select(find = {}) {
-        let isErr = false
-        let res = null
-
-        try {
-
-            //ltdt
-            let ltdt = await getData()
-            // console.log('select ltdt',ltdt)
-
-            //filter
-            if (iseobj(find)) {
-
-                //q
-                let q = new mingo.Query(find)
-                // console.log('q', q)
-
-                //find
-                res = q.find(ltdt).all()
-                // console.log('select(find) ltdt',res)
-
-            }
-            else {
-                res = ltdt
-            }
-
-            //check
-            if (!isarr(res)) {
-                isErr = true
-                res = `can not select by find[${JSON.stringify(find)}]`
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-        // console.log('res', res)
-
-        //check
-        if (isErr) {
-            return Promise.reject(res)
-        }
-
-        return res
-    }
-
-    /**
-     * 由主鍵id查詢單筆數據，因直接由LMDB取值，不需如select提取全表數據再過濾，故數據量大時效能較佳
-     *
-     * @memberOf WOrmLmdb
-     * @param {String} id 輸入主鍵字串
-     * @returns {Promise} 回傳Promise，resolve回傳數據物件，若無此id則回傳null，reject回傳錯誤訊息
-     */
-    async function selectById(id) {
-        let isErr = false
-        let res = null
-
-        try {
-
-            //check
-            if (!isestr(id)) {
-                //未給有效id視為查無數據
-                return null
-            }
-
-            //waitOpen
-            await waitOpen()
-
-            //查找資料表內id
-            let v = await getValue(id) //不會有catch
-
-            //check, 判定基準與insert、save、del內對既有數據之認定一致
-            if (iseobj(v)) {
-                res = v
-            }
-            else {
-                //不存在id, 回傳null
-                res = null
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //check
-        if (isErr) {
-            return Promise.reject(res)
-        }
-
-        return res
-    }
-
-    /**
-     * 插入數據
-     *
-     * @memberOf WOrmLmdb
-     * @param {Object|Array} data 輸入數據物件或陣列
-     * @returns {Promise} 回傳Promise，resolve回傳插入結果，reject回傳錯誤訊息
-     */
-    async function insert(data) {
-        let isErr = false
-
-        //check
-        if (!iseobj(data) && !isearr(data)) {
-            return {
-                n: 0,
-                nInserted: 0,
-                ok: 1,
-            }
-        }
-
-        //cloneDeep, 與外部數據脫勾
-        data = cloneDeep(data)
-
-        //res
-        let res = null
-        try {
-
-            //check
-            if (!isarr(data)) {
-                data = [data]
-            }
-
-            //check id
-            data = map(data, function(v) {
-                if (!isestr(v.id)) {
-                    v.id = genIDSeq()
-                }
-                return v
-            })
-
-            //each
-            //ifNoExists, 由LMDB於同一寫交易內原子完成[檢查v.id未存在]與[寫入], 併發時同一v.id僅有一次成功,
-            //同批含重複v.id時亦僅首筆成功, 故不逐筆await而一次送出, 由LMDB寫執行緒依序處理並合併為批次寫交易
-            //注意: 回調函數須為同步函數, 且client.put須於回調函數內直接呼叫,
-            //若將client.put置於await之後, 該寫入會逸出條件批次而變成無條件寫入, 並使回傳值與實際狀態不一致
-            let nAll = size(data)
-            let ltdone = await Promise.all(map(data, function(v) {
-                // console.log(v)
-                return client.ifNoExists(v.id, () => {
-                    client.put(v.id, v)
-                })
-            }))
-
-            //nPush
-            let nPush = 0
-            each(ltdone, function(done) {
-                if (done) {
-                    //未存在v.id, 已寫入
-                    nPush++
-                }
-                else {
-                    //已存在v.id則不push
-                }
-            })
-
-            //res
-            res = {
-                n: nAll,
-                nInserted: nPush,
-                ok: 1,
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證插入多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'insert', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        //check
-        if (isErr) {
-            return Promise.reject(res)
-        }
-
-        return res
-    }
-
-    /**
-     * 儲存數據
-     *
-     * @memberOf WOrmLmdb
-     * @param {Object|Array} data 輸入數據物件或陣列
-     * @param {Object} [option={}] 輸入設定物件，預設為{}
-     * @param {boolean} [option.autoInsert=true] 輸入是否於儲存時發現原本無數據，則自動改以插入處理，預設為true
-     * @returns {Promise} 回傳Promise，resolve回傳儲存結果，reject回傳錯誤訊息
-     */
-    async function save(data, option = {}) {
-        let isErr = false
-
-        //check
-        if (!iseobj(data) && !isearr(data)) {
-            return []
-        }
-
-        //cloneDeep, 與外部數據脫勾
-        data = cloneDeep(data)
-
-        //autoInsert
-        let autoInsert = get(option, 'autoInsert', true)
-
-        //res
-        let res = null
-        try {
-
-            //check
-            if (!isarr(data)) {
-                data = [data]
-            }
-
-            //check id
-            data = map(data, function(v) {
-                if (!isestr(v.id)) {
-                    v.id = genIDSeq()
-                }
-                return v
-            })
-
-            //pmSeries
-            res = await pmSeries(data, async(v) => {
-
-                //rest
-                let rest = null
-
-                //快速路徑, 先不開寫交易直接預讀, 內容相同者本就不須寫入, 可省去開啟寫交易之成本
-                //預讀值縱使已被其他寫入者更動而過期亦不影響正確性, 因內容相同時本次save等價於無操作,
-                //無操作可視為於預讀當下即已完成, 其後他人之寫入結果與[本次save先執行再輪到他人]相同
-                let vp = await getValue(v.id) //不會有catch
-                if (iseobj(vp) && isEqual(v, vp)) {
-                    //內容相同不更新
-                    return {
-                        n: 0,
-                        nModified: 0,
-                        ok: 1,
-                    }
-                }
-
-                //existed, updated, inserted
-                let existed = false
-                let updated = false
-                let inserted = false
-
-                //transaction, 由LMDB於同一寫交易內原子完成[查找v.id]與[合併寫入],
-                //併發時不會有兩方各自讀到同一舊值再各自寫入而導致遺失更新
-                //注意: 回調函數須為同步函數, client.get於寫交易內為同步取值, 不可使用await,
-                //若將client.get或client.put置於await之後, 該操作會逸出本交易而失去原子性
-                await client.transaction(() => {
-
-                    //查找資料表內v.id
-                    let vv = client.get(v.id)
-
-                    //existed
-                    existed = iseobj(vv)
-
-                    //check
-                    if (existed) {
-                        //已存在v.id
-                        if (isEqual(v, vv)) {
-                            //內容相同不更新
-                        }
-                        else {
-                            //內容不同須更新
-
-                            //merge and put
-                            client.put(v.id, merge(vv, v))
-
-                            updated = true
-                        }
-                    }
-                    else {
-                        //內容不存在, 若autoInsert則須插入
-                        if (autoInsert) {
-
-                            //put
-                            client.put(v.id, v)
-
-                            inserted = true
-                        }
-                    }
-
-                })
-
-                //rest
-                if (inserted) {
-                    //內容不存在而自動插入, 回傳形狀同insert
-                    rest = {
-                        n: 1,
-                        nInserted: 1,
-                        ok: 1,
-                    }
-                }
-                else if (updated) {
-                    rest = {
-                        n: 1,
-                        nModified: 1,
-                        ok: 1,
-                    }
-                }
-                else {
-                    //rest.n === 0:
-                    // 內容相同不更新, 不須update
-                    // 內容不存在且未開啟autoInsert
-                    rest = {
-                        n: 0,
-                        nModified: 0,
-                        ok: 1,
-                    }
-                }
-
-                //emit, 原autoInsert係轉呼叫insert故會發出insert事件, 此處維持既有行為,
-                //須於交易外發出, 避免外部訂閱函數於寫交易內執行
-                if (inserted) {
-
-                    //update, 不能保證插入多少, 一律重設快取
-                    _cache = null
-
-                    try {
-
-                        //emit
-                        ee.emit('change', 'insert', [v], rest)
-
-                    }
-                    catch (err) {
-                        console.log(err)
-                    }
-
-                }
-
-                return rest
-            })
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證變更多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'save', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        //check
-        if (isErr) {
-            return Promise.reject(res)
-        }
-
-        return res
-    }
-
-    /**
-     * 刪除數據
-     *
-     * @memberOf WOrmLmdb
-     * @param {Object|Array} data 輸入數據物件或陣列
-     * @returns {Promise} 回傳Promise，resolve回傳刪除結果，reject回傳錯誤訊息
-     */
-    async function del(data) {
-        let isErr = false
-
-        //check
-        if (!iseobj(data) && !isearr(data)) {
-            return []
-        }
-
-        //cloneDeep, 與外部數據脫勾
-        data = cloneDeep(data)
-
-        //res
-        let res = null
-        try {
-
-            //check
-            if (!isarr(data)) {
-                data = [data]
-            }
-
-            //pmSeries
-            res = await pmSeries(data, async(v) => {
-
-                //rest
-                let rest = null
-
-                //id
-                let id = get(v, 'id', '')
-
-                //check
-                if (isestr(id)) {
-
-                    //查找資料表內v.id
-                    let vv = await getValue(v.id) //不會有catch
-
-                    //check
-                    if (iseobj(vv)) {
-                        //已存在v.id則須刪除
-
-                        //del
-                        await client.del(v.id)
-
-                        //rest
-                        rest = {
-                            n: 1,
-                            nDeleted: 1,
-                            ok: 1,
-                        }
-
-                    }
-                    else {
-                        //不存在v.id則不刪除
-
-                        //rest
-                        rest = {
-                            n: 1,
-                            nDeleted: 0,
-                            ok: 1,
-                        }
-
-                    }
-
-                }
-                else {
-                    //未給v.id則不刪除
-
-                    //rest
-                    rest = {
-                        n: 1,
-                        nDeleted: 0,
-                        ok: 0, //未給v.id視為有問題數據, 故ok給0
-                    }
-
-                }
-
-                return rest
-            })
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證刪除多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'del', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        //check
-        if (isErr) {
-            return Promise.reject(res)
-        }
-
-        return res
-    }
-
-    /**
-     * 刪除全部數據，需與del分開，避免未傳數據導致直接刪除全表
-     *
-     * @memberOf WOrmLmdb
-     * @param {Object} [find={}] 輸入刪除條件物件
-     * @returns {Promise} 回傳Promise，resolve回傳刪除結果，reject回傳錯誤訊息
-     */
-    async function delAll(find = {}) {
-        let isErr = false
-
-        //res
-        let res = null
-        try {
-
-            //ltdt
-            let ltdt = await getData()
-
-            //filter
-            let nAll = size(ltdt)
-            let nDel = 0
-            if (iseobj(find)) {
-
-                //q
-                let q = new mingo.Query(find)
-                // console.log('q', q)
-
-                //find
-                let _res = q.find(ltdt).all()
-                // console.log('_res', _res)
-
-                //nDel
-                nDel = size(_res)
-                // console.log('nDel', nDel)
-
-                if (nDel === 0) {
-                    //未有find結果等於不刪除
-                }
-                else if (nAll === nDel) {
-                    //全在find結果內等於全部刪除
-
-                    //empty
-                    for (let v of ltdt) {
-                        await client.del(v.id)
-                    }
-
-                }
-                else {
-                    //部份在find結果內
-
-                    //_kp
-                    let _kp = {}
-                    each(_res, (v, k) => {
-                        _kp[v.id] = { k, v }
-                    })
-
-                    //del
-                    for (let v of ltdt) {
-                        if (haskey(_kp, v.id)) {
-                            //在find結果內代表須刪除
-                            await client.del(v.id)
-                        }
-                    }
-
-                }
-            }
-            else {
-
-                //nDel
-                nDel = nAll
-
-                //empty
-                for (let v of ltdt) {
-                    await client.del(v.id)
-                }
-
-            }
-
-            //res
-            res = {
-                n: nAll,
-                nDeleted: nDel,
-                ok: 1,
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證刪除多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'delAll', null, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        //check
-        if (isErr) {
-            return Promise.reject(res)
-        }
-
-        return res
-    }
-
-    //close, 關閉內部LMDB env並釋放檔案鎖, close後該實例即報廢, 須重新new WOrmLmdb
-    let close = async () => {
-        if (client && client.status !== 'closed') {
-            await client.close() //lmdb root database之close(), 回傳Promise
-        }
-    }
-
-    //save
-    ee.select = select
-    ee.selectById = selectById
-    ee.insert = insert
-    ee.save = save
-    ee.del = del
-    ee.delAll = delAll
-    ee.close = close
-
-    return ee
-}
-
-
-export default WOrmLmdb
+import { open } from 'lmdb'
+// import mingo from 'mingo' //mingo內未更新import寫法, 會導致ERR_UNSUPPORTED_DIR_IMPORT, 故須改用require引入使用
+import mingo from './reqMingo.js'
+import size from 'lodash-es/size.js'
+import get from 'lodash-es/get.js'
+import each from 'lodash-es/each.js'
+import map from 'lodash-es/map.js'
+import merge from 'lodash-es/merge.js'
+import isEqual from 'lodash-es/isEqual.js'
+import cloneDeep from 'lodash-es/cloneDeep.js'
+import isestr from 'wsemi/src/isestr.mjs'
+import isarr from 'wsemi/src/isarr.mjs'
+import isearr from 'wsemi/src/isearr.mjs'
+import iseobj from 'wsemi/src/iseobj.mjs'
+import isbol from 'wsemi/src/isbol.mjs'
+import haskey from 'wsemi/src/haskey.mjs'
+import evem from 'wsemi/src/evem.mjs'
+import genIDSeq from 'wsemi/src/genIDSeq.mjs'
+import pmSeries from 'wsemi/src/pmSeries.mjs'
+import waitFun from 'wsemi/src/waitFun.mjs'
+
+
+/**
+ * 操作資料庫(LMDB)
+ *
+ * @class
+ * @param {Object} [opt={}] 輸入設定物件，預設{}
+ * @param {String} [opt.url='_db'] 輸入資料庫用資料夾字串，預設'_db'
+ * @param {String} [opt.db='worm'] 輸入使用資料庫名稱字串，預設'worm'
+ * @param {String} [opt.cl='test'] 輸入使用資料表名稱字串，預設'test'
+ * @param {Boolean} [opt.useCache=false] 輸入是否使用select快取，適用於單程序操作，預設false
+ * @returns {Object} 回傳操作資料庫物件，各事件功能詳見說明
+ */
+function WOrmLmdb(opt = {}) {
+
+    //_cache
+    let _cache = null
+
+    //url
+    let url = get(opt, 'url')
+    if (!isestr(url)) {
+        url = './_db'
+    }
+
+    //db
+    let db = get(opt, 'db')
+    if (!isestr(db)) {
+        db = 'worm'
+    }
+
+    //cl
+    let cl = get(opt, 'cl')
+    if (!isestr(cl)) {
+        cl = 'test'
+    }
+
+    //useCache
+    let useCache = get(opt, 'useCache')
+    if (!isbol(useCache)) {
+        useCache = false
+    }
+
+    //storage
+    let storage = `${url}/${db}/${cl}`
+    // console.log('storage',storage)
+
+    // client
+    let client = open({
+        path: storage,
+        compression: true,
+        useVersions: true,
+    })
+
+    //ee
+    let ee = evem()
+
+    //getData
+    let getData = async() => {
+
+        //check
+        if (useCache && isarr(_cache)) {
+            return cloneDeep(_cache) //與外部使用數據脫勾
+        }
+
+        //waitOpen
+        await waitOpen()
+        // console.log('client.status',client.status)
+
+        //ltdt
+        let ltdt = []
+        for await (let { value: dt } of client.getRange()) {
+            // console.log('dt',dt)
+            ltdt.push(dt)
+        }
+
+        if (useCache) {
+            _cache = ltdt
+            return cloneDeep(ltdt) //與外部使用數據脫勾
+        }
+        return ltdt
+    }
+
+    //waitOpen, 等待client開啟, 因getRange與get於client關閉時會拋錯
+    let waitOpen = async () => {
+        await waitFun(() => {
+            if (client.status === 'closed') {
+                console.log(`client.status[${client.status}], level is closed`)
+            }
+            return client.status === 'open'
+        })
+    }
+
+    //getErrMsg, 取錯誤訊息字串, 供逐筆結果之err欄位使用
+    let getErrMsg = (err) => {
+        let m = get(err, 'message')
+        if (isestr(m)) {
+            return m
+        }
+        return String(err)
+    }
+
+    //getValue
+    let getValue = async (key) => {
+        let value = null
+        try {
+            value = await client.get(key)
+        }
+        catch (err) {
+            // if (err.notFound) {
+            //     console.log('資料不存在')
+            // }
+            // else {
+            //     console.log('其他錯誤:', err)
+            // }
+        }
+        return value
+    }
+
+    /**
+     * 查詢數據
+     *
+     * @memberOf WOrmLmdb
+     * @param {Object} [find={}] 輸入查詢條件物件
+     * @returns {Promise} 回傳Promise，resolve回傳數據，reject回傳錯誤訊息
+     */
+    async function select(find = {}) {
+        let isErr = false
+        let res = null
+
+        try {
+
+            //ltdt
+            let ltdt = await getData()
+            // console.log('select ltdt',ltdt)
+
+            //filter
+            if (iseobj(find)) {
+
+                //q
+                let q = new mingo.Query(find)
+                // console.log('q', q)
+
+                //find
+                res = q.find(ltdt).all()
+                // console.log('select(find) ltdt',res)
+
+            }
+            else {
+                res = ltdt
+            }
+
+            //check
+            if (!isarr(res)) {
+                isErr = true
+                res = `can not select by find[${JSON.stringify(find)}]`
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+        // console.log('res', res)
+
+        //check
+        if (isErr) {
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 由主鍵查詢單筆數據，因直接由LMDB取值，不需如select提取全表數據再過濾，故數據量大時效能較佳
+     * 註: 本套件之主鍵欄位固定為id，尚未支援指定其他欄位為主鍵
+     *
+     * @memberOf WOrmLmdb
+     * @param {String} pk 輸入主鍵值字串，本套件之主鍵欄位為id
+     * @returns {Promise} 回傳Promise，resolve回傳數據物件，若無此主鍵則回傳null，reject回傳錯誤訊息
+     */
+    async function selectByPk(pk) {
+        let isErr = false
+        let res = null
+
+        try {
+
+            //check
+            if (!isestr(pk)) {
+                //未給有效主鍵值視為查無數據
+                return null
+            }
+
+            //waitOpen
+            await waitOpen()
+
+            //查找資料表內pk
+            let v = await getValue(pk) //不會有catch
+
+            //check, 判定基準與insert、save、del內對既有數據之認定一致
+            if (iseobj(v)) {
+                res = v
+            }
+            else {
+                //不存在此主鍵, 回傳null
+                res = null
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //check
+        if (isErr) {
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 插入數據
+     *
+     * @memberOf WOrmLmdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @returns {Promise} 回傳Promise，resolve回傳插入結果物件{n,nInserted,ok}，n為輸入筆數、nInserted為實際插入筆數，reject回傳錯誤訊息
+     */
+    async function insert(data) {
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return {
+                n: 0,
+                nInserted: 0,
+                ok: 1,
+            }
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check id
+            data = map(data, function(v) {
+                if (!isestr(v.id)) {
+                    v.id = genIDSeq()
+                }
+                return v
+            })
+
+            //each
+            //ifNoExists, 由LMDB於同一寫交易內原子完成[檢查v.id未存在]與[寫入], 併發時同一v.id僅有一次成功,
+            //同批含重複v.id時亦僅首筆成功, 故不逐筆await而一次送出, 由LMDB寫執行緒依序處理並合併為批次寫交易
+            //注意: 回調函數須為同步函數, 且client.put須於回調函數內直接呼叫,
+            //若將client.put置於await之後, 該寫入會逸出條件批次而變成無條件寫入, 並使回傳值與實際狀態不一致
+            let nAll = size(data)
+            let ltdone = await Promise.all(map(data, function(v) {
+                // console.log(v)
+                return client.ifNoExists(v.id, () => {
+                    client.put(v.id, v)
+                })
+            }))
+
+            //nPush
+            let nPush = 0
+            each(ltdone, function(done) {
+                if (done) {
+                    //未存在v.id, 已寫入
+                    nPush++
+                }
+                else {
+                    //已存在v.id則不push
+                }
+            })
+
+            //res
+            res = {
+                n: nAll,
+                nInserted: nPush,
+                ok: 1,
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證插入多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            try {
+
+                //emit
+                ee.emit('change', 'insert', data, res)
+
+            }
+            catch (err) {
+                console.log(err)
+            }
+        }
+
+        //check
+        if (isErr) {
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 儲存數據
+     *
+     * @memberOf WOrmLmdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @param {Object} [option={}] 輸入設定物件，預設為{}
+     * @param {boolean} [option.autoInsert=true] 輸入是否於儲存時發現原本無數據，則自動改以插入處理，預設為true
+     * @returns {Promise} 回傳Promise，resolve回傳與輸入等長之儲存結果陣列，各筆為{n,nInserted,nModified,ok}，n為主鍵命中筆數，單筆失敗者ok為0並附err，reject回傳錯誤訊息
+     */
+    async function save(data, option = {}) {
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return []
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //autoInsert
+        let autoInsert = get(option, 'autoInsert', true)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check id
+            data = map(data, function(v) {
+                if (!isestr(v.id)) {
+                    v.id = genIDSeq()
+                }
+                return v
+            })
+
+            //pmSeries
+            res = await pmSeries(data, async(v) => {
+
+                //rest
+                let rest = null
+
+                //inserted, 供emit使用
+                let inserted = false
+
+                try {
+
+                    //快速路徑, 先不開寫交易直接預讀, 內容相同者本就不須寫入, 可省去開啟寫交易之成本
+                    //預讀值縱使已被其他寫入者更動而過期亦不影響正確性, 因內容相同時本次save等價於無操作,
+                    //無操作可視為於預讀當下即已完成, 其後他人之寫入結果與[本次save先執行再輪到他人]相同
+                    //註: 預讀僅用於判斷是否略過寫入, 不用於決定寫入內容, 寫入內容一律由交易內讀到之現值決定
+                    let vp = await getValue(v.id) //不會有catch
+                    if (iseobj(vp) && isEqual(merge({}, vp, v), vp)) {
+                        //合併後與現值相同不須寫入, 惟已命中v.id故n為1
+                        return {
+                            n: 1,
+                            nInserted: 0,
+                            nModified: 0,
+                            ok: 1,
+                        }
+                    }
+
+                    //existed, updated
+                    let existed = false
+                    let updated = false
+
+                    //transaction, 由LMDB於同一寫交易內原子完成[查找v.id]與[合併寫入],
+                    //併發時不會有兩方各自讀到同一舊值再各自寫入而導致遺失更新
+                    //注意: 回調函數須為同步函數, client.get於寫交易內為同步取值, 不可使用await,
+                    //若將client.get或client.put置於await之後, 該操作會逸出本交易而失去原子性
+                    await client.transaction(() => {
+
+                        //查找資料表內v.id
+                        let vv = client.get(v.id)
+
+                        //existed
+                        existed = iseobj(vv)
+
+                        //check
+                        if (existed) {
+                            //已存在v.id
+
+                            //vm, 合併後之結果
+                            let vm = merge({}, vv, v)
+
+                            //判定基準為[合併後結果與現值相同], 而非[待寫入物件與現值全等],
+                            //令nModified忠實反映資料庫端是否真的寫入, 僅給部份欄位且值皆相同者不應回報已修改
+                            if (isEqual(vm, vv)) {
+                                //合併後與現值相同不須寫入
+                            }
+                            else {
+                                //合併後與現值不同須更新
+
+                                //put
+                                client.put(v.id, vm)
+
+                                updated = true
+                            }
+                        }
+                        else {
+                            //內容不存在, 若autoInsert則須插入
+                            if (autoInsert) {
+
+                                //put
+                                client.put(v.id, v)
+
+                                inserted = true
+                            }
+                        }
+
+                    })
+
+                    //rest, nInserted與nModified恆存在, 無對應行為者給0
+                    if (inserted) {
+                        rest = {
+                            n: 1,
+                            nInserted: 1,
+                            nModified: 0,
+                            ok: 1,
+                        }
+                    }
+                    else if (updated) {
+                        rest = {
+                            n: 1,
+                            nInserted: 0,
+                            nModified: 1,
+                            ok: 1,
+                        }
+                    }
+                    else {
+                        //未寫入, 有二:
+                        // 已存在v.id而內容相同不更新, 已命中故n為1
+                        // 不存在v.id且未開啟autoInsert, 未命中故n為0
+                        //n為v.id之命中筆數, 與nModified[實際更新筆數]分屬不同語義, 不可混用
+                        rest = {
+                            n: existed ? 1 : 0,
+                            nInserted: 0,
+                            nModified: 0,
+                            ok: 1,
+                        }
+                    }
+
+                }
+                catch (err) {
+
+                    //本筆失敗不中斷整批, 以ok為0並附err回報, 由呼叫端逐筆檢查
+                    rest = {
+                        n: 1,
+                        nInserted: 0,
+                        nModified: 0,
+                        ok: 0,
+                        err: getErrMsg(err),
+                    }
+
+                }
+
+                //emit, 原autoInsert係轉呼叫insert故會發出insert事件, 此處維持既有行為,
+                //須於交易外發出, 避免外部訂閱函數於寫交易內執行
+                if (inserted) {
+
+                    //update, 不能保證插入多少, 一律重設快取
+                    _cache = null
+
+                    try {
+
+                        //emit
+                        ee.emit('change', 'insert', [v], rest)
+
+                    }
+                    catch (err) {
+                        console.log(err)
+                    }
+
+                }
+
+                return rest
+            })
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證變更多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            try {
+
+                //emit
+                ee.emit('change', 'save', data, res)
+
+            }
+            catch (err) {
+                console.log(err)
+            }
+        }
+
+        //check
+        if (isErr) {
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 刪除數據
+     *
+     * @memberOf WOrmLmdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @returns {Promise} 回傳Promise，resolve回傳與輸入等長之刪除結果陣列，各筆為{n,nDeleted,ok}，n為主鍵命中筆數，單筆失敗或未給有效id者ok為0並附err，reject回傳錯誤訊息
+     */
+    async function del(data) {
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return []
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //pmSeries
+            res = await pmSeries(data, async(v) => {
+
+                //rest
+                let rest = null
+
+                try {
+
+                    //id
+                    let id = get(v, 'id', '')
+
+                    //check
+                    if (!isestr(id)) {
+                        //未給有效v.id視為該筆數據有問題而無法處理, 以ok為0並附err回報,
+                        //與[已給v.id但查無數據]之ok為1有別, 二者須可由ok分辨
+                        return {
+                            n: 0,
+                            nDeleted: 0,
+                            ok: 0,
+                            err: `can not delete by invalid id[${id}]`,
+                        }
+                    }
+
+                    //查找資料表內v.id
+                    let vv = await getValue(id) //不會有catch
+
+                    //check
+                    if (iseobj(vv)) {
+                        //已存在v.id則須刪除
+
+                        //del
+                        await client.del(id)
+
+                        //rest
+                        rest = {
+                            n: 1,
+                            nDeleted: 1,
+                            ok: 1,
+                        }
+
+                    }
+                    else {
+                        //不存在v.id則不刪除, 未命中故n為0
+                        rest = {
+                            n: 0,
+                            nDeleted: 0,
+                            ok: 1,
+                        }
+
+                    }
+
+                }
+                catch (err) {
+
+                    //本筆失敗不中斷整批, 以ok為0並附err回報, 由呼叫端逐筆檢查
+                    rest = {
+                        n: 1,
+                        nDeleted: 0,
+                        ok: 0,
+                        err: getErrMsg(err),
+                    }
+
+                }
+
+                return rest
+            })
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證刪除多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            try {
+
+                //emit
+                ee.emit('change', 'del', data, res)
+
+            }
+            catch (err) {
+                console.log(err)
+            }
+        }
+
+        //check
+        if (isErr) {
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 刪除全部數據，需與del分開，避免未傳數據導致直接刪除全表
+     *
+     * @memberOf WOrmLmdb
+     * @param {Object} [find={}] 輸入刪除條件物件
+     * @returns {Promise} 回傳Promise，resolve回傳刪除結果物件{n,nDeleted,ok}，n與nDeleted同為實際刪除筆數，reject回傳錯誤訊息
+     */
+    async function delAll(find = {}) {
+        let isErr = false
+
+        //res
+        let res = null
+        try {
+
+            //ltdt
+            let ltdt = await getData()
+
+            //filter
+            let nAll = size(ltdt)
+            let nDel = 0
+            if (iseobj(find)) {
+
+                //q
+                let q = new mingo.Query(find)
+                // console.log('q', q)
+
+                //find
+                let _res = q.find(ltdt).all()
+                // console.log('_res', _res)
+
+                //nDel
+                nDel = size(_res)
+                // console.log('nDel', nDel)
+
+                if (nDel === 0) {
+                    //未有find結果等於不刪除
+                }
+                else if (nAll === nDel) {
+                    //全在find結果內等於全部刪除
+
+                    //empty
+                    for (let v of ltdt) {
+                        await client.del(v.id)
+                    }
+
+                }
+                else {
+                    //部份在find結果內
+
+                    //_kp
+                    let _kp = {}
+                    each(_res, (v, k) => {
+                        _kp[v.id] = { k, v }
+                    })
+
+                    //del
+                    for (let v of ltdt) {
+                        if (haskey(_kp, v.id)) {
+                            //在find結果內代表須刪除
+                            await client.del(v.id)
+                        }
+                    }
+
+                }
+            }
+            else {
+
+                //nDel
+                nDel = nAll
+
+                //empty
+                for (let v of ltdt) {
+                    await client.del(v.id)
+                }
+
+            }
+
+            //res, n為實際刪除筆數而非全表筆數, 故與nDeleted同值
+            res = {
+                n: nDel,
+                nDeleted: nDel,
+                ok: 1,
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證刪除多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            try {
+
+                //emit
+                ee.emit('change', 'delAll', null, res)
+
+            }
+            catch (err) {
+                console.log(err)
+            }
+        }
+
+        //check
+        if (isErr) {
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    //close, 關閉內部LMDB env並釋放檔案鎖, close後該實例即報廢, 須重新new WOrmLmdb
+    let close = async () => {
+        if (client && client.status !== 'closed') {
+            await client.close() //lmdb root database之close(), 回傳Promise
+        }
+    }
+
+    //save
+    ee.select = select
+    ee.selectByPk = selectByPk
+    ee.insert = insert
+    ee.save = save
+    ee.del = del
+    ee.delAll = delAll
+    ee.close = close
+
+    return ee
+}
+
+
+export default WOrmLmdb