duckdb 0.6.2-dev6.0 → 0.6.2-dev604.0

package/src/parquet-amalgamation.hpp

@@ -7193,7 +7193,7 @@ public:
 			return;
 		}
 		if (new_size > alloc_len) {
-			alloc_len = new_size;
+			alloc_len = NextPowerOfTwo(new_size);
 			allocated_data = allocator.Allocate(alloc_len);
 			ptr = (char *)allocated_data.get();
 		}
@@ -7387,7 +7387,6 @@ namespace duckdb {
 class DbpDecoder {
 public:
 	DbpDecoder(const uint8_t *buffer, uint32_t buffer_len) : buffer_((char *)buffer, buffer_len) {
-
 		//<block size in values> <number of miniblocks in a block> <total value count> <first value>
 		// overall header
 		block_value_count = ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_);
@@ -7396,6 +7395,7 @@ public:
 		start_value = ParquetDecodeUtils::ZigzagToInt(ParquetDecodeUtils::VarintDecode<int64_t>(buffer_));
 
 		// some derivatives
+		D_ASSERT(miniblocks_per_block > 0);
 		values_per_miniblock = block_value_count / miniblocks_per_block;
 		miniblock_bit_widths = std::unique_ptr<uint8_t[]>(new data_t[miniblocks_per_block]);
 
@@ -7474,6 +7474,17 @@ public:
 		}
 		start_value = values[batch_size - 1];
 	}
+	void Finalize() {
+		if (values_left_in_miniblock == 0) {
+			return;
+		}
+		auto data = unique_ptr<uint32_t[]>(new uint32_t[values_left_in_miniblock]);
+		GetBatch<uint32_t>((char *)data.get(), values_left_in_miniblock);
+	}
+
+	uint64_t TotalValues() {
+		return total_value_count;
+	}
 
 private:
 	ByteBuffer buffer_;
@@ -7579,11 +7590,31 @@ public:
 
 	virtual unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns);
 
+	template <class VALUE_TYPE, class CONVERSION>
+	void PlainTemplated(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, uint64_t num_values,
+	                    parquet_filter_t &filter, idx_t result_offset, Vector &result) {
+		auto result_ptr = FlatVector::GetData<VALUE_TYPE>(result);
+		auto &result_mask = FlatVector::Validity(result);
+		for (idx_t row_idx = 0; row_idx < num_values; row_idx++) {
+			if (HasDefines() && defines[row_idx + result_offset] != max_define) {
+				result_mask.SetInvalid(row_idx + result_offset);
+				continue;
+			}
+			if (filter[row_idx + result_offset]) {
+				VALUE_TYPE val = CONVERSION::PlainRead(*plain_data, *this);
+				result_ptr[row_idx + result_offset] = val;
+			} else { // there is still some data there that we have to skip over
+				CONVERSION::PlainSkip(*plain_data, *this);
+			}
+		}
+	}
+
 protected:
+	Allocator &GetAllocator();
 	// readers that use the default Read() need to implement those
 	virtual void Plain(shared_ptr<ByteBuffer> plain_data, uint8_t *defines, idx_t num_values, parquet_filter_t &filter,
 	                   idx_t result_offset, Vector &result);
-	virtual void Dictionary(shared_ptr<ByteBuffer> dictionary_data, idx_t num_entries);
+	virtual void Dictionary(shared_ptr<ResizeableBuffer> dictionary_data, idx_t num_entries);
 	virtual void Offsets(uint32_t *offsets, uint8_t *defines, idx_t num_values, parquet_filter_t &filter,
 	                     idx_t result_offset, Vector &result);
 
@@ -7591,6 +7622,11 @@ protected:
 	virtual void DictReference(Vector &result);
 	virtual void PlainReference(shared_ptr<ByteBuffer>, Vector &result);
 
+	virtual void PrepareDeltaLengthByteArray(ResizeableBuffer &buffer);
+	virtual void PrepareDeltaByteArray(ResizeableBuffer &buffer);
+	virtual void DeltaByteArray(uint8_t *defines, idx_t num_values, parquet_filter_t &filter, idx_t result_offset,
+	                            Vector &result);
+
 	// applies any skips that were registered using Skip()
 	virtual void ApplyPendingSkips(idx_t num_values);
 
