duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

package/src/duckdb/src/main/relation/cross_product_relation.cpp

@@ -16,14 +16,14 @@ CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_p
 }
 
 unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
 
 unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_unique<JoinRef>(JoinRefType::CROSS);
+	auto cross_product_ref = make_uniq<JoinRef>(JoinRefType::CROSS);
 	cross_product_ref->left = left->GetTableRef();
 	cross_product_ref->right = right->GetTableRef();
 	return std::move(cross_product_ref);

package/src/duckdb/src/main/relation/delete_relation.cpp

@@ -14,7 +14,7 @@ DeleteRelation::DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedE
 }
 
 BoundStatement DeleteRelation::Bind(Binder &binder) {
-	auto basetable = make_unique<BaseTableRef>();
+	auto basetable = make_uniq<BaseTableRef>();
 	basetable->schema_name = schema_name;
 	basetable->table_name = table_name;
 

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -7,15 +7,15 @@
 
 namespace duckdb {
 
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)) {
+ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type)
+    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
-	ExplainStatement explain(std::move(select));
+	ExplainStatement explain(std::move(select), type);
 	return binder.Bind((SQLStatement &)explain);
 }
 

package/src/duckdb/src/main/relation/filter_relation.cpp

@@ -24,17 +24,17 @@ unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
 		// child node is a join: push filter into WHERE clause of select node
 		auto child_node = child->GetQueryNode();
 		D_ASSERT(child_node->type == QueryNodeType::SELECT_NODE);
