duckdb 1.3.2-dev0.0 → 1.3.3-dev0.0

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -221,6 +221,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
     {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
     {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
+    {"iceberg_to_ducklake", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY},
     {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY},
     {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -624,6 +625,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
+    {"st_makebox2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -996,6 +998,9 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"ca_cert_file", "httpfs"},
     {"calendar", "icu"},
     {"disable_parquet_prefetching", "parquet"},
+    {"ducklake_max_retry_count", "ducklake"},
+    {"ducklake_retry_backoff", "ducklake"},
+    {"ducklake_retry_wait_ms", "ducklake"},
     {"enable_geoparquet_conversion", "parquet"},
     {"enable_server_cert_verification", "httpfs"},
     {"force_download", "httpfs"},

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -560,7 +560,7 @@ struct EnableFSSTVectorsSetting {
 struct EnableHTTPLoggingSetting {
 	using RETURN_TYPE = bool;
 	static constexpr const char *Name = "enable_http_logging";
-	static constexpr const char *Description = "Enables HTTP logging";
+	static constexpr const char *Description = "(deprecated) Enables HTTP logging";
 	static constexpr const char *InputType = "BOOLEAN";
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
@@ -750,7 +750,7 @@ struct HTTPLoggingOutputSetting {
 	using RETURN_TYPE = string;
 	static constexpr const char *Name = "http_logging_output";
 	static constexpr const char *Description =
-	    "The file to which HTTP logging output should be saved, or empty to print to the terminal";
+	    "(deprecated) The file to which HTTP logging output should be saved, or empty to print to the terminal";
 	static constexpr const char *InputType = "VARCHAR";
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);

package/src/duckdb/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp

@@ -60,6 +60,7 @@ private:
 	unordered_map<idx_t, RelationStats> materialized_cte_stats;
 	//! Stats of Delim Scans of the Delim Join that is currently being optimized
 	optional_ptr<RelationStats> delim_scan_stats;
+	idx_t depth;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parallel/concurrentqueue.hpp

@@ -84,6 +84,14 @@ public:
 		}
 		return max;
 	}
+
+	template <typename It>
+	bool enqueue_bulk(It itemFirst, size_t count) {
+		for (size_t i = 0; i < count; i++) {
+			q.push(std::move(*itemFirst++));
+		}
+		return true;
+	}
 };
 
 } // namespace duckdb_moodycamel

package/src/duckdb/src/include/duckdb/planner/filter/expression_filter.hpp

@@ -35,6 +35,8 @@ public:
 	unique_ptr<Expression> ToExpression(const Expression &column) const override;
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<TableFilter> Deserialize(Deserializer &deserializer);
+	static void ReplaceExpressionRecursive(unique_ptr<Expression> &expr, const Expression &column,
+	                                       ExpressionType replace_type = ExpressionType::BOUND_REF);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -198,7 +198,7 @@ public:
 			error += StringUtil::Format("Node %lld: Start %lld, Count %lld", i, nodes[i].row_start,
 			                            nodes[i].node->count.load());
 		}
-		throw InternalException("Could not find node in column segment tree!\n%s%s", error, Exception::GetStackTrace());
+		throw InternalException("Could not find node in column segment tree!\n%s", error);
 	}
 
 	bool TryGetSegmentIndex(SegmentLock &l, idx_t row_number, idx_t &result) {

package/src/duckdb/src/main/client_context_file_opener.cpp

@@ -24,6 +24,10 @@ optional_ptr<DatabaseInstance> ClientContextFileOpener::TryGetDatabase() {
 	return context.db.get();
 }
 
+shared_ptr<HTTPUtil> &ClientContextFileOpener::GetHTTPUtil() {
+	return TryGetDatabase()->config.http_util;
+}
+
 unique_ptr<CatalogTransaction> FileOpener::TryGetCatalogTransaction(optional_ptr<FileOpener> opener) {
 	if (!opener) {
 		return nullptr;

package/src/duckdb/src/main/database_manager.cpp

@@ -256,8 +256,13 @@ vector<reference<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext
 		return true;
 	});
 
-	result.push_back(*system);
-	result.push_back(*context.client_data->temporary_objects);
+	if (!max_db_count.IsValid() || max_db_count.GetIndex() >= 1) {
+		result.push_back(*system);
+	}
+	if (!max_db_count.IsValid() || max_db_count.GetIndex() >= 2) {
+		result.push_back(*context.client_data->temporary_objects);
+	}
+
 	return result;
 }
 

