duckdb 1.4.0 → 1.4.1

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

@@ -24,6 +24,14 @@ BoundStatement InsertRelation::Bind(Binder &binder) {
 	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> InsertRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from an insert relation");
+}
+
+string InsertRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &InsertRelation::Columns() {
 	return columns;
 }

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

@@ -49,6 +49,10 @@ unique_ptr<QueryNode> QueryRelation::GetQueryNode() {
 	return std::move(select->node);
 }
 
+string QueryRelation::GetQuery() {
+	return query;
+}
+
 unique_ptr<TableRef> QueryRelation::GetTableRef() {
 	auto subquery_ref = make_uniq<SubqueryRef>(GetSelectStatement(), GetAlias());
 	return std::move(subquery_ref);

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

@@ -35,6 +35,14 @@ BoundStatement UpdateRelation::Bind(Binder &binder) {
 	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> UpdateRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from an update relation");
+}
+
+string UpdateRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &UpdateRelation::Columns() {
 	return columns;
 }

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

@@ -25,6 +25,14 @@ BoundStatement WriteCSVRelation::Bind(Binder &binder) {
 	return binder.Bind(copy.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> WriteCSVRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from a write CSV relation");
+}
+
+string WriteCSVRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &WriteCSVRelation::Columns() {
 	return columns;
 }

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

@@ -25,6 +25,14 @@ BoundStatement WriteParquetRelation::Bind(Binder &binder) {
 	return binder.Bind(copy.Cast<SQLStatement>());
 }
 
+unique_ptr<QueryNode> WriteParquetRelation::GetQueryNode() {
+	throw InternalException("Cannot create a query node from a write parquet relation");
+}
+
+string WriteParquetRelation::GetQuery() {
+	return string();
+}
+
 const vector<ColumnDefinition> &WriteParquetRelation::Columns() {
 	return columns;
 }

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

@@ -394,8 +394,8 @@ string Relation::ToString() {
 }
 
 // LCOV_EXCL_START
-unique_ptr<QueryNode> Relation::GetQueryNode() {
-	throw InternalException("Cannot create a query node from this node type");
+string Relation::GetQuery() {
+	return GetQueryNode()->ToString();
 }
 
 void Relation::Head(idx_t limit) {

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

@@ -1,5 +1,6 @@
 #include "duckdb/optimizer/filter_combiner.hpp"
 
+#include "duckdb/common/enums/expression_type.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
 #include "duckdb/planner/expression.hpp"
@@ -907,6 +908,12 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 	idx_t left_equivalence_set = GetEquivalenceSet(left_node);
 	idx_t right_equivalence_set = GetEquivalenceSet(right_node);
 	if (left_equivalence_set == right_equivalence_set) {
+		if (comparison.GetExpressionType() == ExpressionType::COMPARE_GREATERTHAN ||
+		    comparison.GetExpressionType() == ExpressionType::COMPARE_LESSTHAN) {
+			// non equal comparison has equal equivalence set, then it is unsatisfiable
+			// e.g., j > i AND i < j is unsatisfiable
+			return FilterResult::UNSATISFIABLE;
+		}
 		// this equality filter already exists, prune it
 		return FilterResult::SUCCESS;
 	}

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

@@ -207,17 +207,23 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOpera
 	}
 	return result;
 }
-void FilterPushdown::PushFilters() {
+FilterResult FilterPushdown::PushFilters() {
 	for (auto &f : filters) {
 		auto result = combiner.AddFilter(std::move(f->filter));
 		D_ASSERT(result != FilterResult::UNSUPPORTED);
-		(void)result;
+		if (result == FilterResult::UNSATISFIABLE) {
+			// one of the filters is unsatisfiable - abort filter pushdown
+			return FilterResult::UNSATISFIABLE;
+		}
 	}
 	filters.clear();
+	return FilterResult::SUCCESS;
 }
 
 FilterResult FilterPushdown::AddFilter(unique_ptr<Expression> expr) {
-	PushFilters();
+	if (PushFilters() == FilterResult::UNSATISFIABLE) {
+		return FilterResult::UNSATISFIABLE;
+	}
 	// split up the filters by AND predicate
 	vector<unique_ptr<Expression>> expressions;
 	expressions.push_back(std::move(expr));

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

@@ -4,6 +4,7 @@
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_empty_result.hpp"
 
 namespace duckdb {
 unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperator> op) {
@@ -48,7 +49,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperat
 		// the table function does not support filter pushdown: push a LogicalFilter on top
 		return FinishPushdown(std::move(op));
 	}
-	PushFilters();
+	if (PushFilters() == FilterResult::UNSATISFIABLE) {
+		return make_uniq<LogicalEmptyResult>(std::move(op));
+	}
 
 	//! We generate the table filters that will be executed during the table scan
 	vector<FilterPushdownResult> pushdown_results;

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

@@ -56,13 +56,8 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 		// Is the constant cast invertible?
 		if (!cast_constant.IsNull() &&
 		    !BoundCastExpression::CastIsInvertible(cast_expression.return_type, target_type)) {
-			// Is it actually invertible?
-			Value uncast_constant;
-			if (!cast_constant.TryCastAs(rewriter.context, constant_value.type(), uncast_constant, &error_message,
-			                             true) ||
-			    uncast_constant != constant_value) {
-				return nullptr;
-			}
+			// Cast is not invertible, so we do not rewrite this expression to ensure that the cast is executed
+			return nullptr;
 		}
 
 		//! We can cast, now we change our column_ref_expression from an operator cast to a column reference
@@ -75,6 +70,7 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 			expr.left = std::move(new_constant_expr);
 			expr.right = std::move(child_expression);
 		}
+		changes_made = true;
 	}
 	return nullptr;
 }

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

@@ -5,10 +5,7 @@ namespace duckdb {
 
 RelationStatement::RelationStatement(shared_ptr<Relation> relation_p)
     : SQLStatement(StatementType::RELATION_STATEMENT), relation(std::move(relation_p)) {
-	if (relation->type == RelationType::QUERY_RELATION) {
-		auto &query_relation = relation->Cast<QueryRelation>();
-		query = query_relation.query;
-	}
+	query = relation->GetQuery();
 }
 
 unique_ptr<SQLStatement> RelationStatement::Copy() const {

package/src/duckdb/src/parser/transform/statement/transform_create_function.cpp

@@ -47,6 +47,8 @@ unique_ptr<MacroFunction> Transformer::TransformMacroFunction(duckdb_libpgquery:
 			default_expr = make_uniq<ConstantExpression>(std::move(default_value));
 			default_expr->SetAlias(param.name);
 			macro_func->default_parameters[param.name] = std::move(default_expr);
+		} else if (!macro_func->default_parameters.empty()) {
+			throw ParserException("Parameter without a default follows parameter with a default");
 		}
 	}
 

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -186,9 +186,10 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 	}
 }
 
