duckdb 0.3.2-dev10.0 → 0.3.2-dev1000.0

package/src/statement.cpp

@@ -135,30 +135,45 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 
 		for (duckdb::idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
 			Napi::Value value;
+			// set up a new Napi::Object for some data types, e.g. INTERVAL
+			Napi::Object object_value;
+
+			bool is_object_value {false};
 
 			auto dval = chunk.GetValue(col_idx, row_idx);
-			if (dval.is_null) {
+			if (dval.IsNull()) {
 				row_result.Set(node_names[col_idx], env.Null());
 				continue;
 			}
 
 			// TODO templateroo here
 			switch (chunk.data[col_idx].GetType().id()) {
+			case duckdb::LogicalTypeId::BOOLEAN: {
+				value = Napi::Boolean::New(env, duckdb::BooleanValue::Get(dval));
+			} break;
 			case duckdb::LogicalTypeId::INTEGER: {
-				value = Napi::Number::New(env, dval.value_.integer);
+				value = Napi::Number::New(env, duckdb::IntegerValue::Get(dval));
 			} break;
 			case duckdb::LogicalTypeId::FLOAT: {
-				value = Napi::Number::New(env, dval.value_.float_);
+				value = Napi::Number::New(env, duckdb::FloatValue::Get(dval));
 			} break;
 			case duckdb::LogicalTypeId::DOUBLE: {
-				value = Napi::Number::New(env, dval.value_.double_);
+				value = Napi::Number::New(env, duckdb::DoubleValue::Get(dval));
 			} break;
 			case duckdb::LogicalTypeId::BIGINT: {
-				value = Napi::Number::New(env, dval.value_.bigint);
+				value = Napi::Number::New(env, duckdb::BigIntValue::Get(dval));
 			} break;
 			case duckdb::LogicalTypeId::HUGEINT: {
 				value = Napi::Number::New(env, dval.GetValue<double>());
 			} break;
+			case duckdb::LogicalTypeId::INTERVAL: {
+				auto interval = duckdb::IntervalValue::Get(dval);
+				is_object_value = true;
+				object_value = Napi::Object::New(env);
+				object_value.Set("months", interval.months);
+				object_value.Set("days", interval.days);
+				object_value.Set("micros", interval.micros);
+			} break;
 #if (NAPI_VERSION > 4)
 			case duckdb::LogicalTypeId::DATE: {
 				const auto scale = duckdb::Interval::SECS_PER_DAY * duckdb::Interval::MSECS_PER_SEC;
@@ -169,10 +184,11 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 			} break;
 #endif
 			case duckdb::LogicalTypeId::VARCHAR: {
-				value = Napi::String::New(env, dval.str_value);
+				value = Napi::String::New(env, duckdb::StringValue::Get(dval));
 			} break;
 			case duckdb::LogicalTypeId::BLOB: {
-				value = Napi::Buffer<char>::Copy(env, dval.str_value.c_str(), dval.str_value.length());
+				auto &blob = duckdb::StringValue::Get(dval);
+				value = Napi::Buffer<char>::Copy(env, blob.c_str(), blob.length());
 			} break;
 			case duckdb::LogicalTypeId::SQLNULL: {
 				value = env.Null();
@@ -182,7 +198,11 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 				    .ThrowAsJavaScriptException();
 				return env.Null();
 			}
-			row_result.Set(node_names[col_idx], value);
+			if (is_object_value == true) {
+				row_result.Set(node_names[col_idx], object_value);
+			} else {
+				row_result.Set(node_names[col_idx], value);
+			}
 		}
 		result.Set(row_idx, row_result);
 	}

package/test/data_type_support.test.js

@@ -0,0 +1,37 @@
+var sqlite3 = require("..");
+var assert = require("assert");
+
+describe("data type support", function () {
+  let db;
+  before(function (done) {
+    db = new sqlite3.Database(":memory:", done);
+  });
+
+  it("supports BOOLEAN values", function (done) {
+    db.run("CREATE TABLE boolean_table (i BOOLEAN)");
+    const stmt = db.prepare("INSERT INTO boolean_table VALUES (?)");
+    const values = [true, false];
+    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]));
+      done();
+    });
+  });
+  it("supports INTERVAL values", function (done) {
+    db.prepare(`SELECT 
+    INTERVAL 1 MINUTE as minutes,
+    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);
+      assert.deepEqual(row.minutes, { months: 0, days: 0, micros: 60 * 1000 * 1000});
+      assert.deepEqual(row.days, { months: 0, days: 5, micros: 0});
+      assert.deepEqual(row.months, {months: 4, days: 0, micros: 0});
+      assert.deepEqual(row.combined, {months: 4, days: 5, micros: 60 * 1000 * 1000});
+      done();
+    });
+  });
+});

package/test/parquet.js

@@ -0,0 +1,16 @@
+var sqlite3 = require('..');
+var assert = require('assert');
+var helper = require('./support/helper');
+
+describe('can query parquet', function() {
+    var db;
+
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
+
+    it('should be able to read parquet files', function(done) {
+        db.run("select * from parquet_scan('../../data/parquet-testing/userdata1.parquet')", done);
+    });
+
+});