-		auto &select_node = (SelectNode &)*child_node;
+		auto &select_node = child_node->Cast<SelectNode>();
 		if (!select_node.where_clause) {
 			select_node.where_clause = condition->Copy();
 		} else {
-			select_node.where_clause = make_unique<ConjunctionExpression>(
+			select_node.where_clause = make_uniq<ConjunctionExpression>(
 			    ExpressionType::CONJUNCTION_AND, std::move(select_node.where_clause), condition->Copy());
 		}
 		return child_node;
 	} else {
-		auto result = make_unique<SelectNode>();
-		result->select_list.push_back(make_unique<StarExpression>());
+		auto result = make_uniq<SelectNode>();
+		result->select_list.push_back(make_uniq<StarExpression>());
 		result->from_table = child->GetTableRef();
 		result->where_clause = condition->Copy();
 		return std::move(result);

package/src/duckdb/src/main/relation/insert_relation.cpp

@@ -15,7 +15,7 @@ InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string schema_name,
 
 BoundStatement InsertRelation::Bind(Binder &binder) {
 	InsertStatement stmt;
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 
 	stmt.schema = schema_name;

package/src/duckdb/src/main/relation/join_relation.cpp

@@ -27,14 +27,14 @@ JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> rig
 }
 
 unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
 
 unique_ptr<TableRef> JoinRelation::GetTableRef() {
-	auto join_ref = make_unique<JoinRef>(JoinRefType::REGULAR);
+	auto join_ref = make_uniq<JoinRef>(JoinRefType::REGULAR);
 	join_ref->left = left->GetTableRef();
 	join_ref->right = right->GetTableRef();
 	if (condition) {

package/src/duckdb/src/main/relation/limit_relation.cpp

@@ -14,12 +14,12 @@ LimitRelation::LimitRelation(shared_ptr<Relation> child_p, int64_t limit, int64_
 
 unique_ptr<QueryNode> LimitRelation::GetQueryNode() {
 	auto child_node = child->GetQueryNode();
-	auto limit_node = make_unique<LimitModifier>();
+	auto limit_node = make_uniq<LimitModifier>();
 	if (limit >= 0) {
-		limit_node->limit = make_unique<ConstantExpression>(Value::BIGINT(limit));
+		limit_node->limit = make_uniq<ConstantExpression>(Value::BIGINT(limit));
 	}
 	if (offset > 0) {
-		limit_node->offset = make_unique<ConstantExpression>(Value::BIGINT(offset));
+		limit_node->offset = make_uniq<ConstantExpression>(Value::BIGINT(offset));
 	}
 
 	child_node->modifiers.push_back(std::move(limit_node));

package/src/duckdb/src/main/relation/order_relation.cpp

@@ -14,10 +14,10 @@ OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> o
 }
 
 unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
-	auto select = make_unique<SelectNode>();
+	auto select = make_uniq<SelectNode>();
 	select->from_table = child->GetTableRef();
-	select->select_list.push_back(make_unique<StarExpression>());
-	auto order_node = make_unique<OrderModifier>();
+	select->select_list.push_back(make_uniq<StarExpression>());
+	auto order_node = make_uniq<OrderModifier>();
 	for (idx_t i = 0; i < orders.size(); i++) {
 		order_node->orders.emplace_back(orders[i].type, orders[i].null_order, orders[i].expression->Copy());
 	}

package/src/duckdb/src/main/relation/projection_relation.cpp

@@ -32,12 +32,12 @@ unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
 		result = child->GetQueryNode();
 	} else {
 		// child node is not a join: create a new select node and push the child as a table reference
-		auto select = make_unique<SelectNode>();
+		auto select = make_uniq<SelectNode>();
 		select->from_table = child->GetTableRef();
 		result = std::move(select);
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = (SelectNode &)*result;
+	auto &select_node = result->Cast<SelectNode>();
 	select_node.aggregate_handling = AggregateHandling::NO_AGGREGATES_ALLOWED;
 	select_node.select_list.clear();
 	for (auto &expr : expressions) {

package/src/duckdb/src/main/relation/query_relation.cpp

@@ -39,7 +39,7 @@ unique_ptr<QueryNode> QueryRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> QueryRelation::GetTableRef() {
-	auto subquery_ref = make_unique<SubqueryRef>(GetSelectStatement(), GetAlias());
+	auto subquery_ref = make_uniq<SubqueryRef>(GetSelectStatement(), GetAlias());
 	return std::move(subquery_ref);
 }
 

package/src/duckdb/src/main/relation/read_csv_relation.cpp

@@ -44,8 +44,10 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 	options.auto_detect = true;
 	BufferedCSVReader reader(*context, std::move(options));
 
-	for (idx_t i = 0; i < reader.return_types.size(); i++) {
-		columns.emplace_back(reader.names[i], reader.return_types[i]);
+	auto &types = reader.GetTypes();
+	auto &names = reader.GetNames();
+	for (idx_t i = 0; i < types.size(); i++) {
+		columns.emplace_back(names[i], types[i]);
 	}
 
 	AddNamedParameter("auto_detect", Value::BOOLEAN(true));

package/src/duckdb/src/main/relation/setop_relation.cpp

@@ -16,9 +16,9 @@ SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> r
 }
 
 unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
-	auto result = make_unique<SetOperationNode>();
+	auto result = make_uniq<SetOperationNode>();
 	if (setop_type == SetOperationType::EXCEPT || setop_type == SetOperationType::INTERSECT) {
-		result->modifiers.push_back(make_unique<DistinctModifier>());
+		result->modifiers.push_back(make_uniq<DistinctModifier>());
 	}
 	result->left = left->GetQueryNode();
 	result->right = right->GetQueryNode();

package/src/duckdb/src/main/relation/table_function_relation.cpp

@@ -41,8 +41,8 @@ void TableFunctionRelation::InitializeColumns() {
 }
 
 unique_ptr<QueryNode> TableFunctionRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
@@ -50,29 +50,29 @@ unique_ptr<QueryNode> TableFunctionRelation::GetQueryNode() {
 unique_ptr<TableRef> TableFunctionRelation::GetTableRef() {
 	vector<unique_ptr<ParsedExpression>> children;
 	if (input_relation) { // input relation becomes first parameter if present, always
-		auto subquery = make_unique<SubqueryExpression>();
-		subquery->subquery = make_unique<SelectStatement>();
+		auto subquery = make_uniq<SubqueryExpression>();
+		subquery->subquery = make_uniq<SelectStatement>();
 		subquery->subquery->node = input_relation->GetQueryNode();
 		subquery->subquery_type = SubqueryType::SCALAR;
 		children.push_back(std::move(subquery));
 	}
 	for (auto &parameter : parameters) {
-		children.push_back(make_unique<ConstantExpression>(parameter));
+		children.push_back(make_uniq<ConstantExpression>(parameter));
 	}
 
 	for (auto &parameter : named_parameters) {
 		// Hackity-hack some comparisons with column refs
 		// This is all but pretty, basically the named parameter is the column, the table is empty because that's what
 		// the function binder likes
-		auto column_ref = make_unique<ColumnRefExpression>(parameter.first);
-		auto constant_value = make_unique<ConstantExpression>(parameter.second);
-		auto comparison = make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(column_ref),
-		                                                    std::move(constant_value));
+		auto column_ref = make_uniq<ColumnRefExpression>(parameter.first);
+		auto constant_value = make_uniq<ConstantExpression>(parameter.second);
+		auto comparison = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(column_ref),
+		                                                  std::move(constant_value));
 		children.push_back(std::move(comparison));
 	}
 
-	auto table_function = make_unique<TableFunctionRef>();
-	auto function = make_unique<FunctionExpression>(name, std::move(children));
+	auto table_function = make_uniq<TableFunctionRef>();
+	auto function = make_uniq<FunctionExpression>(name, std::move(children));
 	table_function->function = std::move(function);
 	return std::move(table_function);
 }

package/src/duckdb/src/main/relation/table_relation.cpp

@@ -14,14 +14,14 @@ TableRelation::TableRelation(const std::shared_ptr<ClientContext> &context, uniq
 }
 
 unique_ptr<QueryNode> TableRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
 
 unique_ptr<TableRef> TableRelation::GetTableRef() {
-	auto table_ref = make_unique<BaseTableRef>();
+	auto table_ref = make_uniq<BaseTableRef>();
 	table_ref->schema_name = description->schema;
 	table_ref->table_name = description->table;
 	return std::move(table_ref);

package/src/duckdb/src/main/relation/update_relation.cpp

@@ -17,12 +17,12 @@ UpdateRelation::UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedE
 }
 
 BoundStatement UpdateRelation::Bind(Binder &binder) {
-	auto basetable = make_unique<BaseTableRef>();
+	auto basetable = make_uniq<BaseTableRef>();
 	basetable->schema_name = schema_name;
 	basetable->table_name = table_name;
 
 	UpdateStatement stmt;
-	stmt.set_info = make_unique<UpdateSetInfo>();
+	stmt.set_info = make_uniq<UpdateSetInfo>();
 
 	stmt.set_info->condition = condition ? condition->Copy() : nullptr;
 	stmt.table = std::move(basetable);

package/src/duckdb/src/main/relation/value_relation.cpp

@@ -16,7 +16,7 @@ ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, cons
 		auto &list = values[row_idx];
 		vector<unique_ptr<ParsedExpression>> expressions;
 		for (idx_t col_idx = 0; col_idx < list.size(); col_idx++) {
-			expressions.push_back(make_unique<ConstantExpression>(list[col_idx]));
+			expressions.push_back(make_uniq<ConstantExpression>(list[col_idx]));
 		}
 		this->expressions.push_back(std::move(expressions));
 	}
@@ -31,14 +31,14 @@ ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, cons
 }
 
 unique_ptr<QueryNode> ValueRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
 
 unique_ptr<TableRef> ValueRelation::GetTableRef() {
-	auto table_ref = make_unique<ExpressionListRef>();
+	auto table_ref = make_uniq<ExpressionListRef>();
 	// set the expected types/names
 	if (columns.empty()) {
 		// no columns yet: only set up names

package/src/duckdb/src/main/relation/view_relation.cpp

@@ -14,14 +14,14 @@ ViewRelation::ViewRelation(const std::shared_ptr<ClientContext> &context, string
 }
 
 unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
 
 unique_ptr<TableRef> ViewRelation::GetTableRef() {
-	auto table_ref = make_unique<BaseTableRef>();
+	auto table_ref = make_uniq<BaseTableRef>();
 	table_ref->schema_name = schema_name;
 	table_ref->table_name = view_name;
 	return std::move(table_ref);

package/src/duckdb/src/main/relation/write_csv_relation.cpp

@@ -16,7 +16,7 @@ WriteCSVRelation::WriteCSVRelation(shared_ptr<Relation> child_p, string csv_file
 BoundStatement WriteCSVRelation::Bind(Binder &binder) {
 	CopyStatement copy;
 	copy.select_statement = child->GetQueryNode();
-	auto info = make_unique<CopyInfo>();
+	auto info = make_uniq<CopyInfo>();
 	info->is_from = false;
 	info->file_path = csv_file;
 	info->format = "csv";

package/src/duckdb/src/main/relation/write_parquet_relation.cpp

@@ -16,7 +16,7 @@ WriteParquetRelation::WriteParquetRelation(shared_ptr<Relation> child_p, string
 BoundStatement WriteParquetRelation::Bind(Binder &binder) {
 	CopyStatement copy;
 	copy.select_statement = child->GetQueryNode();
-	auto info = make_unique<CopyInfo>();
+	auto info = make_uniq<CopyInfo>();
 	info->is_from = false;
 	info->file_path = parquet_file;
 	info->format = "parquet";

package/src/duckdb/src/main/relation.cpp

@@ -25,6 +25,7 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/main/relation/join_relation.hpp"
 #include "duckdb/main/relation/value_relation.hpp"
+#include "duckdb/parser/statement/explain_statement.hpp"
 
 namespace duckdb {
 
@@ -82,8 +83,8 @@ shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
 
 	auto expr = std::move(expression_list[0]);
 	for (idx_t i = 1; i < expression_list.size(); i++) {
-		expr = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
-		                                          std::move(expression_list[i]));
+		expr = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+		                                        std::move(expression_list[i]));
 	}
 	return make_shared<FilterRelation>(shared_from_this(), std::move(expr));
 }
@@ -123,7 +124,7 @@ shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const str
 			if (expr->type != ExpressionType::COLUMN_REF) {
 				throw ParserException("Expected a single expression as join condition");
 			}
-			auto &colref = (ColumnRefExpression &)*expr;
+			auto &colref = expr->Cast<ColumnRefExpression>();
 			if (colref.IsQualified()) {
 				throw ParserException("Expected unqualified column for column in USING clause");
 			}
@@ -187,9 +188,9 @@ string Relation::GetAlias() {
 }
 
 unique_ptr<TableRef> Relation::GetTableRef() {
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = GetQueryNode();
-	return make_unique<SubqueryRef>(std::move(select), GetAlias());
+	return make_uniq<SubqueryRef>(std::move(select), GetAlias());
 }
 
 unique_ptr<QueryResult> Relation::Execute() {
@@ -303,8 +304,8 @@ unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
 	return Query(sql);
 }
 
-unique_ptr<QueryResult> Relation::Explain() {
-	auto explain = make_shared<ExplainRelation>(shared_from_this());
+unique_ptr<QueryResult> Relation::Explain(ExplainType type) {
+	auto explain = make_shared<ExplainRelation>(shared_from_this(), type);
 	return explain->Execute();
 }
 

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
 //===--------------------------------------------------------------------===//
@@ -454,11 +474,15 @@ Value CustomExtensionRepository::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 
 void EnableProgressBarSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.enable_progress_bar = ClientConfig().enable_progress_bar;
 }
 
 void EnableProgressBarSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).enable_progress_bar = input.GetValue<bool>();
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.enable_progress_bar = input.GetValue<bool>();
 }
 
 Value EnableProgressBarSetting::GetSetting(ClientContext &context) {
@@ -469,11 +493,15 @@ Value EnableProgressBarSetting::GetSetting(ClientContext &context) {
 // Enable Progress Bar Print
 //===--------------------------------------------------------------------===//
 void EnableProgressBarPrintSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).print_progress_bar = input.GetValue<bool>();
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.print_progress_bar = input.GetValue<bool>();
 }
 
 void EnableProgressBarPrintSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).print_progress_bar = ClientConfig().print_progress_bar;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.print_progress_bar = ClientConfig().print_progress_bar;
 }
 
 Value EnableProgressBarPrintSetting::GetSetting(ClientContext &context) {
@@ -484,16 +512,15 @@ Value EnableProgressBarPrintSetting::GetSetting(ClientContext &context) {
 // Experimental Parallel CSV
 //===--------------------------------------------------------------------===//
 void ExperimentalParallelCSVSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.options.experimental_parallel_csv_reader = input.GetValue<bool>();
+	Printer::Print("experimental_parallel_csv is deprecated and will be removed with the next release - the parallel "
+	               "CSV reader is now standard and does not need to be manually enabled anymore 1");
 }
 
 void ExperimentalParallelCSVSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.experimental_parallel_csv_reader = DBConfig().options.experimental_parallel_csv_reader;
 }
 
 Value ExperimentalParallelCSVSetting::GetSetting(ClientContext &context) {
-	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(config.options.experimental_parallel_csv_reader);
+	return Value();
 }
 
 //===--------------------------------------------------------------------===//
@@ -652,6 +679,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
 //===--------------------------------------------------------------------===//
@@ -670,8 +713,8 @@ void LogQueryPathSetting::SetLocal(ClientContext &context, const Value &input) {
 		client_data.log_query_writer = nullptr;
 	} else {
 		client_data.log_query_writer =
-		    make_unique<BufferedFileWriter>(FileSystem::GetFileSystem(context), path,
-		                                    BufferedFileWriter::DEFAULT_OPEN_FLAGS, client_data.file_opener.get());
+		    make_uniq<BufferedFileWriter>(FileSystem::GetFileSystem(context), path,
+		                                  BufferedFileWriter::DEFAULT_OPEN_FLAGS, client_data.file_opener.get());
 	}
 }
 
@@ -755,7 +798,7 @@ void PerfectHashThresholdSetting::ResetLocal(ClientContext &context) {
 }
 
 void PerfectHashThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto bits = input.GetValue<int32_t>();
+	auto bits = input.GetValue<int64_t>();
 	if (bits < 0 || bits > 32) {
 		throw ParserException("Perfect HT threshold out of range: should be within range 0 - 32");
 	}
@@ -766,6 +809,22 @@ Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
 	return Value::BIGINT(ClientConfig::GetConfig(context).perfect_ht_threshold);
 }
 
+//===--------------------------------------------------------------------===//
+// Pivot Limit
+//===--------------------------------------------------------------------===//
+
+void PivotLimitSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).pivot_limit = ClientConfig().pivot_limit;
+}
+
+void PivotLimitSetting::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).pivot_limit = input.GetValue<uint64_t>();
+}
+
+Value PivotLimitSetting::GetSetting(ClientContext &context) {
+	return Value::BIGINT(ClientConfig::GetConfig(context).pivot_limit);
+}
+
 //===--------------------------------------------------------------------===//
 // PreserveIdentifierCase
 //===--------------------------------------------------------------------===//
