duckdb 0.7.2-dev1867.0 → 0.7.2-dev1898.0

package/src/duckdb/src/main/config.cpp

@@ -78,10 +78,12 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_LOCAL(HomeDirectorySetting),
                                                  DUCKDB_LOCAL(LogQueryPathSetting),
                                                  DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
+                                                 DUCKDB_LOCAL(IntegerDivisionSetting),
                                                  DUCKDB_LOCAL(MaximumExpressionDepthSetting),
                                                  DUCKDB_GLOBAL(MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
+                                                 DUCKDB_LOCAL(OrderedAggregateThreshold),
                                                  DUCKDB_GLOBAL(PasswordSetting),
                                                  DUCKDB_LOCAL(PerfectHashThresholdSetting),
                                                  DUCKDB_LOCAL(PivotLimitSetting),

package/src/duckdb/src/main/settings/settings.cpp

@@ -141,6 +141,26 @@ Value DebugForceNoCrossProduct::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(ClientConfig::GetConfig(context).force_no_cross_product);
 }
 
+//===--------------------------------------------------------------------===//
+// Debug Ordered Aggregate Threshold
+//===--------------------------------------------------------------------===//
+
+void OrderedAggregateThreshold::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).ordered_aggregate_threshold = ClientConfig().ordered_aggregate_threshold;
+}
+
+void OrderedAggregateThreshold::SetLocal(ClientContext &context, const Value &input) {
+	const auto param = input.GetValue<uint64_t>();
+	if (!param) {
+		throw ParserException("Invalid option for PRAGMA ordered_aggregate_threshold, value must be positive");
+	}
+	ClientConfig::GetConfig(context).ordered_aggregate_threshold = param;
+}
+
+Value OrderedAggregateThreshold::GetSetting(ClientContext &context) {
+	return Value::UBIGINT(ClientConfig::GetConfig(context).ordered_aggregate_threshold);
+}
+
 //===--------------------------------------------------------------------===//
 // Debug Window Mode
 //===--------------------------------------------------------------------===//
@@ -660,6 +680,22 @@ Value HomeDirectorySetting::GetSetting(ClientContext &context) {
 	return Value(config.home_directory);
 }
 
+//===--------------------------------------------------------------------===//
+// Integer Division
+//===--------------------------------------------------------------------===//
+void IntegerDivisionSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).integer_division = ClientConfig().integer_division;
+}
+
+void IntegerDivisionSetting::SetLocal(ClientContext &context, const Value &input) {
+	auto &config = ClientConfig::GetConfig(context);
+	config.integer_division = input.GetValue<bool>();
+}
+
+Value IntegerDivisionSetting::GetSetting(ClientContext &context) {
+	auto &config = ClientConfig::GetConfig(context);
+	return Value(config.integer_division);
+}
 //===--------------------------------------------------------------------===//
 // Log Query Path
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -14,7 +14,7 @@ ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &r
 	op->matchers.push_back(make_uniq<ExpressionMatcher>());
 	op->policy = SetMatcher::Policy::SOME;
 	// we only match on simple arithmetic expressions (+, -, *, /)
-	op->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*", "/"});
+	op->function = make_uniq<ManyFunctionMatcher>(unordered_set<string> {"+", "-", "*", "//"});
 	// and only with numeric results
 	op->type = make_uniq<IntegerTypeMatcher>();
 	op->matchers[0]->type = make_uniq<IntegerTypeMatcher>();
@@ -55,8 +55,7 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 			return ExpressionRewriter::ConstantOrNull(std::move(root.children[1 - constant_child]),
 			                                          Value::Numeric(root.return_type, 0));
 		}
-	} else {
-		D_ASSERT(func_name == "/");
+	} else if (func_name == "//") {
 		if (constant_child == 1) {
 			if (constant.value == 1) {
 				// divide by 1, replace with non-constant child
@@ -66,6 +65,8 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 				return make_uniq<BoundConstantExpression>(Value(root.return_type));
 			}
 		}
+	} else {
+		throw InternalException("Unrecognized function name in ArithmeticSimplificationRule");
 	}
 	return nullptr;
 }

package/src/duckdb/src/parser/parser.cpp

@@ -125,7 +125,7 @@ end:
 }
 
 void Parser::ParseQuery(const string &query) {
-	Transformer transformer(options.max_expression_depth);
+	Transformer transformer(options);
 	string parser_error;
 	{
 		// check if there are any unicode spaces in the string

package/src/duckdb/src/parser/transform/expression/transform_operator.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
+#include "duckdb/parser/parser_options.hpp"
 #include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
@@ -24,12 +25,15 @@ unique_ptr<ParsedExpression> Transformer::TransformUnaryOperator(const string &o
 	return std::move(result);
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
+unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
                                                                   unique_ptr<ParsedExpression> right) {
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
 
+	if (options.integer_division && op == "/") {
+		op = "//";
+	}
 	if (op == "~" || op == "!~") {
 		// rewrite 'asdf' SIMILAR TO '.*sd.*' into regexp_full_match('asdf', '.*sd.*')
 		bool invert_similar = op == "!~";
@@ -47,7 +51,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(const string &
 			return make_uniq<ComparisonExpression>(target_type, std::move(children[0]), std::move(children[1]));
 		}
 		// not a special operator: convert to a function expression
-		auto result = make_uniq<FunctionExpression>(op, std::move(children));
+		auto result = make_uniq<FunctionExpression>(std::move(op), std::move(children));
 		result->is_operator = true;
 		return std::move(result);
 	}
@@ -197,7 +201,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		// postfix operator, only ! is currently supported
 		return TransformUnaryOperator(name + "__postfix", std::move(left_expr));
 	} else {
-		return TransformBinaryOperator(name, std::move(left_expr), std::move(right_expr));
+		return TransformBinaryOperator(std::move(name), std::move(left_expr), std::move(right_expr));
 	}
 }
 

package/src/duckdb/src/parser/transformer.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb {
 
@@ -21,12 +22,12 @@ StackChecker::StackChecker(StackChecker &&other) noexcept
 	other.stack_usage = 0;
 }
 
-Transformer::Transformer(idx_t max_expression_depth_p)
-    : parent(nullptr), max_expression_depth(max_expression_depth_p), stack_depth(DConstants::INVALID_INDEX) {
+Transformer::Transformer(ParserOptions &options)
+    : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 Transformer::Transformer(Transformer *parent)
-    : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
+    : parent(parent), options(parent->options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 Transformer::~Transformer() {
@@ -63,10 +64,10 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 		node = node->parent;
 	}
 	D_ASSERT(node->stack_depth != DConstants::INVALID_INDEX);
-	if (node->stack_depth + extra_stack >= max_expression_depth) {
+	if (node->stack_depth + extra_stack >= options.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);
+		                      options.max_expression_depth);
 	}
 	return StackChecker(*node, extra_stack);
 }