-static unique_ptr<LogicalDependentJoin>
-CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_columns, JoinType join_type,
-                              unique_ptr<LogicalOperator> original_plan, bool perform_delim) {
+static unique_ptr<LogicalDependentJoin> CreateDuplicateEliminatedJoin(const CorrelatedColumns &correlated_columns,
+                                                                      JoinType join_type,
+                                                                      unique_ptr<LogicalOperator> original_plan,
+                                                                      bool perform_delim) {
 	auto delim_join = make_uniq<LogicalDependentJoin>(join_type);
 	delim_join->correlated_columns = correlated_columns;
 	delim_join->perform_delim = perform_delim;
@@ -216,7 +217,7 @@ static bool PerformDelimOnType(const LogicalType &type) {
 	return true;
 }
 
-static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnInfo> &correlated_columns) {
+static bool PerformDuplicateElimination(Binder &binder, CorrelatedColumns &correlated_columns) {
 	if (!ClientConfig::GetConfig(binder.context).enable_optimizer) {
 		// if optimizations are disabled we always do a delim join
 		return true;
@@ -235,7 +236,8 @@ static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnI
 	auto type = LogicalType::BIGINT;
 	auto name = "delim_index";
 	CorrelatedColumnInfo info(binding, type, name, 0);
-	correlated_columns.insert(correlated_columns.begin(), std::move(info));
+	correlated_columns.AddColumn(std::move(info));
+	correlated_columns.SetDelimIndexToZero();
 	return false;
 }
 
@@ -403,7 +405,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 }
 
 unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-                                                    vector<CorrelatedColumnInfo> &correlated, JoinType join_type,
+                                                    CorrelatedColumns &correlated, JoinType join_type,
                                                     unique_ptr<Expression> condition) {
 	// scan the right operator for correlated columns
 	// correlated LATERAL JOIN

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

@@ -345,11 +345,7 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 			try {
 				dummy_binder->Bind(*query_node);
 			} catch (const std::exception &ex) {
-				// TODO: we would like to do something like "error = ErrorData(ex);" here,
-				//  but that breaks macro's like "create macro m(x) as table (from query_table(x));",
-				//  because dummy-binding these always throws an error instead of a ParameterNotResolvedException.
-				//  So, for now, we allow macro's with bind errors to be created.
-				//  Binding is still useful because we can create the dependencies.
+				error = ErrorData(ex);
 			}
 		}
 

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

@@ -232,10 +232,18 @@ BoundStatement Binder::Bind(MergeIntoStatement &stmt) {
 	auto bound_join_node = Bind(join);
 
 	auto root = CreatePlan(*bound_join_node);
+	auto join_ref = reference<LogicalOperator>(*root);
+	while (join_ref.get().children.size() == 1) {
+		join_ref = *join_ref.get().children[0];
+	}
+	if (join_ref.get().children.size() != 2) {
+		throw NotImplementedException("Expected a join after binding a join operator - but got a %s",
+		                              join_ref.get().type);
+	}
 	// kind of hacky, CreatePlan turns a RIGHT join into a LEFT join so the children get reversed from what we need
 	bool inverted = join.type == JoinType::RIGHT;
-	auto &source = root->children[inverted ? 1 : 0];
-	auto &get = root->children[inverted ? 0 : 1]->Cast<LogicalGet>();
+	auto &source = join_ref.get().children[inverted ? 1 : 0];
+	auto &get = join_ref.get().children[inverted ? 0 : 1]->Cast<LogicalGet>();
 
 	auto merge_into = make_uniq<LogicalMergeInto>(table);
 	merge_into->table_index = GenerateTableIndex();

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

@@ -2,6 +2,7 @@
 #include "duckdb/parser/statement/pragma_statement.hpp"
 #include "duckdb/planner/operator/logical_pragma.hpp"
 #include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
@@ -28,16 +29,32 @@ unique_ptr<BoundPragmaInfo> Binder::BindPragma(PragmaInfo &info, QueryErrorConte
 	}
 
 	// bind the pragma function
-	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
+	auto entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name,
+	                                                           OnEntryNotFound::RETURN_NULL);
+	if (!entry) {
+		// try to find whether a table extry might exist
+		auto table_entry = Catalog::GetEntry<TableFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA,
+		                                                                info.name, OnEntryNotFound::RETURN_NULL);
+		if (table_entry) {
+			// there is a table entry with the same name, now throw more explicit error message
+			throw CatalogException("Pragma Function with name %s does not exist, but a table function with the same "
+			                       "name exists, try `CALL %s(...)`",
+			                       info.name, info.name);
+		}
+		// rebind to throw exception
+		entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name,
+		                                                      OnEntryNotFound::THROW_EXCEPTION);
+	}
+
 	FunctionBinder function_binder(*this);
 	ErrorData error;
-	auto bound_idx = function_binder.BindFunction(entry.name, entry.functions, params, error);
+	auto bound_idx = function_binder.BindFunction(entry->name, entry->functions, params, error);
 	if (!bound_idx.IsValid()) {
 		D_ASSERT(error.HasError());
 		error.AddQueryLocation(error_context);
 		error.Throw();
 	}
-	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx.GetIndex());
+	auto bound_function = entry->functions.GetFunctionByOffset(bound_idx.GetIndex());
 	// bind and check named params
 	BindNamedParameters(bound_function.named_parameters, named_parameters, error_context, bound_function.name);
 	return make_uniq<BoundPragmaInfo>(std::move(bound_function), std::move(params), std::move(named_parameters));

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

@@ -58,10 +58,15 @@ static void ConstructPivots(PivotRef &ref, vector<PivotValueElement> &pivot_valu
 	}
 }
 
-static void ExtractPivotExpressions(ParsedExpression &root_expr, case_insensitive_set_t &handled_columns) {
+static void ExtractPivotExpressions(ParsedExpression &root_expr, case_insensitive_set_t &handled_columns,
+                                    optional_ptr<DummyBinding> macro_binding) {
 	ParsedExpressionIterator::VisitExpression<ColumnRefExpression>(
 	    root_expr, [&](const ColumnRefExpression &child_colref) {
 		    if (child_colref.IsQualified()) {
+			    if (child_colref.column_names[0].find(DummyBinding::DUMMY_NAME) != string::npos && macro_binding &&
+			        macro_binding->HasMatchingBinding(child_colref.GetName())) {
+				    throw ParameterNotResolvedException();
+			    }
 			    throw BinderException(child_colref, "PIVOT expression cannot contain qualified columns");
 		    }
 		    handled_columns.insert(child_colref.GetColumnName());
@@ -492,7 +497,7 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		}
 	}
 	for (auto &aggr : pivot_aggregates) {
-		ExtractPivotExpressions(aggr.get(), handled_columns);
+		ExtractPivotExpressions(aggr.get(), handled_columns, macro_binding);
 	}
 
 	// first add all pivots to the set of handled columns, and check for duplicates
@@ -521,7 +526,7 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		total_pivots *= pivot.entries.size();
 		// add the pivoted column to the columns that have been handled
 		for (auto &pivot_name : pivot.pivot_expressions) {
-			ExtractPivotExpressions(*pivot_name, handled_columns);
+			ExtractPivotExpressions(*pivot_name, handled_columns, macro_binding);
 		}
 		value_set_t pivots;
 		for (auto &entry : pivot.entries) {

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

@@ -469,8 +469,15 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		}
 	}
 
-	auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters),
-	                                     std::move(input_table_types), std::move(input_table_names));
+	unique_ptr<LogicalOperator> get;
+	try {
+		get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters),
+		                                std::move(input_table_types), std::move(input_table_names));
+	} catch (std::exception &ex) {
+		error = ErrorData(ex);
+		error.AddQueryLocation(ref);
+		error.Throw();
+	}
 	auto table_function_ref = make_uniq<BoundTableFunction>(std::move(get));
 	table_function_ref->subquery = std::move(subquery);
 	return std::move(table_function_ref);

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