package/src/duckdb/src/main/database_path_and_type.cpp

@@ -26,7 +26,7 @@ void DBPathAndType::CheckMagicBytes(FileSystem &fs, string &path, string &db_typ
 	case DataFileType::PARQUET_FILE:
 	case DataFileType::UNKNOWN_FILE: {
 		// FIXME: we should get this from the registered replacement scans instead of hardcoding it here
-		vector<string> supported_suffixes {"parquet", "csv", "json", "jsonl", "ndjson"};
+		vector<string> supported_suffixes {"parquet", "csv", "tsv", "json", "jsonl", "ndjson"};
 		if (ReplacementScan::CanReplace(path, supported_suffixes)) {
 			db_type = "__open_file__";
 			break;

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

@@ -505,23 +505,6 @@ Value EnableFSSTVectorsSetting::GetSetting(const ClientContext &context) {
 	return Value::BOOLEAN(config.options.enable_fsst_vectors);
 }
 
-//===----------------------------------------------------------------------===//
-// Enable H T T P Logging
-//===----------------------------------------------------------------------===//
-void EnableHTTPLoggingSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.enable_http_logging = input.GetValue<bool>();
-}
-
-void EnableHTTPLoggingSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).enable_http_logging = ClientConfig().enable_http_logging;
-}
-
-Value EnableHTTPLoggingSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value::BOOLEAN(config.enable_http_logging);
-}
-
 //===----------------------------------------------------------------------===//
 // Enable H T T P Metadata Cache
 //===----------------------------------------------------------------------===//
@@ -678,23 +661,6 @@ Value HomeDirectorySetting::GetSetting(const ClientContext &context) {
 	return Value(config.home_directory);
 }
 
-//===----------------------------------------------------------------------===//
-// H T T P Logging Output
-//===----------------------------------------------------------------------===//
-void HTTPLoggingOutputSetting::SetLocal(ClientContext &context, const Value &input) {
-	auto &config = ClientConfig::GetConfig(context);
-	config.http_logging_output = input.GetValue<string>();
-}
-
-void HTTPLoggingOutputSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).http_logging_output = ClientConfig().http_logging_output;
-}
-
-Value HTTPLoggingOutputSetting::GetSetting(const ClientContext &context) {
-	auto &config = ClientConfig::GetConfig(context);
-	return Value(config.http_logging_output);
-}
-
 //===----------------------------------------------------------------------===//
 // H T T P Proxy
 //===----------------------------------------------------------------------===//

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

@@ -1088,6 +1088,55 @@ void HomeDirectorySetting::SetLocal(ClientContext &context, const Value &input)
 	config.home_directory = input.IsNull() ? string() : input.ToString();
 }
 