@@ -878,13 +937,17 @@ Value ProfilingModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 
 void ProgressBarTimeSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).wait_time = ClientConfig().wait_time;
-	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.wait_time = ClientConfig().wait_time;
+	config.enable_progress_bar = ClientConfig().enable_progress_bar;
 }
 
 void ProgressBarTimeSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).wait_time = input.GetValue<int32_t>();
-	ClientConfig::GetConfig(context).enable_progress_bar = true;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.wait_time = input.GetValue<int32_t>();
+	config.enable_progress_bar = true;
 }
 
 Value ProgressBarTimeSetting::GetSetting(ClientContext &context) {

package/src/duckdb/src/main/stream_query_result.cpp

@@ -66,9 +66,9 @@ unique_ptr<DataChunk> StreamQueryResult::FetchRaw() {
 
 unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
 	if (HasError() || !context) {
-		return make_unique<MaterializedQueryResult>(GetErrorObject());
+		return make_uniq<MaterializedQueryResult>(GetErrorObject());
 	}
-	auto collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
+	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 
 	ColumnDataAppendState append_state;
 	collection->InitializeAppend(append_state);
@@ -79,10 +79,10 @@ unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
 		}
 		collection->Append(append_state, *chunk);
 	}
-	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),
-	                                                   client_properties);
+	auto result =
+	    make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(collection), client_properties);
 	if (HasError()) {
-		return make_unique<MaterializedQueryResult>(GetErrorObject());
+		return make_uniq<MaterializedQueryResult>(GetErrorObject());
 	}
 	return result;
 }

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -39,7 +39,7 @@ void ColumnLifetimeAnalyzer::StandardVisitOperator(LogicalOperator &op) {
 	LogicalOperatorVisitor::VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		// visit the duplicate eliminated columns on the LHS, if any
-		auto &delim_join = (LogicalDelimJoin &)op;
+		auto &delim_join = op.Cast<LogicalDelimJoin>();
 		for (auto &expr : delim_join.duplicate_eliminated_columns) {
 			VisitExpression(&expr);
 		}
@@ -57,12 +57,13 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		analyzer.VisitOperator(*op.children[0]);
 		return;
 	}
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (everything_referenced) {
 			break;
 		}
