duckdb 0.3.2-dev696.0 → 0.3.2-dev709.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev696.0",
+  "version": "0.3.2-dev709.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -138060,6 +138060,7 @@ typedef struct PGCreateEnumStmt
 namespace duckdb {
 
 class ColumnDefinition;
+class StackChecker;
 struct OrderByNode;
 struct CopyInfo;
 struct CommonTableExpressionInfo;
@@ -138070,10 +138071,10 @@ struct GroupingExpressionMap;
 class Transformer {
 	static constexpr const idx_t DEFAULT_MAX_EXPRESSION_DEPTH = 1000;
 
+	friend class StackChecker;
+
 public:
-	explicit Transformer(Transformer *parent = nullptr, idx_t max_expression_depth_p = DEFAULT_MAX_EXPRESSION_DEPTH)
-	    : parent(parent), max_expression_depth(parent ? parent->max_expression_depth : max_expression_depth_p) {
-	}
+	explicit Transformer(Transformer *parent = nullptr, idx_t max_expression_depth_p = DEFAULT_MAX_EXPRESSION_DEPTH);
 
 	//! Transforms a Postgres parse tree into a set of SQL Statements
 	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
@@ -138285,14 +138286,23 @@ private:
 	unique_ptr<SampleOptions> TransformSampleOptions(duckdb_libpgquery::PGNode *options);
 
 private:
-	//! Default stack limit of the transformer
-	constexpr static idx_t MAX_STACK_SIZE = 1024 * 100;
-	//! For iterative functions that create recursive objects, this is our default stack size per element
-	constexpr static idx_t DEFAULT_ENTRY_STACK_SIZE = 100;
-	int *root = nullptr;
+	//! Current stack depth
+	idx_t stack_depth;
+
+	void InitializeStackCheck();
+	StackChecker StackCheck(idx_t extra_stack = 1);
+};
+
+class StackChecker {
+public:
+	StackChecker(Transformer &transformer, idx_t stack_usage);
+	~StackChecker();
+	StackChecker(StackChecker &&) noexcept;
+	StackChecker(const StackChecker &) = delete;
 
-	void InitializeStackCheck(int *stack_check_var);
-	void StackCheck(idx_t extra_stack = 0);
+private:
+	Transformer &transformer;
+	idx_t stack_usage;
 };
 
 } // namespace duckdb
@@ -140340,7 +140350,7 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			throw NotImplementedException("Unimplemented subscript type");
 		}
 		list_size++;
-		StackCheck(list_size * DEFAULT_ENTRY_STACK_SIZE);
+		StackCheck(list_size);
 	}
 	return result;
 }
@@ -140667,7 +140677,7 @@ unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery:
 		return nullptr;
 	}
 
-	StackCheck();
+	auto stack_checker = StackCheck();
 
 	switch (node->type) {
 	case duckdb_libpgquery::T_PGColumnRef:
@@ -144158,7 +144168,7 @@ namespace duckdb {
 
 unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt *stmt) {
 	D_ASSERT(stmt->type == duckdb_libpgquery::T_PGSelectStmt);
-	StackCheck();
+	auto stack_checker = StackCheck();
 
 	unique_ptr<QueryNode> node;
 
@@ -144544,7 +144554,7 @@ unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root)
 				cur_root = result.get();
 			}
 			list_size++;
-			StackCheck(list_size * DEFAULT_ENTRY_STACK_SIZE);
+			StackCheck(list_size);
 		}
 		return move(result);
 	}
@@ -144695,7 +144705,7 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNode *n) {
-	StackCheck();
+	auto stack_checker = StackCheck();
 
 	switch (n->type) {
 	case duckdb_libpgquery::T_PGRangeVar:
@@ -144740,9 +144750,27 @@ unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNod
 
 namespace duckdb {
 
+StackChecker::StackChecker(Transformer &transformer_p, idx_t stack_usage_p)
+    : transformer(transformer_p), stack_usage(stack_usage_p) {
+	transformer.stack_depth += stack_usage;
+}
+
+StackChecker::~StackChecker() {
+	transformer.stack_depth -= stack_usage;
+}
+
+StackChecker::StackChecker(StackChecker &&other) noexcept
+    : transformer(other.transformer), stack_usage(other.stack_usage) {
+	other.stack_usage = 0;
+}
+
+Transformer::Transformer(Transformer *parent, idx_t max_expression_depth_p)
+    : parent(parent), max_expression_depth(parent ? parent->max_expression_depth : max_expression_depth_p),
+      stack_depth(DConstants::INVALID_INDEX) {
+}
+
 bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
-	int stack_check_var;
-	InitializeStackCheck(&stack_check_var);
+	InitializeStackCheck();
 	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
 		SetParamCount(0);
 		auto stmt = TransformStatement((duckdb_libpgquery::PGNode *)entry->data.ptr_value);
@@ -144753,24 +144781,20 @@ bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<uni
 	return true;
 }
 
-void Transformer::InitializeStackCheck(int *stack_check_var) {
-	this->root = stack_check_var;
+void Transformer::InitializeStackCheck() {
+	stack_depth = 0;
 }
 
-void Transformer::StackCheck(idx_t extra_stack) {
-	if (!root) {
-		return;
+StackChecker Transformer::StackCheck(idx_t extra_stack) {
+	auto node = this;
+	while (node->parent) {
+		node = node->parent;
 	}
-	int current_stack_var;
-	if (&current_stack_var > root) {
-		throw InternalException("Transformer::StackCheck variables are incorrectly set up");
-	}
-	idx_t stack_size = root - &current_stack_var + extra_stack;
-	if (stack_size > MAX_STACK_SIZE) {
-		throw ParserException(
-		    "Stack usage in parsing is too high: the query tree is too deep (stack usage %lld, max stack usage %lld)",
-		    stack_size, MAX_STACK_SIZE);
+	D_ASSERT(node->stack_depth != DConstants::INVALID_INDEX);
+	if (node->stack_depth + extra_stack >= max_expression_depth) {
+		throw ParserException("Max expression depth limit of %lld exceeded", max_expression_depth);
 	}
+	return StackChecker(*node, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "a679c6b8b"
-#define DUCKDB_VERSION "0.3.2-dev696"
+#define DUCKDB_SOURCE_ID "0cb16079e"
+#define DUCKDB_VERSION "0.3.2-dev709"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //

package/src/statement.cpp

@@ -135,6 +135,10 @@ 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) {
@@ -159,6 +163,13 @@ static Napi::Value convert_chunk(Napi::Env &env, std::vector<std::string> names,
 			case duckdb::LogicalTypeId::HUGEINT: {
 				value = Napi::Number::New(env, dval.GetValue<double>());
 			} break;
+			case duckdb::LogicalTypeId::INTERVAL: {
+				is_object_value = true;
+				object_value = Napi::Object::New(env);
+				object_value.Set("months", dval.value_.interval.months);
+				object_value.Set("days", dval.value_.interval.days);
+				object_value.Set("micros", dval.value_.interval.micros);
+			} break;
 #if (NAPI_VERSION > 4)
 			case duckdb::LogicalTypeId::DATE: {
 				const auto scale = duckdb::Interval::SECS_PER_DAY * duckdb::Interval::MSECS_PER_SEC;
@@ -185,7 +196,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

@@ -20,4 +20,18 @@ describe("data type support", function () {
       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();
+    });
+  });
 });