+//===----------------------------------------------------------------------===//
+// Enable H T T P Logging
+//===----------------------------------------------------------------------===//
+void EnableHTTPLoggingSetting::SetLocal(ClientContext &context, const Value &input) {
+	auto &config = ClientConfig::GetConfig(context);
+	config.enable_http_logging = input.GetValue<bool>();
+
+	// NOTE: this is a deprecated setting: we mimick the old behaviour by setting the log storage output to STDOUT and
+	// enabling logging for http only. Note that this behaviour is slightly wonky in that it sets all sorts of logging
+	// config
+	auto &log_manager = LogManager::Get(context);
+	if (config.enable_http_logging) {
+		log_manager.SetEnableLogging(true);
+		log_manager.SetLogLevel(HTTPLogType::LEVEL);
+		unordered_set<string> enabled_log_types = {HTTPLogType::NAME};
+		log_manager.SetEnabledLogTypes(enabled_log_types);
+		log_manager.SetLogStorage(*context.db, LogConfig::STDOUT_STORAGE_NAME);
+	} else {
+		log_manager.SetEnableLogging(false);
+	}
+}
+
+void EnableHTTPLoggingSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).enable_http_logging = ClientConfig().enable_http_logging;
+}
+
+Value EnableHTTPLoggingSetting::GetSetting(const ClientContext &context) {
+	auto &config = ClientConfig::GetConfig(context);
+	return Value::BOOLEAN(config.enable_http_logging);
+}
+
+//===----------------------------------------------------------------------===//
+// H T T P Logging Output
+//===----------------------------------------------------------------------===//
+void HTTPLoggingOutputSetting::SetLocal(ClientContext &context, const Value &input) {
+	throw NotImplementedException("This setting is deprecated and can no longer be used. Check out the DuckDB docs on "
+	                              "logging for more information");
+}
+
+void HTTPLoggingOutputSetting::ResetLocal(ClientContext &context) {
+	throw NotImplementedException("This setting is deprecated and can no longer be used. Check out the DuckDB docs on "
+	                              "logging for more information");
+}
+
+Value HTTPLoggingOutputSetting::GetSetting(const ClientContext &context) {
+	auto &config = ClientConfig::GetConfig(context);
+	return Value(config.http_logging_output);
+}
+
 //===----------------------------------------------------------------------===//
 // Index Scan Percentage
 //===----------------------------------------------------------------------===//

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

@@ -330,7 +330,7 @@ static Value GetIntegralRangeValue(ClientContext &context, const LogicalType &ty
 	auto min = NumericStats::Min(stats);
 	auto max = NumericStats::Max(stats);
 	if (max < min) {
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Maximum());
+		return Value::UHUGEINT(NumericLimits<uhugeint_t>::Maximum());
 	}
 
 	vector<unique_ptr<Expression>> arguments;
@@ -342,8 +342,8 @@ static Value GetIntegralRangeValue(ClientContext &context, const LogicalType &ty
 	if (ExpressionExecutor::TryEvaluateScalar(context, sub, result)) {
 		return result;
 	} else {
-		// Couldn't evaluate: Return max hugeint as range so GetIntegralCompress will return nullptr
-		return Value::HUGEINT(NumericLimits<hugeint_t>::Maximum());
+		// Couldn't evaluate: Return max uhugeint as range so GetIntegralCompress will return nullptr
+		return Value::UHUGEINT(NumericLimits<uhugeint_t>::Maximum());
 	}
 }
 
@@ -354,7 +354,7 @@ unique_ptr<CompressExpression> CompressedMaterialization::GetIntegralCompress(un
 		return nullptr;
 	}
 
