duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/planner/logical_operator_visitor.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_subquery_expression.hpp"
+#include "duckdb/planner/tableref/bound_joinref.hpp"
 
 namespace duckdb {
 
@@ -53,59 +54,82 @@ string LateralBinder::UnsupportedAggregateMessage() {
 	return "LATERAL join cannot contain aggregates!";
 }
 
-class ExpressionDepthReducer : public LogicalOperatorVisitor {
-public:
-	explicit ExpressionDepthReducer(const vector<CorrelatedColumnInfo> &correlated) : correlated_columns(correlated) {
+static void ReduceColumnRefDepth(BoundColumnRefExpression &expr,
+                                 const vector<CorrelatedColumnInfo> &correlated_columns) {
+	// don't need to reduce this
+	if (expr.depth == 0) {
+		return;
 	}
-
-protected:
-	void ReduceColumnRefDepth(BoundColumnRefExpression &expr) {
-		// don't need to reduce this
-		if (expr.depth == 0) {
-			return;
+	for (auto &correlated : correlated_columns) {
+		if (correlated.binding == expr.binding) {
+			D_ASSERT(expr.depth > 1);
+			expr.depth--;
+			break;
 		}
-		for (auto &correlated : correlated_columns) {
-			if (correlated.binding == expr.binding) {
-				D_ASSERT(expr.depth > 1);
-				expr.depth--;
+	}
+}
+
+static void ReduceColumnDepth(vector<CorrelatedColumnInfo> &columns,
+                              const vector<CorrelatedColumnInfo> &affected_columns) {
+	for (auto &s_correlated : columns) {
+		for (auto &affected : affected_columns) {
+			if (affected == s_correlated) {
+				s_correlated.depth--;
 				break;
 			}
 		}
 	}
+}
 
-	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		ReduceColumnRefDepth(expr);
-		return nullptr;
+static void ReduceExpressionSubquery(BoundSubqueryExpression &expr,
+                                     const vector<CorrelatedColumnInfo> &correlated_columns) {
+	ReduceColumnDepth(expr.binder->correlated_columns, correlated_columns);
+}
+
+class ExpressionDepthReducerRecursive : public BoundNodeVisitor {
+public:
+	explicit ExpressionDepthReducerRecursive(const vector<CorrelatedColumnInfo> &correlated)
+	    : correlated_columns(correlated) {
 	}
 
-	void ReduceExpressionSubquery(BoundSubqueryExpression &expr) {
-		for (auto &s_correlated : expr.binder->correlated_columns) {
-			for (auto &correlated : correlated_columns) {
-				if (correlated == s_correlated) {
-					s_correlated.depth--;
-					break;
-				}
-			}
+	void VisitExpression(unique_ptr<Expression> &expression) override {
+		if (expression->type == ExpressionType::BOUND_COLUMN_REF) {
+			ReduceColumnRefDepth(expression->Cast<BoundColumnRefExpression>(), correlated_columns);
+		} else if (expression->type == ExpressionType::SUBQUERY) {
+			ReduceExpressionSubquery(expression->Cast<BoundSubqueryExpression>(), correlated_columns);
 		}
+		BoundNodeVisitor::VisitExpression(expression);
 	}
 
-	void ReduceExpressionDepth(Expression &expr) {
-		if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			ReduceColumnRefDepth(expr.Cast<BoundColumnRefExpression>());
-		}
-		if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
-			auto &subquery_ref = expr.Cast<BoundSubqueryExpression>();
-			ReduceExpressionSubquery(expr.Cast<BoundSubqueryExpression>());
-			// Recursively update the depth in the bindings of the children nodes
-			ExpressionIterator::EnumerateQueryNodeChildren(
-			    *subquery_ref.subquery, [&](Expression &child_expr) { ReduceExpressionDepth(child_expr); });
+	void VisitBoundTableRef(BoundTableRef &ref) override {
+		if (ref.type == TableReferenceType::JOIN) {
+			// rewrite correlated columns in child joins
+			auto &bound_join = ref.Cast<BoundJoinRef>();
+			ReduceColumnDepth(bound_join.correlated_columns, correlated_columns);
 		}
+		// visit the children of the table ref
+		BoundNodeVisitor::VisitBoundTableRef(ref);
+	}
+
+private:
+	const vector<CorrelatedColumnInfo> &correlated_columns;
+};
+
+class ExpressionDepthReducer : public LogicalOperatorVisitor {
+public:
+	explicit ExpressionDepthReducer(const vector<CorrelatedColumnInfo> &correlated) : correlated_columns(correlated) {
+	}
+
+protected:
+	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override {
+		ReduceColumnRefDepth(expr, correlated_columns);
+		return nullptr;
 	}
 
 	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		ReduceExpressionSubquery(expr);
-		ExpressionIterator::EnumerateQueryNodeChildren(
-		    *expr.subquery, [&](Expression &child_expr) { ReduceExpressionDepth(child_expr); });
+		ReduceExpressionSubquery(expr, correlated_columns);
+		ExpressionDepthReducerRecursive recursive(correlated_columns);
+		recursive.VisitBoundQueryNode(*expr.subquery);
 		return nullptr;
 	}
 

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

@@ -16,20 +16,24 @@ QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelect
 }
 
 BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
+
 	auto result = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError()) {
 		return result;
 	}
 
+	// Keep the original column reference's string to return a meaningful error message.
+	auto expr_string = expr_ptr->Cast<ColumnRefExpression>().ToString();
+
+	// Try to bind as an alias.
 	BindResult alias_result;
-	auto found_alias = column_alias_binder.BindAlias(*this, expr, depth, root_expression, alias_result);
+	auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
 	if (found_alias) {
 		return alias_result;
 	}
 
-	return BindResult(StringUtil::Format("Referenced column %s not found in FROM clause and can't find in alias map.",
-	                                     expr.ToString()));
+	return BindResult(
+	    StringUtil::Format("Referenced column %s not found in FROM clause and can't find in alias map.", expr_string));
 }
 
 BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {

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

@@ -0,0 +1,20 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/expression_binder/aggregate_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/alter_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/base_select_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/check_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/column_alias_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/constant_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/group_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/having_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/lateral_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/qualify_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/index_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/insert_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/order_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/relation_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/returning_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/select_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/table_function_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/update_binder.cpp>
+#include </Users/carlo/duckdb/src/planner/expression_binder/where_binder.cpp>

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

@@ -10,17 +10,18 @@ WhereBinder::WhereBinder(Binder &binder, ClientContext &context, optional_ptr<Co
 }
 
 BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
+
 	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError() || !column_alias_binder) {
 		return result;
 	}
 
 	BindResult alias_result;
-	auto found_alias = column_alias_binder->BindAlias(*this, expr, depth, root_expression, alias_result);
+	auto found_alias = column_alias_binder->BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
 	if (found_alias) {
 		return alias_result;
 	}
+
 	return result;
 }
 

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

@@ -148,86 +148,61 @@ void ExpressionIterator::EnumerateExpression(unique_ptr<Expression> &expr,
 	                                      [&](unique_ptr<Expression> &child) { EnumerateExpression(child, callback); });
 }
 
-void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
-                                                   const std::function<void(Expression &child)> &callback) {
-	switch (ref.type) {
-	case TableReferenceType::EXPRESSION_LIST: {
-		auto &bound_expr_list = ref.Cast<BoundExpressionListRef>();
-		for (auto &expr_list : bound_expr_list.values) {
-			for (auto &expr : expr_list) {
-				EnumerateExpression(expr, callback);
-			}
-		}
-		break;
-	}
-	case TableReferenceType::JOIN: {
-		auto &bound_join = ref.Cast<BoundJoinRef>();
-		if (bound_join.condition) {
-			EnumerateExpression(bound_join.condition, callback);
-		}
-		EnumerateTableRefChildren(*bound_join.left, callback);
-		EnumerateTableRefChildren(*bound_join.right, callback);
-		break;
-	}
-	case TableReferenceType::SUBQUERY: {
-		auto &bound_subquery = ref.Cast<BoundSubqueryRef>();
-		EnumerateQueryNodeChildren(*bound_subquery.subquery, callback);
-		break;
-	}
-	case TableReferenceType::TABLE_FUNCTION:
-	case TableReferenceType::EMPTY_FROM:
-	case TableReferenceType::BASE_TABLE:
-	case TableReferenceType::CTE:
-		break;
-	default:
-		throw NotImplementedException("Unimplemented table reference type in ExpressionIterator");
-	}
+void BoundNodeVisitor::VisitExpression(unique_ptr<Expression> &expression) {
+	VisitExpressionChildren(*expression);
+}
+
+void BoundNodeVisitor::VisitExpressionChildren(Expression &expr) {
+	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { VisitExpression(expr); });
 }
 
-void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
-                                                    const std::function<void(Expression &child)> &callback) {
+void BoundNodeVisitor::VisitBoundQueryNode(BoundQueryNode &node) {
 	switch (node.type) {
 	case QueryNodeType::SET_OPERATION_NODE: {
 		auto &bound_setop = node.Cast<BoundSetOperationNode>();
-		EnumerateQueryNodeChildren(*bound_setop.left, callback);
-		EnumerateQueryNodeChildren(*bound_setop.right, callback);
+		VisitBoundQueryNode(*bound_setop.left);
+		VisitBoundQueryNode(*bound_setop.right);
 		break;
 	}
 	case QueryNodeType::RECURSIVE_CTE_NODE: {
 		auto &cte_node = node.Cast<BoundRecursiveCTENode>();
-		EnumerateQueryNodeChildren(*cte_node.left, callback);
-		EnumerateQueryNodeChildren(*cte_node.right, callback);
+		VisitBoundQueryNode(*cte_node.left);
+		VisitBoundQueryNode(*cte_node.right);
 		break;
 	}
 	case QueryNodeType::CTE_NODE: {
 		auto &cte_node = node.Cast<BoundCTENode>();
-		EnumerateQueryNodeChildren(*cte_node.child, callback);
-		EnumerateQueryNodeChildren(*cte_node.query, callback);
+		VisitBoundQueryNode(*cte_node.child);
+		VisitBoundQueryNode(*cte_node.query);
 		break;
 	}
 	case QueryNodeType::SELECT_NODE: {
 		auto &bound_select = node.Cast<BoundSelectNode>();
 		for (auto &expr : bound_select.select_list) {
-			EnumerateExpression(expr, callback);
+			VisitExpression(expr);
+		}
+		if (bound_select.where_clause) {
+			VisitExpression(bound_select.where_clause);
 		}
-		EnumerateExpression(bound_select.where_clause, callback);
 		for (auto &expr : bound_select.groups.group_expressions) {
-			EnumerateExpression(expr, callback);
+			VisitExpression(expr);
+		}
+		if (bound_select.having) {
+			VisitExpression(bound_select.having);
 		}
-		EnumerateExpression(bound_select.having, callback);
 		for (auto &expr : bound_select.aggregates) {
-			EnumerateExpression(expr, callback);
+			VisitExpression(expr);
 		}
 		for (auto &entry : bound_select.unnests) {
 			for (auto &expr : entry.second.expressions) {
-				EnumerateExpression(expr, callback);
+				VisitExpression(expr);
 			}
 		}
 		for (auto &expr : bound_select.windows) {
-			EnumerateExpression(expr, callback);
+			VisitExpression(expr);
 		}
 		if (bound_select.from_table) {
-			EnumerateTableRefChildren(*bound_select.from_table, callback);
+			VisitBoundTableRef(*bound_select.from_table);
 		}
 		break;
 	}
@@ -238,18 +213,64 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:
 			for (auto &expr : node.modifiers[i]->Cast<BoundDistinctModifier>().target_distincts) {
-				EnumerateExpression(expr, callback);
+				VisitExpression(expr);
 			}
 			break;
 		case ResultModifierType::ORDER_MODIFIER:
 			for (auto &order : node.modifiers[i]->Cast<BoundOrderModifier>().orders) {
-				EnumerateExpression(order.expression, callback);
+				VisitExpression(order.expression);
+			}
+			break;
+		case ResultModifierType::LIMIT_MODIFIER: {
+			auto &limit_expr = node.modifiers[i]->Cast<BoundLimitModifier>().limit_val.GetExpression();
+			auto &offset_expr = node.modifiers[i]->Cast<BoundLimitModifier>().offset_val.GetExpression();
+			if (limit_expr) {
+				VisitExpression(limit_expr);
+			}
+			if (offset_expr) {
+				VisitExpression(offset_expr);
 			}
 			break;
+		}
 		default:
 			break;
 		}
 	}
 }
 
+void BoundNodeVisitor::VisitBoundTableRef(BoundTableRef &ref) {
+	switch (ref.type) {
+	case TableReferenceType::EXPRESSION_LIST: {
+		auto &bound_expr_list = ref.Cast<BoundExpressionListRef>();
+		for (auto &expr_list : bound_expr_list.values) {
+			for (auto &expr : expr_list) {
+				VisitExpression(expr);
+			}
+		}
+		break;
+	}
+	case TableReferenceType::JOIN: {
+		auto &bound_join = ref.Cast<BoundJoinRef>();
+		if (bound_join.condition) {
+			VisitExpression(bound_join.condition);
+		}
+		VisitBoundTableRef(*bound_join.left);
+		VisitBoundTableRef(*bound_join.right);
+		break;
+	}
+	case TableReferenceType::SUBQUERY: {
+		auto &bound_subquery = ref.Cast<BoundSubqueryRef>();
+		VisitBoundQueryNode(*bound_subquery.subquery);
+		break;
+	}
+	case TableReferenceType::TABLE_FUNCTION:
+	case TableReferenceType::EMPTY_FROM:
+	case TableReferenceType::BASE_TABLE:
+	case TableReferenceType::CTE:
+		break;
+	default:
+		throw NotImplementedException("Unimplemented table reference type in ExpressionIterator");
+	}
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/filter/conjunction_filter.cpp>
+#include </Users/carlo/duckdb/src/planner/filter/constant_filter.cpp>
+#include </Users/carlo/duckdb/src/planner/filter/null_filter.cpp>

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

@@ -87,21 +87,11 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT: {
 		auto &limit = op.Cast<LogicalLimit>();
-		if (limit.limit) {
-			callback(&limit.limit);
+		if (limit.limit_val.GetExpression()) {
+			callback(&limit.limit_val.GetExpression());
 		}
-		if (limit.offset) {
-			callback(&limit.offset);
-		}
-		break;
-	}
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		auto &limit = op.Cast<LogicalLimitPercent>();
-		if (limit.limit) {
-			callback(&limit.limit);
-		}
-		if (limit.offset) {
-			callback(&limit.offset);
+		if (limit.offset_val.GetExpression()) {
+			callback(&limit.offset_val.GetExpression());
 		}
 		break;
 	}

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

@@ -2,10 +2,9 @@
 
 namespace duckdb {
 
-LogicalLimit::LogicalLimit(int64_t limit_val, int64_t offset_val, unique_ptr<Expression> limit,
-                           unique_ptr<Expression> offset)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(limit_val), offset_val(offset_val),
-      limit(std::move(limit)), offset(std::move(offset)) {
+LogicalLimit::LogicalLimit(BoundLimitNode limit_val, BoundLimitNode offset_val)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT), limit_val(std::move(limit_val)),
+      offset_val(std::move(offset_val)) {
 }
 
 vector<ColumnBinding> LogicalLimit::GetColumnBindings() {
@@ -14,8 +13,17 @@ vector<ColumnBinding> LogicalLimit::GetColumnBindings() {
 
 idx_t LogicalLimit::EstimateCardinality(ClientContext &context) {
 	auto child_cardinality = children[0]->EstimateCardinality(context);
-	if (limit_val >= 0 && idx_t(limit_val) < child_cardinality) {
-		child_cardinality = limit_val;
+	switch (limit_val.Type()) {
+	case LimitNodeType::CONSTANT_VALUE:
+		if (limit_val.GetConstantValue() < child_cardinality) {
+			child_cardinality = limit_val.GetConstantValue();
+		}
+		break;
+	case LimitNodeType::CONSTANT_PERCENTAGE:
+		child_cardinality = idx_t(double(child_cardinality) * limit_val.GetConstantPercentage());
+		break;
+	default:
+		break;
 	}
 	return child_cardinality;
 }

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

@@ -0,0 +1,43 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/operator/logical_aggregate.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_any_join.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_column_data_get.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_comparison_join.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_copy_to_file.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_create.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_create_index.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_create_table.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_cross_product.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_cteref.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_delete.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_delim_get.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_dependent_join.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_distinct.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_dummy_scan.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_empty_result.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_expression_get.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_extension_operator.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_filter.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_get.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_insert.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_join.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_limit.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_limit_percent.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_order.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_pivot.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_positional_join.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_pragma.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_prepare.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_projection.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_recursive_cte.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_materialized_cte.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_sample.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_set.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_reset.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_set_operation.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_simple.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_top_n.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_unconditional_join.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_unnest.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_update.cpp>
+#include </Users/carlo/duckdb/src/planner/operator/logical_window.cpp>

package/src/duckdb/src/planner/parsed_data/ub_duckdb_planner_parsed_data.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/parsed_data/bound_create_table_info.cpp>

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

@@ -12,6 +12,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
+#include "duckdb/execution/column_binding_resolver.hpp"
 
 namespace duckdb {
 
@@ -166,6 +167,8 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 	if (!OperatorSupportsSerialization(*op)) {
 		return;
 	}
+	// verify the column bindings of the plan
+	ColumnBindingResolver::Verify(*op);
 
 	// format (de)serialization of this operator
 	try {

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

@@ -12,6 +12,7 @@
 #include "duckdb/planner/subquery/rewrite_correlated_expressions.hpp"
 #include "duckdb/planner/subquery/rewrite_cte_scan.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
+#include "duckdb/execution/column_binding_resolver.hpp"
 
 namespace duckdb {
 
@@ -447,8 +448,26 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT: {
 		auto &limit = plan->Cast<LogicalLimit>();
-		if (limit.limit || limit.offset) {
-			throw ParserException("Non-constant limit or offset not supported in correlated subquery");
+		switch (limit.limit_val.Type()) {
+		case LimitNodeType::CONSTANT_PERCENTAGE:
+		case LimitNodeType::EXPRESSION_PERCENTAGE:
+			// NOTE: limit percent could be supported in a manner similar to the LIMIT above
+			// but instead of filtering by an exact number of rows, the limit should be expressed as
+			// COUNT computed over the partition multiplied by the percentage
+			throw ParserException("Limit percent operator not supported in correlated subquery");
+		case LimitNodeType::EXPRESSION_VALUE:
+			throw ParserException("Non-constant limit not supported in correlated subquery");
+		default:
+			break;
+		}
+		switch (limit.offset_val.Type()) {
+		case LimitNodeType::EXPRESSION_VALUE:
+			throw ParserException("Non-constant offset not supported in correlated subquery");
+		case LimitNodeType::CONSTANT_PERCENTAGE:
+		case LimitNodeType::EXPRESSION_PERCENTAGE:
+			throw InternalException("Percentage offset in FlattenDependentJoin");
+		default:
+			break;
 		}
 		auto rownum_alias = "limit_rownum";
 		unique_ptr<LogicalOperator> child;
@@ -495,19 +514,34 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		auto row_num_ref =
 		    make_uniq<BoundColumnRefExpression>(rownum_alias, LogicalType::BIGINT, ColumnBinding(window_index, 0));
 
-		int64_t upper_bound_limit = NumericLimits<int64_t>::Maximum();
-		TryAddOperator::Operation(limit.offset_val, limit.limit_val, upper_bound_limit);
-		auto upper_bound = make_uniq<BoundConstantExpression>(Value::BIGINT(upper_bound_limit));
-		condition = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO, row_num_ref->Copy(),
-		                                                 std::move(upper_bound));
+		if (limit.limit_val.Type() == LimitNodeType::CONSTANT_VALUE) {
+			auto upper_bound_limit = NumericLimits<int64_t>::Maximum();
+			auto limit_val = int64_t(limit.limit_val.GetConstantValue());
+			if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
+				// both offset and limit specified - upper bound is offset + limit
+				auto offset_val = int64_t(limit.offset_val.GetConstantValue());
+				TryAddOperator::Operation(limit_val, offset_val, upper_bound_limit);
+			} else {
+				// no offset - upper bound is only the limit
+				upper_bound_limit = limit_val;
+			}
+			auto upper_bound = make_uniq<BoundConstantExpression>(Value::BIGINT(upper_bound_limit));
+			condition = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
+			                                                 row_num_ref->Copy(), std::move(upper_bound));
+		}
 		// we only need to add "row_number >= offset + 1" if offset is bigger than 0
-		if (limit.offset_val > 0) {
-			auto lower_bound = make_uniq<BoundConstantExpression>(Value::BIGINT(limit.offset_val));
+		if (limit.offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
+			auto offset_val = int64_t(limit.offset_val.GetConstantValue());
+			auto lower_bound = make_uniq<BoundConstantExpression>(Value::BIGINT(offset_val));
 			auto lower_comp = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHAN,
 			                                                       row_num_ref->Copy(), std::move(lower_bound));
-			auto conj = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(lower_comp),
-			                                                  std::move(condition));
-			condition = std::move(conj);
+			if (condition) {
+				auto conj = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
+				                                                  std::move(lower_comp), std::move(condition));
+				condition = std::move(conj);
+			} else {
+				condition = std::move(lower_comp);
+			}
 		}
 		filter->expressions.push_back(std::move(condition));
 		filter->children.push_back(std::move(window));
@@ -517,12 +551,6 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		}
 		return std::move(filter);
 	}
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		// NOTE: limit percent could be supported in a manner similar to the LIMIT above
-		// but instead of filtering by an exact number of rows, the limit should be expressed as
-		// COUNT computed over the partition multiplied by the percentage
-		throw ParserException("Limit percent operator not supported in correlated subquery");
-	}
 	case LogicalOperatorType::LOGICAL_WINDOW: {
 		auto &window = plan->Cast<LogicalWindow>();
 		// push into children