duckdb 1.3.1-dev6.0 → 1.3.1

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

@@ -312,7 +312,7 @@ string QueryProfiler::ToString(ProfilerPrintFormat format) const {
 			return "";
 		}
 		auto renderer = TreeRenderer::CreateRenderer(GetExplainFormat(format));
-		std::stringstream str;
+		duckdb::stringstream str;
 		auto &info = root->GetProfilingInfo();
 		if (info.Enabled(info.expanded_settings, MetricsType::OPERATOR_TIMING)) {
 			info.metrics[MetricsType::OPERATOR_TIMING] = main_query.Elapsed();
@@ -586,7 +586,7 @@ static string RenderTiming(double timing) {
 }
 
 string QueryProfiler::QueryTreeToString() const {
-	std::stringstream str;
+	duckdb::stringstream str;
 	QueryTreeToStream(str);
 	return str.str();
 }

package/src/duckdb/src/main/query_result.cpp

@@ -62,7 +62,7 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
 
 QueryResult::QueryResult(QueryResultType type, ErrorData error)
     : BaseQueryResult(type, std::move(error)),
-      client_properties("UTC", ArrowOffsetSize::REGULAR, false, false, false, nullptr) {
+      client_properties("UTC", ArrowOffsetSize::REGULAR, false, false, false, V1_0, nullptr) {
 }
 
 QueryResult::~QueryResult() {

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

@@ -646,6 +646,7 @@ DefaultSecretGenerator::DefaultSecretGenerator(Catalog &catalog, SecretManager &
 }
 
 unique_ptr<CatalogEntry> DefaultSecretGenerator::CreateDefaultEntryInternal(const string &entry_name) {
+	lock_guard<mutex> guard(lock);
 	auto secret_lu = persistent_secrets.find(entry_name);
 	if (secret_lu == persistent_secrets.end()) {
 		return nullptr;
@@ -718,6 +719,7 @@ unique_ptr<CatalogEntry> DefaultSecretGenerator::CreateDefaultEntry(ClientContex
 vector<string> DefaultSecretGenerator::GetDefaultEntries() {
 	vector<string> ret;
 
+	lock_guard<mutex> guard(lock);
 	for (const auto &res : persistent_secrets) {
 		ret.push_back(res);
 	}

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

@@ -177,6 +177,13 @@ Value ArrowOutputListViewSetting::GetSetting(const ClientContext &context) {
 	return Value::BOOLEAN(config.options.arrow_use_list_view);
 }
 
+//===----------------------------------------------------------------------===//
+// Arrow Output Version
+//===----------------------------------------------------------------------===//
+void ArrowOutputVersionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.arrow_output_version = DBConfig().options.arrow_output_version;
+}
+
 //===----------------------------------------------------------------------===//
 // Asof Loop Join Threshold
 //===----------------------------------------------------------------------===//

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

@@ -38,6 +38,18 @@ const string GetDefaultUserAgent() {
 	return StringUtil::Format("duckdb/%s(%s)", DuckDB::LibraryVersion(), DuckDB::Platform());
 }
 
+namespace {
+
+template <class T>
+static DatabaseInstance &GetDB(DatabaseInstance *db) {
+	if (!db) {
+		throw InvalidInputException("Cannot change/set %s before the database is started", T::Name);
+	}
+	return *db;
+}
+
+} // namespace
+
 //===----------------------------------------------------------------------===//
 // Access Mode
 //===----------------------------------------------------------------------===//
@@ -270,6 +282,57 @@ Value ArrowLargeBufferSizeSetting::GetSetting(const ClientContext &context) {
 	return Value::BOOLEAN(export_large_buffers_arrow);
 }
 
+//===----------------------------------------------------------------------===//
+// Arrow Output Format Version
+//===----------------------------------------------------------------------===//
+void ArrowOutputVersionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto arrow_version = input.ToString();
+	if (arrow_version == "1.0") {
+		config.options.arrow_output_version = V1_0;
+	} else if (arrow_version == "1.1") {
+		config.options.arrow_output_version = V1_1;
+	} else if (arrow_version == "1.2") {
+		config.options.arrow_output_version = V1_2;
+	} else if (arrow_version == "1.3") {
+		config.options.arrow_output_version = V1_3;
+	} else if (arrow_version == "1.4") {
+		config.options.arrow_output_version = V1_4;
+	} else if (arrow_version == "1.5") {
+		config.options.arrow_output_version = V1_5;
+	} else {
+		throw NotImplementedException("Unrecognized parameter for option arrow_output_version, expected either "
+		                              "\'1.0\', \'1.1\', \'1.2\', \'1.3\', \'1.4\', \'1.5\'");
+	}
+}
+
+Value ArrowOutputVersionSetting::GetSetting(const ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	string arrow_version;
+	switch (config.options.arrow_output_version) {
+	case V1_0:
+		arrow_version = "1.0";
+		break;
+	case V1_1:
+		arrow_version = "1.1";
+		break;
+	case V1_2:
+		arrow_version = "1.2";
+		break;
+	case V1_3:
+		arrow_version = "1.3";
+		break;
+	case V1_4:
+		arrow_version = "1.4";
+		break;
+	case V1_5:
+		arrow_version = "1.5";
+		break;
+	default:
+		throw InternalException("Unrecognized arrow output version");
+	}
+	return Value(arrow_version);
+}
+
 //===----------------------------------------------------------------------===//
 // Checkpoint Threshold
 //===----------------------------------------------------------------------===//
@@ -554,20 +617,16 @@ Value DisabledCompressionMethodsSetting::GetSetting(const ClientContext &context
 //===----------------------------------------------------------------------===//
 // Disabled Filesystems
 //===----------------------------------------------------------------------===//
-void DisabledFilesystemsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	if (!db) {
-		throw InternalException("disabled_filesystems can only be set in an active database");
-	}
-	auto &fs = FileSystem::GetFileSystem(*db);
+void DisabledFilesystemsSetting::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &input) {
+	auto &db = GetDB<DisabledFilesystemsSetting>(db_p);
+	auto &fs = FileSystem::GetFileSystem(db);
 	auto list = StringUtil::Split(input.ToString(), ",");
 	fs.SetDisabledFileSystems(list);
 }
 
-void DisabledFilesystemsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	if (!db) {
-		throw InternalException("disabled_filesystems can only be set in an active database");
-	}
-	auto &fs = FileSystem::GetFileSystem(*db);
+void DisabledFilesystemsSetting::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<DisabledFilesystemsSetting>(db_p);
+	auto &fs = FileSystem::GetFileSystem(db);
 	fs.SetDisabledFileSystems(vector<string>());
 }
 
@@ -692,12 +751,14 @@ Value EnableExternalFileCacheSetting::GetSetting(const ClientContext &context) {
 Value EnableLogging::GetSetting(const ClientContext &context) {
 	return context.db->GetLogManager().GetConfig().enabled;
 }
-void EnableLogging::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter) {
-	db->GetLogManager().SetEnableLogging(parameter.GetValue<bool>());
+void EnableLogging::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &parameter) {
+	auto &db = GetDB<EnableLogging>(db_p);
+	db.GetLogManager().SetEnableLogging(parameter.GetValue<bool>());
 }
 
-void EnableLogging::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	db->GetLogManager().SetEnableLogging(false);
+void EnableLogging::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<EnableLogging>(db_p);
+	db.GetLogManager().SetEnableLogging(false);
 }
 
 //===----------------------------------------------------------------------===//
@@ -706,12 +767,14 @@ void EnableLogging::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
 Value LoggingMode::GetSetting(const ClientContext &context) {
 	return EnumUtil::ToString(context.db->GetLogManager().GetConfig().mode);
 }
-void LoggingMode::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter) {
-	db->GetLogManager().SetLogMode(EnumUtil::FromString<LogMode>(parameter.GetValue<string>()));
+void LoggingMode::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &parameter) {
+	auto &db = GetDB<LoggingMode>(db_p);
+	db.GetLogManager().SetLogMode(EnumUtil::FromString<LogMode>(parameter.GetValue<string>()));
 }
 
-void LoggingMode::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	db->GetLogManager().SetLogMode(LogMode::LEVEL_ONLY);
+void LoggingMode::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<LoggingMode>(db_p);
+	db.GetLogManager().SetLogMode(LogMode::LEVEL_ONLY);
 }
 
 //===----------------------------------------------------------------------===//
@@ -720,12 +783,14 @@ void LoggingMode::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
 Value LoggingLevel::GetSetting(const ClientContext &context) {
 	return EnumUtil::ToString(context.db->GetLogManager().GetConfig().level);
 }
-void LoggingLevel::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter) {
-	db->GetLogManager().SetLogLevel(EnumUtil::FromString<LogLevel>(parameter.GetValue<string>()));
+void LoggingLevel::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &parameter) {
+	auto &db = GetDB<LoggingLevel>(db_p);
+	db.GetLogManager().SetLogLevel(EnumUtil::FromString<LogLevel>(parameter.GetValue<string>()));
 }
 
