duckdb 0.3.5-dev75.0 → 0.3.5-dev758.0

package/src/statement.cpp

@@ -121,6 +121,89 @@ static duckdb::Value bind_parameter(const Napi::Value source) {
 	return duckdb::Value();
 }
 
+static Napi::Value convert_col_val(Napi::Env &env, duckdb::Value dval, duckdb::LogicalTypeId id) {
+	Napi::Value value;
+
+	// TODO templateroo here
+	switch (id) {
+	case duckdb::LogicalTypeId::BOOLEAN: {
+		value = Napi::Boolean::New(env, duckdb::BooleanValue::Get(dval));
+	} break;
+	case duckdb::LogicalTypeId::INTEGER: {
+		value = Napi::Number::New(env, duckdb::IntegerValue::Get(dval));
+	} break;
+	case duckdb::LogicalTypeId::FLOAT: {
+		value = Napi::Number::New(env, duckdb::FloatValue::Get(dval));
+	} break;
+	case duckdb::LogicalTypeId::DOUBLE: {
+		value = Napi::Number::New(env, duckdb::DoubleValue::Get(dval));
+	} break;
+	case duckdb::LogicalTypeId::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::DECIMAL: {
+		value = Napi::Number::New(env, dval.GetValue<double>());
+	} break;
+	case duckdb::LogicalTypeId::INTERVAL: {
+		auto interval = duckdb::IntervalValue::Get(dval);
+		auto object_value = Napi::Object::New(env);
+		object_value.Set("months", interval.months);
+		object_value.Set("days", interval.days);
+		object_value.Set("micros", interval.micros);
+		value = object_value;
+	} break;
+#if (NAPI_VERSION > 4)
+	case duckdb::LogicalTypeId::DATE: {
+		const auto scale = duckdb::Interval::SECS_PER_DAY * duckdb::Interval::MSECS_PER_SEC;
+		value = Napi::Date::New(env, double(dval.GetValue<int32_t>() * scale));
+	} break;
+	case duckdb::LogicalTypeId::TIMESTAMP:
+	case duckdb::LogicalTypeId::TIMESTAMP_TZ: {
+		value = Napi::Date::New(env, double(dval.GetValue<int64_t>() / duckdb::Interval::MICROS_PER_MSEC));
+	} break;
+#endif
+	case duckdb::LogicalTypeId::VARCHAR: {
+		value = Napi::String::New(env, duckdb::StringValue::Get(dval));
+	} break;
+	case duckdb::LogicalTypeId::BLOB: {
+		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();
+	} break;
+	case duckdb::LogicalTypeId::LIST: {
+		auto child_type = duckdb::ListType::GetChildType(dval.type());
+		auto &child_values = duckdb::ListValue::GetChildren(dval);
+		auto object_value = Napi::Array::New(env);
+		for (duckdb::idx_t child_idx = 0; child_idx < child_values.size(); child_idx++) {
+			auto child_value = child_values.at(child_idx);
+			object_value.Set(child_idx, convert_col_val(env, child_value, child_type.id()));
+		}
+		value = object_value;
+	} break;
+	case duckdb::LogicalTypeId::STRUCT: {
+		auto &child_types = duckdb::StructType::GetChildTypes(dval.type());
+		auto &child_values = duckdb::StructValue::GetChildren(dval);
+		auto object_value = Napi::Object::New(env);
+		for (duckdb::idx_t child_idx = 0; child_idx < child_values.size(); child_idx++) {
+			auto child_value = child_values.at(child_idx);
+			auto child_type = child_types.at(child_idx);
+			object_value.Set(child_type.first, convert_col_val(env, child_value, child_type.second.id()));
+		}
+		value = object_value;
+	} break;
+	default:
+		Napi::Error::New(env, "Data type is not supported " + dval.type().ToString()).ThrowAsJavaScriptException();
+		return env.Null();
+	}
+
+	return value;
+}
+
 static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names, duckdb::DataChunk &chunk) {
 	Napi::EscapableHandleScope scope(env);
 	std::vector<Napi::String> node_names;
@@ -134,75 +217,13 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 		Napi::Object row_result = Napi::Object::New(env);
 
 		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);
