duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -0,0 +1,33 @@
+#include "duckdb/planner/filter/struct_filter.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+StructFilter::StructFilter(idx_t child_idx_p, string child_name_p, unique_ptr<TableFilter> child_filter_p)
+    : TableFilter(TableFilterType::STRUCT_EXTRACT), child_idx(child_idx_p), child_name(std::move(child_name_p)),
+      child_filter(std::move(child_filter_p)) {
+}
+
+FilterPropagateResult StructFilter::CheckStatistics(BaseStatistics &stats) {
+	D_ASSERT(stats.GetType().id() == LogicalTypeId::STRUCT);
+	// Check the child statistics
+	auto &child_stats = StructStats::GetChildStats(stats, child_idx);
+	return child_filter->CheckStatistics(child_stats);
+}
+
+string StructFilter::ToString(const string &column_name) {
+	return child_filter->ToString(column_name + "." + child_name);
+}
+
+bool StructFilter::Equals(const TableFilter &other_p) const {
+	if (!TableFilter::Equals(other_p)) {
+		return false;
+	}
+	auto &other = other_p.Cast<StructFilter>();
+	return other.child_idx == child_idx && StringUtil::CIEquals(other.child_name, child_name) &&
+	       other.child_filter->Equals(*child_filter);
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/joinside.cpp

@@ -60,7 +60,7 @@ JoinSide JoinSide::GetJoinSide(Expression &expression, const unordered_set<idx_t
 	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expression.Cast<BoundColumnRefExpression>();
 		if (colref.depth > 0) {
-			throw Exception("Non-inner join on correlated columns not supported");
+			throw NotImplementedException("Non-inner join on correlated columns not supported");
 		}
 		return GetJoinSide(colref.binding.table_index, left_bindings, right_bindings);
 	}

package/src/duckdb/src/planner/logical_operator.cpp

@@ -185,9 +185,10 @@ unique_ptr<LogicalOperator> LogicalOperator::Copy(ClientContext &context) const
 		this->Serialize(serializer);
 		serializer.End();
 	} catch (NotImplementedException &ex) {
+		ErrorData error(ex);
 		throw NotImplementedException("Logical Operator Copy requires the logical operator and all of its children to "
 		                              "be serializable: " +
-		                              std::string(ex.what()));
+		                              error.RawMessage());
 	}
 	stream.Rewind();
 	bound_parameter_map_t parameters;

package/src/duckdb/src/planner/operator/logical_copy_database.cpp