-void LoggingLevel::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	db->GetLogManager().SetLogLevel(LogConfig::DEFAULT_LOG_LEVEL);
+void LoggingLevel::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<LoggingLevel>(db_p);
+	db.GetLogManager().SetLogLevel(LogConfig::DEFAULT_LOG_LEVEL);
 }
 
 //===----------------------------------------------------------------------===//
@@ -734,12 +799,14 @@ void LoggingLevel::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
 Value LoggingStorage::GetSetting(const ClientContext &context) {
 	return context.db->GetLogManager().GetConfig().storage;
 }
-void LoggingStorage::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter) {
-	db->GetLogManager().SetLogStorage(*db, parameter.GetValue<string>());
+void LoggingStorage::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &parameter) {
+	auto &db = GetDB<LoggingStorage>(db_p);
+	db.GetLogManager().SetLogStorage(db, parameter.GetValue<string>());
 }
 
-void LoggingStorage::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	db->GetLogManager().SetLogStorage(*db, LogConfig::DEFAULT_LOG_STORAGE);
+void LoggingStorage::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<LoggingStorage>(db_p);
+	db.GetLogManager().SetLogStorage(db, LogConfig::DEFAULT_LOG_STORAGE);
 }
 
 //===----------------------------------------------------------------------===//
@@ -752,18 +819,21 @@ Value EnabledLogTypes::GetSetting(const ClientContext &context) {
 	}
 	return StringUtil::Join(loggers, ",");
 }
