w-orm-postgresql 1.0.11 → 1.0.12

package/g-basic.mjs

@@ -110,6 +110,19 @@ let rsa = [
     },
 ]
 
+let rsb = [
+    {
+        time: '2025-01-01T00:20:00Z',
+        name: 'bulk-1',
+        value: 201,
+    },
+    {
+        time: '2025-01-01T00:21:00Z',
+        name: 'bulk-2',
+        value: 202,
+    },
+]
+
 async function test() {
 
     //wo
@@ -132,6 +145,9 @@ async function test() {
     wo.on('change', function(mode, data, res) {
         console.log('change', mode)
     })
+    wo.on('error', function(mode, data, err) {
+        console.log('error', mode, err)
+    })
 
     //delAll
     await wo.delAll()
@@ -151,6 +167,24 @@ async function test() {
             console.log('insert catch', msg)
         })
 
+    //insertBulk, 全批視為一個單位, 全部插入成功或一筆都不寫入
+    await wo.insertBulk(rsb)
+        .then(function(msg) {
+            console.log('insertBulk then', msg)
+        })
+        .catch(function(msg) {
+            console.log('insertBulk catch', msg)
+        })
+
+    //insertBulk by pk existed, 任一筆之主鍵已存在即整批reject且不寫入任何一筆
+    await wo.insertBulk(rsb)
+        .then(function(msg) {
+            console.log('insertBulk by pk existed then', msg)
+        })
+        .catch(function(msg) {
+            console.log('insertBulk by pk existed catch', `${msg}`) //reject回傳Error物件, 以樣板字串取其訊息以免印出堆疊
+        })
+
     //save
     await wo.save(rsm, { autoInsert: false })
         .then(function(msg) {
@@ -213,6 +247,15 @@ async function test() {
             console.log('del catch', msg)
         })
 
+    //del by data without pk, 該筆無法處理故ok為0並附err, 整批仍resolve且另發出error事件
+    await wo.del({ name: 'no-pk' })
+        .then(function(msg) {
+            console.log('del by data without pk then', msg)
+        })
+        .catch(function(msg) {
+            console.log('del by data without pk catch', msg)
+        })
+
     //del
     let ssDel = await wo.select()
     let ds = ssDel.filter(function(v) {
@@ -298,6 +341,10 @@ test()
 // delAll then { n: 0, nDeleted: 0, ok: 1 }
 // change insert
 // insert then { n: 13, nInserted: 13, ok: 1 }
+// change insertBulk
+// insertBulk then { n: 2, nInserted: 2, ok: 1 }
+// error insertBulk duplicate key value violates unique constraint "users_pkey"
+// insertBulk by pk existed catch error: duplicate key value violates unique constraint "users_pkey"
 // change save
 // save then [
 //   { n: 1, nInserted: 0, nModified: 0, ok: 1 },
@@ -317,6 +364,8 @@ test()
 //   { time: 2025-01-01T00:07:00.000Z, name: 'rosemary', value: 124.76 },
 //   { time: 2025-01-01T00:08:00.000Z, name: 'kettle', value: 524 },
 //   { time: 2025-01-01T00:09:00.000Z, name: 'peter', value: 127 },
+//   { time: 2025-01-01T00:20:00.000Z, name: 'bulk-1', value: 201 },
+//   { time: 2025-01-01T00:21:00.000Z, name: 'bulk-2', value: 202 },
 //   {
 //     time: 2025-01-01T00:10:00.000Z,
 //     name: 'rosemary(modify)',
@@ -352,6 +401,8 @@ test()
 //   { time: 2025-01-01T00:03:00.000Z, name: 'peter', value: 200 },
 //   { time: 2025-01-01T00:05:00.000Z, name: 'kettle', value: 488 },
 //   { time: 2025-01-01T00:08:00.000Z, name: 'kettle', value: 524 },
+//   { time: 2025-01-01T00:20:00.000Z, name: 'bulk-1', value: 201 },
+//   { time: 2025-01-01T00:21:00.000Z, name: 'bulk-2', value: 202 },
 //   {
 //     time: 2025-01-01T00:11:00.000Z,
 //     name: 'kettle(modify)',
@@ -374,6 +425,9 @@ test()
 // save then [ { n: 1, nInserted: 1, nModified: 0, ok: 1 } ]
 // change del
 // del then [ { n: 0, nDeleted: 0, ok: 1 } ]
+// error del invalid time[undefined]
+// change del
+// del by data without pk then [ { n: 0, nDeleted: 0, ok: 0, err: 'invalid time[undefined]' } ]
 // change del
 // del then [
 //   { n: 1, nDeleted: 1, ok: 1 },
@@ -391,6 +445,8 @@ test()
 //   { time: 2025-01-01T00:01:00.000Z, name: 'rosemary', value: 123.456 },
 //   { time: 2025-01-01T00:04:00.000Z, name: 'rosemary', value: 123.1236 },
 //   { time: 2025-01-01T00:07:00.000Z, name: 'rosemary', value: 124.76 },
+//   { time: 2025-01-01T00:20:00.000Z, name: 'bulk-1', value: 201 },
+//   { time: 2025-01-01T00:21:00.000Z, name: 'bulk-2', value: 202 },
 //   {
 //     time: 2025-01-01T00:10:00.000Z,
 //     name: 'rosemary(modify)',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "w-orm-postgresql",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "main": "dist/w-orm-postgresql.umd.js",
   "dependencies": {
     "mongo-sql": "^6.2.0",

package/src/WOrmPostgresql.mjs

@@ -245,6 +245,77 @@ function WOrmPostgresql(opt = {}) {
         _cache[key] = cloneDeep(data) //與外部使用數據脫勾
     }
 
+    //insertBatches, 分批送出插入語句並以交易包覆, 回傳實際插入筆數, 供insert與insertBulk共用
+    //PostgreSQL之協定以int16記綁定參數個數故上限為65535, 單一語句可送之筆數受欄位數所限,
+    //超出者須分批送出; 分批後單語句之原子性已不足以維持[失敗即不留下部份寫入], 故一律以交易包覆,
+    //令單批與分批之保證來源一致而不因批數而異
+    //兩函數之衝突政策由useConflict區分, 語句各自獨立:
+    //  true : 添加ON CONFLICT DO NOTHING, 已存在主鍵者跳過而不中斷整批, 為insert之語義
+    //  false: 不添加, 任一筆撞主鍵之唯一約束即整句失敗且不寫入任何一筆, 為insertBulk之全有全無語義
+    let insertBatches = async (client, data, useConflict) => {
+
+        //nCols, 取各筆欄位數之最大值
+        let nCols = 1
+        data.forEach(function(v) {
+            nCols = Math.max(nCols, size(keys(v)))
+        })
+
+        //nPerBatch
+        let nPerBatch = Math.max(1, Math.floor(65535 / nCols))
+
+        //ltdata, 分批
+        let ltdata = []
+        for (let i = 0; i < size(data); i += nPerBatch) {
+            ltdata.push(data.slice(i, i + nPerBatch))
+        }
+
+        //transaction
+        await client.query('BEGIN')
+
+        try {
+
+            //nIns
+            let nIns = 0
+
+            //each batch
+            for (let dt of ltdata) {
+
+                //mr
+                let mr = mongoSql.sql({
+                    type: 'insert',
+                    table: cl,
+                    values: dt,
+                })
+
+                //sql
+                let sql = mr.query
+                if (useConflict) {
+                    sql = `${sql} ON CONFLICT (${pkName}) DO NOTHING`
+                }
+
+                //insert
+                let r = await client.query(sql, mr.values)
+
+                //nIns
+                nIns += r.rowCount
+
+            }
+
+            //commit
+            await client.query('COMMIT')
+
+            return nIns
+        }
+        catch (err) {
+
+            //rollback, 令已送出之批次一併回滾
+            await client.query('ROLLBACK').catch(() => {})
+
+            throw err
+        }
+
+    }
+
     /**
      * 創建資料表
      * 註: pk未給時採建構時之opt.pk。因insert與save倚賴主鍵之唯一約束達成原子性，
@@ -648,40 +719,137 @@ function WOrmPostgresql(opt = {}) {
                 return v
             })
 
-            //mr
-            let mr = mongoSql.sql({
-                type: 'insert',
-                table: cl,
-                values: data,
-            })
-            // console.log('mr', mr)
-            // console.log('mr.query', mr.query)
-            // console.log('mr.values', mr.values)
+            //nAll
+            let nAll = size(data)
 
-            //添加conflict, 令已存在主鍵者跳過而不中斷整批插入, 主鍵認定與genConflictSQL一致
+            //insert, 以ON CONFLICT DO NOTHING令已存在主鍵者跳過而不中斷整批插入,
             //由PostgreSQL於單一語句內原子完成[檢查主鍵未存在]與[寫入], 併發時同一主鍵僅有一次成功,
             //同批含重複主鍵時亦僅首筆成功, 故不須逐筆插入即可取得實際插入筆數
-            let sql = `${mr.query} ON CONFLICT (${pkName}) DO NOTHING`
+            //筆數過多而超出綁定參數上限者由insertBatches分批送出, 主鍵認定與genConflictSQL一致
+            let nIns = await insertBatches(client, data, true)
+
+            //res
+            res = {
+                n: nAll,
+                nInserted: nIns,
+                ok: 1,
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+        finally {
+            await client.end()
+            client = null
+        }
+
+        //update
+        if (useCache) {
+            clearCache()
+        }
+
+        //emit
+        if (!isErr) {
+            emitChange('insert', data, res)
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤於reject之前發出
+            emitError('insert', data, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+
+    /**
+     * 批次插入數據，全批視為一個單位，全部插入成功或一筆都不寫入
+     *
+     * 本函數非insert之加速版，兩者衝突政策不同：insert於主鍵已存在時跳過該筆且整批ok為1，
+     * 本函數則於任一筆之主鍵已存在時整批reject且不寫入任何一筆，同批含重複主鍵者亦視為衝突。
+     * n為輸入筆數，nInserted為實際插入筆數且成功時恆等於n。
+     * 不提供逐筆結果，故不出現ok:0與err，需要逐筆處置者改用insert。
+     * 因主鍵得承載業務語義，未帶有效主鍵值時不自動補值，一律以reject回報，
+     * 且主鍵檢查於任何寫入之前一次完成，故整批reject時同批之有效筆數亦不會被寫入。
+     *
+     * @memberOf WOrmPostgresql
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @returns {Promise} 回傳Promise，resolve回傳插入結果物件{n,nInserted,ok}，reject回傳錯誤訊息
+     */
+    async function insertBulk(data) {
+        let isErr = false
+        let res = null
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return {
+                n: 0,
+                nInserted: 0,
+                ok: 1,
+            }
+        }
+
+        //cloneDeep
+        data = cloneDeep(data)
+
+        //client
+        let client = new PgClient({ connectionString })
+
+        //connect
+        try {
+
+            //connect
+            await client.connect()
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+            client = null
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤於reject之前發出
+            emitError('insertBulk', data, res)
+
+            return Promise.reject(res)
+        }
+
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check pk, 因主鍵得承載業務語義故不自動補值, 未帶有效主鍵值者屬整批性錯誤
+            data = map(data, function(v, k) {
+                if (!checkPk(get(v, pkName))) {
+                    throw new Error(`invalid data[${k}].${pkName}[${get(v, pkName)}]`)
+                }
+                return v
+            })
 
             //nAll
             let nAll = size(data)
 
-            //insert, ON CONFLICT DO NOTHING時rowCount即為實際插入筆數
-            await client.query(sql, mr.values)
-                .then((r) => {
-
-                    //res
-                    res = {
-                        n: nAll,
-                        nInserted: r.rowCount,
-                        ok: 1,
-                    }
+            //insertBulk, 不添加conflict, 令任一筆撞主鍵之唯一約束即整句失敗且不寫入任何一筆,
+            //同批含重複主鍵者亦於此被偵測為衝突; 筆數過多者由insertBatches分批送出並以交易維持全有全無
+            let nIns = await insertBatches(client, data, false)
 
-                })
-                .catch((err) => {
-                    isErr = true
-                    res = err.message
-                })
+            //res
+            res = {
+                n: nAll,
+                nInserted: nIns,
+                ok: 1,
+            }
 
         }
         catch (err) {
@@ -700,14 +868,14 @@ function WOrmPostgresql(opt = {}) {
 
         //emit
         if (!isErr) {
-            emitChange('insert', data, res)
+            emitChange('insertBulk', data, res)
         }
 
         //check
         if (isErr) {
 
             //emit, 整批性錯誤於reject之前發出
-            emitError('insert', data, res)
+            emitError('insertBulk', data, res)
 
             return Promise.reject(res)
         }
@@ -716,7 +884,7 @@ function WOrmPostgresql(opt = {}) {
     }
 
     /**
-     * 儲存數據，以主鍵time為準更新既有數據，未給之欄位保留
+     * 儲存數據，以主鍵為準更新既有數據，未給之欄位保留
      *
      * 回傳陣列恆與輸入等長，輸入單一物件亦回傳長度1之陣列。
      * 各筆之n為主鍵命中筆數，值為0或1，命中(不論內容有無變更)或經插入而產生皆為1；
@@ -1361,6 +1529,7 @@ function WOrmPostgresql(opt = {}) {
     ee.select = select
     ee.selectByPk = selectByPk
     ee.insert = insert
+    ee.insertBulk = insertBulk
     ee.save = save
     ee.del = del
     ee.delAll = delAll

package/test/api-postgresql.test.mjs

@@ -957,6 +957,32 @@ describe('insert nInserted', function() {
         let vdup = await wo.selectByPk('2025-02-01T00:05:00Z')
         vget[8] = vdup.name
 
+        //跨批次之插入
+        //欄位數愈多則單一語句可送之筆數愈少, 以21欄之資料表令每批上限為3120筆, 送3200筆即須分為2批
+        //其中既有主鍵者跳過而其餘照插, 與insertBulk之全有全無不同
+        let clBat = 'insertbatch'
+        let woBat = WOrm(genOpt(clBat))
+        let vSample = { time: '2000-01-01T00:00:00Z' }
+        Array.from({ length: 20 }, (v, k) => k).forEach((k) => {
+            vSample[`f${k}`] = 'abc'
+        })
+        await woBat.createTable(clBat, null, vSample).catch(() => {})
+        await woBat.delAll()
+
+        //genRec
+        let genRec = (k) => {
+            let v = { time: new Date(Date.UTC(2025, 8, 1, 0, 0, 0) + k * 1000).toISOString() }
+            Array.from({ length: 20 }, (v2, k2) => k2).forEach((k2) => {
+                v[`f${k2}`] = `v${k}-${k2}`
+            })
+            return v
+        }
+
+        //先插入末筆之主鍵, 令後續之大批次於第2批撞上該筆
+        await woBat.insert(genRec(3199))
+        vget[9] = await woBat.insert(Array.from({ length: 3200 }, (v, k) => genRec(k)))
+        vget[10] = (await woBat.select()).length
+
     })
 
     vans[1] = { n: 3, nInserted: 3, ok: 1 }
@@ -999,6 +1025,16 @@ describe('insert nInserted', function() {
         assert.strict.deepStrictEqual(vget[8], vans[8])
     })
 
+    vans[9] = { n: 3200, nInserted: 3199, ok: 1 }
+    it(`should get ${JSON.stringify(vans[9])} for insert across batches with 1 pk existed`, async function() {
+        assert.strict.deepStrictEqual(vget[9], vans[9])
+    })
+
+    vans[10] = 3200
+    it(`should get ${JSON.stringify(vans[10])} for records after insert across batches`, async function() {
+        assert.strict.deepStrictEqual(vget[10], vans[10])
+    })
+
 })
 
 
@@ -1674,6 +1710,230 @@ describe('events', function() {
 })
 
 
+describe('insertBulk', function() {
+    let vans = {}
+    let vget = {}
+
+    before(async function() {
+        this.timeout(300000)
+
+        //wo
+        let cl = 'bulk'
+        let wo = WOrm(genOpt(cl))
+
+        //createTable
+        await wo.createTable(cl, null, {
+            time: '2000-01-01T00:00:00Z',
+            name: 'abc',
+            value: 0.1,
+        }).catch(() => {})
+        await wo.delAll()
+
+        //genTime, 依序產生不重複之主鍵值
+        let genTime = (k) => {
+            return new Date(Date.UTC(2025, 7, 1, 0, 0, 0) + k * 1000).toISOString()
+        }
+
+        //evChange, evError
+        let evChange = []
+        let evError = []
+        wo.on('change', (mode) => {
+            evChange.push(mode)
+        })
+        wo.on('error', (mode) => {
+            evError.push(mode)
+        })
+
+        //nRec, 取得目前筆數
+        let nRec = async () => {
+            return (await wo.select()).length
+        }
+
+        //無衝突, nInserted須等於n
+        vget[1] = await wo.insertBulk([
+            { time: genTime(0), name: 'peter', value: 1 },
+            { time: genTime(1), name: 'rosemary', value: 2 },
+            { time: genTime(2), name: 'kettle', value: 3 },
+        ])
+        vget[2] = await nRec()
+        vget[3] = evChange.slice()
+
+        //撞既有主鍵, 整批reject且不寫入任何一筆
+        evChange = []
+        evError = []
+        vget[4] = await wo.insertBulk([
+            { time: genTime(10), name: 'new-1', value: 11 },
+            { time: genTime(0), name: 'conflict', value: 12 },
+            { time: genTime(11), name: 'new-2', value: 13 },
+        ])
+            .then(() => 'resolved')
+            .catch(() => 'rejected')
+        vget[5] = await nRec()
+        vget[6] = evError.slice()
+        vget[7] = evChange.slice()
+
+        //同批含重複主鍵, 亦視為衝突而整批reject
+        evChange = []
+        evError = []
+        vget[8] = await wo.insertBulk([
+            { time: genTime(20), name: 'dup-1', value: 21 },
+            { time: genTime(20), name: 'dup-2', value: 22 },
+            { time: genTime(21), name: 'uniq', value: 23 },
+        ])
+            .then(() => 'resolved')
+            .catch(() => 'rejected')
+        vget[9] = await nRec()
+
+        //未帶有效主鍵, 不補值而整批reject
+        vget[10] = await wo.insertBulk([
+            { time: genTime(30), name: 'ok', value: 31 },
+            { name: 'no-pk', value: 32 },
+        ])
+            .then(() => 'resolved')
+            .catch(() => 'rejected')
+        vget[11] = await nRec()
+
+        //輸入無效
+        vget[12] = await wo.insertBulk(null)
+
+        //單一物件亦回傳單一物件
+        vget[13] = await wo.insertBulk({ time: genTime(40), name: 'single', value: 41 })
+        vget[14] = await nRec()
+
+        //跨批次之回滾
+        //欄位數愈多則單一語句可送之筆數愈少, 以21欄之資料表令每批上限為3120筆,
+        //送3200筆即須分為2批, 末筆撞既有主鍵時第1批已送出, 須由交易回滾方能維持全有全無
+        let clBat = 'bulkbatch'
+        let woBat = WOrm(genOpt(clBat))
+        let vSample = { time: '2000-01-01T00:00:00Z' }
+        Array.from({ length: 20 }, (v, k) => k).forEach((k) => {
+            vSample[`f${k}`] = 'abc'
+        })
+        await woBat.createTable(clBat, null, vSample).catch(() => {})
+        await woBat.delAll()
+
+        //genRec
+        let genRec = (k) => {
+            let v = { time: genTime(k) }
+            Array.from({ length: 20 }, (v2, k2) => k2).forEach((k2) => {
+                v[`f${k2}`] = `v${k}-${k2}`
+            })
+            return v
+        }
+
+        //先插入末筆之主鍵, 令後續之大批次於第2批撞上
+        let kLast = 3199
+        await woBat.insert(genRec(kLast))
+        let nBefore = (await woBat.select()).length
+
+        //3200筆之批次, 末筆與既有衝突
+        vget[15] = await woBat.insertBulk(Array.from({ length: 3200 }, (v, k) => genRec(k)))
+            .then(() => 'resolved')
+            .catch(() => 'rejected')
+
+        //失敗後資料表不得有任何新增
+        vget[16] = (await woBat.select()).length - nBefore
+
+        //跨批次且無衝突者須全數寫入
+        await woBat.delAll()
+        vget[17] = await woBat.insertBulk(Array.from({ length: 3200 }, (v, k) => genRec(k)))
+        vget[18] = (await woBat.select()).length
+
+    })
+
+    vans[1] = { n: 3, nInserted: 3, ok: 1 }
+    it(`should get ${JSON.stringify(vans[1])} for insertBulk without conflict`, async function() {
+        assert.strict.deepStrictEqual(vget[1], vans[1])
+    })
+
+    vans[2] = 3
+    it(`should get ${JSON.stringify(vans[2])} for records after insertBulk without conflict`, async function() {
+        assert.strict.deepStrictEqual(vget[2], vans[2])
+    })
+
+    vans[3] = ['insertBulk']
+    it(`should get ${JSON.stringify(vans[3])} for change modes by insertBulk`, async function() {
+        assert.strict.deepStrictEqual(vget[3], vans[3])
+    })
+
+    vans[4] = 'rejected'
+    it(`should get ${JSON.stringify(vans[4])} for insertBulk with pk existed`, async function() {
+        assert.strict.deepStrictEqual(vget[4], vans[4])
+    })
+
+    vans[5] = 3
+    it(`should get ${JSON.stringify(vans[5])} for records after insertBulk with pk existed`, async function() {
+        assert.strict.deepStrictEqual(vget[5], vans[5])
+    })
+
+    vans[6] = ['insertBulk']
+    it(`should get ${JSON.stringify(vans[6])} for error modes by insertBulk with pk existed`, async function() {
+        assert.strict.deepStrictEqual(vget[6], vans[6])
+    })
+
+    vans[7] = []
+    it(`should get ${JSON.stringify(vans[7])} for change modes by insertBulk rejected`, async function() {
+        assert.strict.deepStrictEqual(vget[7], vans[7])
+    })
+
+    vans[8] = 'rejected'
+    it(`should get ${JSON.stringify(vans[8])} for insertBulk with duplicated pk in same batch`, async function() {
+        assert.strict.deepStrictEqual(vget[8], vans[8])
+    })
+
+    vans[9] = 3
+    it(`should get ${JSON.stringify(vans[9])} for records after insertBulk with duplicated pk`, async function() {
+        assert.strict.deepStrictEqual(vget[9], vans[9])
+    })
+
+    vans[10] = 'rejected'
+    it(`should get ${JSON.stringify(vans[10])} for insertBulk without valid pk`, async function() {
+        assert.strict.deepStrictEqual(vget[10], vans[10])
+    })
+
+    vans[11] = 3
+    it(`should get ${JSON.stringify(vans[11])} for records after insertBulk without valid pk`, async function() {
+        assert.strict.deepStrictEqual(vget[11], vans[11])
+    })
+
+    vans[12] = { n: 0, nInserted: 0, ok: 1 }
+    it(`should get ${JSON.stringify(vans[12])} for insertBulk with invalid data`, async function() {
+        assert.strict.deepStrictEqual(vget[12], vans[12])
+    })
+
+    vans[13] = { n: 1, nInserted: 1, ok: 1 }
+    it(`should get ${JSON.stringify(vans[13])} for insertBulk with single object`, async function() {
+        assert.strict.deepStrictEqual(vget[13], vans[13])
+    })
+
+    vans[14] = 4
+    it(`should get ${JSON.stringify(vans[14])} for records after insertBulk with single object`, async function() {
+        assert.strict.deepStrictEqual(vget[14], vans[14])
+    })
+
+    vans[15] = 'rejected'
+    it(`should get ${JSON.stringify(vans[15])} for insertBulk across batches with pk existed`, async function() {
+        assert.strict.deepStrictEqual(vget[15], vans[15])
+    })
+
+    vans[16] = 0
+    it(`should get ${JSON.stringify(vans[16])} for increment of records after insertBulk across batches failed`, async function() {
+        assert.strict.deepStrictEqual(vget[16], vans[16])
+    })
+
+    vans[17] = { n: 3200, nInserted: 3200, ok: 1 }
+    it(`should get ${JSON.stringify(vans[17])} for insertBulk across batches without conflict`, async function() {
+        assert.strict.deepStrictEqual(vget[17], vans[17])
+    })
+
+    vans[18] = 3200
+    it(`should get ${JSON.stringify(vans[18])} for records after insertBulk across batches`, async function() {
+        assert.strict.deepStrictEqual(vget[18], vans[18])
+    })
+
+})
+
+
 //runProc, 另起行程對同一資料表操作, 用於驗證跨行程之原子性
 //子行程以--input-type=module執行, 並以pathToFileURL轉換src路徑, 避免專案路徑含非ASCII字元而無法import
 function runProc(tag, opt, mode, payload) {