Add .map and .reduce on SQLiteCloudRowset

Author: gionatamettifogo

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlitecloud-js",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "SQLiteCloud drivers for Typescript/Javascript in edge, web and node clients",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

src/connection.ts

@@ -567,6 +567,7 @@ function parseRowset(buffer: Buffer, spaceIndex: number): SQLiteCloudRowset {
     buffer = fwdBuffer
   }
 
+  console.assert(data && data.length === metadata.numberOfRows * metadata.numberOfColumns, 'SQLiteCloudConnection.parseRowset - invalid rowset data')
   return new SQLiteCloudRowset(metadata, data)
 }
 
@@ -606,6 +607,7 @@ function parseRowsetChunks(buffers: Buffer[]) {
     }
   }
 
+  console.assert(data && data.length === metadata.numberOfRows * metadata.numberOfColumns, 'SQLiteCloudConnection.parseRowsetChunks - invalid rowset data')
   return new SQLiteCloudRowset(metadata, data)
 }
 

src/rowset.ts

@@ -30,12 +30,9 @@ export class SQLiteCloudRow {
 export class SQLiteCloudRowset extends Array<SQLiteCloudRow> {
   constructor(metadata: SQLCloudRowsetMetadata, data: any[]) {
     super(metadata.numberOfRows)
-    console.assert(data.length === metadata.numberOfRows * metadata.numberOfColumns, 'Invalid rowset data')
-    console.assert(metadata.columns.length === metadata.numberOfColumns, 'Invalid columns metadata')
-    console.assert(
-      metadata.numberOfRows >= 0 && metadata.numberOfColumns >= 0,
-      `Invalid rowset dimensions ${metadata.numberOfRows} x ${metadata.numberOfColumns}`
-    )
+
+    // console.assert(data !== undefined && data.length === metadata.numberOfRows * metadata.numberOfColumns, 'Invalid rowset data')
+    // console.assert(metadata !== undefined && metadata.columns.length === metadata.numberOfColumns, 'Invalid columns metadata')
 
     this.#metadata = metadata
     this.#data = data
@@ -113,6 +110,32 @@ export class SQLiteCloudRowset extends Array<SQLiteCloudRow> {
 
     const slicedMetadata = { ...this.#metadata, numberOfRows: end - start }
     const slicedData = this.#data.slice(start * this.numberOfColumns, end * this.numberOfColumns)
+
+    console.assert(
+      slicedData && slicedData.length === slicedMetadata.numberOfRows * slicedMetadata.numberOfColumns,
+      'SQLiteCloudRowset.slice - invalid rowset data'
+    )
     return new SQLiteCloudRowset(slicedMetadata, slicedData)
   }
+
+  map(fn: (row: SQLiteCloudRow, index: number, rowset: SQLiteCloudRow[]) => any): any[] {
+    const results: any[] = []
+    for (let i = 0; i < this.numberOfRows; i++) {
+      const row = this[i]
+      results.push(fn(row, i, this))
+    }
+    return results
+  }
+
+  /** Returns an instance of SQLiteCloudRowset where rows have been filtered via given callback */
+  filter(fn: (row: SQLiteCloudRow, index: number, rowset: SQLiteCloudRow[]) => boolean): SQLiteCloudRow[] {
+    const filteredData: any[] = []
+    for (let i = 0; i < this.numberOfRows; i++) {
+      const row = this[i]
+      if (fn(row, i, this)) {
+        filteredData.push(...this.#data.slice(i * this.numberOfColumns, (i + 1) * this.numberOfColumns))
+      }
+    }
+    return new SQLiteCloudRowset({ ...this.#metadata, numberOfRows: filteredData.length / this.numberOfColumns }, filteredData)
+  }
 }

test/connection.test.ts

@@ -280,25 +280,29 @@ describe('connection', () => {
   })
 
   describe('operations', () => {
-    it('should serialize operations', done => {
-      const numQueries = 20
-      let completed = 0
+    it(
+      'should serialize operations',
+      done => {
+        const numQueries = 20
+        let completed = 0
 
-      for (let i = 0; i < numQueries; i++) {
-        chinook.sendCommands(`select ${i} as "count", 'hello' as 'string'`, (error, results) => {
-          expect(error).toBeNull()
-          expect(results.numberOfColumns).toBe(2)
-          expect(results.numberOfRows).toBe(1)
-          expect(results.version == 1 || results.version == 2).toBeTruthy()
-          expect(results.columnsNames).toEqual(['count', 'string'])
-          expect(results.getItem(0, 0)).toBe(i)
+        for (let i = 0; i < numQueries; i++) {
+          chinook.sendCommands(`select ${i} as "count", 'hello' as 'string'`, (error, results) => {
+            expect(error).toBeNull()
+            expect(results.numberOfColumns).toBe(2)
+            expect(results.numberOfRows).toBe(1)
+            expect(results.version == 1 || results.version == 2).toBeTruthy()
+            expect(results.columnsNames).toEqual(['count', 'string'])
+            expect(results.getItem(0, 0)).toBe(i)
 
-          if (++completed >= numQueries) {
-            done()
-          }
-        })
-      }
-    })
+            if (++completed >= numQueries) {
+              done()
+            }
+          })
+        }
+      },
+      LONG_TIMEOUT
+    )
 
     it('should apply short timeout', done => {
       // this operation sends 150 packets and cannot complete in 20ms

test/rowset.test.ts

@@ -2,7 +2,7 @@
  * rowset.test.ts - test rowset container
  */
 
-import { SQLiteCloudRowset } from '../src/index'
+import { SQLiteCloudRowset, SQLiteCloudRow } from '../src/index'
 import { SQLiteCloudConnection } from '../src/connection'
 import { CHINOOK_DATABASE_URL, getChinookConnection, getChinookConfig } from './shared'
 
@@ -34,6 +34,58 @@ describe('rowset', () => {
     })
   })
 
+  it('implements .map', done => {
+    const connection = getChinookConnection()
+    connection.sendCommands('SELECT * FROM tracks LIMIT 10;', (error, rowset) => {
+      expect(rowset).toBeInstanceOf(SQLiteCloudRowset)
+      expect(rowset.numberOfColumns).toBe(9)
+      expect(rowset.numberOfRows).toBe(10)
+      expect(Array.isArray(rowset)).toBeTruthy()
+      expect(rowset).toHaveLength(10)
+
+      rowset.map((row: SQLiteCloudRow) => {
+        expect(row).toBeInstanceOf(SQLiteCloudRow)
+        expect(Object.keys(row)).toHaveLength(9)
+      })
+
+      connection.close()
+      done()
+    })
+  })
+
+  it('implements .filter', done => {
+    const connection = getChinookConnection()
+    connection.sendCommands('SELECT * FROM tracks LIMIT 10;', (error, rowset) => {
+      expect(rowset).toBeInstanceOf(SQLiteCloudRowset)
+      expect(rowset.numberOfColumns).toBe(9)
+      expect(rowset.numberOfRows).toBe(10)
+      expect(Array.isArray(rowset)).toBeTruthy()
+      expect(rowset).toHaveLength(10)
+
+      const filtered = rowset.filter((row: SQLiteCloudRow) => row.AlbumId === 1)
+      expect(filtered).toBeInstanceOf(SQLiteCloudRowset)
+      expect(filtered.numberOfColumns).toBe(9)
+      expect(filtered.numberOfRows).toBe(6)
+
+      connection.close()
+      done()
+    })
+  })
+
+  it('implements .reduce', done => {
+    const connection = getChinookConnection()
+    connection.sendCommands('SELECT * FROM invoices;', (error, rowset) => {
+      expect(rowset).toBeInstanceOf(SQLiteCloudRowset)
+
+      // doing "SELECT sum(Total) FROM invoices" the wrong way (not using SQL) to test reduce...
+      const total = rowset.reduce((acc: number, row: SQLiteCloudRow) => acc + (row?.Total ? (row.Total as number) : 0), 0)
+      expect(Math.floor(total)).toBe(2328)
+
+      connection.close()
+      done()
+    })
+  })
+
   it('can be sliced like an array', done => {
     const connection = getChinookConnection()
     connection.sendCommands('SELECT * FROM tracks LIMIT 50;', (error, rowset) => {