duckdb 0.6.2-dev6.0 → 0.6.2-dev623.0

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

@@ -1,10 +1,9 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
+import * as helper from './support/helper';
 
 describe('null error', function() {
     var filename = 'test/tmp/test_sqlite_ok_error.db';
-    var db;
+    var db: sqlite3.Database;
 
     before(function(done) {
         helper.ensureExists('test/tmp');
@@ -17,7 +16,7 @@ describe('null error', function() {
     });
 
     it('should insert rows with lots of null values', function(done) {
-        var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) {
+        var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err: null | Error) {
             if (err) throw err;
 
             for (var i = 0; i < 100; i++) {
@@ -32,7 +31,7 @@ describe('null error', function() {
     });
 
     it('should have created the database', function() {
-        assert.fileExists(filename);
+        helper.fileExists(filename);
     });
 
     after(function() {

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

@@ -1,7 +1,7 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as helper from './support/helper';
 
 describe('open/close', function() {
     before(function() {
@@ -13,7 +13,7 @@ describe('open/close', function() {
             helper.deleteFile('test/tmp/test_create.db');
         });
 
-        var db;
+        var db: sqlite3.Database;
         it('should open the database', function(done) {
             db = new sqlite3.Database('test/tmp/test_create.db', done);
         });
@@ -23,7 +23,7 @@ describe('open/close', function() {
         });
 
         it('should have created the file', function() {
-            assert.fileExists('test/tmp/test_create.db');
+            helper.fileExists('test/tmp/test_create.db');
         });
 
         after(function() {
@@ -123,7 +123,7 @@ describe('open/close', function() {
         });
 
         it('should not have created the file', function() {
-            assert.fileDoesNotExist('test/tmp/test_readonly.db');
+            helper.fileDoesNotExist('test/tmp/test_readonly.db');
         });
 
         after(function() {
@@ -132,7 +132,7 @@ describe('open/close', function() {
     });
 
     describe('open and close memory database queuing', function() {
-        var db;
+        var db: sqlite3.Database;
         it('should open the database', function(done) {
             db = new sqlite3.Database(':memory:', done);
         });
@@ -155,7 +155,7 @@ describe('open/close', function() {
         var completedSecond = false;
         var closed = false;
 
-        var db;
+        var db: sqlite3.Database;
         before(function(done) {
             db = new sqlite3.Database(':memory:', done);
         });
@@ -164,7 +164,7 @@ describe('open/close', function() {
             db.run("CREATE TABLE foo (id INT, num INT)", done);
         });
 
-        var stmt;
+        var stmt: sqlite3.Statement;
         it('should prepare/run a statement', function(done) {
             stmt = db.prepare('INSERT INTO foo VALUES (?, ?)');
             stmt.run(1, 2, done);

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

@@ -1,22 +1,21 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
+import * as helper from './support/helper';
 
 describe('parallel', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         helper.deleteFile('test/tmp/test_parallel_inserts.db');
         helper.ensureExists('test/tmp');
         db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done);
     });
 
-    var columns = [];
+    var columns: string[] = [];
     for (var i = 0; i < 128; i++) {
         columns.push('id' + i + " INTEGER");
     }
 
     it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (" + columns + ")", function(err) {
+        db.run("CREATE TABLE foo (" + columns + ")", function(err: null | Error) {
             done();
         });
     });
@@ -37,7 +36,7 @@ describe('parallel', function() {
     });
 
     it('should verify that the database exists', function() {
-        assert.fileExists('test/tmp/test_parallel_inserts.db');
+        helper.fileExists('test/tmp/test_parallel_inserts.db');
     });
 
     after(function() {

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

@@ -1,9 +1,7 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
 
 describe('can query parquet', function() {
-    var db;
+    var db: sqlite3.Database;
 
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);

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

@@ -1,8 +1,9 @@
-var sqlite3 = require("..");
-var assert = require("assert");
+import * as sqlite3 from "..";
+import * as assert from "assert";
+import {DuckDbError, TableData} from "..";
 
 describe("pathname search support", function () {
-  let db;
+  let db: sqlite3.Database;
   describe("without search paths", () => {
     before((done) => {
       db = new sqlite3.Database(":memory:", done);
@@ -10,19 +11,20 @@ describe("pathname search support", function () {
 
     it("supports a full path", function (done) {
       db.prepare('select * from "test/support/prepare.csv"').all(
-        (err, result) => {
-          assert(err === null);
-          assert(result.length === 5000);
+        (err: null | Error, result: TableData) => {
+          assert.equal(err, null);
+          assert.equal(result.length, 5000);
           done();
         }
       );
     });
 
     it("don't not support a partial path", function (done) {
-      db.prepare('select * from "prepare.csv"').all((err, result) => {
-        assert(err.code === "DUCKDB_NODEJS_ERROR");
-        assert(err.errno === -1);
-        assert(result == null);
+      db.prepare('select * from "prepare.csv"').all((err: null | DuckDbError, result: TableData) => {
+        assert.ok(err);
+        assert.equal(err.code, "DUCKDB_NODEJS_ERROR");
+        assert.equal(err.errno, -1);
+        assert.equal(result, null);
         done();
       });
     });
@@ -37,18 +39,18 @@ describe("pathname search support", function () {
 
     it("supports a full path", function (done) {
       db.prepare('select * from "test/support/prepare.csv"').all(
-        (err, result) => {
-          assert(err === null);
-          assert(result.length === 5000);
+        (err: null | Error, result: TableData) => {
+          assert.equal(err, null);
+          assert.equal(result.length, 5000);
           done();
         }
       );
     });
 
     it("supports a partial path", function (done) {
-      db.prepare('select * from "prepare.csv"').all((err, result) => {
-        assert(err === null);
-        assert(result.length === 5000);
+      db.prepare('select * from "prepare.csv"').all((err: null | Error, result: TableData) => {
+        assert.equal(err, null);
+        assert.equal(result.length, 5000);
         done();
       });
     });
@@ -63,18 +65,18 @@ describe("pathname search support", function () {
 
     it("supports a full path", function (done) {
       db.prepare('select * from "test/support/prepare.csv"').all(
-        (err, result) => {
-          assert(err === null);
-          assert(result.length === 5000);
+        (err: null | Error, result: TableData) => {
+          assert.equal(err, null);
+          assert.equal(result.length, 5000);
           done();
         }
       );
     });
 
     it("supports a partial path", function (done) {
-      db.prepare('select * from "prepare.csv"').all((err, result) => {
-        assert(err === null);
-        assert(result.length === 5000);
+      db.prepare('select * from "prepare.csv"').all((err: null | Error, result: TableData) => {
+        assert.equal(err, null);
+        assert.equal(result.length, 5000);
         done();
       });
     });

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

@@ -1,14 +1,15 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import {DuckDbError, RowData, Statement, TableData} from "..";
 
 describe('prepare', function() {
     describe('invalid SQL', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         var stmt;
         it('should fail preparing a statement with invalid SQL', function(done) {
-            stmt = db.prepare('CRATE TALE foo text bar)', function(err, statement) {
+            stmt = db.prepare('CRATE TALE foo text bar)', function(err: null | DuckDbError, statement: Statement) {
                 if (err && err.errno == sqlite3.ERROR /*&&
                     err.message === 'Parser: syntax error at or near "CRATE' */) {
                     done();
@@ -21,7 +22,7 @@ describe('prepare', function() {
     });
 
     describe('simple prepared statement', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         it('should prepare, run and finalize the statement', function(done) {
@@ -34,7 +35,7 @@ describe('prepare', function() {
     });
 
     describe('inserting and retrieving rows', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         var inserted = 0;
@@ -54,7 +55,7 @@ describe('prepare', function() {
                     i,
                     i * Math.PI,
                      null,
-                    function(err) {
+                    function(err: null | Error) {
                         if (err) throw err;
                         inserted++;
                     }
@@ -67,12 +68,12 @@ describe('prepare', function() {
 
 
         it('should prepare a statement and return values again', function(done) {
-            var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err) {
+            var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err: null | Error) {
                 if (err) throw err;
                 assert.equal(stmt.sql, 'SELECT txt, num, flt, blb FROM foo ORDER BY num');
             });
 
-            stmt.each(function(err, row) {
+            stmt.each(function(err: null | Error, row: RowData) {
                 if (err) throw err;
                 assert.equal(row.txt, 'String ' + retrieved);
                 assert.equal(row.num, retrieved);
@@ -126,7 +127,7 @@ describe('prepare', function() {
 
 
     describe('inserting with accidental undefined', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         var inserted = 0;
@@ -137,10 +138,10 @@ describe('prepare', function() {
         });
 
         it('should insert two rows', function(done) {
-            db.prepare('INSERT INTO foo VALUES(4)').run(function(err) {
+            db.prepare('INSERT INTO foo VALUES(4)').run(function(err: null | Error) {
                 if (err) throw err;
                 inserted++;
-            }).run(undefined, function (err) {
+            }).run(undefined, function (err: null | Error) {
                 // The second time we pass undefined as a parameter. This is
                 // a mistake, but it should either throw an error or be ignored,
                 // not silently fail to run the statement.
@@ -174,13 +175,13 @@ describe('prepare', function() {
         */
 
         it('should retrieve the data', function(done) {
-                    var stmt = db.prepare("SELECT num FROM foo", function(err) {
+                    var stmt = db.prepare("SELECT num FROM foo", function(err: null | Error) {
                         if (err) throw err;
                     });
 
-                    stmt.each(function(err, row) {
+                    stmt.each(function(err: null | Error, row: RowData) {
                         if (err) throw err;
-                        assert(row);
+                        assert.ok(row);
                         assert.equal(row.num, 4);
                         retrieved++;
                     });
@@ -267,7 +268,7 @@ describe('prepare', function() {
     */
 
     describe('prepare() parameter binding', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:',
             function(err) {
                 db.run("CREATE TEMPORARY VIEW foo AS SELECT * FROM read_csv_auto('test/support/prepare.csv')", done)
@@ -291,7 +292,7 @@ describe('prepare', function() {
 
         it('should retrieve particular rows', function(done) {
             db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?")
-                .each(10, 'String 10', function(err, row) {
+                .each(10, 'String 10', function(err: null | Error, row: RowData) {
                     if (err) throw err;
                     assert.equal(row.txt, 'String 10');
                     assert.equal(row.num, 10);
@@ -310,7 +311,7 @@ describe('prepare', function() {
     });
 
     describe('all()', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:',
             function(err) {
                 db.run("CREATE TEMPORARY VIEW foo AS SELECT * FROM read_csv_auto('test/support/prepare.csv')", done)
@@ -322,7 +323,7 @@ describe('prepare', function() {
 
         it('should retrieve particular rows', function(done) {
             db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num")
-                .all(count, function(err, rows) {
+                .all(count, function(err: null | Error, rows: TableData) {
                     if (err) throw err;
                     for (var i = 0; i < rows.length; i++) {
                         assert.equal(rows[i].txt, 'String ' + i);
@@ -343,7 +344,7 @@ describe('prepare', function() {
     });
 
     describe('all()', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:',
             function(err) {
                 db.run("CREATE TEMPORARY VIEW foo AS SELECT * FROM read_csv_auto('test/support/prepare.csv')", done)
@@ -352,7 +353,7 @@ describe('prepare', function() {
 
         it('should retrieve particular rows', function(done) {
            db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000")
-                .all(function(err, rows) {
+                .all(function(err: null | Error, rows: TableData) {
                     if (err) throw err;
                     assert.ok(rows.length === 0);
                 })
@@ -363,7 +364,7 @@ describe('prepare', function() {
     });
 
     describe('high concurrency', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         function randomString() {
@@ -378,10 +379,12 @@ describe('prepare', function() {
         }
 
         // Generate random data.
-        var data = [];
+        var data: [string, number, number, null][] = [];
+        var retrieved_marks: boolean[] = [];
         var length = Math.floor(Math.random() * 1000) + 200;
         for (var i = 0; i < length; i++) {
             data.push([ randomString(), i, i * Math.random(), null ]);
+            retrieved_marks.push(false);
         }
         var inserted = 0;
         var retrieved = 0;
@@ -393,7 +396,7 @@ describe('prepare', function() {
         it('should insert all values', function(done) {
             for (var i = 0; i < data.length; i++) {
                 var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
-                stmt.run(data[i][0], data[i][1], data[i][2], data[i][3], function(err) {
+                stmt.run(data[i][0], data[i][1], data[i][2], data[i][3], function(err: null | Error) {
                     if (err) throw err;
                     inserted++;
                 }).finalize(function(err) {
@@ -405,11 +408,11 @@ describe('prepare', function() {
 
         it('should retrieve all values', function(done) {
             db.prepare("SELECT txt, num, flt, blb FROM foo")
-                .all(function(err, rows) {
+                .all(function(err: null | Error, rows: TableData) {
                     if (err) throw err;
 
                     for (var i = 0; i < rows.length; i++) {
-                        assert.ok(data[rows[i].num] !== true);
+                        assert.ok(retrieved_marks[rows[i].num] !== true);
 
                         assert.equal(rows[i].txt, data[rows[i].num][0]);
                         assert.equal(rows[i].num, data[rows[i].num][1]);
@@ -417,7 +420,7 @@ describe('prepare', function() {
                         //assert.equal(rows[i].blb, data[rows[i].num][3]);
 
                         // Mark the data row as already retrieved.
-                        data[rows[i].num] = true;
+                        retrieved_marks[rows[i].num] = true;
                         retrieved++;
 
                     }
@@ -462,7 +465,7 @@ describe('prepare', function() {
     });
 */
     describe('Database#run() and Database#all()', function() {
-        var db;
+        var db: sqlite3.Database;
         before(function(done) { db = new sqlite3.Database(':memory:', done); });
 
         var inserted = 0;
@@ -482,7 +485,7 @@ describe('prepare', function() {
                     i,
                     i * Math.PI,
                      null,
-                    function(err) {
+                    function(err: null | Error) {
                         if (err) throw err;
                         inserted++;
                         if (inserted == count) done();
@@ -492,7 +495,7 @@ describe('prepare', function() {
         });
 
         it('should retrieve all rows', function(done) {
-            db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
+            db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err: null | Error, rows: TableData) {
                 if (err) throw err;
                 for (var i = 0; i < rows.length; i++) {
                     assert.equal(rows[i].txt, 'String ' + i);
@@ -511,44 +514,44 @@ describe('prepare', function() {
 
         describe('using aggregate functions', function() {
             it("should aggregate string_agg(txt)", function (done) {
-                db.all("SELECT string_agg(txt, ',') as string_agg FROM foo WHERE num < 2", function (err, res) {
+                db.all("SELECT string_agg(txt, ',') as string_agg FROM foo WHERE num < 2", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].string_agg, "String 0,String 1");
                     done(err);
                 });
             });
 
             it("should aggregate min(flt)", function (done) {
-                db.all("SELECT min(flt) as min FROM foo WHERE flt > 0", function (err, res) {
+                db.all("SELECT min(flt) as min FROM foo WHERE flt > 0", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].min, Math.PI);
                     done(err);
                 });
             });
             it("should aggregate max(flt)", function (done) {
-                db.all("SELECT max(flt) as max FROM foo", function (err, res) {
+                db.all("SELECT max(flt) as max FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].max, Math.PI * 999);
                     done(err);
                 });
             });
             it("should aggregate avg(flt)", function (done) {
-                db.all("SELECT avg(flt) as avg FROM foo", function (err, res) {
+                db.all("SELECT avg(flt) as avg FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].avg, 1569.2255304681016);
                     done(err);
                 });
             });
             it("should aggregate first(flt)", function (done) {
-                db.all("SELECT first(flt) as first FROM foo WHERE flt > 0", function (err, res) {
+                db.all("SELECT first(flt) as first FROM foo WHERE flt > 0", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].first, Math.PI);
                     done(err);
                 });
             });
             it("should aggregate approx_count_distinct(flt)", function (done) {
-                db.all("SELECT approx_count_distinct(flt) as approx_count_distinct FROM foo", function (err, res) {
+                db.all("SELECT approx_count_distinct(flt) as approx_count_distinct FROM foo", function (err: null | Error, res: TableData) {
                     assert.ok(res[0].approx_count_distinct >= 950);
                     done(err);
                 });
             });
             it("should aggregate sum(flt)", function (done) {
-                db.all("SELECT sum(flt) as sum FROM foo", function (err, res) {
+                db.all("SELECT sum(flt) as sum FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].sum, 1569225.5304681016);
                     done(err);
                 });
@@ -556,75 +559,75 @@ describe('prepare', function() {
 
 
             it("should aggregate min(num)", function (done) {
-                db.all("SELECT min(num) as min FROM foo WHERE num > 0", function (err, res) {
+                db.all("SELECT min(num) as min FROM foo WHERE num > 0", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].min, 1);
                     done(err);
                 });
             });
             it("should aggregate max(num)", function (done) {
-                db.all("SELECT max(num) as max FROM foo", function (err, res) {
+                db.all("SELECT max(num) as max FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].max, 999);
                     done(err);
                 });
             });
             it("should aggregate count(num)", function (done) {
-                db.all("SELECT count(num) as count FROM foo", function (err, res) {
+                db.all("SELECT count(num) as count FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].count, 1000);
                     done(err);
                 });
             });
             it("should aggregate avg(num)", function (done) {
-                db.all("SELECT avg(num) as avg FROM foo", function (err, res) {
+                db.all("SELECT avg(num) as avg FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].avg, 499.5);
                     done(err);
                 });
             });
             it("should aggregate first(num)", function (done) {
-                db.all("SELECT first(num) as first FROM foo WHERE num > 0", function (err, res) {
+                db.all("SELECT first(num) as first FROM foo WHERE num > 0", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].first, 1);
                     done(err);
                 });
             });
             it("should aggregate approx_count_distinct(num)", function (done) {
-                db.all("SELECT approx_count_distinct(num) as approx_count_distinct FROM foo", function (err, res) {
+                db.all("SELECT approx_count_distinct(num) as approx_count_distinct FROM foo", function (err: null | Error, res: TableData) {
                     assert.ok(res[0].approx_count_distinct >= 950);
                     done(err);
                 });
             });
             it("should aggregate approx_quantile(num, 0.5)", function (done) {
-                db.all("SELECT approx_quantile(num, 0.5) as approx_quantile FROM foo", function (err, res) {
+                db.all("SELECT approx_quantile(num, 0.5) as approx_quantile FROM foo", function (err: null | Error, res: TableData) {
                     assert.ok(res[0].approx_quantile >= 499);
                     done(err);
                 });
             });
             it("should aggregate reservoir_quantile(num, 0.5, 10)", function (done) {
-                db.all("SELECT reservoir_quantile(num, 0.5, 10) as reservoir_quantile FROM foo", function (err, res) {
+                db.all("SELECT reservoir_quantile(num, 0.5, 10) as reservoir_quantile FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].reservoir_quantile, 4);
                     done(err);
                 });
             });
             it("should aggregate var_samp(num)", function (done) {
-                db.all("SELECT var_samp(num) as var_samp FROM foo", function (err, res) {
+                db.all("SELECT var_samp(num) as var_samp FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].var_samp, 83416.66666666667);
                     done(err);
                 });
             });
             it("should aggregate kurtosis(num)", function (done) {
-                db.all("SELECT kurtosis(num) as kurtosis FROM foo", function (err, res) {
+                db.all("SELECT kurtosis(num) as kurtosis FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].kurtosis, -1.1999999999999997);
                     done(err);
                 });
             });
 
             it("should aggregate sum(num)", function (done) {
-                db.all("SELECT sum(num) as sum FROM foo", function (err, res) {
+                db.all("SELECT sum(num) as sum FROM foo", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].sum, 499500);
                     done(err);
                 });
             });
 
             it("should aggregate product(num)", function (done) {
-                db.all("SELECT product(num) as product FROM foo WHERE num < 20 AND num > 0", function (err, res) {
+                db.all("SELECT product(num) as product FROM foo WHERE num < 20 AND num > 0", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].product, 121645100408832000);
                     done(err);
                 });
@@ -632,7 +635,7 @@ describe('prepare', function() {
 
 
             it("should aggregate product(flt)", function (done) {
-                db.all("SELECT product(flt) as product FROM foo WHERE num < 10 AND num > 0", function (err, res) {
+                db.all("SELECT product(flt) as product FROM foo WHERE num < 10 AND num > 0", function (err: null | Error, res: TableData) {
                     assert.equal(res[0].product, 10817125966.120956);
                     done(err);
                 });

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

@@ -1,11 +1,11 @@
-var duckdb = require('..');
-var assert = require('assert');
+import * as duckdb from '..';
+import * as assert from 'assert';
 
 describe('QueryResult', () => {
     const total = 1000;
 
-    let db;
-    let conn;
+    let db: duckdb.Database;
+    let conn: duckdb.Connection;
     before((done) => {
         db = new duckdb.Database(':memory:', () => {
             conn = new duckdb.Connection(db, done);