-		auto &comp_join = (LogicalComparisonJoin &)op;
+		auto &comp_join = op.Cast<LogicalComparisonJoin>();
 		if (comp_join.join_type == JoinType::MARK || comp_join.join_type == JoinType::SEMI ||
 		    comp_join.join_type == JoinType::ANTI) {
 			break;
@@ -115,7 +116,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = (LogicalFilter &)op;
+		auto &filter = op.Cast<LogicalFilter>();
 		if (everything_referenced) {
 			break;
 		}

package/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp

@@ -11,7 +11,7 @@ void CommonAggregateOptimizer::VisitOperator(LogicalOperator &op) {
 	LogicalOperatorVisitor::VisitOperator(op);
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		ExtractCommonAggregates((LogicalAggregate &)op);
+		ExtractCommonAggregates(op.Cast<LogicalAggregate>());
 		break;
 	default:
 		break;
@@ -33,10 +33,10 @@ void CommonAggregateOptimizer::ExtractCommonAggregates(LogicalAggregate &aggr) {
 	idx_t total_erased = 0;
 	for (idx_t i = 0; i < aggr.expressions.size(); i++) {
 		idx_t original_index = i + total_erased;
-		auto entry = aggregate_remap.find(aggr.expressions[i].get());
+		auto entry = aggregate_remap.find(*aggr.expressions[i]);
 		if (entry == aggregate_remap.end()) {
 			// aggregate does not exist yet: add it to the map
-			aggregate_remap[aggr.expressions[i].get()] = i;
+			aggregate_remap[*aggr.expressions[i]] = i;
 			if (i != original_index) {
 				// this aggregate is not erased, however an agregate BEFORE it has been erased
 				// so we need to remap this aggregaet