-void EnabledLogTypes::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter) {
+void EnabledLogTypes::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &parameter) {
+	auto &db = GetDB<EnabledLogTypes>(db_p);
+
 	auto values = StringUtil::Split(parameter.GetValue<string>(), ",");
 	unordered_set<string> set;
 	for (const auto &value : values) {
 		set.insert(value);
 	}
-	db->GetLogManager().SetEnabledLogTypes(set);
+	db.GetLogManager().SetEnabledLogTypes(set);
 }
 
-void EnabledLogTypes::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+void EnabledLogTypes::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<EnabledLogTypes>(db_p);
 	unordered_set<string> set;
-	db->GetLogManager().SetEnabledLogTypes(set);
+	db.GetLogManager().SetEnabledLogTypes(set);
 }
 
 //===----------------------------------------------------------------------===//
@@ -776,18 +846,20 @@ Value DisabledLogTypes::GetSetting(const ClientContext &context) {
 	}
 	return StringUtil::Join(loggers, ",");
 }
-void DisabledLogTypes::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter) {
+void DisabledLogTypes::SetGlobal(DatabaseInstance *db_p, DBConfig &config, const Value &parameter) {
+	auto &db = GetDB<DisabledLogTypes>(db_p);
 	auto values = StringUtil::Split(parameter.GetValue<string>(), ",");
 	unordered_set<string> set;
 	for (const auto &value : values) {
 		set.insert(value);
 	}
-	db->GetLogManager().SetDisabledLogTypes(set);
+	db.GetLogManager().SetDisabledLogTypes(set);
 }
 
-void DisabledLogTypes::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+void DisabledLogTypes::ResetGlobal(DatabaseInstance *db_p, DBConfig &config) {
+	auto &db = GetDB<DisabledLogTypes>(db_p);
 	unordered_set<string> set;
-	db->GetLogManager().SetDisabledLogTypes(set);
+	db.GetLogManager().SetDisabledLogTypes(set);
 }
 
 //===----------------------------------------------------------------------===//

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

@@ -224,7 +224,7 @@ void Optimizer::RunBuiltInOptimizers() {
 
 	// transform ORDER BY + LIMIT to TopN
 	RunOptimizer(OptimizerType::TOP_N, [&]() {
-		TopN topn;
+		TopN topn(context);
 		plan = topn.Optimize(std::move(plan));
 	});
 

package/src/duckdb/src/optimizer/topn_optimizer.cpp

@@ -14,7 +14,10 @@
 
 namespace duckdb {
 
-bool TopN::CanOptimize(LogicalOperator &op) {
+TopN::TopN(ClientContext &context_p) : context(context_p) {
+}
+
+bool TopN::CanOptimize(LogicalOperator &op, optional_ptr<ClientContext> context) {
 	if (op.type == LogicalOperatorType::LOGICAL_LIMIT) {
 		auto &limit = op.Cast<LogicalLimit>();
 
@@ -28,14 +31,21 @@ bool TopN::CanOptimize(LogicalOperator &op) {
 		}
 
 		auto child_op = op.children[0].get();
+		if (context) {
+			// estimate child cardinality if the context is available
+			child_op->EstimateCardinality(*context);
+		}
 
-		auto constant_limit = static_cast<double>(limit.limit_val.GetConstantValue());
-		auto child_card = static_cast<double>(child_op->estimated_cardinality);
+		if (child_op->has_estimated_cardinality) {
+			// only check if we should switch to full sorting if we have estimated cardinality
+			auto constant_limit = static_cast<double>(limit.limit_val.GetConstantValue());
+			auto child_card = static_cast<double>(child_op->estimated_cardinality);
 
-		// if the child cardinality is not 98 times more than the
-		bool limit_is_large = constant_limit > 5000;
-		if (constant_limit > child_card * 0.007 && limit_is_large) {
-			return false;
+			// if the limit is > 0.7% of the child cardinality, sorting the whole table is faster
+			bool limit_is_large = constant_limit > 5000;
+			if (constant_limit > child_card * 0.007 && limit_is_large) {
+				return false;
+			}
 		}
 
 		while (child_op->type == LogicalOperatorType::LOGICAL_PROJECTION) {
@@ -116,7 +126,7 @@ void TopN::PushdownDynamicFilters(LogicalTopN &op) {
 }
 
 unique_ptr<LogicalOperator> TopN::Optimize(unique_ptr<LogicalOperator> op) {
-	if (CanOptimize(*op)) {
+	if (CanOptimize(*op, &context)) {
 
 		vector<unique_ptr<LogicalOperator>> projections;
 

package/src/duckdb/src/parallel/executor.cpp

@@ -589,6 +589,11 @@ PendingExecutionResult Executor::ExecuteTask(bool dry_run) {
 		if (!HasError()) {
 			// we (partially) processed a task and no exceptions were thrown
 			// give back control to the caller
+			if (task && DBConfig::GetConfig(context).options.scheduler_process_partial) {
+				auto &token = *task->token;
+				TaskScheduler::GetScheduler(context).ScheduleTask(token, task);
+				task.reset();
+			}
 			return PendingExecutionResult::RESULT_NOT_READY;
 		}
 		execution_result = PendingExecutionResult::EXECUTION_ERROR;

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

@@ -25,7 +25,7 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 }
 
 string CreateSequenceInfo::ToString() const {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	ss << "CREATE";
 	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
 		ss << " OR REPLACE";

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

@@ -27,9 +27,12 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	default:
 		throw InternalException("Unsupported interval transformation");
 	}
+	SetQueryLocation(*expr, node.location);
 
 	if (!node.typmods) {
-		return make_uniq<CastExpression>(LogicalType::INTERVAL, std::move(expr));
+		auto result = make_uniq<CastExpression>(LogicalType::INTERVAL, std::move(expr));
+		SetQueryLocation(*result, node.location);
+		return std::move(result);
 	}
 
 	int32_t mask = NumericCast<int32_t>(
@@ -137,6 +140,7 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	}
 	// first push a cast to the parse type
 	expr = make_uniq<CastExpression>(parse_type, std::move(expr));
+	SetQueryLocation(*expr, node.location);
 
 	// next, truncate it if the target type doesn't match the parse type
 	if (target_type != parse_type) {

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -199,24 +199,32 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	}
 
 	// the first child is the list, the second child is the lambda expression
-	const idx_t list_idx = 0;
-	const idx_t lambda_expr_idx = 1;
+	constexpr idx_t list_idx = 0;
+	constexpr idx_t lambda_expr_idx = 1;
 	D_ASSERT(function.children[lambda_expr_idx]->GetExpressionClass() == ExpressionClass::LAMBDA);
 
+	vector<LogicalType> function_child_types;
+
 	// bind the list
 	ErrorData error;
 	for (idx_t i = 0; i < function.children.size(); i++) {
-		if (i != lambda_expr_idx) {
-			if (function.children[i]->GetExpressionClass() == ExpressionClass::LAMBDA) {
-				return BindResult("No function matches the given name and argument types: '" + function.ToString() +
-				                  "'. You might need to add explicit type casts.");
-			}
+		if (i == lambda_expr_idx) {
+			function_child_types.push_back(LogicalType::LAMBDA);
+			continue;
+		}
 
-			BindChild(function.children[i], depth, error);
-			if (error.HasError()) {
-				return BindResult(std::move(error));
-			}
+		if (function.children[i]->GetExpressionClass() == ExpressionClass::LAMBDA) {
+			return BindResult("No function matches the given name and argument types: '" + function.ToString() +
+			                  "'. You might need to add explicit type casts.");
+		}
+
+		BindChild(function.children[i], depth, error);
+		if (error.HasError()) {
+			return BindResult(std::move(error));
 		}
+
+		const auto &child = BoundExpression::GetExpression(*function.children[i]);
+		function_child_types.push_back(child->return_type);
 	}
 
 	// get the logical type of the children of the list
@@ -227,20 +235,9 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 		return BindResult("Invalid LIST argument during lambda function binding!");
 	}
 
-	LogicalType list_child_type = list_child->return_type.id();
-	if (list_child->return_type.id() != LogicalTypeId::SQLNULL &&
-	    list_child->return_type.id() != LogicalTypeId::UNKNOWN) {
-
-		if (list_child->return_type.id() == LogicalTypeId::ARRAY) {
-			list_child_type = ArrayType::GetChildType(list_child->return_type);
-		} else {
-			list_child_type = ListType::GetChildType(list_child->return_type);
-		}
-	}
-
 	// bind the lambda parameter
 	auto &lambda_expr = function.children[lambda_expr_idx]->Cast<LambdaExpression>();
-	BindResult bind_lambda_result = BindExpression(lambda_expr, depth, list_child_type, &bind_lambda_function);
+	BindResult bind_lambda_result = BindExpression(lambda_expr, depth, function_child_types, &bind_lambda_function);
 
 	if (bind_lambda_result.HasError()) {
 		return BindResult(bind_lambda_result.error);
@@ -268,7 +265,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 
 	// capture the (lambda) columns
 	auto &bound_lambda_expr = children[lambda_expr_idx]->Cast<BoundLambdaExpression>();
-	CaptureLambdaColumns(bound_lambda_expr, bound_lambda_expr.lambda_expr, &bind_lambda_function, list_child_type);
+	CaptureLambdaColumns(bound_lambda_expr, bound_lambda_expr.lambda_expr, &bind_lambda_function, function_child_types);
 
 	FunctionBinder function_binder(binder);
 	unique_ptr<Expression> result =

package/src/duckdb/src/planner/binder/expression/bind_lambda.cpp

@@ -62,7 +62,8 @@ void ExtractParameters(LambdaExpression &expr, vector<string> &column_names, vec
 	D_ASSERT(!column_names.empty());
 }
 
-BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth, const LogicalType &list_child_type,
+BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
+                                            const vector<LogicalType> &function_child_types,
                                             optional_ptr<bind_lambda_function_t> bind_lambda_function) {
 	if (expr.syntax_type == LambdaSyntaxType::LAMBDA_KEYWORD && !bind_lambda_function) {
 		return BindResult("invalid lambda expression");
@@ -93,7 +94,7 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	vector<string> column_aliases;
 	ExtractParameters(expr, column_names, column_aliases);
 	for (idx_t i = 0; i < column_names.size(); i++) {
-		column_types.push_back((*bind_lambda_function)(i, list_child_type));
+		column_types.push_back((*bind_lambda_function)(context, function_child_types, i));
 	}
 
 	// base table alias
@@ -134,7 +135,7 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &ori
                                                      unique_ptr<Expression> &replacement,
                                                      BoundLambdaExpression &bound_lambda_expr,
                                                      const optional_ptr<bind_lambda_function_t> bind_lambda_function,
-                                                     const LogicalType &list_child_type) {
+                                                     const vector<LogicalType> &function_child_types) {
 
 	// check if the original expression is a lambda parameter
 	if (original->GetExpressionClass() == ExpressionClass::BOUND_LAMBDA_REF) {
@@ -164,9 +165,9 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &ori
 			// error resolving the lambda index
 			throw InternalException("Failed to bind lambda parameter internally");
 		}
-
 		// refers to a lambda parameter inside the current lambda function
-		auto logical_type = (*bind_lambda_function)(bound_lambda_ref.binding.column_index, list_child_type);
+		auto logical_type =
+		    (*bind_lambda_function)(context, function_child_types, bound_lambda_ref.binding.column_index);
 		auto index = bound_lambda_expr.parameter_count - bound_lambda_ref.binding.column_index - 1;
 		replacement = make_uniq<BoundReferenceExpression>(alias, logical_type, index);
 		return;
@@ -186,7 +187,7 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &ori
 
 void ExpressionBinder::CaptureLambdaColumns(BoundLambdaExpression &bound_lambda_expr, unique_ptr<Expression> &expr,
                                             const optional_ptr<bind_lambda_function_t> bind_lambda_function,
-                                            const LogicalType &list_child_type) {
+                                            const vector<LogicalType> &function_child_types) {
 
 	if (expr->GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
 		throw BinderException("subqueries in lambda expressions are not supported");
@@ -216,7 +217,8 @@ void ExpressionBinder::CaptureLambdaColumns(BoundLambdaExpression &bound_lambda_
 		auto original = std::move(expr);
 		unique_ptr<Expression> replacement;
 
-		TransformCapturedLambdaColumn(original, replacement, bound_lambda_expr, bind_lambda_function, list_child_type);
+		TransformCapturedLambdaColumn(original, replacement, bound_lambda_expr, bind_lambda_function,
+		                              function_child_types);
 
 		// replace the expression
 		expr = std::move(replacement);
@@ -224,7 +226,7 @@ void ExpressionBinder::CaptureLambdaColumns(BoundLambdaExpression &bound_lambda_
 	} else {
 		// recursively enumerate the children of the expression
 		ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-			CaptureLambdaColumns(bound_lambda_expr, child, bind_lambda_function, list_child_type);
+			CaptureLambdaColumns(bound_lambda_expr, child, bind_lambda_function, function_child_types);
 		});
 	}
 

package/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp

@@ -77,8 +77,9 @@ LogicalType ExpressionBinder::ResolveOperatorType(OperatorExpression &op, vector
 	case ExpressionType::OPERATOR_COALESCE: {
 		return ResolveCoalesceType(op, children);
 	}
-	case ExpressionType::OPERATOR_TRY:
-		return ExpressionBinder::GetExpressionReturnType(*children[0]);
+	case ExpressionType::OPERATOR_TRY: {
+		return children[0]->return_type;
+	}
 	case ExpressionType::OPERATOR_NOT:
 		return ResolveNotType(op, children);
 	default:

package/src/duckdb/src/planner/binder/statement/bind_copy.cpp

@@ -266,10 +266,6 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type)
 		}
 	}
 	if (!write_empty_file) {
-		if (rotate) {
-			throw NotImplementedException(
-			    "Can't combine WRITE_EMPTY_FILE false with file rotation (e.g., ROW_GROUPS_PER_FILE)");
-		}
 		if (per_thread_output) {
 			throw NotImplementedException("Can't combine WRITE_EMPTY_FILE false with PER_THREAD_OUTPUT");
 		}

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -298,6 +298,9 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		unique_ptr<FunctionData> bind_data;
 		auto scan_function = table.GetScanFunction(context, bind_data, table_lookup);
+		if (bind_data && !bind_data->SupportStatementCache()) {
+			SetAlwaysRequireRebind();
+		}
 		// TODO: bundle the type and name vector in a struct (e.g PackedColumnMetadata)
 		vector<LogicalType> table_types;
 		vector<string> table_names;

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -240,6 +240,9 @@ unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &tab
 		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
 		                            table_function.name);
 	}
+	if (bind_data && !bind_data->SupportStatementCache()) {
+		SetAlwaysRequireRebind();
+	}
 	if (return_types.size() != return_names.size()) {
 		throw InternalException("Failed to bind \"%s\": return_types/names must have same size", table_function.name);
 	}

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -191,6 +191,9 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 			return false;
 		}
 	}
+	if (source_type.IsSigned() && target_type.IsUnsigned()) {
+		return false;
+	}
 	return true;
 }
 

package/src/duckdb/src/planner/expression/bound_columnref_expression.cpp

@@ -37,7 +37,7 @@ bool BoundColumnRefExpression::Equals(const BaseExpression &other_p) const {
 string BoundColumnRefExpression::GetName() const {
 #ifdef DEBUG
 	if (DBConfigOptions::debug_print_bindings) {
-		return binding.ToString();
+		return StringUtil::Format("%s (%s)", binding.ToString(), return_type.ToString());
 	}
 #endif
 	return Expression::GetName();

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -127,7 +127,6 @@ unique_ptr<Expression> BoundFunctionExpression::Deserialize(Deserializer &deseri
 		}
 		// Otherwise, fall thorugh and continue on normally
 	}
-
 	auto result = make_uniq<BoundFunctionExpression>(std::move(function_return_type), std::move(entry.first),
 	                                                 std::move(children), std::move(entry.second));
 	result->is_operator = is_operator;

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -17,7 +17,7 @@ BoundReferenceExpression::BoundReferenceExpression(LogicalType type, storage_t i
 string BoundReferenceExpression::ToString() const {
 #ifdef DEBUG
 	if (DBConfigOptions::debug_print_bindings) {
-		return "#" + to_string(index);
+		return StringUtil::Format("#%llu (%s)", index, return_type.ToString());
 	}
 #endif
 	if (!alias.empty()) {

package/src/duckdb/src/planner/expression_binder.cpp

@@ -88,8 +88,10 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		// binding a function expression requires an extra parameter for macros
 		return BindExpression(function, depth, expr);
 	}
-	case ExpressionClass::LAMBDA:
-		return BindExpression(expr_ref.Cast<LambdaExpression>(), depth, LogicalTypeId::INVALID, nullptr);
+	case ExpressionClass::LAMBDA: {
+		const vector<LogicalType> function_child_types;
+		return BindExpression(expr_ref.Cast<LambdaExpression>(), depth, function_child_types, nullptr);
+	}
 	case ExpressionClass::OPERATOR:
 		return BindExpression(expr_ref.Cast<OperatorExpression>(), depth);
 	case ExpressionClass::SUBQUERY: