duckdb 0.3.5-dev359.0 → 0.3.5-dev368.0

package/package.json

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

package/src/duckdb.cpp

@@ -113027,6 +113027,7 @@ bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result)
 ParserOptions ClientContext::GetParserOptions() {
 	ParserOptions options;
 	options.preserve_identifier_case = ClientConfig::GetConfig(*this).preserve_identifier_case;
+	options.max_expression_depth = ClientConfig::GetConfig(*this).max_expression_depth;
 	return options;
 }
 
@@ -113246,6 +113247,16 @@ struct LogQueryPathSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct MaximumExpressionDepthSetting {
+	static constexpr const char *Name = "max_expression_depth";
+	static constexpr const char *Description =
+	    "The maximum expression depth limit in the parser. WARNING: increasing this setting and using very deep "
+	    "expressions might lead to stack overflow errors.";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct MaximumMemorySetting {
 	static constexpr const char *Name = "max_memory";
 	static constexpr const char *Description = "The maximum memory of the system (e.g. 1GB)";
@@ -113379,6 +113390,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(ExternalThreadsSetting),
                                                  DUCKDB_GLOBAL(ForceCompressionSetting),
                                                  DUCKDB_LOCAL(LogQueryPathSetting),
+                                                 DUCKDB_LOCAL(MaximumExpressionDepthSetting),
                                                  DUCKDB_GLOBAL(MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
@@ -126949,6 +126961,17 @@ Value LogQueryPathSetting::GetSetting(ClientContext &context) {
 	return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value();
 }
 
+//===--------------------------------------------------------------------===//
+// Maximum Expression Depth
+//===--------------------------------------------------------------------===//
+void MaximumExpressionDepthSetting::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).max_expression_depth = input.GetValue<uint64_t>();
+}
+
+Value MaximumExpressionDepthSetting::GetSetting(ClientContext &context) {
+	return Value::UBIGINT(ClientConfig::GetConfig(context).max_expression_depth);
+}
+
 //===--------------------------------------------------------------------===//
 // Maximum Memory
 //===--------------------------------------------------------------------===//
@@ -149577,12 +149600,11 @@ struct GroupingExpressionMap;
 //! The transformer class is responsible for transforming the internal Postgres
 //! parser representation into the DuckDB representation
 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);
+	explicit Transformer(idx_t max_expression_depth_p);
+	explicit Transformer(Transformer *parent);
 
 	//! Transforms a Postgres parse tree into a set of SQL Statements
 	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
@@ -149971,7 +149993,7 @@ Parser::Parser(ParserOptions options_p) : options(options_p) {
 }
 
 void Parser::ParseQuery(const string &query) {
-	Transformer transformer;
+	Transformer transformer(options.max_expression_depth);
 	{
 		PostgresParser::SetPreserveIdentifierCase(options.preserve_identifier_case);
 		PostgresParser parser;
@@ -156945,9 +156967,12 @@ StackChecker::StackChecker(StackChecker &&other) noexcept
 	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) {
+Transformer::Transformer(idx_t max_expression_depth_p)
+    : parent(nullptr), max_expression_depth(max_expression_depth_p), stack_depth(DConstants::INVALID_INDEX) {
+}
+
+Transformer::Transformer(Transformer *parent)
+    : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
@@ -156973,7 +156998,9 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 	}
 	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);
+		throw ParserException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
+		                      "increase the maximum expression depth.",
+		                      max_expression_depth);
 	}
 	return StackChecker(*node, extra_stack);
 }

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "35411c758"
-#define DUCKDB_VERSION "v0.3.5-dev359"
+#define DUCKDB_SOURCE_ID "14b9456ba"
+#define DUCKDB_VERSION "v0.3.5-dev368"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17200,6 +17200,8 @@ struct ClientConfig {
 	//! Preserve identifier case while parsing.
 	//! If false, all unquoted identifiers are lower-cased (e.g. "MyTable" -> "mytable").
 	bool preserve_identifier_case = true;
+	//! The maximum expression depth limit in the parser
+	idx_t max_expression_depth = 1000;
 
 	// Whether or not aggressive query verification is enabled
 	bool query_verification_enabled = false;
@@ -21375,6 +21377,7 @@ namespace duckdb {
 
 struct ParserOptions {
 	bool preserve_identifier_case = true;
+	idx_t max_expression_depth = 1000;
 };
 
 //! The parser is responsible for parsing the query and converting it into a set