@@ -0,0 +1,32 @@
+#include "duckdb/planner/operator/logical_copy_database.hpp"
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_info.hpp"
+
+namespace duckdb {
+
+CopyDatabaseInfo::CopyDatabaseInfo(Catalog &from_database, Catalog &to_database)
+    : from_database(from_database), to_database(to_database) {
+}
+
+CopyDatabaseInfo::~CopyDatabaseInfo() {
+}
+
+LogicalCopyDatabase::LogicalCopyDatabase(unique_ptr<CopyDatabaseInfo> info_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_DATABASE), info(std::move(info_p)) {
+}
+
+LogicalCopyDatabase::~LogicalCopyDatabase() {
+}
+
+void LogicalCopyDatabase::Serialize(Serializer &serializer) const {
+	throw NotImplementedException("LogicalCopyDatabase::Serialize");
+}
+unique_ptr<LogicalOperator> LogicalCopyDatabase::Deserialize(Deserializer &deserializer) {
+	throw NotImplementedException("LogicalCopyDatabase::Deserialize");
+}
+
+void LogicalCopyDatabase::ResolveTypes() {
+	types.emplace_back(LogicalType::BOOLEAN);
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
 
 #include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/function/copy_function.hpp"
 #include "duckdb/function/function_serialization.hpp"
 
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
-
 namespace duckdb {
 
 void LogicalCopyToFile::Serialize(Serializer &serializer) const {
@@ -32,6 +31,8 @@ void LogicalCopyToFile::Serialize(Serializer &serializer) const {
 		serializer.WriteObject(212, "function_data",
 		                       [&](Serializer &obj) { function.serialize(obj, *bind_data, function); });
 	}
+
+	serializer.WriteProperty(213, "file_extension", file_extension);
 }
 
 unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(Deserializer &deserializer) {
@@ -70,13 +71,21 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(Deserializer &deseria
 		if (!function.copy_to_bind) {
 			throw InternalException("Copy function \"%s\" has neither bind nor (de)serialize", function.name);
 		}
-		bind_data = function.copy_to_bind(context, *copy_info, names, expected_types);
+
+		CopyFunctionBindInput function_bind_input(*copy_info);
+		bind_data = function.copy_to_bind(context, function_bind_input, names, expected_types);
 	}
 
+	auto default_extension = function.extension;
+
+	auto file_extension =
+	    deserializer.ReadPropertyWithDefault<string>(213, "file_extension", std::move(default_extension));
+
 	auto result = make_uniq<LogicalCopyToFile>(function, std::move(bind_data), std::move(copy_info));
 	result->file_path = file_path;
 	result->use_tmp_file = use_tmp_file;
 	result->filename_pattern = filename_pattern;
+	result->file_extension = file_extension;
 	result->overwrite_or_ignore = overwrite_or_ignore;
 	result->per_thread_output = per_thread_output;
 	result->partition_output = partition_output;

package/src/duckdb/src/planner/operator/logical_create_table.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 
+#include "duckdb/planner/binder.hpp"
+
 namespace duckdb {
 
 LogicalCreateTable::LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -23,7 +23,10 @@ LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<Fun
 }
 
 optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
-	return TableScanFunction::GetTableEntry(function, bind_data.get());
+	if (!function.get_bind_info) {
+		return nullptr;
+	}
+	return function.get_bind_info(bind_data.get()).table;
 }
 
 string LogicalGet::ParamsToString() const {

package/src/duckdb/src/planner/operator/logical_join.cpp

@@ -15,6 +15,7 @@ vector<ColumnBinding> LogicalJoin::GetColumnBindings() {
 		// for SEMI and ANTI join we only project the left hand side
 		return left_bindings;
 	}
+
 	if (join_type == JoinType::MARK) {
 		// for MARK join we project the left hand side plus the MARK column
 		left_bindings.emplace_back(mark_index, 0);
@@ -22,6 +23,9 @@ vector<ColumnBinding> LogicalJoin::GetColumnBindings() {
 	}
 	// for other join types we project both the LHS and the RHS
 	auto right_bindings = MapBindings(children[1]->GetColumnBindings(), right_projection_map);
+	if (join_type == JoinType::RIGHT_SEMI || join_type == JoinType::RIGHT_ANTI) {
+		return right_bindings;
+	}
 	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
 	return left_bindings;
 }
@@ -39,6 +43,10 @@ void LogicalJoin::ResolveTypes() {
 	}
 	// for any other join we project both sides
 	auto right_types = MapTypes(children[1]->types, right_projection_map);
+	if (join_type == JoinType::RIGHT_SEMI || join_type == JoinType::RIGHT_ANTI) {
+		types = right_types;
+		return;
+	}
 	types.insert(types.end(), right_types.begin(), right_types.end());
 }
 

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

@@ -47,32 +47,33 @@ void Planner::CreatePlan(SQLStatement &statement) {
 
 		auto max_tree_depth = ClientConfig::GetConfig(context).max_expression_depth;
 		CheckTreeDepth(*plan, max_tree_depth);
-	} catch (const ParameterNotResolvedException &ex) {
-		// parameter types could not be resolved
-		this->names = {"unknown"};
-		this->types = {LogicalTypeId::UNKNOWN};
+	} catch (const std::exception &ex) {
+		ErrorData error(ex);
 		this->plan = nullptr;
-		parameters_resolved = false;
-	} catch (const Exception &ex) {
-		auto &config = DBConfig::GetConfig(context);
-
-		this->plan = nullptr;
-		for (auto &extension_op : config.operator_extensions) {
-			auto bound_statement =
-			    extension_op->Bind(context, *this->binder, extension_op->operator_info.get(), statement);
-			if (bound_statement.plan != nullptr) {
-				this->names = bound_statement.names;
-				this->types = bound_statement.types;
-				this->plan = std::move(bound_statement.plan);
-				break;
+		if (error.Type() == ExceptionType::PARAMETER_NOT_RESOLVED) {
+			// parameter types could not be resolved
+			this->names = {"unknown"};
+			this->types = {LogicalTypeId::UNKNOWN};
+			parameters_resolved = false;
+		} else if (error.Type() != ExceptionType::INVALID) {
+			// different exception type - try operator_extensions
+			auto &config = DBConfig::GetConfig(context);
+			for (auto &extension_op : config.operator_extensions) {
+				auto bound_statement =
+				    extension_op->Bind(context, *this->binder, extension_op->operator_info.get(), statement);
+				if (bound_statement.plan != nullptr) {
+					this->names = bound_statement.names;
+					this->types = bound_statement.types;
+					this->plan = std::move(bound_statement.plan);
+					break;
+				}
 			}
-		}
-
-		if (!this->plan) {
+			if (!this->plan) {
+				throw;
+			}
+		} else {
 			throw;
 		}
-	} catch (std::exception &ex) {
-		throw;
 	}
 	this->properties = binder->properties;
 	this->properties.parameter_count = parameter_count;
@@ -127,7 +128,6 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 	case StatementType::CALL_STATEMENT:
 	case StatementType::EXPORT_STATEMENT:
 	case StatementType::PRAGMA_STATEMENT:
-	case StatementType::SHOW_STATEMENT:
 	case StatementType::SET_STATEMENT:
 	case StatementType::LOAD_STATEMENT:
 	case StatementType::EXTENSION_STATEMENT:
@@ -136,6 +136,7 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 	case StatementType::LOGICAL_PLAN_STATEMENT:
 	case StatementType::ATTACH_STATEMENT:
 	case StatementType::DETACH_STATEMENT:
+	case StatementType::COPY_DATABASE_STATEMENT:
 		CreatePlan(*statement);
 		break;
 	default:

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -5,7 +5,7 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
 #include "duckdb/parser/statement/multi_statement.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
+#include "duckdb/parser/parsed_data/bound_pragma_info.hpp"
 #include "duckdb/function/function.hpp"
 
 #include "duckdb/main/client_context.hpp"
@@ -33,7 +33,7 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 			// PRAGMA statement: check if we need to replace it by a new set of statements
 			PragmaHandler handler(context);
 			string new_query;
-			bool expanded = handler.HandlePragma(statements[i].get(), new_query);
+			bool expanded = handler.HandlePragma(*statements[i], new_query);
 			if (expanded) {
 				// this PRAGMA statement gets replaced by a new query string
 				// push the new query string through the parser again and add it to the transformer
@@ -68,23 +68,14 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 	context.RunFunctionInTransactionInternal(lock, [&]() { HandlePragmaStatementsInternal(statements); });
 }
 
-bool PragmaHandler::HandlePragma(SQLStatement *statement, string &resulting_query) { // PragmaInfo &info
-	auto info = *(statement->Cast<PragmaStatement>()).info;
-	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
-	string error;
-
-	FunctionBinder function_binder(context);
-	idx_t bound_idx = function_binder.BindFunction(entry.name, entry.functions, info, error);
-	if (bound_idx == DConstants::INVALID_INDEX) {
-		throw BinderException(error);
-	}
-	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx);
-	if (bound_function.query) {
-		QueryErrorContext error_context(statement, statement->stmt_location);
-		Binder::BindNamedParameters(bound_function.named_parameters, info.named_parameters, error_context,
-		                            bound_function.name);
-		FunctionParameters parameters {info.parameters, info.named_parameters};
-		resulting_query = bound_function.query(context, parameters);
+bool PragmaHandler::HandlePragma(SQLStatement &statement, string &resulting_query) {
+	auto info = statement.Cast<PragmaStatement>().info->Copy();
+	QueryErrorContext error_context(statement.stmt_location);
+	auto binder = Binder::CreateBinder(context);
+	auto bound_info = binder->BindPragma(*info, error_context);
+	if (bound_info->function.query) {
+		FunctionParameters parameters {bound_info->parameters, bound_info->named_parameters};
+		resulting_query = bound_info->function.query(context, parameters);
 		return true;
 	}
 	return false;

package/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/planner/subquery/has_correlated_expressions.hpp"
 #include "duckdb/planner/subquery/rewrite_correlated_expressions.hpp"
+#include "duckdb/planner/subquery/rewrite_cte_scan.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
 
 namespace duckdb {
@@ -54,6 +55,35 @@ bool FlattenDependentJoins::DetectCorrelatedExpressions(LogicalOperator *op, boo
 	}
 	// set the entry in the map
 	has_correlated_expressions[op] = has_correlation;
+
+	// If we detect correlation in a materialized or recursive CTE, the entire right side of the operator
+	// needs to be marked as correlated. Otherwise, function PushDownDependentJoinInternal does not do the
+	// right thing.
+	if (op->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE ||
+	    op->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
+		if (has_correlation) {
+			MarkSubtreeCorrelated(*op->children[1].get());
+		}
+	}
+	return has_correlation;
+}
+
+bool FlattenDependentJoins::MarkSubtreeCorrelated(LogicalOperator &op) {
+	// Do not mark base table scans as correlated
+	auto entry = has_correlated_expressions.find(&op);
+	D_ASSERT(entry != has_correlated_expressions.end());
+	bool has_correlation = entry->second;
+	for (auto &child : op.children) {
+		has_correlation |= MarkSubtreeCorrelated(*child.get());
+	}
+	if (op.type != LogicalOperatorType::LOGICAL_GET || op.children.size() == 1) {
+		if (op.type == LogicalOperatorType::LOGICAL_CTE_REF) {
+			has_correlated_expressions[&op] = true;
+			return true;
+		} else {
+			has_correlated_expressions[&op] = has_correlation;
+		}
+	}
 	return has_correlation;
 }
 
@@ -94,6 +124,18 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		// we reached a node without correlated expressions
 		// we can eliminate the dependent join now and create a simple cross product
 		// now create the duplicate eliminated scan for this node
+		if (plan->type == LogicalOperatorType::LOGICAL_CTE_REF) {
+			auto &op = plan->Cast<LogicalCTERef>();
+
+			auto rec_cte = binder.recursive_ctes.find(op.cte_index);
+			if (rec_cte != binder.recursive_ctes.end()) {
+				D_ASSERT(rec_cte->second->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
+				auto &rec_cte_op = rec_cte->second->Cast<LogicalRecursiveCTE>();
+				RewriteCTEScan cte_rewriter(op.cte_index, rec_cte_op.correlated_columns);
+				cte_rewriter.VisitOperator(*plan);
+			}
+		}
+
 		auto left_columns = plan->GetColumnBindings().size();
 		auto delim_index = binder.GenerateTableIndex();
 		this->base_binding = ColumnBinding(delim_index, 0);
@@ -284,7 +326,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN: {
 		auto &dependent_join = plan->Cast<LogicalJoin>();
 		if (!((dependent_join.join_type == JoinType::INNER) || (dependent_join.join_type == JoinType::LEFT))) {
-			throw Exception("Dependent join can only be INNER or LEFT type");
+			throw NotImplementedException("Dependent join can only be INNER or LEFT type");
 		}
 		D_ASSERT(plan->children.size() == 2);
 		// Push all the bindings down to the left side so the right side knows where to refer DELIM_GET from
@@ -345,7 +387,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			}
 		} else if (join.join_type == JoinType::MARK) {
 			if (right_has_correlation) {
-				throw Exception("MARK join with correlation in RHS not supported");
+				throw NotImplementedException("MARK join with correlation in RHS not supported");
 			}
 			// push the child into the LHS
 			plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]),
@@ -355,7 +397,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			rewriter.VisitOperator(*plan);
 			return plan;
 		} else {
-			throw Exception("Unsupported join type for flattening correlated subquery");
+			throw NotImplementedException("Unsupported join type for flattening correlated subquery");
 		}
 		// both sides have correlation
 		// push into both sides
@@ -575,11 +617,62 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		this->data_offset = 0;
 		return plan;
 	}
+	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: {
-		throw BinderException("Recursive CTEs not (yet) supported in correlated subquery");
+
+#ifdef DEBUG
+		plan->children[0]->ResolveOperatorTypes();
+		plan->children[1]->ResolveOperatorTypes();
+#endif
+		idx_t table_index = 0;
+		plan->children[0] =
+		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
+		if (plan->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
+			auto &setop = plan->Cast<LogicalRecursiveCTE>();
+			base_binding.table_index = setop.table_index;
+			base_binding.column_index = setop.column_count;
+			table_index = setop.table_index;
+			setop.correlated_columns = correlated_columns;
+		} else if (plan->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
+			auto &setop = plan->Cast<LogicalMaterializedCTE>();
+			base_binding.table_index = setop.table_index;
+			base_binding.column_index = setop.column_count;
+			table_index = setop.table_index;
+		}
+
+		RewriteCTEScan cte_rewriter(table_index, correlated_columns);
+		cte_rewriter.VisitOperator(*plan->children[1]);
+
+		parent_propagate_null_values = false;
+		plan->children[1] =
+		    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values, lateral_depth);
+		RewriteCorrelatedExpressions rewriter(this->base_binding, correlated_map, lateral_depth);
+		rewriter.VisitOperator(*plan);
+
+		RewriteCorrelatedExpressions recursive_rewriter(this->base_binding, correlated_map, lateral_depth, true);
+		recursive_rewriter.VisitOperator(*plan->children[0]);
+		recursive_rewriter.VisitOperator(*plan->children[1]);
+
+#ifdef DEBUG
+		plan->children[0]->ResolveOperatorTypes();
+		plan->children[1]->ResolveOperatorTypes();
+#endif
+		if (plan->type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
+			// we have to refer to the recursive CTE index now
+			auto &setop = plan->Cast<LogicalRecursiveCTE>();
+			base_binding.table_index = setop.table_index;
+			base_binding.column_index = setop.column_count;
+			setop.column_count += correlated_columns.size();
+		}
+
+		return plan;
 	}
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE: {
-		throw BinderException("Materialized CTEs not (yet) supported in correlated subquery");
+	case LogicalOperatorType::LOGICAL_CTE_REF: {
+		auto &cteref = plan->Cast<LogicalCTERef>();
+		// Read correlated columns from CTE_SCAN instead of from DELIM_SCAN
+		base_binding.table_index = cteref.table_index;
+		base_binding.column_index = cteref.chunk_types.size() - cteref.correlated_columns;
+		return plan;
 	}
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
 		throw BinderException("Nested lateral joins or lateral joins in correlated subqueries are not (yet) supported");

package/src/duckdb/src/planner/subquery/rewrite_cte_scan.cpp

@@ -0,0 +1,36 @@
+#include "duckdb/planner/subquery/rewrite_cte_scan.hpp"
+
+#include "duckdb/planner/operator/list.hpp"
+
+#include "duckdb/planner/expression/bound_case_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_operator_expression.hpp"
+#include "duckdb/planner/expression/bound_subquery_expression.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/tableref/bound_joinref.hpp"
+#include "duckdb/planner/operator/logical_dependent_join.hpp"
+
+namespace duckdb {
+
+RewriteCTEScan::RewriteCTEScan(idx_t table_index, const vector<CorrelatedColumnInfo> &correlated_columns)
+    : table_index(table_index), correlated_columns(correlated_columns) {
+}
+
+void RewriteCTEScan::VisitOperator(LogicalOperator &op) {
+	if (op.type == LogicalOperatorType::LOGICAL_CTE_REF) {
+		auto &cteref = op.Cast<LogicalCTERef>();
+
+		if (cteref.cte_index == table_index) {
+			for (auto &c : this->correlated_columns) {
+				cteref.chunk_types.push_back(c.type);
+				cteref.bound_columns.push_back(c.name);
+			}
+			cteref.correlated_columns += correlated_columns.size();
+		}
+	}
+	VisitOperatorChildren(op);
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/table_binding.cpp

@@ -52,8 +52,9 @@ bool Binding::HasMatchingBinding(const string &column_name) {
 	return TryGetBindingIndex(column_name, result);
 }
 
-string Binding::ColumnNotFoundError(const string &column_name) const {
-	return StringUtil::Format("Values list \"%s\" does not have a column named \"%s\"", alias, column_name);
+ErrorData Binding::ColumnNotFoundError(const string &column_name) const {
+	return ErrorData(ExceptionType::BINDER,
+	                 StringUtil::Format("Values list \"%s\" does not have a column named \"%s\"", alias, column_name));
 }
 
 BindResult Binding::Bind(ColumnRefExpression &colref, idx_t depth) {
@@ -218,14 +219,15 @@ optional_ptr<StandardEntry> TableBinding::GetStandardEntry() {
 	return entry;
 }
 
-string TableBinding::ColumnNotFoundError(const string &column_name) const {
-	return StringUtil::Format("Table \"%s\" does not have a column named \"%s\"", alias, column_name);
+ErrorData TableBinding::ColumnNotFoundError(const string &column_name) const {
+	return ErrorData(ExceptionType::BINDER,
+	                 StringUtil::Format("Table \"%s\" does not have a column named \"%s\"", alias, column_name));
 }
 
-DummyBinding::DummyBinding(vector<LogicalType> types_p, vector<string> names_p, string dummy_name_p)
-    : Binding(BindingType::DUMMY, DummyBinding::DUMMY_NAME + dummy_name_p, std::move(types_p), std::move(names_p),
+DummyBinding::DummyBinding(vector<LogicalType> types, vector<string> names, string dummy_name)
+    : Binding(BindingType::DUMMY, DummyBinding::DUMMY_NAME + dummy_name, std::move(types), std::move(names),
               DConstants::INVALID_INDEX),
-      dummy_name(std::move(dummy_name_p)) {
+      dummy_name(std::move(dummy_name)) {
 }
 
 BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
@@ -239,14 +241,14 @@ BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	return BindResult(make_uniq<BoundColumnRefExpression>(colref.GetName(), types[column_index], binding, depth));
 }
 
-BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t lambda_index, idx_t depth) {
+BindResult DummyBinding::Bind(LambdaRefExpression &lambdaref, idx_t depth) {
 	column_t column_index;
-	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
-		throw InternalException("Column %s not found in bindings", colref.GetColumnName());
+	if (!TryGetBindingIndex(lambdaref.GetName(), column_index)) {
+		throw InternalException("Column %s not found in bindings", lambdaref.GetName());
 	}
 	ColumnBinding binding(index, column_index);
-	return BindResult(
-	    make_uniq<BoundLambdaRefExpression>(colref.GetName(), types[column_index], binding, lambda_index, depth));
+	return BindResult(make_uniq<BoundLambdaRefExpression>(lambdaref.GetName(), types[column_index], binding,
+	                                                      lambdaref.lambda_idx, depth));
 }
 
 unique_ptr<ParsedExpression> DummyBinding::ParamToArg(ColumnRefExpression &colref) {

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

@@ -8,18 +8,20 @@
 
 namespace duckdb {
 
-BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p)
-    : block_manager(block_manager), readers(0), block_id(block_id_p), buffer(nullptr), eviction_timestamp(0),
-      can_destroy(false), memory_charge(block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr) {
+BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, MemoryTag tag)
+    : block_manager(block_manager), readers(0), block_id(block_id_p), tag(tag), buffer(nullptr), eviction_timestamp(0),
+      can_destroy(false), memory_charge(tag, block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr) {
 	eviction_timestamp = 0;
 	state = BlockState::BLOCK_UNLOADED;
 	memory_usage = Storage::BLOCK_ALLOC_SIZE;
 }
 
-BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, unique_ptr<FileBuffer> buffer_p,
-                         bool can_destroy_p, idx_t block_size, BufferPoolReservation &&reservation)
-    : block_manager(block_manager), readers(0), block_id(block_id_p), eviction_timestamp(0), can_destroy(can_destroy_p),
-      memory_charge(block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr) {
+BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, MemoryTag tag,
+                         unique_ptr<FileBuffer> buffer_p, bool can_destroy_p, idx_t block_size,
+                         BufferPoolReservation &&reservation)
+    : block_manager(block_manager), readers(0), block_id(block_id_p), tag(tag), eviction_timestamp(0),
+      can_destroy(can_destroy_p), memory_charge(tag, block_manager.buffer_manager.GetBufferPool()),
+      unswizzled(nullptr) {
 	buffer = std::move(buffer_p);
 	state = BlockState::BLOCK_LOADED;
 	memory_usage = block_size;
@@ -78,8 +80,8 @@ BufferHandle BlockHandle::Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileB
 		if (handle->can_destroy) {
 			return BufferHandle();
 		} else {
-			handle->buffer =
-			    block_manager.buffer_manager.ReadTemporaryBuffer(handle->block_id, std::move(reusable_buffer));
+			handle->buffer = block_manager.buffer_manager.ReadTemporaryBuffer(handle->tag, handle->block_id,
+			                                                                  std::move(reusable_buffer));
 		}
 	}
 	handle->state = BlockState::BLOCK_LOADED;
@@ -96,7 +98,7 @@ unique_ptr<FileBuffer> BlockHandle::UnloadAndTakeBlock() {
 
 	if (block_id >= MAXIMUM_BLOCK && !can_destroy) {
 		// temporary block that cannot be destroyed: write to temporary file
-		block_manager.buffer_manager.WriteTemporaryBuffer(block_id, *buffer);
+		block_manager.buffer_manager.WriteTemporaryBuffer(tag, block_id, *buffer);
 	}
 	memory_charge.Resize(0);
 	state = BlockState::BLOCK_UNLOADED;

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

@@ -23,7 +23,7 @@ shared_ptr<BlockHandle> BlockManager::RegisterBlock(block_id_t block_id) {
 		}
 	}
 	// create a new block pointer for this block
-	auto result = make_shared<BlockHandle>(*this, block_id);
+	auto result = make_shared<BlockHandle>(*this, block_id, MemoryTag::BASE_TABLE);
 	// register the block pointer in the set of blocks as a weak pointer
 	blocks[block_id] = weak_ptr<BlockHandle>(result);
 	return result;