@@ -7611,10 +7647,13 @@ protected:
 
 	ParquetReader &reader;
 	LogicalType type;
+	unique_ptr<Vector> byte_array_data;
 
 	idx_t pending_skips = 0;
 
 private:
+	void AllocateBlock(idx_t size);
+	void AllocateCompressed(idx_t size);
 	void PrepareRead(parquet_filter_t &filter);
 	void PreparePage(PageHeader &page_hdr);
 	void PrepareDataPage(PageHeader &page_hdr);
@@ -7630,12 +7669,14 @@ private:
 
 	shared_ptr<ResizeableBuffer> block;
 
+	ResizeableBuffer compressed_buffer;
 	ResizeableBuffer offset_buffer;
 
 	unique_ptr<RleBpDecoder> dict_decoder;
 	unique_ptr<RleBpDecoder> defined_decoder;
 	unique_ptr<RleBpDecoder> repeated_decoder;
 	unique_ptr<DbpDecoder> dbp_decoder;
+	unique_ptr<RleBpDecoder> rle_decoder;
 
 	// dummies for Skip()
 	parquet_filter_t none_filter;
@@ -7908,7 +7949,8 @@ public:
 	                                                      idx_t max_repeat = 0, idx_t max_define = 1,
 	                                                      bool can_have_nulls = true);
 
-	virtual unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::format::RowGroup &row_group) = 0;
+	virtual unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::format::RowGroup &row_group,
+	                                                           Allocator &allocator) = 0;
 
 	//! indicates whether the write need to analyse the data before preparing it
 	virtual bool HasAnalyze() {

package/test/{affected.test.js → affected.test.ts}

@@ -1,22 +1,22 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
 
 describe('query properties', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:');
         db.run("CREATE TABLE foo (id INT, txt TEXT)", done);
     });
 
-/*
-    it('should return the correct lastID', function(done) {
+    it.skip('should return the correct lastID', function(done) {
         var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
         var j = 1;
         for (var i = 0; i < 5000; i++) {
-            stmt.run(i, "demo", function(err) {
+            stmt.run(i, "demo", function(err: null | Error) {
                 if (err) throw err;
                 // Relies on SQLite's row numbering to be gapless and starting
                 // from 1.
+                // @ts-ignore
                 assert.equal(j++, this.lastID);
             });
         }
@@ -24,13 +24,11 @@ describe('query properties', function() {
     });
 
 
-    it('should return the correct changes count', function(done) {
-        db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err) {
+    it.skip('should return the correct changes count', function(done) {
+        db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err: null | Error) {
             if (err) throw err;
            // FIXME assert.equal(2500, this.changes);
             done();
         });
     });
-    */
-
 });

package/test/{arrow.test.js → arrow.test.ts}

