duckdb 0.3.2-dev685.0 → 0.3.2-dev706.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev685.0",
+  "version": "0.3.2-dev706.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 "3e3b464ce"
-#define DUCKDB_VERSION "0.3.2-dev685"
+#define DUCKDB_SOURCE_ID "18b71004d"
+#define DUCKDB_VERSION "0.3.2-dev706"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //