duckdb 1.1.3 → 1.1.4-dev9.0

package/src/duckdb/src/optimizer/pullup/pullup_set_operation.cpp

@@ -6,7 +6,7 @@
 namespace duckdb {
 
 static void ReplaceFilterTableIndex(Expression &expr, LogicalSetOperation &setop) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.depth == 0);
 

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

@@ -10,7 +10,7 @@ namespace duckdb {
 using Filter = FilterPushdown::Filter;
 
 static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, unique_ptr<Expression> expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr->Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == proj.group_index);
 		D_ASSERT(colref.binding.column_index < proj.groups.size());
@@ -24,7 +24,7 @@ static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, uniqu
 }
 
 void FilterPushdown::ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindings) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		bindings.push_back(colref.binding);
 	}

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

@@ -9,7 +9,7 @@ using Filter = FilterPushdown::Filter;
 unique_ptr<LogicalOperator> FilterPushdown::PushdownFilter(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
 	auto &filter = op->Cast<LogicalFilter>();
-	if (!filter.projection_map.empty()) {
+	if (filter.HasProjectionMap()) {
 		return FinishPushdown(std::move(op));
 	}
 	// filter: gather the filters and remove the filter from the set of operations

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

@@ -13,7 +13,7 @@ namespace duckdb {
 using Filter = FilterPushdown::Filter;
 
 static unique_ptr<Expression> ReplaceColRefWithNull(unique_ptr<Expression> expr, unordered_set<idx_t> &right_bindings) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 		if (right_bindings.find(bound_colref.binding.table_index) != right_bindings.end()) {
 			// bound colref belongs to RHS

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

@@ -36,7 +36,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 #endif
 			// this filter references the marker
 			// we can turn this into a SEMI join if the filter is on only the marker
-			if (filters[i]->filter->type == ExpressionType::BOUND_COLUMN_REF && convert_mark_joins &&
+			if (filters[i]->filter->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF && convert_mark_joins &&
 			    comp_join.convert_mark_to_semi) {
 				// filter just references the marker: turn into semi join
 #ifdef DEBUG
@@ -51,9 +51,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 			// turn this into an ANTI join if all join conditions have null_values_are_equal=true, then the result of
 			// the MARK join is always TRUE or FALSE, and never NULL this happens in the case of a correlated EXISTS
 			// clause
-			if (filters[i]->filter->type == ExpressionType::OPERATOR_NOT) {
+			if (filters[i]->filter->GetExpressionType() == ExpressionType::OPERATOR_NOT) {
 				auto &op_expr = filters[i]->filter->Cast<BoundOperatorExpression>();
-				if (op_expr.children[0]->type == ExpressionType::BOUND_COLUMN_REF) {
+				if (op_expr.children[0]->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 					// the filter is NOT(marker), check the join conditions
 					bool all_null_values_are_equal = true;
 					for (auto &cond : comp_join.conditions) {

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

@@ -3,11 +3,13 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/common/types.hpp"
 
 namespace duckdb {
 
 static bool IsVolatile(LogicalProjection &proj, const unique_ptr<Expression> &expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr->Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == proj.table_index);
 		D_ASSERT(colref.binding.column_index < proj.expressions.size());
@@ -24,7 +26,7 @@ static bool IsVolatile(LogicalProjection &proj, const unique_ptr<Expression> &ex
 }
 
 static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj, unique_ptr<Expression> expr) {
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr->Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == proj.table_index);
 		D_ASSERT(colref.binding.column_index < proj.expressions.size());
@@ -51,7 +53,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<Logica
 		auto &f = *filter;
 		D_ASSERT(f.bindings.size() <= 1);
 		bool is_volatile = IsVolatile(proj, f.filter);
-		if (is_volatile) {
+		if (is_volatile || f.filter->CanThrow()) {
 			// We can't push down related expressions if the column in the
 			// expression is generated by the functions which have side effects
 			remain_expressions.push_back(std::move(f.filter));

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

@@ -13,7 +13,7 @@ using Filter = FilterPushdown::Filter;
 
 static void ReplaceSetOpBindings(vector<ColumnBinding> &bindings, Filter &filter, Expression &expr,
                                  LogicalSetOperation &setop) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == setop.table_index);
 		D_ASSERT(colref.depth == 0);

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

@@ -0,0 +1,52 @@
+#include "duckdb/optimizer/filter_pushdown.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/operator/logical_empty_result.hpp"
+#include "duckdb/planner/operator/logical_unnest.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> FilterPushdown::PushdownUnnest(unique_ptr<LogicalOperator> op) {
+	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_UNNEST);
+	auto &unnest = op->Cast<LogicalUnnest>();
+	// push filter through logical projection
+	// all the BoundColumnRefExpressions in the filter should refer to the LogicalProjection
+	// we can rewrite them by replacing those references with the expression of the LogicalProjection node
+	FilterPushdown child_pushdown(optimizer, convert_mark_joins);
+	// There are some expressions can not be pushed down. We should keep them
+	// and add an extra filter operator.
+	vector<unique_ptr<Expression>> remain_expressions;
+	for (auto &filter : filters) {
+		auto &f = *filter;
+		auto can_push = true;
+		for (auto &binding : f.bindings) {
+			if (binding == unnest.unnest_index) {
+				can_push = false;
+				break;
+			}
+		}
+		// if the expression index table index is the unnest index, then the filter is on the
+		// unnest, and it should not be pushed down.
+		if (!can_push) {
+			// We can't push down related expressions if the column in the
+			// expression is generated by the functions which have side effects
+			remain_expressions.push_back(std::move(f.filter));
+		} else {
+			// add the filter to the child pushdown
+			if (child_pushdown.AddFilter(std::move(f.filter)) == FilterResult::UNSATISFIABLE) {
+				// filter statically evaluates to false, strip tree
+				return make_uniq<LogicalEmptyResult>(std::move(op));
+			}
+		}
+	}
+	child_pushdown.GenerateFilters();
+	// now push into children
+	op->children[0] = child_pushdown.Rewrite(std::move(op->children[0]));
+	if (op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
+		// child returns an empty result: generate an empty result here too
+		return make_uniq<LogicalEmptyResult>(std::move(op));
+	}
+	return AddLogicalFilter(std::move(op), std::move(remain_expressions));
+}
+
+} // namespace duckdb

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

@@ -39,7 +39,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownWindow(unique_ptr<LogicalOpe
 	// into the children.
 	vector<column_binding_set_t> window_exprs_partition_bindings;
 	for (auto &expr : window.expressions) {
-		if (expr->expression_class != ExpressionClass::BOUND_WINDOW) {
+		if (expr->GetExpressionClass() != ExpressionClass::BOUND_WINDOW) {
 			continue;
 		}
 		auto &window_expr = expr->Cast<BoundWindowExpression>();
@@ -53,7 +53,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownWindow(unique_ptr<LogicalOpe
 		column_binding_set_t partition_bindings;
 		// 2. Get the binding information of the partitions of the window expression
 		for (auto &partition_expr : partitions) {
-			switch (partition_expr->type) {
+			switch (partition_expr->GetExpressionType()) {
 			// TODO: Add expressions for function expressions like FLOOR, CEIL etc.
 			case ExpressionType::BOUND_COLUMN_REF: {
 				auto &partition_col = partition_expr->Cast<BoundColumnRefExpression>();

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

@@ -28,7 +28,7 @@ unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator
 	auto new_filter = make_uniq<LogicalFilter>();
 
 	for (auto &expr : op->expressions) {
-		if (expr->type == ExpressionType::BOUND_FUNCTION) {
+		if (expr->GetExpressionType() == ExpressionType::BOUND_FUNCTION) {
 			auto &func = expr->Cast<BoundFunctionExpression>();
 			if (func.function.name != "regexp_full_match" || func.children.size() != 2) {
 				continue;

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

@@ -29,7 +29,7 @@ void RemoveDuplicateGroups::VisitAggregate(LogicalAggregate &aggr) {
 	vector<pair<idx_t, idx_t>> duplicates;
 	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
 		const auto &group = groups[group_idx];
-		if (group->type != ExpressionType::BOUND_COLUMN_REF) {
+		if (group->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
 			continue;
 		}
 		const auto &colref = group->Cast<BoundColumnRefExpression>();

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

@@ -8,6 +8,7 @@
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
@@ -18,15 +19,17 @@
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_set_operation.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/function/scalar/struct_utils.hpp"
 
 namespace duckdb {
 
-void RemoveUnusedColumns::ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding) {
+void BaseColumnPruner::ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding) {
 	auto colrefs = column_references.find(current_binding);
 	if (colrefs != column_references.end()) {
-		for (auto &colref : colrefs->second) {
-			D_ASSERT(colref->binding == current_binding);
-			colref->binding = new_binding;
+		for (auto &colref_p : colrefs->second.bindings) {
+			auto &colref = colref_p.get();
+			D_ASSERT(colref.binding == current_binding);
+			colref.binding = new_binding;
 		}
 	}
 }
@@ -86,8 +89,8 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 			// this reduces the amount of columns we need to extract from the join hash table
 			for (auto &cond : comp_join.conditions) {
 				if (cond.comparison == ExpressionType::COMPARE_EQUAL) {
-					if (cond.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
-					    cond.right->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
+					if (cond.left->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF &&
+					    cond.right->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
 						// comparison join between two bound column refs
 						// we can replace any reference to the RHS (build-side) with a reference to the LHS (probe-side)
 						auto &lhs_col = cond.left->Cast<BoundColumnRefExpression>();
@@ -95,9 +98,10 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 						// if there are any columns that refer to the RHS,
 						auto colrefs = column_references.find(rhs_col.binding);
 						if (colrefs != column_references.end()) {
-							for (auto &entry : colrefs->second) {
-								entry->binding = lhs_col.binding;
-								column_references[lhs_col.binding].push_back(entry);
+							for (auto &entry : colrefs->second.bindings) {
+								auto &colref = entry.get();
+								colref.binding = lhs_col.binding;
+								AddBinding(colref);
 							}
 							column_references.erase(rhs_col.binding);
 						}
@@ -209,7 +213,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 				return;
 			}
 
-			auto &final_column_ids = get.GetColumnIds();
+			auto final_column_ids = get.GetColumnIds();
 
 			// Create "selection vector" of all column ids
 			vector<idx_t> proj_sel;
@@ -221,12 +225,13 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 			// Clear unused ids, exclude filter columns that are projected out immediately
 			ClearUnusedExpressions(proj_sel, get.table_index, false);
 
+			vector<unique_ptr<Expression>> filter_expressions;
 			// for every table filter, push a column binding into the column references map to prevent the column from
 			// being projected out
 			for (auto &filter : get.table_filters.filters) {
 				optional_idx index;
 				for (idx_t i = 0; i < final_column_ids.size(); i++) {
-					if (final_column_ids[i] == filter.first) {
+					if (final_column_ids[i].GetPrimaryIndex() == filter.first) {
 						index = i;
 						break;
 					}
@@ -234,20 +239,39 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 				if (!index.IsValid()) {
 					throw InternalException("Could not find column index for table filter");
 				}
+
+				auto column_type =
+				    filter.first == COLUMN_IDENTIFIER_ROW_ID ? LogicalType::ROW_TYPE : get.returned_types[filter.first];
+
 				ColumnBinding filter_binding(get.table_index, index.GetIndex());
-				if (column_references.find(filter_binding) == column_references.end()) {
-					column_references.insert(make_pair(filter_binding, vector<BoundColumnRefExpression *>()));
-				}
+				auto column_ref = make_uniq<BoundColumnRefExpression>(std::move(column_type), filter_binding);
+				auto filter_expr = filter.second->ToExpression(*column_ref);
+				VisitExpression(&filter_expr);
+				filter_expressions.push_back(std::move(filter_expr));
 			}
 
 			// Clear unused ids, include filter columns that are projected out immediately
 			ClearUnusedExpressions(col_sel, get.table_index);
 
 			// Now set the column ids in the LogicalGet using the "selection vector"
-			vector<column_t> column_ids;
+			vector<ColumnIndex> column_ids;
 			column_ids.reserve(col_sel.size());
 			for (auto col_sel_idx : col_sel) {
-				column_ids.push_back(final_column_ids[col_sel_idx]);
+				auto entry = column_references.find(ColumnBinding(get.table_index, col_sel_idx));
+				if (entry == column_references.end()) {
+					throw InternalException("RemoveUnusedColumns - could not find referenced column");
+				}
+				if (final_column_ids[col_sel_idx].HasChildren()) {
+					throw InternalException("RemoveUnusedColumns - LogicalGet::column_ids already has children");
+				}
+				ColumnIndex new_index(final_column_ids[col_sel_idx].GetPrimaryIndex(), entry->second.child_columns);
+				column_ids.emplace_back(new_index);
+			}
+			if (column_ids.empty()) {
+				// this generally means we are only interested in whether or not anything exists in the table (e.g.
+				// EXISTS(SELECT * FROM tbl)) in this case, we just scan the row identifier column as it means we do not
+				// need to read any of the columns
+				column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
 			}
 			get.SetColumnIds(std::move(column_ids));
 
@@ -255,6 +279,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 				// Now set the projection cols by matching the "selection vector" that excludes filter columns
 				// with the "selection vector" that includes filter columns
 				idx_t col_idx = 0;
+				get.projection_ids.clear();
 				for (auto proj_sel_idx : proj_sel) {
 					for (; col_idx < col_sel.size(); col_idx++) {
 						if (proj_sel_idx == col_sel[col_idx]) {
@@ -264,24 +289,8 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 					}
 				}
 			}
-
-			if (final_column_ids.empty()) {
-				// this generally means we are only interested in whether or not anything exists in the table (e.g.
-				// EXISTS(SELECT * FROM tbl)) in this case, we just scan the row identifier column as it means we do not
-				// need to read any of the columns
-				get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID);
-			}
 		}
 		return;
-	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = op.Cast<LogicalFilter>();
-		if (!filter.projection_map.empty()) {
-			// if we have any entries in the filter projection map don't prune any columns
-			// FIXME: we can do something more clever here
-			everything_referenced = true;
-		}
-		break;
-	}
 	case LogicalOperatorType::LOGICAL_DISTINCT: {
 		auto &distinct = op.Cast<LogicalDistinct>();
 		if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
@@ -339,15 +348,136 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 	}
 }
 
-unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundColumnRefExpression &expr,
-                                                         unique_ptr<Expression> *expr_ptr) {
-	// add a column reference
-	column_references[expr.binding].push_back(&expr);
+bool BaseColumnPruner::HandleStructExtractRecursive(Expression &expr, optional_ptr<BoundColumnRefExpression> &colref,
+                                                    vector<idx_t> &indexes) {
+	if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
+		return false;
+	}
+	auto &function = expr.Cast<BoundFunctionExpression>();
+	if (function.function.name != "struct_extract_at" && function.function.name != "struct_extract" &&
+	    function.function.name != "array_extract") {
+		return false;
+	}
+	if (!function.bind_info) {
+		return false;
+	}
+	if (function.children[0]->return_type.id() != LogicalTypeId::STRUCT) {
+		return false;
+	}
+	auto &bind_data = function.bind_info->Cast<StructExtractBindData>();
+	indexes.push_back(bind_data.index);
+	// struct extract, check if left child is a bound column ref
+	if (function.children[0]->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
+		// column reference - check if it is a struct
+		auto &ref = function.children[0]->Cast<BoundColumnRefExpression>();
+		if (ref.return_type.id() != LogicalTypeId::STRUCT) {
+			return false;
+		}
+		colref = &ref;
+		return true;
+	}
+	// not a column reference - try to handle this recursively
+	if (!HandleStructExtractRecursive(*function.children[0], colref, indexes)) {
+		return false;
+	}
+	return true;
+}
+
+bool BaseColumnPruner::HandleStructExtract(Expression &expr) {
+	optional_ptr<BoundColumnRefExpression> colref;
+	vector<idx_t> indexes;
+	if (!HandleStructExtractRecursive(expr, colref, indexes)) {
+		return false;
+	}
+	D_ASSERT(!indexes.empty());
+	// construct the ColumnIndex
+	ColumnIndex index = ColumnIndex(indexes[0]);
+	for (idx_t i = 1; i < indexes.size(); i++) {
+		ColumnIndex new_index(indexes[i]);
+		new_index.AddChildIndex(std::move(index));
+		index = std::move(new_index);
+	}
+	AddBinding(*colref, std::move(index));
+	return true;
+}
+
+void MergeChildColumns(vector<ColumnIndex> &current_child_columns, ColumnIndex &new_child_column) {
+	if (current_child_columns.empty()) {
+		// there's already a reference to the full column - we can't extract only a subfield
+		// skip struct projection pushdown
+		return;
+	}
+	// if we are already extract sub-fields, add it (if it is not there yet)
+	for (auto &binding : current_child_columns) {
+		if (binding.GetPrimaryIndex() != new_child_column.GetPrimaryIndex()) {
+			continue;
+		}
+		// found a match: sub-field is already projected
+		// check if we have child columns
+		auto &nested_child_columns = binding.GetChildIndexesMutable();
+		if (!new_child_column.HasChildren()) {
+			// new child is a reference to a full column - clear any existing bindings (if any)
+			nested_child_columns.clear();
+		} else {
+			// new child has a sub-reference - merge recursively
+			D_ASSERT(new_child_column.ChildIndexCount() == 1);
+			MergeChildColumns(nested_child_columns, new_child_column.GetChildIndex(0));
+		}
+		return;
+	}
+	// this child column is not projected yet - add it in
+	current_child_columns.push_back(std::move(new_child_column));
+}
+
+void BaseColumnPruner::AddBinding(BoundColumnRefExpression &col, ColumnIndex child_column) {
+	auto entry = column_references.find(col.binding);
+	if (entry == column_references.end()) {
+		// column not referenced yet - add a binding to it entirely
+		ReferencedColumn column;
+		column.bindings.push_back(col);
+		column.child_columns.push_back(std::move(child_column));
+		column_references.insert(make_pair(col.binding, std::move(column)));
+	} else {
+		// column reference already exists - check add the binding
+		auto &column = entry->second;
+		column.bindings.push_back(col);
+
+		MergeChildColumns(column.child_columns, child_column);
+	}
+}
+
+void BaseColumnPruner::AddBinding(BoundColumnRefExpression &col) {
+	auto entry = column_references.find(col.binding);
+	if (entry == column_references.end()) {
+		// column not referenced yet - add a binding to it entirely
+		column_references[col.binding].bindings.push_back(col);
+	} else {
+		// column reference already exists - add the binding and clear any sub-references
+		auto &column = entry->second;
+		column.bindings.push_back(col);
+		column.child_columns.clear();
+	}
+}
+
+void BaseColumnPruner::VisitExpression(unique_ptr<Expression> *expression) {
+	auto &expr = **expression;
+	if (HandleStructExtract(expr)) {
+		// already handled
+		return;
+	}
+	// recurse
+	LogicalOperatorVisitor::VisitExpression(expression);
+}
+
+unique_ptr<Expression> BaseColumnPruner::VisitReplace(BoundColumnRefExpression &expr,
+                                                      unique_ptr<Expression> *expr_ptr) {
+	// add a reference to the entire column
+	AddBinding(expr);
 	return nullptr;
 }
 
-unique_ptr<Expression> RemoveUnusedColumns::VisitReplace(BoundReferenceExpression &expr,
-                                                         unique_ptr<Expression> *expr_ptr) {
+unique_ptr<Expression> BaseColumnPruner::VisitReplace(BoundReferenceExpression &expr,
+                                                      unique_ptr<Expression> *expr_ptr) {
 	// BoundReferenceExpression should not be used here yet, they only belong in the physical plan
 	throw InternalException("BoundReferenceExpression should not be used here yet!");
 }

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -1,9 +1,10 @@
 #include "duckdb/optimizer/rule/arithmetic_simplification.hpp"
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/function/function_binder.hpp"
+#include "duckdb/optimizer/expression_rewriter.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/optimizer/expression_rewriter.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/optimizer/rule/comparison_simplification.cpp

@@ -3,6 +3,7 @@
 
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/optimizer/expression_rewriter.hpp"
 
 namespace duckdb {
 
@@ -28,12 +29,12 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
 		return nullptr;
 	}
-	if (constant_value.IsNull() && !(expr.type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-	                                 expr.type == ExpressionType::COMPARE_DISTINCT_FROM)) {
+	if (constant_value.IsNull() && !(expr.GetExpressionType() == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
+	                                 expr.GetExpressionType() == ExpressionType::COMPARE_DISTINCT_FROM)) {
 		// comparison with constant NULL, return NULL
 		return make_uniq<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
 	}
-	if (column_ref_expr->expression_class == ExpressionClass::BOUND_CAST) {
+	if (column_ref_expr->GetExpressionClass() == ExpressionClass::BOUND_CAST) {
 		//! Here we check if we can apply the expression on the constant side
 		//! We can do this if the cast itself is invertible and casting the constant is
 		//! invertible in practice.
@@ -46,7 +47,8 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 		// Can we cast the constant at all?
 		string error_message;
 		Value cast_constant;
-		auto new_constant = constant_value.DefaultTryCastAs(target_type, cast_constant, &error_message, true);
+		auto new_constant =
+		    constant_value.TryCastAs(rewriter.context, target_type, cast_constant, &error_message, true);
 		if (!new_constant) {
 			return nullptr;
 		}
@@ -56,7 +58,8 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 		    !BoundCastExpression::CastIsInvertible(cast_expression.return_type, target_type)) {
 			// Is it actually invertible?
 			Value uncast_constant;
-			if (!cast_constant.DefaultTryCastAs(constant_value.type(), uncast_constant, &error_message, true) ||
+			if (!cast_constant.TryCastAs(rewriter.context, constant_value.type(), uncast_constant, &error_message,
+			                             true) ||
 			    uncast_constant != constant_value) {
 				return nullptr;
 			}

package/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp

@@ -48,7 +48,7 @@ unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
 		// we can't simplify conjunctions with a constant NULL
 		return nullptr;
 	}
-	if (conjunction.type == ExpressionType::CONJUNCTION_AND) {
+	if (conjunction.GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
 		if (!BooleanValue::Get(constant_value)) {
 			// FALSE in AND, result of expression is false
 			return make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
@@ -57,7 +57,7 @@ unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
 			return RemoveExpression(conjunction, constant_expr);
 		}
 	} else {
-		D_ASSERT(conjunction.type == ExpressionType::CONJUNCTION_OR);
+		D_ASSERT(conjunction.GetExpressionType() == ExpressionType::CONJUNCTION_OR);
 		if (!BooleanValue::Get(constant_value)) {
 			// FALSE in OR, remove the expression from the set
 			return RemoveExpression(conjunction, constant_expr);

package/src/duckdb/src/optimizer/rule/constant_folding.cpp

@@ -13,7 +13,7 @@ class ConstantFoldingExpressionMatcher : public FoldableConstantMatcher {
 public:
 	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override {
 		// we also do not match on ConstantExpressions, because we cannot fold those any further
-		if (expr.type == ExpressionType::VALUE_CONSTANT) {
+		if (expr.GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 			return false;
 		}
 		return FoldableConstantMatcher::Match(expr, bindings);
@@ -29,7 +29,7 @@ unique_ptr<Expression> ConstantFoldingRule::Apply(LogicalOperator &op, vector<re
                                                   bool &changes_made, bool is_root) {
 	auto &root = bindings[0].get();
 	// the root is a scalar expression that we have to fold
-	D_ASSERT(root.IsFoldable() && root.type != ExpressionType::VALUE_CONSTANT);
+	D_ASSERT(root.IsFoldable() && root.GetExpressionType() != ExpressionType::VALUE_CONSTANT);
 
 	// use an ExpressionExecutor to execute the expression
 	Value result_value;