duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

package/src/duckdb/src/parser/transformer.cpp

@@ -4,24 +4,11 @@
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb {
 
-StackChecker::StackChecker(Transformer &transformer_p, idx_t stack_usage_p)
-    : transformer(transformer_p), stack_usage(stack_usage_p) {
-	transformer.stack_depth += stack_usage;
-}
-
-StackChecker::~StackChecker() {
-	transformer.stack_depth -= stack_usage;
-}
-
-StackChecker::StackChecker(StackChecker &&other) noexcept
-    : transformer(other.transformer), stack_usage(other.stack_usage) {
-	other.stack_usage = 0;
-}
-
 Transformer::Transformer(ParserOptions &options)
     : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
@@ -58,7 +45,7 @@ void Transformer::InitializeStackCheck() {
 	stack_depth = 0;
 }
 
-StackChecker Transformer::StackCheck(idx_t extra_stack) {
+StackChecker<Transformer> Transformer::StackCheck(idx_t extra_stack) {
 	auto &root = RootTransformer();
 	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
 	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
@@ -66,7 +53,7 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 		                      "increase the maximum expression depth.",
 		                      options.max_expression_depth);
 	}
-	return StackChecker(root, extra_stack);
+	return StackChecker<Transformer>(root, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {
@@ -104,24 +91,42 @@ void Transformer::SetParamCount(idx_t new_count) {
 	auto &root = RootTransformer();
 	root.prepared_statement_parameter_index = new_count;
 }
-void Transformer::SetNamedParam(const string &name, int32_t index) {
+
+static void ParamTypeCheck(PreparedParamType last_type, PreparedParamType new_type) {
+	// Mixing positional/auto-increment and named parameters is not supported
+	if (last_type == PreparedParamType::INVALID) {
+		return;
+	}
+	if (last_type == PreparedParamType::NAMED) {
+		if (new_type != PreparedParamType::NAMED) {
+			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
+		}
+	}
+	if (last_type != PreparedParamType::NAMED) {
+		if (new_type == PreparedParamType::NAMED) {
+			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
+		}
+	}
+}
+
+void Transformer::SetParam(const string &identifier, idx_t index, PreparedParamType type) {
 	auto &root = RootTransformer();
-	D_ASSERT(!root.named_param_map.count(name));
-	root.named_param_map[name] = index;
+	ParamTypeCheck(root.last_param_type, type);
+	root.last_param_type = type;
+	D_ASSERT(!root.named_param_map.count(identifier));
+	root.named_param_map[identifier] = index;
 }
-bool Transformer::GetNamedParam(const string &name, int32_t &index) {
+
+bool Transformer::GetParam(const string &identifier, idx_t &index, PreparedParamType type) {
 	auto &root = RootTransformer();
-	auto entry = root.named_param_map.find(name);
+	ParamTypeCheck(root.last_param_type, type);
+	auto entry = root.named_param_map.find(identifier);
 	if (entry == root.named_param_map.end()) {
 		return false;
 	}
 	index = entry->second;
 	return true;
 }
-bool Transformer::HasNamedParameters() const {
-	auto &root = RootTransformer();
-	return !root.named_param_map.empty();
-}
 
 unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode &stmt) {
 	switch (stmt.type) {
@@ -209,4 +214,18 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 	}
 }
 
+unique_ptr<QueryNode> Transformer::TransformMaterializedCTE(unique_ptr<QueryNode> root,
+                                                            vector<unique_ptr<CTENode>> &materialized_ctes) {
+	while (!materialized_ctes.empty()) {
+		unique_ptr<CTENode> node_result;
+		node_result = std::move(materialized_ctes.back());
+		node_result->cte_map = root->cte_map.Copy();
+		node_result->child = std::move(root);
+		root = std::move(node_result);
+		materialized_ctes.pop_back();
+	}
+
+	return root;
+}
+
 } // namespace duckdb

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

@@ -86,7 +86,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
 	AggregateBinder aggregate_binder(binder, context);
-	string error, filter_error;
+	string error;
 
 	// Now we bind the filter (if any)
 	if (aggr.filter) {
@@ -167,9 +167,6 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	} else if (depth > 0 && !aggregate_binder.HasBoundColumns()) {
 		return BindResult("Aggregate with only constant parameters has to be bound in the root subquery");
 	}
-	if (!filter_error.empty()) {
-		return BindResult(filter_error);
-	}
 
 	if (aggr.filter) {
 		auto &child = BoundExpression::GetExpression(*aggr.filter);

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

@@ -119,6 +119,7 @@ BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t de
 	if (!error.empty()) {
 		return BindResult(error);
 	}
+
 	// the children have been successfully resolved
 	auto &left = BoundExpression::GetExpression(*expr.left);
 	auto &right = BoundExpression::GetExpression(*expr.right);

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

@@ -69,21 +69,30 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 	}
 
 	switch (func->type) {
-	case CatalogType::SCALAR_FUNCTION_ENTRY:
+	case CatalogType::SCALAR_FUNCTION_ENTRY: {
 		// scalar function
 
 		// check for lambda parameters, ignore ->> operator (JSON extension)
+		bool try_bind_lambda = false;
 		if (function.function_name != "->>") {
 			for (auto &child : function.children) {
 				if (child->expression_class == ExpressionClass::LAMBDA) {
-					return BindLambdaFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
+					try_bind_lambda = true;
 				}
 			}
 		}
 
+		if (try_bind_lambda) {
+			auto result = BindLambdaFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
+			if (!result.HasError()) {
+				// Lambda bind successful
+				return result;
+			}
+		}
+
 		// other scalar function
 		return BindFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
-
+	}
 	case CatalogType::MACRO_ENTRY:
 		// macro function
 		return BindMacro(function, func->Cast<ScalarMacroCatalogEntry>(), depth, expr_ptr);
@@ -134,7 +143,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	string error;
 
 	if (function.children.size() != 2) {
-		throw BinderException("Invalid function arguments!");
+		return BindResult("Invalid function arguments!");
 	}
 	D_ASSERT(function.children[1]->GetExpressionClass() == ExpressionClass::LAMBDA);
 
@@ -148,7 +157,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	auto &list_child = BoundExpression::GetExpression(*function.children[0]);
 	if (list_child->return_type.id() != LogicalTypeId::LIST && list_child->return_type.id() != LogicalTypeId::SQLNULL &&
 	    list_child->return_type.id() != LogicalTypeId::UNKNOWN) {
-		throw BinderException(" Invalid LIST argument to " + function.function_name + "!");
+		return BindResult(" Invalid LIST argument to " + function.function_name + "!");
 	}
 
 	LogicalType list_child_type = list_child->return_type.id();

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

@@ -1,12 +1,12 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
-#include "duckdb/function/scalar_macro_function.hpp"
-
 namespace duckdb {
 
 void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
@@ -79,8 +79,10 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	new_macro_binding->arguments = &positionals;
 	macro_binding = new_macro_binding.get();
 
-	// replace current expression with stored macro expression, and replace params
+	// replace current expression with stored macro expression
 	expr = macro_def.expression->Copy();
+
+	// now replace the parameters
 	ReplaceMacroParametersRecursive(expr);
 
 	// bind the unfolded macro

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

@@ -7,35 +7,25 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
-	D_ASSERT(expr.parameter_nr > 0);
-	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.parameter_nr);
-	bound_parameter->alias = expr.alias;
 	if (!binder.parameters) {
 		throw BinderException("Unexpected prepared parameter. This type of statement can't be prepared!");
 	}
-	auto parameter_idx = expr.parameter_nr;
-	// check if a parameter value has already been supplied
-	if (parameter_idx <= binder.parameters->parameter_data.size()) {
+	auto parameter_id = expr.identifier;
+
+	D_ASSERT(binder.parameters);
+	// Check if a parameter value has already been supplied
+	auto &parameter_data = binder.parameters->GetParameterData();
+	auto param_data_it = parameter_data.find(parameter_id);
+	if (param_data_it != parameter_data.end()) {
 		// it has! emit a constant directly
-		auto &data = binder.parameters->parameter_data[parameter_idx - 1];
-		auto constant = make_uniq<BoundConstantExpression>(data.value);
+		auto &data = param_data_it->second;
+		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
 		constant->alias = expr.alias;
+		constant->return_type = binder.parameters->GetReturnType(parameter_id);
 		return BindResult(std::move(constant));
 	}
-	auto entry = binder.parameters->parameters.find(parameter_idx);
-	if (entry == binder.parameters->parameters.end()) {
-		// no entry yet: create a new one
-		auto data = make_shared<BoundParameterData>();
-		data->return_type = binder.parameters->GetReturnType(parameter_idx - 1);
-		bound_parameter->return_type = data->return_type;
-		bound_parameter->parameter_data = data;
-		binder.parameters->parameters[parameter_idx] = std::move(data);
-	} else {
-		// a prepared statement with this parameter index was already there: use it
-		auto &data = entry->second;
-		bound_parameter->parameter_data = data;
-		bound_parameter->return_type = binder.parameters->GetReturnType(parameter_idx - 1);
-	}
+
+	auto bound_parameter = binder.parameters->BindParameterExpression(expr);
 	return BindResult(std::move(bound_parameter));
 }
 

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

@@ -32,11 +32,8 @@ public:
 	unique_ptr<QueryNode> Copy() const override {
 		throw InternalException("Cannot copy bound subquery node");
 	}
-	void Serialize(FieldWriter &writer) const override {
-		throw InternalException("Cannot serialize bound subquery node");
-	}
 
-	void FormatSerialize(FormatSerializer &serializer) const override {
+	void Serialize(Serializer &serializer) const override {
 		throw InternalException("Cannot serialize bound subquery node");
 	}
 };

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

@@ -0,0 +1,64 @@
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundQueryNode> Binder::BindNode(CTENode &statement) {
+	auto result = make_uniq<BoundCTENode>();
+
+	// first recursively visit the materialized CTE operations
+	// the left side is visited first and is added to the BindContext of the right side
+	D_ASSERT(statement.query);
+	D_ASSERT(statement.child);
+
+	result->ctename = statement.ctename;
+	result->setop_index = GenerateTableIndex();
+
+	result->query_binder = Binder::CreateBinder(context, this);
+	result->query = result->query_binder->BindNode(*statement.query);
+
+	// the result types of the CTE are the types of the LHS
+	result->types = result->query->types;
+	// names are picked from the LHS, unless aliases are explicitly specified
+	result->names = result->query->names;
+	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
+		result->names[i] = statement.aliases[i];
+	}
+
+	// This allows the right side to reference the CTE
+	bind_context.AddGenericBinding(result->setop_index, statement.ctename, result->names, result->types);
+
+	result->child_binder = Binder::CreateBinder(context, this);
+
+	// Move all modifiers to the child node.
+	for (auto &modifier : statement.modifiers) {
+		statement.child->modifiers.push_back(std::move(modifier));
+	}
+
+	statement.modifiers.clear();
+
+	// Add bindings of left side to temporary CTE bindings context
+	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
+	                                                 result->types);
+	result->child = result->child_binder->BindNode(*statement.child);
+
+	// the result types of the CTE are the types of the LHS
+	result->types = result->child->types;
+	// names are picked from the LHS, unless aliases are explicitly specified
+	result->names = result->child->names;
+	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
+		result->names[i] = statement.aliases[i];
+	}
+
+	MoveCorrelatedExpressions(*result->query_binder);
+	MoveCorrelatedExpressions(*result->child_binder);
+
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -1,25 +1,29 @@
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/aggregate/distributive_functions.hpp"
+#include "duckdb/function/function_binder.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 #include "duckdb/planner/expression_binder/group_binder.hpp"
 #include "duckdb/planner/expression_binder/having_binder.hpp"
-#include "duckdb/planner/expression_binder/qualify_binder.hpp"
 #include "duckdb/planner/expression_binder/order_binder.hpp"
+#include "duckdb/planner/expression_binder/qualify_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/conjunction_expression.hpp"
 
 namespace duckdb {
 
@@ -380,10 +384,28 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			auto bound_expr = group_binder.Bind(group_expressions[i], &group_type);
 			D_ASSERT(bound_expr->return_type.id() != LogicalTypeId::INVALID);
 
+			// find out whether the expression contains a subquery, it can't be copied if so
+			auto &bound_expr_ref = *bound_expr;
+			bool contains_subquery = bound_expr_ref.HasSubquery();
+
 			// push a potential collation, if necessary
-			bound_expr = ExpressionBinder::PushCollation(context, std::move(bound_expr),
-			                                             StringType::GetCollation(group_type), true);
-			result->groups.group_expressions.push_back(std::move(bound_expr));
+			auto collated_expr = ExpressionBinder::PushCollation(context, std::move(bound_expr),
+			                                                     StringType::GetCollation(group_type), true);
+			if (!contains_subquery && !collated_expr->Equals(bound_expr_ref)) {
+				// if there is a collation on a group x, we should group by the collated expr,
+				// but also push a first(x) aggregate in case x is selected (uncollated)
+				info.collated_groups[i] = result->aggregates.size();
+
+				auto first_fun = FirstFun::GetFunction(LogicalType::VARCHAR);
+				vector<unique_ptr<Expression>> first_children;
+				// FIXME: would be better to just refer to this expression, but for now we copy
+				first_children.push_back(bound_expr_ref.Copy());
+
+				FunctionBinder function_binder(context);
+				auto function = function_binder.BindAggregateFunction(first_fun, std::move(first_children));
+				result->aggregates.push_back(std::move(function));
+			}
+			result->groups.group_expressions.push_back(std::move(collated_expr));
 
 			// in the unbound expression we DO bind the table names of any ColumnRefs
 			// we do this to make sure that "table.a" and "a" are treated the same

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

@@ -0,0 +1,26 @@
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/operator/logical_materialized_cte.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_set_operation.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
+	// Generate the logical plan for the cte_query and child.
+	auto cte_query = CreatePlan(*node.query);
+	auto cte_child = CreatePlan(*node.child);
+
+	auto root = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
+	                                              std::move(cte_query), std::move(cte_child));
+
+	// check if there are any unplanned subqueries left in either child
+	has_unplanned_dependent_joins =
+	    node.child_binder->has_unplanned_dependent_joins || node.query_binder->has_unplanned_dependent_joins;
+
+	return VisitQueryNode(node, std::move(root));
+}
+
+} // namespace duckdb

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