@@ -440,7 +440,7 @@ void Binder::MoveCorrelatedExpressions(Binder &other) {
 	other.correlated_columns.clear();
 }
 
-void Binder::MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other) {
+void Binder::MergeCorrelatedColumns(CorrelatedColumns &other) {
 	for (idx_t i = 0; i < other.size(); i++) {
 		AddCorrelatedColumn(other[i]);
 	}
@@ -449,7 +449,7 @@ void Binder::MergeCorrelatedColumns(vector<CorrelatedColumnInfo> &other) {
 void Binder::AddCorrelatedColumn(const CorrelatedColumnInfo &info) {
 	// we only add correlated columns to the list if they are not already there
 	if (std::find(correlated_columns.begin(), correlated_columns.end(), info) == correlated_columns.end()) {
-		correlated_columns.push_back(info);
+		correlated_columns.AddColumn(info);
 	}
 }
 

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

@@ -17,7 +17,7 @@ void LateralBinder::ExtractCorrelatedColumns(Expression &expr) {
 			// add the correlated column info
 			CorrelatedColumnInfo info(bound_colref);
 			if (std::find(correlated_columns.begin(), correlated_columns.end(), info) == correlated_columns.end()) {
-				correlated_columns.push_back(std::move(info));
+				correlated_columns.AddColumn(std::move(info)); // TODO is adding to the front OK here?
 			}
 		}
 	}
@@ -54,8 +54,7 @@ string LateralBinder::UnsupportedAggregateMessage() {
 	return "LATERAL join cannot contain aggregates!";
 }
 
-static void ReduceColumnRefDepth(BoundColumnRefExpression &expr,
-                                 const vector<CorrelatedColumnInfo> &correlated_columns) {
+static void ReduceColumnRefDepth(BoundColumnRefExpression &expr, const CorrelatedColumns &correlated_columns) {
 	// don't need to reduce this
 	if (expr.depth == 0) {
 		return;
@@ -69,8 +68,7 @@ static void ReduceColumnRefDepth(BoundColumnRefExpression &expr,
 	}
 }
 
-static void ReduceColumnDepth(vector<CorrelatedColumnInfo> &columns,
-                              const vector<CorrelatedColumnInfo> &affected_columns) {
+static void ReduceColumnDepth(CorrelatedColumns &columns, const CorrelatedColumns &affected_columns) {
 	for (auto &s_correlated : columns) {
 		for (auto &affected : affected_columns) {
 			if (affected == s_correlated) {
@@ -83,8 +81,7 @@ static void ReduceColumnDepth(vector<CorrelatedColumnInfo> &columns,
 
 class ExpressionDepthReducerRecursive : public BoundNodeVisitor {
 public:
-	explicit ExpressionDepthReducerRecursive(const vector<CorrelatedColumnInfo> &correlated)
-	    : correlated_columns(correlated) {
+	explicit ExpressionDepthReducerRecursive(const CorrelatedColumns &correlated) : correlated_columns(correlated) {
 	}
 
 	void VisitExpression(unique_ptr<Expression> &expression) override {
@@ -106,20 +103,19 @@ public:
 		BoundNodeVisitor::VisitBoundTableRef(ref);
 	}
 
-	static void ReduceExpressionSubquery(BoundSubqueryExpression &expr,
-	                                     const vector<CorrelatedColumnInfo> &correlated_columns) {
+	static void ReduceExpressionSubquery(BoundSubqueryExpression &expr, const CorrelatedColumns &correlated_columns) {
 		ReduceColumnDepth(expr.binder->correlated_columns, correlated_columns);
 		ExpressionDepthReducerRecursive recursive(correlated_columns);
 		recursive.VisitBoundQueryNode(*expr.subquery);
 	}
 
 private:
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 };
 
 class ExpressionDepthReducer : public LogicalOperatorVisitor {
 public:
-	explicit ExpressionDepthReducer(const vector<CorrelatedColumnInfo> &correlated) : correlated_columns(correlated) {
+	explicit ExpressionDepthReducer(const CorrelatedColumns &correlated) : correlated_columns(correlated) {
 	}
 
 protected:
@@ -133,10 +129,10 @@ protected:
 		return nullptr;
 	}
 
-	const vector<CorrelatedColumnInfo> &correlated_columns;
+	const CorrelatedColumns &correlated_columns;
 };
 
-void LateralBinder::ReduceExpressionDepth(LogicalOperator &op, const vector<CorrelatedColumnInfo> &correlated) {
+void LateralBinder::ReduceExpressionDepth(LogicalOperator &op, const CorrelatedColumns &correlated) {
 	ExpressionDepthReducer depth_reducer(correlated);
 	depth_reducer.VisitOperator(op);
 }

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

@@ -27,9 +27,13 @@ BindResult TableFunctionBinder::BindColumnReference(unique_ptr<ParsedExpression>
 		if (lambda_ref) {
 			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
 		}
+
 		if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(col_ref.GetName())) {
 			throw ParameterNotResolvedException();
 		}
+	} else if (col_ref.column_names[0].find(DummyBinding::DUMMY_NAME) != string::npos && binder.macro_binding &&
+	           binder.macro_binding->HasMatchingBinding(col_ref.GetName())) {
+		throw ParameterNotResolvedException();
 	}
 
 	auto query_location = col_ref.GetQueryLocation();

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

@@ -103,7 +103,9 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 	case ExpressionClass::STAR:
 		return BindResult(BinderException::Unsupported(expr_ref, "STAR expression is not supported here"));
 	default:
-		throw NotImplementedException("Unimplemented expression class");
+		return BindResult(
+		    NotImplementedException("Unimplemented expression class in ExpressionBinder::BindExpression: %s",
+		                            EnumUtil::ToString(expr_ref.GetExpressionClass())));
 	}
 }
 

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 LogicalDependentJoin::LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-                                           vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+                                           CorrelatedColumns correlated_columns, JoinType type,
                                            unique_ptr<Expression> condition)
     : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_DEPENDENT_JOIN), join_condition(std::move(condition)),
       correlated_columns(std::move(correlated_columns)) {
@@ -17,7 +17,7 @@ LogicalDependentJoin::LogicalDependentJoin(JoinType join_type)
 
 unique_ptr<LogicalOperator> LogicalDependentJoin::Create(unique_ptr<LogicalOperator> left,
                                                          unique_ptr<LogicalOperator> right,
-                                                         vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+                                                         CorrelatedColumns correlated_columns, JoinType type,
                                                          unique_ptr<Expression> condition) {
 	return make_uniq<LogicalDependentJoin>(std::move(left), std::move(right), std::move(correlated_columns), type,
 	                                       std::move(condition));

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

@@ -18,9 +18,8 @@
 
 namespace duckdb {
 
-FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated,
-                                             bool perform_delim, bool any_join,
-                                             optional_ptr<FlattenDependentJoins> parent)
+FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const CorrelatedColumns &correlated, bool perform_delim,
+                                             bool any_join, optional_ptr<FlattenDependentJoins> parent)
     : binder(binder), delim_offset(DConstants::INVALID_INDEX), correlated_columns(correlated),
       perform_delim(perform_delim), any_join(any_join), parent(parent) {
 	for (idx_t i = 0; i < correlated_columns.size(); i++) {
@@ -30,8 +29,7 @@ FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<Correl
 	}
 }
 
-static void CreateDelimJoinConditions(LogicalComparisonJoin &delim_join,
-                                      const vector<CorrelatedColumnInfo> &correlated_columns,
+static void CreateDelimJoinConditions(LogicalComparisonJoin &delim_join, const CorrelatedColumns &correlated_columns,
                                       vector<ColumnBinding> bindings, idx_t base_offset, bool perform_delim) {
 	auto col_count = perform_delim ? correlated_columns.size() : 1;
 	for (idx_t i = 0; i < col_count; i++) {
@@ -50,7 +48,7 @@ static void CreateDelimJoinConditions(LogicalComparisonJoin &delim_join,
 
 unique_ptr<LogicalOperator> FlattenDependentJoins::DecorrelateIndependent(Binder &binder,
                                                                           unique_ptr<LogicalOperator> plan) {
-	vector<CorrelatedColumnInfo> correlated;
+	CorrelatedColumns correlated;
 	FlattenDependentJoins flatten(binder, correlated);
 	return flatten.Decorrelate(std::move(plan));
 }
@@ -80,12 +78,12 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::Decorrelate(unique_ptr<Logica
 			entry->second = false;
 
 			// rewrite
-			idx_t lateral_depth = 0;
+			idx_t next_lateral_depth = 0;
 
-			RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, lateral_depth);
+			RewriteCorrelatedExpressions rewriter(base_binding, correlated_map, next_lateral_depth);
 			rewriter.VisitOperator(*plan);
 
-			RewriteCorrelatedExpressions recursive_rewriter(base_binding, correlated_map, lateral_depth, true);
+			RewriteCorrelatedExpressions recursive_rewriter(base_binding, correlated_map, next_lateral_depth, true);
 			recursive_rewriter.VisitOperator(*plan);
 		} else {
 			op.children[0] = Decorrelate(std::move(op.children[0]));
@@ -94,8 +92,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::Decorrelate(unique_ptr<Logica
 		if (!op.perform_delim) {
 			// if we are not performing a delim join, we push a row_number() OVER() window operator on the LHS
 			// and perform all duplicate elimination on that row number instead
-			D_ASSERT(op.correlated_columns[0].type.id() == LogicalTypeId::BIGINT);
-			auto window = make_uniq<LogicalWindow>(op.correlated_columns[0].binding.table_index);
+			const auto &op_col = op.correlated_columns[op.correlated_columns.GetDelimIndex()];
+			auto window = make_uniq<LogicalWindow>(op_col.binding.table_index);
 			auto row_number = make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT,
 			                                                   nullptr, nullptr);
 			row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
@@ -114,9 +112,9 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::Decorrelate(unique_ptr<Logica
 		flatten.DetectCorrelatedExpressions(*delim_join->children[1], op.is_lateral_join, lateral_depth);
 
 		if (delim_join->children[1]->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
-			auto &cte = delim_join->children[1]->Cast<LogicalMaterializedCTE>();
+			auto &cte_ref = delim_join->children[1]->Cast<LogicalMaterializedCTE>();
 			// check if the left side of the CTE has correlated expressions
-			auto entry = flatten.has_correlated_expressions.find(*cte.children[0]);
+			auto entry = flatten.has_correlated_expressions.find(*cte_ref.children[0]);
 			if (entry != flatten.has_correlated_expressions.end()) {
 				if (!entry->second) {
 					// the left side of the CTE has no correlated expressions, we can push the DEPENDENT_JOIN down
@@ -132,7 +130,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::Decorrelate(unique_ptr<Logica
 		delim_join->children[1] =
 		    flatten.PushDownDependentJoin(std::move(delim_join->children[1]), propagate_null_values, lateral_depth);
 		data_offset = flatten.data_offset;
-		auto left_offset = delim_join->children[0]->GetColumnBindings().size();
+		const auto left_offset = delim_join->children[0]->GetColumnBindings().size();
 		if (!parent) {
 			delim_offset = left_offset + flatten.delim_offset;
 		}

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

@@ -7,7 +7,7 @@
 
 namespace duckdb {
 
-HasCorrelatedExpressions::HasCorrelatedExpressions(const vector<CorrelatedColumnInfo> &correlated, bool lateral,
+HasCorrelatedExpressions::HasCorrelatedExpressions(const CorrelatedColumns &correlated, bool lateral,
                                                    idx_t lateral_depth)
     : has_correlated_expressions(false), lateral(lateral), correlated_columns(correlated),
       lateral_depth(lateral_depth) {

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

@@ -14,7 +14,7 @@
 
 namespace duckdb {
 
-RewriteCTEScan::RewriteCTEScan(idx_t table_index, const vector<CorrelatedColumnInfo> &correlated_columns)
+RewriteCTEScan::RewriteCTEScan(idx_t table_index, const CorrelatedColumns &correlated_columns)
     : table_index(table_index), correlated_columns(correlated_columns) {
 }
 
@@ -49,7 +49,7 @@ void RewriteCTEScan::VisitOperator(LogicalOperator &op) {
 				// The correlated columns must be placed at the beginning of the
 				// correlated_columns list. Otherwise, further column accesses
 				// and rewrites will fail.
-				join.correlated_columns.emplace(join.correlated_columns.begin(), corr);
+				join.correlated_columns.AddColumn(std::move(corr));
 			}
 		}
 	}

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

@@ -341,8 +341,6 @@ unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalTyp
 
 template <class T>
 bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = state.Cast<BitpackingAnalyzeState<T>>();
-
 	// We use BITPACKING_METADATA_GROUP_SIZE tuples, which can exceed the block size.
 	// In that case, we disable bitpacking.
 	// we are conservative here by multiplying by 2
@@ -351,6 +349,7 @@ bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 		return false;
 	}
 
+	auto &analyze_state = state.Cast<BitpackingAnalyzeState<T>>();
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);