duckdb 1.1.2-dev4.0 → 1.1.2-dev6.0

package/src/duckdb/src/main/query_profiler.cpp

@@ -121,6 +121,7 @@ bool QueryProfiler::OperatorRequiresProfiling(PhysicalOperatorType op_type) {
 	case PhysicalOperatorType::UNION:
 	case PhysicalOperatorType::RECURSIVE_CTE:
 	case PhysicalOperatorType::EMPTY_RESULT:
+	case PhysicalOperatorType::EXTENSION:
 		return true;
 	default:
 		return false;
@@ -134,9 +135,12 @@ void QueryProfiler::Finalize(ProfilingNode &node) {
 
 		auto &info = node.GetProfilingInfo();
 		auto type = PhysicalOperatorType(info.GetMetricValue<uint8_t>(MetricsType::OPERATOR_TYPE));
-		if (type == PhysicalOperatorType::UNION && info.Enabled(MetricsType::OPERATOR_CARDINALITY)) {
-			info.AddToMetric(MetricsType::OPERATOR_CARDINALITY,
-			                 child->GetProfilingInfo().metrics[MetricsType::OPERATOR_CARDINALITY].GetValue<idx_t>());
+		if (type == PhysicalOperatorType::UNION &&
+		    info.Enabled(info.expanded_settings, MetricsType::OPERATOR_CARDINALITY)) {
+
+			auto &child_info = child->GetProfilingInfo();
+			auto value = child_info.metrics[MetricsType::OPERATOR_CARDINALITY].GetValue<idx_t>();
+			info.AddToMetric(MetricsType::OPERATOR_CARDINALITY, value);
 		}
 	}
 }
@@ -147,12 +151,14 @@ void QueryProfiler::StartExplainAnalyze() {
 
 template <class METRIC_TYPE>
 static void GetCumulativeMetric(ProfilingNode &node, MetricsType cumulative_metric, MetricsType child_metric) {
-	node.GetProfilingInfo().metrics[cumulative_metric] = node.GetProfilingInfo().metrics[child_metric];
+	auto &info = node.GetProfilingInfo();
+	info.metrics[cumulative_metric] = info.metrics[child_metric];
+
 	for (idx_t i = 0; i < node.GetChildCount(); i++) {
 		auto child = node.GetChild(i);
 		GetCumulativeMetric<METRIC_TYPE>(*child, cumulative_metric, child_metric);
-		node.GetProfilingInfo().AddToMetric(
-		    cumulative_metric, child->GetProfilingInfo().metrics[cumulative_metric].GetValue<METRIC_TYPE>());
+		auto value = child->GetProfilingInfo().metrics[cumulative_metric].GetValue<METRIC_TYPE>();
+		info.AddToMetric(cumulative_metric, value);
 	}
 }
 
@@ -174,51 +180,52 @@ void QueryProfiler::EndQuery() {
 	}
 
 	main_query.End();
-	if (root && root->GetProfilingInfo().Enabled(MetricsType::OPERATOR_CARDINALITY)) {
-		Finalize(*root->GetChild(0));
+	if (root) {
+		auto &info = root->GetProfilingInfo();
+		if (info.Enabled(info.expanded_settings, MetricsType::OPERATOR_CARDINALITY)) {
+			Finalize(*root->GetChild(0));
+		}
 	}
 	running = false;
 
 	// Print or output the query profiling after query termination.
 	// EXPLAIN ANALYZE output is not written by the profiler.
 	if (IsEnabled() && !is_explain_analyze) {
-		// Expand the query info.
 		if (root) {
 			auto &info = root->GetProfilingInfo();
 			info = ProfilingInfo(ClientConfig::GetConfig(context).profiler_settings);
+			auto &child_info = root->children[0]->GetProfilingInfo();
 			info.metrics[MetricsType::QUERY_NAME] = query_info.query_name;
 
-			if (info.Enabled(MetricsType::BLOCKED_THREAD_TIME)) {
+			auto &settings = info.expanded_settings;
+			if (info.Enabled(settings, MetricsType::BLOCKED_THREAD_TIME)) {
 				info.metrics[MetricsType::BLOCKED_THREAD_TIME] = query_info.blocked_thread_time;
 			}
-			if (info.Enabled(MetricsType::OPERATOR_TIMING)) {
-				info.metrics[MetricsType::OPERATOR_TIMING] = main_query.Elapsed();
+			if (info.Enabled(settings, MetricsType::LATENCY)) {
+				info.metrics[MetricsType::LATENCY] = main_query.Elapsed();
+			}
+			if (info.Enabled(settings, MetricsType::ROWS_RETURNED)) {
+				info.metrics[MetricsType::ROWS_RETURNED] = child_info.metrics[MetricsType::OPERATOR_CARDINALITY];
 			}
-			if (info.Enabled(MetricsType::CPU_TIME)) {
+			if (info.Enabled(settings, MetricsType::CPU_TIME)) {
 				GetCumulativeMetric<double>(*root, MetricsType::CPU_TIME, MetricsType::OPERATOR_TIMING);
 			}
-			if (info.Enabled(MetricsType::CUMULATIVE_CARDINALITY)) {
+			if (info.Enabled(settings, MetricsType::CUMULATIVE_CARDINALITY)) {
 				GetCumulativeMetric<idx_t>(*root, MetricsType::CUMULATIVE_CARDINALITY,
 				                           MetricsType::OPERATOR_CARDINALITY);
 			}
-			if (info.Enabled(MetricsType::CUMULATIVE_ROWS_SCANNED)) {
+			if (info.Enabled(settings, MetricsType::CUMULATIVE_ROWS_SCANNED)) {
 				GetCumulativeMetric<idx_t>(*root, MetricsType::CUMULATIVE_ROWS_SCANNED,
 				                           MetricsType::OPERATOR_ROWS_SCANNED);
 			}
+			if (info.Enabled(settings, MetricsType::RESULT_SET_SIZE)) {
+				info.metrics[MetricsType::RESULT_SET_SIZE] = child_info.metrics[MetricsType::RESULT_SET_SIZE];
+			}
 
 			MoveOptimizerPhasesToRoot();
-			if (info.Enabled(MetricsType::CUMULATIVE_OPTIMIZER_TIMING)) {
+			if (info.Enabled(settings, MetricsType::CUMULATIVE_OPTIMIZER_TIMING)) {
 				info.metrics.at(MetricsType::CUMULATIVE_OPTIMIZER_TIMING) = GetCumulativeOptimizers(*root);
 			}
-
-			if (info.Enabled(MetricsType::OPERATOR_TYPE)) {
-				info.settings.erase(MetricsType::OPERATOR_TYPE);
-			}
-
-			if (info.Enabled(MetricsType::RESULT_SET_SIZE)) {
-				info.metrics[MetricsType::RESULT_SET_SIZE] =
-				    root->children[0]->GetProfilingInfo().metrics[MetricsType::RESULT_SET_SIZE];
-			}
 		}
 
 		string tree = ToString();
@@ -283,34 +290,20 @@ void QueryProfiler::EndPhase() {
 	}
 }
 
-bool SettingIsEnabled(const profiler_settings_t &settings, MetricsType metric) {
-	if (settings.find(metric) != settings.end()) {
-		return true;
-	}
-
-	switch (metric) {
-	case MetricsType::OPERATOR_TIMING:
-		return SettingIsEnabled(settings, MetricsType::CPU_TIME);
-	case MetricsType::OPERATOR_CARDINALITY:
-		return SettingIsEnabled(settings, MetricsType::CUMULATIVE_CARDINALITY);
-	case MetricsType::OPERATOR_ROWS_SCANNED:
-		return SettingIsEnabled(settings, MetricsType::CUMULATIVE_ROWS_SCANNED);
-	default:
-		break;
-	}
-
-	return false;
-}
-
 OperatorProfiler::OperatorProfiler(ClientContext &context) : context(context) {
 	enabled = QueryProfiler::Get(context).IsEnabled();
-	auto &settings = ClientConfig::GetConfig(context).profiler_settings;
+	auto &context_metrics = ClientConfig::GetConfig(context).profiler_settings;
 
-	profiler_settings_t op_metrics = ProfilingInfo::DefaultOperatorSettings();
-	for (auto &metric : op_metrics) {
-		if (SettingIsEnabled(settings, metric)) {
-			operator_settings.insert(metric);
-		}
+	// Expand.
+	for (const auto metric : context_metrics) {
+		settings.insert(metric);
+		ProfilingInfo::Expand(settings, metric);
+	}
+
+	// Reduce.
+	auto root_metrics = ProfilingInfo::DefaultRootSettings();
+	for (const auto metric : root_metrics) {
+		settings.erase(metric);
 	}
 }
 
@@ -318,15 +311,13 @@ void OperatorProfiler::StartOperator(optional_ptr<const PhysicalOperator> phys_o
 	if (!enabled) {
 		return;
 	}
-
 	if (active_operator) {
 		throw InternalException("OperatorProfiler: Attempting to call StartOperator while another operator is active");
 	}
-
 	active_operator = phys_op;
 
-	// start timing for current element
-	if (HasOperatorSetting(MetricsType::OPERATOR_TIMING)) {
+	// Start the timing of the current operator.
+	if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_TIMING)) {
 		op.Start();
 	}
 }
@@ -335,26 +326,22 @@ void OperatorProfiler::EndOperator(optional_ptr<DataChunk> chunk) {
 	if (!enabled) {
 		return;
 	}
-
 	if (!active_operator) {
 		throw InternalException("OperatorProfiler: Attempting to call EndOperator while another operator is active");
 	}
 
-	if (!operator_settings.empty()) {
-		// get the operator info for the current element
-		auto &curr_operator_info = GetOperatorInfo(*active_operator);
-
-		// finish timing for the current element
-		if (HasOperatorSetting(MetricsType::OPERATOR_TIMING)) {
+	if (!settings.empty()) {
+		auto &info = GetOperatorInfo(*active_operator);
+		if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_TIMING)) {
 			op.End();
-			curr_operator_info.AddTime(op.Elapsed());
+			info.AddTime(op.Elapsed());
 		}
-		if (HasOperatorSetting(MetricsType::OPERATOR_CARDINALITY) && chunk) {
-			curr_operator_info.AddReturnedElements(chunk->size());
+		if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_CARDINALITY) && chunk) {
+			info.AddReturnedElements(chunk->size());
 		}
-		if (HasOperatorSetting(MetricsType::RESULT_SET_SIZE) && chunk) {
-			idx_t result_set_size = chunk->GetAllocationSize();
-			curr_operator_info.AddResultSetSize(result_set_size);
+		if (ProfilingInfo::Enabled(settings, MetricsType::RESULT_SET_SIZE) && chunk) {
+			auto result_set_size = chunk->GetAllocationSize();
+			info.AddResultSetSize(result_set_size);
 		}
 	}
 	active_operator = nullptr;
@@ -364,11 +351,10 @@ OperatorInformation &OperatorProfiler::GetOperatorInfo(const PhysicalOperator &p
 	auto entry = timings.find(phys_op);
 	if (entry != timings.end()) {
 		return entry->second;
-	} else {
-		// add new entry
-		timings[phys_op] = OperatorInformation();
-		return timings[phys_op];
 	}
+	// Add a new entry.
+	timings[phys_op] = OperatorInformation();
+	return timings[phys_op];
 }
 
 void OperatorProfiler::Flush(const PhysicalOperator &phys_op) {
@@ -389,30 +375,31 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 		auto &op = node.first.get();
 		auto entry = tree_map.find(op);
 		D_ASSERT(entry != tree_map.end());
+
 		auto &tree_node = entry->second.get();
+		auto &info = tree_node.GetProfilingInfo();
 
-		if (profiler.HasOperatorSetting(MetricsType::OPERATOR_TIMING)) {
-			tree_node.GetProfilingInfo().AddToMetric<double>(MetricsType::OPERATOR_TIMING, node.second.time);
+		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::OPERATOR_TIMING)) {
+			info.AddToMetric<double>(MetricsType::OPERATOR_TIMING, node.second.time);
 		}
-		if (profiler.HasOperatorSetting(MetricsType::OPERATOR_CARDINALITY)) {
-			tree_node.GetProfilingInfo().AddToMetric<idx_t>(MetricsType::OPERATOR_CARDINALITY,
-			                                                node.second.elements_returned);
+		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::OPERATOR_CARDINALITY)) {
+			info.AddToMetric<idx_t>(MetricsType::OPERATOR_CARDINALITY, node.second.elements_returned);
 		}
-		if (profiler.HasOperatorSetting(MetricsType::OPERATOR_ROWS_SCANNED)) {
+		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::OPERATOR_ROWS_SCANNED)) {
 			if (op.type == PhysicalOperatorType::TABLE_SCAN) {
 				auto &scan_op = op.Cast<PhysicalTableScan>();
 				auto &bind_data = scan_op.bind_data;
+
 				if (bind_data && scan_op.function.cardinality) {
 					auto cardinality = scan_op.function.cardinality(context, &(*bind_data));
 					if (cardinality && cardinality->has_estimated_cardinality) {
-						tree_node.GetProfilingInfo().AddToMetric<idx_t>(MetricsType::OPERATOR_ROWS_SCANNED,
-						                                                cardinality->estimated_cardinality);
+						info.AddToMetric<idx_t>(MetricsType::OPERATOR_ROWS_SCANNED, cardinality->estimated_cardinality);
 					}
 				}
 			}
 		}
-		if (profiler.HasOperatorSetting(MetricsType::RESULT_SET_SIZE)) {
-			tree_node.GetProfilingInfo().AddToMetric<idx_t>(MetricsType::RESULT_SET_SIZE, node.second.result_set_size);
+		if (ProfilingInfo::Enabled(profiler.settings, MetricsType::RESULT_SET_SIZE)) {
+			info.AddToMetric<idx_t>(MetricsType::RESULT_SET_SIZE, node.second.result_set_size);
 		}
 	}
 	profiler.timings.clear();
@@ -420,10 +407,15 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 
 void QueryProfiler::SetInfo(const double &blocked_thread_time) {
 	lock_guard<mutex> guard(flush_lock);
-	if (!IsEnabled() || !running || !root->GetProfilingInfo().Enabled(MetricsType::BLOCKED_THREAD_TIME)) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 
+	auto &info = root->GetProfilingInfo();
+	auto metric_enabled = info.Enabled(info.expanded_settings, MetricsType::BLOCKED_THREAD_TIME);
+	if (!metric_enabled) {
+		return;
+	}
 	query_info.blocked_thread_time = blocked_thread_time;
 }
 
@@ -701,8 +693,8 @@ profiler_settings_t EraseQueryRootSettings(profiler_settings_t settings) {
 	return settings;
 }
 
-unique_ptr<ProfilingNode> QueryProfiler::CreateTree(const PhysicalOperator &root_p, profiler_settings_t settings,
-                                                    idx_t depth) {
+unique_ptr<ProfilingNode> QueryProfiler::CreateTree(const PhysicalOperator &root_p, const profiler_settings_t &settings,
+                                                    const idx_t depth) {
 	if (OperatorRequiresProfiling(root_p.type)) {
 		query_requires_profiling = true;
 	}
@@ -718,11 +710,8 @@ unique_ptr<ProfilingNode> QueryProfiler::CreateTree(const PhysicalOperator &root
 
 	if (depth != 0) {
 		info.AddToMetric<uint8_t>(MetricsType::OPERATOR_TYPE, static_cast<uint8_t>(root_p.type));
-		if (info.Enabled(MetricsType::QUERY_NAME)) {
-			info.settings.erase(MetricsType::QUERY_NAME);
-		}
 	}
-	if (info.Enabled(MetricsType::EXTRA_INFO)) {
+	if (info.Enabled(info.settings, MetricsType::EXTRA_INFO)) {
 		info.extra_info = root_p.ParamsToString();
 	}
 
@@ -769,10 +758,11 @@ void QueryProfiler::Print() {
 void QueryProfiler::MoveOptimizerPhasesToRoot() {
 	auto &root_info = root->GetProfilingInfo();
 	auto &root_metrics = root_info.metrics;
+
 	for (auto &entry : phase_timings) {
 		auto &phase = entry.first;
 		auto &timing = entry.second;
-		if (root_info.Enabled(phase)) {
+		if (root_info.Enabled(root_info.expanded_settings, phase)) {
 			root_metrics[phase] = Value::CreateValue(timing);
 		}
 	}

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

@@ -1,7 +1,7 @@
 #include "duckdb/main/relation/read_csv_relation.hpp"
 
 #include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"

package/src/duckdb/src/main/secret/secret.cpp

@@ -87,7 +87,8 @@ void KeyValueSecret::Serialize(Serializer &serializer) const {
 		map_values.push_back(Value::STRUCT(map_struct));
 	}
 
-	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
+	// Warning: the secret map is serialized into a single MAP value with type ANY
+	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::ANY);
 	auto map = Value::MAP(ListType::GetChildType(map_type), map_values);
 	serializer.WriteProperty(201, "secret_map", map);
 

package/src/duckdb/src/main/secret/secret_manager.cpp

@@ -97,6 +97,20 @@ unique_ptr<BaseSecret> SecretManager::DeserializeSecret(Deserializer &deserializ
 	vector<string> scope;
 	deserializer.ReadList(103, "scope",
 	                      [&](Deserializer::List &list, idx_t i) { scope.push_back(list.ReadElement<string>()); });
+	auto serialization_type =
+	    deserializer.ReadPropertyWithExplicitDefault(104, "serialization_type", SecretSerializationType::CUSTOM);
+
+	switch (serialization_type) {
+	// This allows us to skip looking up the secret type for deserialization altogether
+	case SecretSerializationType::KEY_VALUE_SECRET:
+		return KeyValueSecret::Deserialize<KeyValueSecret>(deserializer, {scope, type, provider, name});
+	// Continues below: we need to do a type lookup to find the secret deserialize method
+	case SecretSerializationType::CUSTOM:
+		break;
+	default:
+		throw IOException("Unrecognized secret serialization type found in secret '%s': %s", secret_path,
+		                  EnumUtil::ToString(serialization_type));
+	}
 
 	SecretType deserialized_type;
 	if (!TryLookupTypeInternal(type, deserialized_type)) {

package/src/duckdb/src/optimizer/cte_filter_pusher.cpp

@@ -39,8 +39,10 @@ unique_ptr<LogicalOperator> CTEFilterPusher::Optimize(unique_ptr<LogicalOperator
 void CTEFilterPusher::FindCandidates(LogicalOperator &op) {
 	if (op.type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
 		// We encountered a new CTE, add it to the map
-		cte_info_map.insert(to_string(op.Cast<LogicalMaterializedCTE>().table_index),
-		                    make_uniq<MaterializedCTEInfo>(op));
+		auto key = to_string(op.Cast<LogicalMaterializedCTE>().table_index);
+		auto value = make_uniq<MaterializedCTEInfo>(op);
+
+		cte_info_map.insert(key, std::move(value));
 	} else if (op.type == LogicalOperatorType::LOGICAL_FILTER &&
 	           op.children[0]->type == LogicalOperatorType::LOGICAL_CTE_REF) {
 		// We encountered a filtered CTE ref, update the according CTE info

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -81,13 +81,6 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 		if (candidate.joins.size() == candidate.delim_get_count && all_removed) {
 			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
 			delim_join.duplicate_eliminated_columns.clear();
-			if (all_equality_conditions) {
-				for (auto &cond : delim_join.conditions) {
-					if (IsEqualityJoinCondition(cond)) {
-						cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-					}
-				}
-			}
 		}
 
 		// Only DelimJoins are ever created as SINGLE joins,

package/src/duckdb/src/optimizer/in_clause_rewriter.cpp

@@ -6,12 +6,19 @@
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
 unique_ptr<LogicalOperator> InClauseRewriter::Rewrite(unique_ptr<LogicalOperator> op) {
 	if (op->children.size() == 1) {
+		if (op->children[0]->type == LogicalOperatorType::LOGICAL_GET) {
+			auto &get = op->children[0]->Cast<LogicalGet>();
+			if (get.function.to_string && get.function.to_string(get.bind_data.get()) == "REMOTE") {
+				return op;
+			}
+		}
 		root = std::move(op->children[0]);
 		VisitOperatorExpressions(*op);
 		op->children[0] = std::move(root);

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -31,7 +31,7 @@ static bool FilterRemovesNull(ClientContext &context, ExpressionRewriter &rewrit
                               unordered_set<idx_t> &right_bindings) {
 	// make a copy of the expression
 	auto copy = expr->Copy();
-	// replace all BoundColumnRef expressions frmo the RHS with NULL constants in the copied expression
+	// replace all BoundColumnRef expressions from the RHS with NULL constants in the copied expression
 	copy = ReplaceColRefWithNull(std::move(copy), right_bindings);
 
 	// attempt to flatten the expression by running the expression rewriter on it
@@ -97,6 +97,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 			// bindings match right side or both sides: we cannot directly push it into the right
 			// however, if the filter removes rows with null values from the RHS we can turn the left outer join
 			// in an inner join, and then push down as we would push down an inner join
+			// Edit: This is only possible if the bindings match BOTH sides, so the filter can be pushed down to both
+			// children. If the filter can only be applied to the right side, and the filter filters
+			// all tuples, then the inner join cannot be converted.
 			if (FilterRemovesNull(optimizer.context, optimizer.rewriter, filters[i]->filter.get(), right_bindings)) {
 				// the filter removes NULL values, turn it into an inner join
 				join.join_type = JoinType::INNER;

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -1,13 +1,13 @@
 #include "duckdb/optimizer/unnest_rewriter.hpp"
 
 #include "duckdb/common/pair.hpp"
-#include "duckdb/planner/operator/logical_delim_get.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_unnest_expression.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_unnest.hpp"
+#include "duckdb/planner/operator/logical_delim_get.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_unnest.hpp"
 #include "duckdb/planner/operator/logical_window.hpp"
-#include "duckdb/planner/expression/bound_unnest_expression.hpp"
-#include "duckdb/planner/expression/bound_columnref_expression.hpp"
 
 namespace duckdb {
 
@@ -35,8 +35,8 @@ void UnnestRewriterPlanUpdater::VisitExpression(unique_ptr<Expression> *expressi
 unique_ptr<LogicalOperator> UnnestRewriter::Optimize(unique_ptr<LogicalOperator> op) {
 
 	UnnestRewriterPlanUpdater updater;
-	vector<unique_ptr<LogicalOperator> *> candidates;
-	FindCandidates(&op, candidates);
+	vector<reference<unique_ptr<LogicalOperator>>> candidates;
+	FindCandidates(op, candidates);
 
 	// rewrite the plan and update the bindings
 	for (auto &candidate : candidates) {
@@ -47,7 +47,7 @@ unique_ptr<LogicalOperator> UnnestRewriter::Optimize(unique_ptr<LogicalOperator>
 			// update the bindings of the BOUND_UNNEST expression
 			UpdateBoundUnnestBindings(updater, candidate);
 			// update the sequence of LOGICAL_PROJECTION(s)
-			UpdateRHSBindings(&op, candidate, updater);
+			UpdateRHSBindings(op, candidate, updater);
 			// reset
 			delim_columns.clear();
 			lhs_bindings.clear();
@@ -57,12 +57,11 @@ unique_ptr<LogicalOperator> UnnestRewriter::Optimize(unique_ptr<LogicalOperator>
 	return op;
 }
 
-void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
-                                    vector<unique_ptr<LogicalOperator> *> &candidates) {
-	auto op = op_ptr->get();
+void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> &op,
+                                    vector<reference<unique_ptr<LogicalOperator>>> &candidates) {
 	// search children before adding, so that we add candidates bottom-up
 	for (auto &child : op->children) {
-		FindCandidates(&child, candidates);
+		FindCandidates(child, candidates);
 	}
 
 	// search for operator that has a LOGICAL_DELIM_JOIN as its child
@@ -100,14 +99,15 @@ void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
 		curr_op = &curr_op->get()->children[0];
 	}
 
-	if (curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST) {
-		candidates.push_back(op_ptr);
+	if (curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST &&
+	    curr_op->get()->children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
+		candidates.push_back(op);
 	}
 }
 
-bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
+bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> &candidate) {
 
-	auto &topmost_op = (LogicalOperator &)**candidate;
+	auto &topmost_op = *candidate;
 	if (topmost_op.type != LogicalOperatorType::LOGICAL_PROJECTION &&
 	    topmost_op.type != LogicalOperatorType::LOGICAL_WINDOW &&
 	    topmost_op.type != LogicalOperatorType::LOGICAL_FILTER &&
@@ -158,10 +158,10 @@ bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
 	return true;
 }
 
-void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, unique_ptr<LogicalOperator> *candidate,
+void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> &plan, unique_ptr<LogicalOperator> &candidate,
                                        UnnestRewriterPlanUpdater &updater) {
 
-	auto &topmost_op = (LogicalOperator &)**candidate;
+	auto &topmost_op = *candidate;
 	idx_t shift = lhs_bindings.size();
 
 	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
@@ -189,7 +189,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 	}
 
 	// update all bindings by shifting them
-	updater.VisitOperator(*plan_ptr->get());
+	updater.VisitOperator(*plan);
 	updater.replace_bindings.clear();
 
 	// update all bindings coming from the LHS to RHS bindings
@@ -212,7 +212,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 	unnest.expressions.clear();
 	unnest.children.clear();
 	// update the bindings of the plan
-	updater.VisitOperator(*plan_ptr->get());
+	updater.VisitOperator(*plan);
 	updater.replace_bindings.clear();
 	// add the children again
 	for (auto &temp_bound_unnest : temp_bound_unnests) {
@@ -253,9 +253,9 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 }
 
 void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater,
-                                               unique_ptr<LogicalOperator> *candidate) {
+                                               unique_ptr<LogicalOperator> &candidate) {
 
-	auto &topmost_op = (LogicalOperator &)**candidate;
+	auto &topmost_op = *candidate;
 
 	// traverse LOGICAL_PROJECTION(s)
 	auto curr_op = &topmost_op.children[0];

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -335,8 +335,13 @@ idx_t TaskScheduler::GetEstimatedCPUId() {
 #elif defined(_GNU_SOURCE)
 	auto cpu = sched_getcpu();
 	if (cpu < 0) {
+#ifndef DUCKDB_NO_THREADS
 		// fallback to thread id
 		return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
+#else
+
+		return 0;
+#endif
 	}
 	return (idx_t)cpu;
 #elif defined(__aarch64__) && defined(__APPLE__)
@@ -345,8 +350,12 @@ idx_t TaskScheduler::GetEstimatedCPUId() {
 	asm volatile("mrs %x0, tpidrro_el0" : "=r"(c)::"memory");
 	return (idx_t)(c & (1 << 3) - 1);
 #else
+#ifndef DUCKDB_NO_THREADS
 	// fallback to thread id
 	return (idx_t)std::hash<std::thread::id>()(std::this_thread::get_id());
+#else
+	return 0;
+#endif
 #endif
 #endif
 }

package/src/duckdb/src/parser/parsed_data/exported_table_data.cpp

@@ -0,0 +1,22 @@
+#include "duckdb/parser/parsed_data/exported_table_data.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+ExportedTableInfo::ExportedTableInfo(TableCatalogEntry &entry, ExportedTableData table_data_p,
+                                     vector<string> &not_null_columns_p)
+    : entry(entry), table_data(std::move(table_data_p)) {
+	table_data.not_null_columns = not_null_columns_p;
+}
+
+ExportedTableInfo::ExportedTableInfo(ClientContext &context, ExportedTableData table_data_p)
+    : entry(GetEntry(context, table_data_p)), table_data(std::move(table_data_p)) {
+}
+
+TableCatalogEntry &ExportedTableInfo::GetEntry(ClientContext &context, const ExportedTableData &table_data) {
+	return Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, table_data.database_name, table_data.schema_name,
+	                         table_data.table_name)
+	    .Cast<TableCatalogEntry>();
+}
+
+} // namespace duckdb

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

@@ -102,6 +102,9 @@ void ParsedExpressionIterator::EnumerateChildren(
 		if (star_expr.expr) {
 			callback(star_expr.expr);
 		}
+		for (auto &item : star_expr.replace_list) {
+			callback(item.second);
+		}
 		break;
 	}
 	case ExpressionClass::SUBQUERY: {

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -98,8 +98,10 @@ string InsertStatement::ToString() const {
 	auto values_list = GetValuesList();
 	if (values_list) {
 		D_ASSERT(!default_values);
+		auto saved_alias = values_list->alias;
 		values_list->alias = string();
 		result += values_list->ToString();
+		values_list->alias = saved_alias;
 	} else if (select_statement) {
 		D_ASSERT(!default_values);
 		result += select_statement->ToString();
@@ -154,7 +156,11 @@ string InsertStatement::ToString() const {
 			if (i > 0) {
 				result += ", ";
 			}
-			result += returning_list[i]->ToString();
+			auto column = returning_list[i]->ToString();
+			if (!returning_list[i]->alias.empty()) {
+				column += StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->alias));
+			}
+			result += column;
 		}
 	}
 	return result;

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

@@ -11,7 +11,7 @@ static unique_ptr<ParsedExpression> TransformBooleanTestInternal(unique_ptr<Pars
                                                                  int query_location) {
 	auto bool_value = make_uniq<ConstantExpression>(Value::BOOLEAN(comparison_value));
 	Transformer::SetQueryLocation(*bool_value, query_location);
-	// we cast the argument to bool to remove ambiguity wrt function binding on the comparision
+	// we cast the argument to bool to remove ambiguity wrt function binding on the comparison
 	auto cast_argument = make_uniq<CastExpression>(LogicalType::BOOLEAN, std::move(argument));
 
 	auto result = make_uniq<ComparisonExpression>(comparison_type, std::move(cast_argument), std::move(bool_value));