@@ -1,11 +1,12 @@
-var duckdb = require('..');
-var assert = require('assert');
-var fs = require('fs');
+import * as duckdb from '..';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import {QueryResult} from "..";
 
 describe('arrow IPC API fails neatly when extension not loaded', function() {
     // Note: arrow IPC api requires the arrow extension to be loaded. The tests for this functionality reside in:
     //       https://github.com/duckdblabs/arrow
-    let db;
+    let db: duckdb.Database;
     let conn;
     before((done) => {
         db = new duckdb.Database(':memory:', {"allow_unsigned_extensions": "true"}, () => {
@@ -20,13 +21,13 @@ describe('arrow IPC API fails neatly when extension not loaded', function() {
         db.arrowIPCStream(query).then(
             () => Promise.reject(new Error('Expected method to reject.')),
             err => {
-                assert(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
+                assert.ok(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
             }
         );
 
-        db.arrowIPCAll(`SELECT * FROM ipc_table`, function (err, result) {
+        db.arrowIPCAll(`SELECT * FROM ipc_table`, function (err: null | Error, result: QueryResult) {
             if (err) {
-                assert(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
+                assert.ok(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
             } else {
                 assert.fail("Expected error");
             }
@@ -36,16 +37,16 @@ describe('arrow IPC API fails neatly when extension not loaded', function() {
     });
 
     it('register buffer should be disabled currently', function(done) {
-        db.register_buffer("test", [new Uint8Array(new ArrayBuffer(10))], true, (err) => {
-            assert(err)
-            assert(err.includes("Function with name scan_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"));
+        db.register_buffer("test", [new Uint8Array(new ArrayBuffer(10))], true, (err: null | Error) => {
+            assert.ok(err)
+            assert.ok(err.toString().includes("Function with name scan_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"));
             done()
         });
     });
 
     it('unregister will silently do nothing', function(done) {
         db.unregister_buffer("test", (err) => {
-            assert(!err)
+            assert.ok(!err)
             done()
         });
     });

package/test/{data_type_support.test.js → data_type_support.test.ts}

@@ -1,8 +1,9 @@
-var sqlite3 = require("..");
-var assert = require("assert");
+import * as sqlite3 from "..";
+import * as assert from "assert";
+import {RowData, TableData} from "..";
 
 describe("data type support", function () {
-  let db;
+  let db: sqlite3.Database;
   before(function (done) {
     db = new sqlite3.Database(":memory:", done);
   });
@@ -14,9 +15,9 @@ describe("data type support", function () {
     values.forEach((bool) => {
       stmt.run(bool);
     });
-    db.prepare("SELECT i from boolean_table;").all((err, res) => {
-      assert(err === null);
-      assert(res.every((v, i) => v.i === values[i]));
+    db.prepare("SELECT i from boolean_table;").all((err: null | Error, res: TableData) => {
+      assert.equal(err, null);
+      assert.ok(res.every((v, i) => v.i === values[i]));
       done();
     });
   });
@@ -26,9 +27,9 @@ describe("data type support", function () {
     const stmt = db.prepare("INSERT INTO integer_table VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
 
     // Numerical limits
-    signedMinValue = (bitWidth) => Math.max(-(2**(bitWidth-1)-1)-1, Number.MIN_SAFE_INTEGER);
-    signedMaxValue = (bitWidth) => Math.min(2**(bitWidth-1)-1, Number.MAX_SAFE_INTEGER);
-    unsignedMaxValue = (bitWidth) => Math.min(2**(bitWidth)-1, Number.MAX_SAFE_INTEGER);
+    let signedMinValue = (bitWidth: number) => Math.max(-(2**(bitWidth-1)-1)-1, Number.MIN_SAFE_INTEGER);
+    let signedMaxValue = (bitWidth: number) => Math.min(2**(bitWidth-1)-1, Number.MAX_SAFE_INTEGER);
+    let unsignedMaxValue = (bitWidth: number) => Math.min(2**(bitWidth)-1, Number.MAX_SAFE_INTEGER);
     let minValues = [signedMinValue(8), signedMinValue(16), signedMinValue(32), signedMinValue(64), 0, 0, 0, 0];
     let maxValues = [signedMinValue(8), signedMinValue(16), signedMinValue(32), signedMinValue(64), unsignedMaxValue(8), unsignedMaxValue(16), unsignedMaxValue(32), unsignedMaxValue(64)];
 
@@ -36,11 +37,11 @@ describe("data type support", function () {
     stmt.run(...minValues);
     stmt.run(...maxValues);
 
-    db.prepare("SELECT * from integer_table;").all((err, res) => {
-      assert(err === null);
-      assert(res.length === 2);
-      assert(Object.entries(res[0]).length === 8);
-      assert(Object.entries(res[1]).length === 8);
+    db.prepare("SELECT * from integer_table;").all((err: null | Error, res: TableData) => {
+      assert.equal(err, null);
+      assert.equal(res.length, 2);
+      assert.equal(Object.entries(res[0]).length, 8);
+      assert.equal(Object.entries(res[1]).length, 8);
       assert.deepEqual(Object.entries(res[0]).map(v => v[1]), minValues);
       assert.deepEqual(Object.entries(res[1]).map(v => v[1]), maxValues);
       done();
@@ -54,8 +55,8 @@ describe("data type support", function () {
     INTERVAL 5 DAY as days,
     INTERVAL 4 MONTH as months,
     INTERVAL 4 MONTH + INTERVAL 5 DAY + INTERVAL 1 MINUTE as combined;`
-    ).each((err, row) => {
-      assert(err === null);
+    ).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.minutes, {
         months: 0,
         days: 0,
@@ -74,7 +75,7 @@ describe("data type support", function () {
 
   it("supports STRUCT values", function (done) {
     db.prepare(`SELECT {'x': 1, 'y': 2, 'z': {'a': 'b'}} as struct`).each(
-      (err, row) => {
+      (err: null | Error, row: RowData) => {
         assert.deepEqual(row.struct, { x: 1, y: 2, z: { a: "b" } });
         done();
       }
@@ -86,8 +87,8 @@ describe("data type support", function () {
     db.run("INSERT INTO struct_table VALUES ({'a': 'hello', 'b': true})");
     db.run("INSERT INTO struct_table VALUES ({'a': 'goodbye', 'b': false})");
     db.run("INSERT INTO struct_table VALUES ({'a': 'aloha', 'b': NULL})");
-    db.prepare("SELECT s from struct_table;").all((err, res) => {
-      assert(err === null);
+    db.prepare("SELECT s from struct_table;").all((err: null | Error, res: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(res, [
         { s: { a: "hello", b: true } },
         { s: { a: "goodbye", b: false } },
@@ -106,8 +107,8 @@ describe("data type support", function () {
       {'a': 43, 'b': NULL}
    ] l UNION ALL SELECT NULL`
     );
-    db.prepare("SELECT l from recursive_struct").all((err, res) => {
-      assert(err === null);
+    db.prepare("SELECT l from recursive_struct").all((err: null | Error, res: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(res, [
         {
           l: [
@@ -135,32 +136,32 @@ describe("data type support", function () {
   });
 
   it("supports LIST values", function (done) {
-    db.prepare(`SELECT ['duck', 'duck', 'goose'] as list`).each((err, row) => {
-      assert(err === null);
+    db.prepare(`SELECT ['duck', 'duck', 'goose'] as list`).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.list, ["duck", "duck", "goose"]);
       done();
     });
   });
 
   it("supports LIST with NULL values", function (done) {
-    db.prepare(`SELECT ['duck', 'duck', NULL] as list`).each((err, row) => {
-      assert(err === null);
+    db.prepare(`SELECT ['duck', 'duck', NULL] as list`).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.list, ["duck", "duck", null]);
       done();
     });
   });
 
   it("supports DATE values", function (done) {
-    db.prepare(`SELECT '2021-01-01'::DATE as dt;`).each((err, row) => {
-      assert(err === null);
+    db.prepare(`SELECT '2021-01-01'::DATE as dt;`).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.dt, new Date(Date.UTC(2021, 0, 1)));
       done();
     });
   });
   it("supports TIMESTAMP values", function (done) {
     db.prepare(`SELECT '2021-01-01T00:00:00'::TIMESTAMP as ts;`).each(
-      (err, row) => {
-        assert(err === null);
+      (err: null | Error, row: RowData) => {
+        assert.equal(err, null);
         assert.deepEqual(row.ts, new Date(Date.UTC(2021, 0, 1)));
         done();
       }
@@ -168,8 +169,8 @@ describe("data type support", function () {
   });
   it("supports TIMESTAMP WITH TIME ZONE values", function (done) {
     db.prepare(`SELECT '2021-01-01T00:00:00Z'::TIMESTAMPTZ as tstz;`).each(
-      (err, row) => {
-        assert(err === null);
+      (err: null | Error, row: RowData) => {
+        assert.equal(err, null);
         assert.deepEqual(row.tstz, new Date(Date.UTC(2021, 0, 1)));
         done();
       }
@@ -182,14 +183,14 @@ describe("data type support", function () {
     values.forEach((d) => {
       stmt.run(d);
     });
-    db.prepare("SELECT d from decimal_table;").all((err, res) => {
-      assert(err === null);
-      assert(res.every((v, i) => v.d === values[i]));
+    db.prepare("SELECT d from decimal_table;").all((err: null | Error, res: TableData) => {
+      assert.equal(err, null);
+      assert.ok(res.every((v, i) => v.d === values[i]));
       done();
     });
   });
   it("converts unsupported data types to strings", function(done) {
-      db.all("SELECT CAST('11:10:10' AS TIME) as time", function(err, rows) {
+      db.all("SELECT CAST('11:10:10' AS TIME) as time", function(err: null | Error, rows: TableData) {
           assert.equal(rows[0].time, '11:10:10');
           done();
       });

package/test/{database_fail.test.js → database_fail.test.ts}

@@ -1,24 +1,27 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import {DuckDbError, RowData} from "..";
 
 describe('error handling', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);
     });
 
     it('throw when calling Database() without new', function() {
         assert.throws(function() {
+            // @ts-ignore
             sqlite3.Database(':memory:');
         }, (/Class constructors cannot be invoked without 'new'/));
 
         assert.throws(function() {
+            // @ts-ignore
             sqlite3.Statement();
         }, (/Class constructors cannot be invoked without 'new'/));
     });
 
     it('should error when calling Database#each on a missing table', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
+        db.each('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -30,7 +33,7 @@ describe('error handling', function() {
     });
 
     it('Database#all prepare fail', function(done) {
-        db.all('SELECT id, txt FROM foo', function(err, row) {
+        db.all('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -42,7 +45,7 @@ describe('error handling', function() {
     });
 
     it('Database#run prepare fail', function(done) {
-        db.run('SELECT id, txt FROM foo', function(err, row) {
+        db.run('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: void) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -53,11 +56,10 @@ describe('error handling', function() {
         });
     });
 
-/*
-    it('Database#each prepare fail', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
+    it.skip('Database#each prepare fail', function(done) {
+        db.each('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             assert.ok(false, "this should not be called");
-        }, function(err, num) {
+        }, function(err: null | DuckDbError, num: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -67,9 +69,9 @@ describe('error handling', function() {
             }
         });
     });
-*/
+
     it('Database#each prepare fail without completion handler', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
+        db.each('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -79,9 +81,9 @@ describe('error handling', function() {
             }
         });
     });
-/*
-    it('Database#get prepare fail with param binding', function(done) {
-        db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+
+    it.skip('Database#get prepare fail with param binding', function(done) {
+        db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -91,9 +93,9 @@ describe('error handling', function() {
             }
         });
     });
-*/
+
     it('Database#all prepare fail with param binding', function(done) {
-        db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+        db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -105,7 +107,7 @@ describe('error handling', function() {
     });
 
     it('Database#run prepare fail with param binding', function(done) {
-        db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+        db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: void) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -116,11 +118,10 @@ describe('error handling', function() {
         });
     });
 
-/*
-    it('Database#each prepare fail with param binding', function(done) {
-        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+    it.skip('Database#each prepare fail with param binding', function(done) {
+        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             assert.ok(false, "this should not be called");
-        }, function(err, num) {
+        }, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -130,9 +131,9 @@ describe('error handling', function() {
             }
         });
     });
-*/
+
     it('Database#each prepare fail with param binding without completion handler', function(done) {
-        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);

package/test/{each.test.js → each.test.ts}

@@ -1,8 +1,9 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import {RowData} from "..";
 
 describe('each', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database('test/support/big.db', done);
     });
@@ -12,7 +13,7 @@ describe('each', function() {
         var retrieved = 0;
         
 
-        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err, row) {
+        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err: null | Error, row: RowData) {
             if (err) throw err;
             retrieved++;
 
@@ -22,18 +23,18 @@ describe('each', function() {
             }
         });
     });
-/*
-    it('Statement#each with complete callback', function(done) {
+
+    it.skip('Statement#each with complete callback', function(done) {
         var total = 10000;
         var retrieved = 0;
 
-        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err, row) {
+        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err: null | Error, row: RowData) {
             if (err) throw err;
             retrieved++;
-        }, function(err, num) {
+        }, function(err: null | Error, num: RowData) {
             assert.equal(retrieved, num);
             assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
             done();
         });
-    });*/
+    });
 });

package/test/{exec.test.js → exec.test.ts}

@@ -1,23 +1,24 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import {TableData} from "..";
 
 describe('exec', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);
     });
 
     it('Database#exec', function(done) {
         var sql = fs.readFileSync('test/support/script.sql', 'utf8');
-        db.exec(sql, function(err) {
+        db.exec(sql, function(err: null | Error) {
             if (err) throw err;
             done();
         });
     });
 
     it('retrieve database structure', function(done) {
-        db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err, rows) {
+        db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err: null | Error, rows: TableData) {
             if (err) throw err;
             assert.deepEqual(rows, [
                // { type: 'index', name: 'grid_key_lookup' },