+			duckdb::Value dval = chunk.GetValue(col_idx, row_idx);
 			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, duckdb::IntegerValue::Get(dval));
-			} break;
-			case duckdb::LogicalTypeId::FLOAT: {
-				value = Napi::Number::New(env, duckdb::FloatValue::Get(dval));
-			} break;
-			case duckdb::LogicalTypeId::DOUBLE: {
-				value = Napi::Number::New(env, duckdb::DoubleValue::Get(dval));
-			} break;
-			case duckdb::LogicalTypeId::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;
-				value = Napi::Date::New(env, double(dval.GetValue<int32_t>() * scale));
-			} break;
-			case duckdb::LogicalTypeId::TIMESTAMP: {
-				value = Napi::Date::New(env, double(dval.GetValue<int64_t>() / duckdb::Interval::MICROS_PER_MSEC));
-			} break;
-#endif
-			case duckdb::LogicalTypeId::VARCHAR: {
-				value = Napi::String::New(env, duckdb::StringValue::Get(dval));
-			} break;
-			case duckdb::LogicalTypeId::BLOB: {
-				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();
-			} break;
-			default:
-				Napi::Error::New(env, "Data type is not supported " + dval.type().ToString())
-				    .ThrowAsJavaScriptException();
-				return env.Null();
-			}
-			if (is_object_value == true) {
-				row_result.Set(node_names[col_idx], object_value);
-			} else {
-				row_result.Set(node_names[col_idx], value);
-			}
+			row_result.Set(node_names[col_idx], convert_col_val(env, dval, chunk.data[col_idx].GetType().id()));
 		}
 		result.Set(row_idx, row_result);
 	}

package/test/data_type_support.test.js

@@ -21,16 +21,73 @@ describe("data type support", function () {
     });
   });
   it("supports INTERVAL values", function (done) {
-    db.prepare(`SELECT 
+    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) => {
+    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});
+      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();
+    });
+  });
+  it("supports STRUCT values", function (done) {
+    db.prepare(`SELECT {'x': 1, 'y': 2, 'z': {'a': 'b'}} as struct`).each(
+      (err, row) => {
+        assert.deepEqual(row.struct, { x: 1, y: 2, z: { a: "b" } });
+        done();
+      }
+    );
+  });
+  it("supports LIST values", function (done) {
+    db.prepare(`SELECT ['duck', 'duck', 'goose'] as list`).each((err, row) => {
+      assert.deepEqual(row.list, ["duck", "duck", "goose"]);
+      done();
+    });
+  });
+  it("supports DATE values", function (done) {
+    db.prepare(`SELECT '2021-01-01'::DATE as dt;`).each((err, row) => {
+      assert(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);
+      assert.deepEqual(row.ts, new Date(Date.UTC(2021, 0, 1)));
+      done();
+    });
+  });
+  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);
+      assert.deepEqual(row.tstz, new Date(Date.UTC(2021, 0, 1)));
+      done();
+    });
+  });
+  it("supports DECIMAL values", function (done) {
+    db.run("CREATE TABLE decimal_table (d DECIMAL(24, 6))");
+    const stmt = db.prepare("INSERT INTO decimal_table VALUES (?)");
+    const values = [0, -1, 23534642362547.543463];
+    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]));
       done();
     });
   });

package/test/prepare.test.js

@@ -543,7 +543,7 @@ describe('prepare', function() {
             });
             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) {
-                    assert.ok(res[0].approx_count_distinct >= 1000);
+                    assert.ok(res[0].approx_count_distinct >= 950);
                     done(err);
                 });
             });
@@ -587,7 +587,7 @@ describe('prepare', function() {
             });
             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) {
-                    assert.ok(res[0].approx_count_distinct >= 1000);
+                    assert.ok(res[0].approx_count_distinct >= 950);
                     done(err);
                 });
             });