@@ -10,15 +10,15 @@ namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->plan_subquery = plan_subquery;
-	node.right_binder->plan_subquery = plan_subquery;
+	node.left_binder->is_outside_flattened = is_outside_flattened;
+	node.right_binder->is_outside_flattened = is_outside_flattened;
 
 	auto left_node = node.left_binder->CreatePlan(*node.left);
 	auto right_node = node.right_binder->CreatePlan(*node.right);
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_subqueries =
-	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
+	has_unplanned_dependent_joins =
+	    node.left_binder->has_unplanned_dependent_joins || node.right_binder->has_unplanned_dependent_joins;
 
 	// for both the left and right sides, cast them to the same types
 	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
@@ -30,7 +30,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
 		return VisitQueryNode(node, std::move(root));
 	}
-	auto root = make_uniq<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all,
+	auto root = make_uniq<LogicalRecursiveCTE>(node.ctename, node.setop_index, node.types.size(), node.union_all,
 	                                           std::move(left_node), std::move(right_node));
 
 	return VisitQueryNode(node, std::move(root));

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

@@ -60,8 +60,8 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->plan_subquery = plan_subquery;
-	node.right_binder->plan_subquery = plan_subquery;
+	node.left_binder->is_outside_flattened = is_outside_flattened;
+	node.right_binder->is_outside_flattened = is_outside_flattened;
 
 	auto left_node = node.left_binder->CreatePlan(*node.left);
 	auto right_node = node.right_binder->CreatePlan(*node.right);