-	// Get range and cast to UBIGINT (might fail for HUGEINT, in which case we just return)
+	// Get range and cast to UBIGINT (might fail for UHUGEINT, in which case we just return)
 	Value range_value = GetIntegralRangeValue(context, type, stats);
 	if (!range_value.DefaultTryCastAs(LogicalType::UBIGINT)) {
 		return nullptr;

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

@@ -242,7 +242,7 @@ bool FilterCombiner::IsDenseRange(vector<Value> &in_list) {
 	if (in_list.empty()) {
 		return true;
 	}
-	if (!in_list[0].type().IsIntegral()) {
+	if (!in_list[0].type().IsIntegral() || in_list[0].type() == LogicalType::UHUGEINT) {
 		return false;
 	}
 	// sort the input list

package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp

@@ -10,19 +10,27 @@
 
 namespace duckdb {
 
-JoinOrderOptimizer::JoinOrderOptimizer(ClientContext &context) : context(context), query_graph_manager(context) {
+JoinOrderOptimizer::JoinOrderOptimizer(ClientContext &context)
+    : context(context), query_graph_manager(context), depth(1) {
 }
 
 JoinOrderOptimizer JoinOrderOptimizer::CreateChildOptimizer() {
 	JoinOrderOptimizer child_optimizer(context);
 	child_optimizer.materialized_cte_stats = materialized_cte_stats;
 	child_optimizer.delim_scan_stats = delim_scan_stats;
+	child_optimizer.depth = depth + 1;
 	return child_optimizer;
 }
 
 unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOperator> plan,
                                                          optional_ptr<RelationStats> stats) {
 
+	if (depth > query_graph_manager.context.config.max_expression_depth) {
+		// Very deep plans will eventually consume quite some stack space
+		// Returning the current plan is always a valid choice
+		return plan;
+	}
+
 	// make sure query graph manager has not extracted a relation graph already
 	LogicalOperator *op = plan.get();
 

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

@@ -256,6 +256,9 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 				ColumnBinding filter_binding(get.table_index, index.GetIndex());
 				auto column_ref = make_uniq<BoundColumnRefExpression>(std::move(column_type), filter_binding);
 				auto filter_expr = filter.second->ToExpression(*column_ref);
+				if (filter_expr->IsScalar()) {
+					filter_expr = std::move(column_ref);
+				}
 				VisitExpression(&filter_expr);
 				filter_expressions.push_back(std::move(filter_expr));
 			}

package/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp

@@ -1,26 +1,51 @@
 #include "duckdb/common/helper.hpp"
 #include "duckdb/optimizer/statistics_propagator.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/filter/expression_filter.hpp"
 #include "duckdb/planner/filter/null_filter.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/table_filter.hpp"
+#include "duckdb/function/scalar/generic_common.hpp"
+#include "duckdb/function/scalar/generic_functions.hpp"
 
 namespace duckdb {
 
+static void GetColumnIndex(unique_ptr<Expression> &expr, idx_t &index) {
+	if (expr->type == ExpressionType::BOUND_REF) {
+		auto &bound_ref = expr->Cast<BoundReferenceExpression>();
+		index = bound_ref.index;
+		return;
+	}
+	ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) { GetColumnIndex(child, index); });
+}
+
 FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding stats_binding, BaseStatistics &stats,
                                                                  TableFilter &filter) {
 	if (filter.filter_type == TableFilterType::EXPRESSION_FILTER) {
 		auto &expr_filter = filter.Cast<ExpressionFilter>();
+
+		// get physical storage index of the filter
+		// since it is a table filter, every storage index is the same
+		idx_t physical_index = DConstants::INVALID_INDEX;
+		GetColumnIndex(expr_filter.expr, physical_index);
+		D_ASSERT(physical_index != DConstants::INVALID_INDEX);
+
 		auto column_ref = make_uniq<BoundColumnRefExpression>(stats.GetType(), stats_binding);
 		auto filter_expr = expr_filter.ToExpression(*column_ref);
 		// handle the filter before updating the statistics
 		// otherwise the filter can be pruned by the updated statistics
-		auto copy_expr = filter_expr->Copy();
 		auto propagate_result = HandleFilter(filter_expr);
-		UpdateFilterStatistics(*copy_expr);
+		auto colref = make_uniq<BoundReferenceExpression>(stats.GetType(), physical_index);
+		UpdateFilterStatistics(*filter_expr);
+
+		// replace BoundColumnRefs with BoundRefs
+		ExpressionFilter::ReplaceExpressionRecursive(filter_expr, *colref, ExpressionType::BOUND_COLUMN_REF);
+		expr_filter.expr = std::move(filter_expr);
 		return propagate_result;
 	}
 	return filter.CheckStatistics(stats);
@@ -46,6 +71,41 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFi
 	}
 }
 
+static bool IsConstantOrNullFilter(TableFilter &table_filter) {
+	if (table_filter.filter_type != TableFilterType::EXPRESSION_FILTER) {
+		return false;
+	}
+	auto &expr_filter = table_filter.Cast<ExpressionFilter>();
+	if (expr_filter.expr->type != ExpressionType::BOUND_FUNCTION) {
+		return false;
+	}
+	auto &func = expr_filter.expr->Cast<BoundFunctionExpression>();
+	return ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true));
+}
+
+static bool CanReplaceConstantOrNull(TableFilter &table_filter) {
+	if (!IsConstantOrNullFilter(table_filter)) {
+		throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter");
+	}
+	D_ASSERT(table_filter.filter_type == TableFilterType::EXPRESSION_FILTER);
+	auto &expr_filter = table_filter.Cast<ExpressionFilter>();
+	auto &func = expr_filter.expr->Cast<BoundFunctionExpression>();
+	if (ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true))) {
+		for (auto child = ++func.children.begin(); child != func.children.end(); child++) {
+			switch (child->get()->type) {
+			case ExpressionType::BOUND_REF:
+			case ExpressionType::VALUE_CONSTANT:
+				continue;
+			default:
+				// expression type could be a function like Coalesce
+				return false;
+			}
+		}
+	}
+	// all children of constant or null are bound refs to the table filter column
+	return true;
+}
+
 unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet &get,
                                                                      unique_ptr<LogicalOperator> &node_ptr) {
 	if (get.function.cardinality) {
@@ -99,10 +159,15 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet
 			// erase this condition
 			get.table_filters.filters.erase(table_filter_column);
 			break;
-		case FilterPropagateResult::FILTER_TRUE_OR_NULL:
+		case FilterPropagateResult::FILTER_TRUE_OR_NULL: {
+			if (IsConstantOrNullFilter(*get.table_filters.filters[table_filter_column]) &&
+			    !CanReplaceConstantOrNull(*get.table_filters.filters[table_filter_column])) {
+				break;
+			}
 			// filter is true or null; we can replace this with a not null filter
 			get.table_filters.filters[table_filter_column] = make_uniq<IsNotNullFilter>();
 			break;
+		}
 		case FilterPropagateResult::FILTER_FALSE_OR_NULL:
 		case FilterPropagateResult::FILTER_ALWAYS_FALSE:
 			// filter is always false; this entire filter should be replaced by an empty result block

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

@@ -14,7 +14,7 @@ SetVariableStatement::SetVariableStatement(string name_p, unique_ptr<ParsedExpre
 }
 
 SetVariableStatement::SetVariableStatement(const SetVariableStatement &other)
-    : SetVariableStatement(other.name, other.value->Copy(), other.scope) {
+    : SetStatement(other), value(other.value->Copy()) {
 }
 
 unique_ptr<SQLStatement> SetVariableStatement::Copy() const {

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

@@ -445,10 +445,9 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnNameWithManyDots(Col
 }
 
 unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error) {
-
-	// try binding as a lambda parameter
 	if (!col_ref.IsQualified()) {
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
+		// Try binding as a lambda parameter.
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName());
 		if (lambda_ref) {
 			return lambda_ref;
 		}

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

@@ -38,10 +38,9 @@ string AlterBinder::UnsupportedAggregateMessage() {
 }
 
 BindResult AlterBinder::BindColumnReference(ColumnRefExpression &col_ref, idx_t depth) {
-
-	// try binding as a lambda parameter
 	if (!col_ref.IsQualified()) {
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
+		// Try binding as a lambda parameter.
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName());
 		if (lambda_ref) {
 			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
 		}

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

@@ -44,9 +44,9 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, i
 	auto col_ref = expr_ptr->Cast<ColumnRefExpression>();
 	const auto &column_name = col_ref.GetColumnName();
 
-	// Try binding as a lambda parameter
 	if (!col_ref.IsQualified()) {
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
+		// Try binding as a lambda parameter.
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName());
 		if (lambda_ref) {
 			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
 		}

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

@@ -18,18 +18,18 @@ BindResult TableFunctionBinder::BindLambdaReference(LambdaRefExpression &expr, i
 
 BindResult TableFunctionBinder::BindColumnReference(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
                                                     bool root_expression) {
-	// try binding as a lambda parameter
 	auto &col_ref = expr_ptr->Cast<ColumnRefExpression>();
 	if (!col_ref.IsQualified()) {
-		auto column_name = col_ref.GetName();
-		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, column_name);
+		// Try binding as a lambda parameter.
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName());
 		if (lambda_ref) {
 			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
 		}
-		if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(column_name)) {
+		if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(col_ref.GetName())) {
 			throw ParameterNotResolvedException();
 		}
 	}
+
 	auto query_location = col_ref.GetQueryLocation();
 	auto column_names = col_ref.column_names;
 	auto result_name = StringUtil::Join(column_names, ".");

package/src/duckdb/src/planner/filter/expression_filter.cpp

@@ -36,13 +36,14 @@ string ExpressionFilter::ToString(const string &column_name) const {
 	return ToExpression(*name_expr)->ToString();
 }
 
-static void ReplaceExpressionRecursive(unique_ptr<Expression> &expr, const Expression &column) {
-	if (expr->type == ExpressionType::BOUND_REF) {
+void ExpressionFilter::ReplaceExpressionRecursive(unique_ptr<Expression> &expr, const Expression &column,
+                                                  ExpressionType replace_type) {
+	if (expr->type == replace_type) {
 		expr = column.Copy();
 		return;
 	}
 	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { ReplaceExpressionRecursive(child, column); });
+	    *expr, [&](unique_ptr<Expression> &child) { ReplaceExpressionRecursive(child, column, replace_type); });
 }
 
 unique_ptr<Expression> ExpressionFilter::ToExpression(const Expression &column) const {

package/src/duckdb/src/planner/table_filter.cpp

@@ -58,7 +58,8 @@ bool DynamicTableFilterSet::HasFilters() const {
 unique_ptr<TableFilterSet>
 DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan,
                                             optional_ptr<TableFilterSet> existing_filters) const {
-	D_ASSERT(HasFilters());
+	lock_guard<mutex> l(lock);
+	D_ASSERT(!filters.empty());
 	auto result = make_uniq<TableFilterSet>();
 	if (existing_filters) {
 		for (auto &entry : existing_filters->filters) {

package/src/duckdb/src/storage/buffer/buffer_pool.cpp

@@ -211,7 +211,7 @@ void EvictionQueue::PurgeIteration(const idx_t purge_size) {
 	}
 
 	// bulk purge
-	idx_t actually_dequeued = q.try_dequeue_bulk(purge_nodes.begin(), purge_size);
+	const idx_t actually_dequeued = q.try_dequeue_bulk(purge_nodes.begin(), purge_size);
 
 	// retrieve all alive nodes that have been wrongly dequeued
 	idx_t alive_nodes = 0;
@@ -219,11 +219,13 @@ void EvictionQueue::PurgeIteration(const idx_t purge_size) {
 		auto &node = purge_nodes[i];
 		auto handle = node.TryGetBlockHandle();
 		if (handle) {
-			q.enqueue(std::move(node));
-			alive_nodes++;
+			purge_nodes[alive_nodes++] = std::move(node);
 		}
 	}
 
+	// bulk re-add (TODO order them by timestamp to better retain the LRU behavior)
+	q.enqueue_bulk(purge_nodes.begin(), alive_nodes);
+
 	total_dead_nodes -= actually_dequeued - alive_nodes;
 }
 

package/src/duckdb/src/storage/compression/fsst.cpp

@@ -64,7 +64,7 @@ struct FSSTStorage {
 	static char *FetchStringPointer(StringDictionaryContainer dict, data_ptr_t baseptr, int32_t dict_offset);
 	static bp_delta_offsets_t CalculateBpDeltaOffsets(int64_t last_known_row, idx_t start, idx_t scan_count);
 	static bool ParseFSSTSegmentHeader(data_ptr_t base_ptr, duckdb_fsst_decoder_t *decoder_out,
-	                                   bitpacking_width_t *width_out);
+	                                   bitpacking_width_t *width_out, const idx_t block_size);
 	static bp_delta_offsets_t StartScan(FSSTScanState &scan_state, data_ptr_t base_data, idx_t start,
 	                                    idx_t vector_count);
 	static void EndScan(FSSTScanState &scan_state, bp_delta_offsets_t &offsets, idx_t start, idx_t scan_count);
@@ -335,14 +335,15 @@ public:
 	idx_t Finalize() {
 		auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db);
 		auto handle = buffer_manager.Pin(current_segment->block);
-		D_ASSERT(current_dictionary.end == info.GetBlockSize());
+		if (current_dictionary.end != info.GetBlockSize()) {
+			throw InternalException("dictionary end does not match the block size in FSSTCompressionState::Finalize");
+		}
 
 		// calculate sizes
 		auto compressed_index_buffer_size =
 		    BitpackingPrimitives::GetRequiredSize(current_segment->count, current_width);
 		auto total_size = sizeof(fsst_compression_header_t) + compressed_index_buffer_size + current_dictionary.size +
 		                  fsst_serialized_symbol_table_size;
-
 		if (total_size != last_fitting_size) {
 			throw InternalException("FSST string compression failed due to incorrect size calculation");
 		}
@@ -365,8 +366,12 @@ public:
 			memset(base_ptr + symbol_table_offset, 0, fsst_serialized_symbol_table_size);
 		}
 
-		Store<uint32_t>(NumericCast<uint32_t>(symbol_table_offset),
-		                data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
+		auto cast_symbol_table_offset = NumericCast<uint32_t>(symbol_table_offset);
+		if (cast_symbol_table_offset > info.GetBlockSize()) {
+			throw InternalException("invalid fsst_symbol_table_offset in FSSTCompressionState::Finalize");
+		}
+
+		Store<uint32_t>(cast_symbol_table_offset, data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
 		Store<uint32_t>((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width));
 
 		if (total_size >= info.GetCompactionFlushLimit()) {
@@ -563,15 +568,16 @@ struct FSSTScanState : public StringScanState {
 };
 
 unique_ptr<SegmentScanState> FSSTStorage::StringInitScan(ColumnSegment &segment) {
-	auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize());
+	auto block_size = segment.GetBlockManager().GetBlockSize();
+	auto string_block_limit = StringUncompressed::GetStringBlockLimit(block_size);
 	auto state = make_uniq<FSSTScanState>(string_block_limit);
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	state->handle = buffer_manager.Pin(segment.block);
 	auto base_ptr = state->handle.Ptr() + segment.GetBlockOffset();
 
 	state->duckdb_fsst_decoder = make_buffer<duckdb_fsst_decoder_t>();
-	auto retval = ParseFSSTSegmentHeader(
-	    base_ptr, reinterpret_cast<duckdb_fsst_decoder_t *>(state->duckdb_fsst_decoder.get()), &state->current_width);
+	auto decoder = reinterpret_cast<duckdb_fsst_decoder_t *>(state->duckdb_fsst_decoder.get());
+	auto retval = ParseFSSTSegmentHeader(base_ptr, decoder, &state->current_width, block_size);
 	if (!retval) {
 		state->duckdb_fsst_decoder = nullptr;
 	}
@@ -736,7 +742,8 @@ void FSSTStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state
 
 	duckdb_fsst_decoder_t decoder;
 	bitpacking_width_t width;
-	auto have_symbol_table = ParseFSSTSegmentHeader(base_ptr, &decoder, &width);
+	auto block_size = segment.GetBlockManager().GetBlockSize();
+	auto have_symbol_table = ParseFSSTSegmentHeader(base_ptr, &decoder, &width, block_size);
 
 	auto result_data = FlatVector::GetData<string_t>(result);
 	if (!have_symbol_table) {
@@ -814,9 +821,12 @@ char *FSSTStorage::FetchStringPointer(StringDictionaryContainer dict, data_ptr_t
 
 // Returns false if no symbol table was found. This means all strings are either empty or null
 bool FSSTStorage::ParseFSSTSegmentHeader(data_ptr_t base_ptr, duckdb_fsst_decoder_t *decoder_out,
-                                         bitpacking_width_t *width_out) {
+                                         bitpacking_width_t *width_out, const idx_t block_size) {
 	auto header_ptr = reinterpret_cast<fsst_compression_header_t *>(base_ptr);
 	auto fsst_symbol_table_offset = Load<uint32_t>(data_ptr_cast(&header_ptr->fsst_symbol_table_offset));
+	if (fsst_symbol_table_offset > block_size) {
+		throw InternalException("invalid fsst_symbol_table_offset in FSSTStorage::ParseFSSTSegmentHeader");
+	}
 	*width_out = (bitpacking_width_t)(Load<uint32_t>(data_ptr_cast(&header_ptr->bitpacking_width)));
 	return duckdb_fsst_import(decoder_out, base_ptr + fsst_symbol_table_offset);
 }