@@ -95,8 +95,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	}
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_subqueries =
-	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
+	has_unplanned_dependent_joins =
+	    node.left_binder->has_unplanned_dependent_joins || node.right_binder->has_unplanned_dependent_joins;
 
 	// create actual logical ops for setops
 	LogicalOperatorType logical_type;

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

@@ -14,6 +14,10 @@
 #include "duckdb/planner/operator/logical_window.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/planner/subquery/flatten_dependent_join.hpp"
+#include "duckdb/common/enums/logical_operator_type.hpp"
+#include "duckdb/planner/operator/logical_dependent_join.hpp"
+#include "duckdb/planner/expression_binder/lateral_binder.hpp"
+#include "duckdb/planner/subquery/recursive_dependent_join_planner.hpp"
 
 namespace duckdb {
 
@@ -134,10 +138,10 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 	}
 }
 
-static unique_ptr<LogicalDelimJoin>
+static unique_ptr<LogicalComparisonJoin>
 CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_columns, JoinType join_type,
                               unique_ptr<LogicalOperator> original_plan, bool perform_delim) {
-	auto delim_join = make_uniq<LogicalDelimJoin>(join_type);
+	auto delim_join = make_uniq<LogicalComparisonJoin>(join_type, LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	if (!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
@@ -156,12 +160,12 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 	for (idx_t i = 0; i < correlated_columns.size(); i++) {
 		auto &col = correlated_columns[i];
 		delim_join->duplicate_eliminated_columns.push_back(make_uniq<BoundColumnRefExpression>(col.type, col.binding));
-		delim_join->delim_types.push_back(col.type);
+		delim_join->mark_types.push_back(col.type);
 	}
 	return delim_join;
 }
 
-static void CreateDelimJoinConditions(LogicalDelimJoin &delim_join,
+static void CreateDelimJoinConditions(LogicalComparisonJoin &delim_join,
                                       const vector<CorrelatedColumnInfo> &correlated_columns,
                                       vector<ColumnBinding> bindings, idx_t base_offset, bool perform_delim) {
 	auto col_count = perform_delim ? correlated_columns.size() : 1;
@@ -327,43 +331,43 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 	}
 }
 
-class RecursiveSubqueryPlanner : public LogicalOperatorVisitor {
-public:
-	explicit RecursiveSubqueryPlanner(Binder &binder) : binder(binder) {
-	}
-	void VisitOperator(LogicalOperator &op) override {
-		if (!op.children.empty()) {
-			root = std::move(op.children[0]);
-			D_ASSERT(root);
-			VisitOperatorExpressions(op);
-			op.children[0] = std::move(root);
-			for (idx_t i = 0; i < op.children.size(); i++) {
-				D_ASSERT(op.children[i]);
-				VisitOperator(*op.children[i]);
-			}
+void RecursiveDependentJoinPlanner::VisitOperator(LogicalOperator &op) {
+	if (!op.children.empty()) {
+		root = std::move(op.children[0]);
+		D_ASSERT(root);
+		if (root->type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
+			// Found a dependent join, flatten it
+			auto &new_root = root->Cast<LogicalDependentJoin>();
+			root = binder.PlanLateralJoin(std::move(new_root.children[0]), std::move(new_root.children[1]),
+			                              new_root.correlated_columns, new_root.join_type,
+			                              std::move(new_root.join_condition));
+		}
+		VisitOperatorExpressions(op);
+		op.children[0] = std::move(root);
+		for (idx_t i = 0; i < op.children.size(); i++) {
+			D_ASSERT(op.children[i]);
+			VisitOperator(*op.children[i]);
 		}
 	}
+}
 
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		return binder.PlanSubquery(expr, root);
-	}
-
-private:
-	unique_ptr<LogicalOperator> root;
-	Binder &binder;
-};
+unique_ptr<Expression> RecursiveDependentJoinPlanner::VisitReplace(BoundSubqueryExpression &expr,
+                                                                   unique_ptr<Expression> *expr_ptr) {
+	return binder.PlanSubquery(expr, root);
+}
 
 unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root) {
 	D_ASSERT(root);
 	// first we translate the QueryNode of the subquery into a logical plan
 	// note that we do not plan nested subqueries yet
 	auto sub_binder = Binder::CreateBinder(context, this);
-	sub_binder->plan_subquery = false;
+	sub_binder->is_outside_flattened = false;
 	auto subquery_root = sub_binder->CreatePlan(*expr.subquery);
 	D_ASSERT(subquery_root);
 
 	// now we actually flatten the subquery
 	auto plan = std::move(subquery_root);
+
 	unique_ptr<Expression> result_expression;
 	if (!expr.IsCorrelated()) {
 		result_expression = PlanUncorrelatedSubquery(*this, expr, root, std::move(plan));
@@ -371,8 +375,8 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 		result_expression = PlanCorrelatedSubquery(*this, expr, root, std::move(plan));
 	}
 	// finally, we recursively plan the nested subqueries (if there are any)
-	if (sub_binder->has_unplanned_subqueries) {
-		RecursiveSubqueryPlanner plan(*this);
+	if (sub_binder->has_unplanned_dependent_joins) {
+		RecursiveDependentJoinPlanner plan(*this);
 		plan.VisitOperator(*root);
 	}
 	return result_expression;
@@ -383,7 +387,6 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 		return;
 	}
 	auto &expr = *expr_ptr;
-
 	// first visit the children of the node, if any
 	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
 
@@ -391,11 +394,11 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
 		auto &subquery = expr.Cast<BoundSubqueryExpression>();
 		// subquery node! plan it
-		if (subquery.IsCorrelated() && !plan_subquery) {
+		if (subquery.IsCorrelated() && !is_outside_flattened) {
 			// detected a nested correlated subquery
 			// we don't plan it yet here, we are currently planning a subquery
 			// nested subqueries will only be planned AFTER the current subquery has been flattened entirely
-			has_unplanned_subqueries = true;
+			has_unplanned_dependent_joins = true;
 			return;
 		}
 		expr_ptr = PlanSubquery(subquery, root);
@@ -411,7 +414,7 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	if (condition) {
 		// extract join conditions, if there are any
-		LogicalComparisonJoin::ExtractJoinConditions(join_type, left, right, std::move(condition), conditions,
+		LogicalComparisonJoin::ExtractJoinConditions(context, join_type, left, right, std::move(condition), conditions,
 		                                             arbitrary_expressions);
 	}
 

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

@@ -5,7 +5,7 @@
 #include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
-#include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
+#include "duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"