duckdb 1.3.4 → 1.4.0

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

@@ -21,6 +21,7 @@
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/main/query_result.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -57,37 +58,70 @@ static void ConstructPivots(PivotRef &ref, vector<PivotValueElement> &pivot_valu
 	}
 }
 
-static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set_t &handled_columns) {
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &child_colref = expr.Cast<ColumnRefExpression>();
-		if (child_colref.IsQualified()) {
-			throw BinderException(expr, "PIVOT expression cannot contain qualified columns");
+static void ExtractPivotExpressions(ParsedExpression &root_expr, case_insensitive_set_t &handled_columns) {
+	ParsedExpressionIterator::VisitExpression<ColumnRefExpression>(
+	    root_expr, [&](const ColumnRefExpression &child_colref) {
+		    if (child_colref.IsQualified()) {
+			    throw BinderException(child_colref, "PIVOT expression cannot contain qualified columns");
+		    }
+		    handled_columns.insert(child_colref.GetColumnName());
+	    });
+}
+
+struct ExtractPivotAggregateOperator {
+	using TYPE = vector<reference<FunctionExpression>>;
+
+	static void HandleAggregate(unique_ptr<ParsedExpression> &expr, FunctionExpression &aggr_function,
+	                            TYPE &aggregates) {
+		aggregates.push_back(aggr_function);
+	}
+};
+
+struct ReplacePivotAggregateOperator {
+	using TYPE = unique_ptr<ParsedExpression>;
+
+	static void HandleAggregate(unique_ptr<ParsedExpression> &expr, FunctionExpression &aggr_function,
+	                            TYPE &replacement_expr) {
+		if (replacement_expr->type != ExpressionType::COLUMN_REF) {
+			throw BinderException(*expr, "Pivot expression can only have one aggregate");
 		}
-		handled_columns.insert(child_colref.GetColumnName());
+		auto aggr = std::move(expr);
+		expr = std::move(replacement_expr);
+		replacement_expr = std::move(aggr);
 	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](ParsedExpression &child) { ExtractPivotExpressions(child, handled_columns); });
-}
+};
 
-void ExtractPivotAggregateExpression(ClientContext &context, ParsedExpression &expr,
-                                     vector<reference<FunctionExpression>> &aggregates) {
-	if (expr.GetExpressionType() == ExpressionType::FUNCTION) {
-		auto &aggr_function = expr.Cast<FunctionExpression>();
+template <class OP>
+void TemplatedHandlePivotAggregate(ClientContext &context, unique_ptr<ParsedExpression> &expr,
+                                   typename OP::TYPE &aggregates) {
+	if (expr->GetExpressionType() == ExpressionType::FUNCTION) {
+		auto &aggr_function = expr->Cast<FunctionExpression>();
 
 		// check if this is an aggregate to ensure it is an aggregate and not a scalar function
-		EntryLookupInfo lookup_info(CatalogType::AGGREGATE_FUNCTION_ENTRY, aggr_function.function_name, expr);
+		EntryLookupInfo lookup_info(CatalogType::AGGREGATE_FUNCTION_ENTRY, aggr_function.function_name, *expr);
 		auto &entry = Catalog::GetEntry(context, aggr_function.catalog, aggr_function.schema, lookup_info);
 		if (entry.type == CatalogType::AGGREGATE_FUNCTION_ENTRY) {
 			// aggregate
-			aggregates.push_back(aggr_function);
+			OP::HandleAggregate(expr, aggr_function, aggregates);
 			return;
 		}
 	}
-	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
-		throw BinderException(expr, "Columns can only be referenced within the aggregate of a PIVOT expression");
+	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
+		throw BinderException(*expr, "Columns can only be referenced within the aggregate of a PIVOT expression");
 	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](ParsedExpression &child) { ExtractPivotAggregateExpression(context, child, aggregates); });
+	ParsedExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<ParsedExpression> &child) {
+		TemplatedHandlePivotAggregate<OP>(context, child, aggregates);
+	});
+}
+
+void ExtractPivotAggregateExpression(ClientContext &context, unique_ptr<ParsedExpression> &expr,
+                                     vector<reference<FunctionExpression>> &aggregates) {
+	TemplatedHandlePivotAggregate<ExtractPivotAggregateOperator>(context, expr, aggregates);
+}
+
+void ReplacePivotAggregateExpression(ClientContext &context, unique_ptr<ParsedExpression> &expr,
+                                     unique_ptr<ParsedExpression> &replacement_expr) {
+	TemplatedHandlePivotAggregate<ReplacePivotAggregateOperator>(context, expr, replacement_expr);
 }
 
 static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns,
@@ -149,7 +183,7 @@ static unique_ptr<SelectNode> PivotFilteredAggregate(ClientContext &context, Piv
 			auto copied_aggr = aggregate->Copy();
 
 			vector<reference<FunctionExpression>> aggregates;
-			ExtractPivotAggregateExpression(context, *copied_aggr, aggregates);
+			ExtractPivotAggregateExpression(context, copied_aggr, aggregates);
 			D_ASSERT(aggregates.size() == 1);
 
 			auto &aggr = aggregates[0].get().Cast<FunctionExpression>();
@@ -174,7 +208,7 @@ struct PivotBindState {
 	vector<string> internal_aggregate_names;
 };
 
-static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state, PivotRef &ref,
+static unique_ptr<SelectNode> PivotInitialAggregate(ClientContext &context, PivotBindState &bind_state, PivotRef &ref,
                                                     vector<unique_ptr<ParsedExpression>> all_columns,
                                                     const case_insensitive_set_t &handled_columns) {
 	auto subquery_stage1 = ConstructInitialGrouping(ref, std::move(all_columns), handled_columns);
@@ -205,10 +239,22 @@ static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state,
 	// finally add the aggregates
 	for (auto &aggregate : ref.aggregates) {
 		auto aggregate_alias = "__internal_pivot_aggregate" + std::to_string(++aggregate_count);
-		bind_state.aggregate_names.push_back(aggregate->GetAlias());
+		auto aggr_name = aggregate->GetAlias();
+		if (aggr_name.empty() && ref.aggregates.size() > 1) {
+			aggr_name = aggregate->ToString();
+		}
+		if (!aggr_name.empty()) {
+			aggr_name = "_" + aggr_name;
+		}
+
+		unique_ptr<ParsedExpression> aggregate_ref;
+		aggregate_ref = make_uniq<ColumnRefExpression>(aggregate_alias);
+		ReplacePivotAggregateExpression(context, aggregate, aggregate_ref);
+
+		bind_state.aggregate_names.push_back(std::move(aggr_name));
 		bind_state.internal_aggregate_names.push_back(aggregate_alias);
-		aggregate->SetAlias(std::move(aggregate_alias));
-		subquery_stage1->select_list.push_back(std::move(aggregate));
+		aggregate_ref->SetAlias(std::move(aggregate_alias));
+		subquery_stage1->select_list.push_back(std::move(aggregate_ref));
 	}
 	return subquery_stage1;
 }
@@ -280,6 +326,11 @@ static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, Piv
 	return subquery_stage2;
 }
 
+void ReplacePivotColumnRef(ParsedExpression &root_expr, const string &name) {
+	ParsedExpressionIterator::VisitExpressionMutable<ColumnRefExpression>(
+	    root_expr, [&](ColumnRefExpression &colref) { colref.column_names[0] = name; });
+}
+
 static unique_ptr<SelectNode> PivotFinalOperator(PivotBindState &bind_state, PivotRef &ref,
                                                  unique_ptr<SelectNode> subquery,
                                                  vector<PivotValueElement> pivot_values) {
@@ -295,7 +346,34 @@ static unique_ptr<SelectNode> PivotFinalOperator(PivotBindState &bind_state, Piv
 	bound_pivot->bound_aggregate_names = std::move(bind_state.aggregate_names);
 	bound_pivot->source = std::move(subquery_ref);
 
-	final_pivot_operator->select_list.push_back(make_uniq<StarExpression>());
+	for (auto &group_name : bound_pivot->bound_group_names) {
+		final_pivot_operator->select_list.push_back(make_uniq<ColumnRefExpression>(group_name));
+	}
+	// gather aggregate names
+	vector<string> aggregate_names;
+	for (auto &pivot_value : bound_pivot->bound_pivot_values) {
+		for (idx_t aggr_idx = 0; aggr_idx < ref.aggregates.size(); aggr_idx++) {
+			auto aggr = ref.aggregates[aggr_idx]->Copy();
+			auto &aggr_name = bound_pivot->bound_aggregate_names[aggr_idx];
+			auto pivot_aggr_name = pivot_value.name + aggr_name;
+			aggregate_names.push_back(std::move(pivot_aggr_name));
+		}
+	}
+	QueryResult::DeduplicateColumns(aggregate_names);
+
+	idx_t aggr_name_idx = 0;
+	for (idx_t pivot_idx = 0; pivot_idx < bound_pivot->bound_pivot_values.size(); pivot_idx++) {
+		for (idx_t aggr_idx = 0; aggr_idx < ref.aggregates.size(); aggr_idx++) {
+			auto aggr = ref.aggregates[aggr_idx]->Copy();
+			auto &pivot_aggr_name = aggregate_names[aggr_name_idx++];
+			// replace column ref with name
+			ReplacePivotColumnRef(*aggr, pivot_aggr_name);
+			aggr->alias = pivot_aggr_name;
+
+			final_pivot_operator->select_list.push_back(std::move(aggr));
+		}
+	}
+
 	final_pivot_operator->from_table = std::move(bound_pivot);
 	return final_pivot_operator;
 }
@@ -325,6 +403,15 @@ void ExtractPivotAggregates(BoundTableRef &node, vector<unique_ptr<Expression>>
 	}
 }
 
+string GetPivotAggregateName(const PivotValueElement &pivot_value, const string &aggr_name, idx_t aggregate_count) {
+	auto name = pivot_value.name;
+	if (aggregate_count > 1 || !aggr_name.empty()) {
+		// if there are multiple aggregates specified we add the name of the aggregate as well
+		name += "_" + aggr_name;
+	}
+	return name;
+}
+
 unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
 	// bind the child table in a child binder
 	auto result = make_uniq<BoundPivotRef>();
@@ -355,11 +442,8 @@ unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
 		for (idx_t aggr_idx = 0; aggr_idx < ref.bound_aggregate_names.size(); aggr_idx++) {
 			auto &aggr = aggregates[aggr_idx];
 			auto &aggr_name = ref.bound_aggregate_names[aggr_idx];
-			auto name = pivot_value.name;
-			if (aggregates.size() > 1 || !aggr_name.empty()) {
-				// if there are multiple aggregates specified we add the name of the aggregate as well
-				name += "_" + (aggr_name.empty() ? aggr->GetName() : aggr_name);
-			}
+			auto name = pivot_value.name + aggr_name;
+
 			string pivot_str;
 			for (auto &value : pivot_value.values) {
 				auto str = value.ToString();
@@ -399,7 +483,7 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 			throw BinderException(*aggr, "Pivot expression cannot contain window functions");
 		}
 		idx_t aggregate_count = pivot_aggregates.size();
-		ExtractPivotAggregateExpression(context, *aggr, pivot_aggregates);
+		ExtractPivotAggregateExpression(context, aggr, pivot_aggregates);
 		if (pivot_aggregates.size() != aggregate_count + 1) {
 			string error_str = pivot_aggregates.size() == aggregate_count
 			                       ? "but no aggregates were found"
@@ -459,11 +543,10 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 			pivots.insert(val);
 		}
 	}
-	auto &client_config = ClientConfig::GetConfig(context);
-	auto pivot_limit = client_config.pivot_limit;
+	auto pivot_limit = DBConfig::GetSetting<PivotLimitSetting>(context);
 	if (total_pivots >= pivot_limit) {
 		throw BinderException(ref, "Pivot column limit of %llu exceeded. Use SET pivot_limit=X to increase the limit.",
-		                      client_config.pivot_limit);
+		                      pivot_limit);
 	}
 
 	// construct the required pivot values recursively
@@ -482,7 +565,8 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	// -> filtered aggregates are faster when there are FEW pivot values
 	// -> LIST is faster when there are MANY pivot values
 	// we switch dynamically based on the number of pivots to compute
-	if (pivot_values.size() <= client_config.pivot_filter_threshold) {
+	auto pivot_filter_threshold = DBConfig::GetSetting<PivotFilterThresholdSetting>(context);
+	if (pivot_values.size() <= pivot_filter_threshold) {
 		// use a set of filtered aggregates
 		pivot_node =
 		    PivotFilteredAggregate(context, ref, std::move(all_columns), handled_columns, std::move(pivot_values));
@@ -497,7 +581,7 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		PivotBindState bind_state;
 		// Pivot Stage 1
 		// SELECT {groups}, {pivots}, {aggregates} FROM {from_clause} GROUP BY {groups}, {pivots}
-		auto subquery_stage1 = PivotInitialAggregate(bind_state, ref, std::move(all_columns), handled_columns);
+		auto subquery_stage1 = PivotInitialAggregate(context, bind_state, ref, std::move(all_columns), handled_columns);
 
 		// Pivot stage 2
 		// SELECT {groups}, LIST({pivots}), LIST({aggregates}) FROM [Q1] GROUP BY {groups}

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

@@ -9,6 +9,10 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
+#include "duckdb/main/client_data.hpp"
+#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
 
@@ -151,6 +155,32 @@ unique_ptr<BoundTableRef> Binder::BindShowTable(ShowRef &ref) {
 		sql = PragmaShowDatabases();
 	} else if (lname == "\"tables\"") {
 		sql = PragmaShowTables();
+	} else if (ref.show_type == ShowType::SHOW_FROM) {
+		auto catalog_name = ref.catalog_name;
+		auto schema_name = ref.schema_name;
+
+		// Check for unqualified name, promote schema to catalog if unambiguous, and set schema_name to empty if so
+		Binder::BindSchemaOrCatalog(catalog_name, schema_name);
+
+		// If fully qualified, check if the schema exists
+		if (!catalog_name.empty() && !schema_name.empty()) {
+			auto schema_entry = Catalog::GetSchema(context, catalog_name, schema_name, OnEntryNotFound::RETURN_NULL);
+			if (!schema_entry) {
+				throw CatalogException("SHOW TABLES FROM: No catalog + schema named \"%s.%s\" found.", catalog_name,
+				                       schema_name);
+			}
+		} else if (catalog_name.empty() && !schema_name.empty()) {
+			// We have a schema name, use default catalog
+			auto &client_data = ClientData::Get(context);
+			auto &default_entry = client_data.catalog_search_path->GetDefault();
+			catalog_name = default_entry.catalog;
+			auto schema_entry = Catalog::GetSchema(context, catalog_name, schema_name, OnEntryNotFound::RETURN_NULL);
+			if (!schema_entry) {
+				throw CatalogException("SHOW TABLES FROM: No catalog + schema named \"%s.%s\" found.", catalog_name,
+				                       schema_name);
+			}
+		}
+		sql = PragmaShowTables(catalog_name, schema_name);
 	} else if (lname == "\"variables\"") {
 		sql = PragmaShowVariables();
 	} else if (lname == "__show_tables_expanded") {

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

@@ -21,6 +21,10 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/planner/operator/logical_window.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+
 namespace duckdb {
 
 enum class TableFunctionBindType { STANDARD_TABLE_FUNCTION, TABLE_IN_OUT_FUNCTION, TABLE_PARAMETER_FUNCTION };
@@ -191,12 +195,14 @@ unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &tab
                                                               vector<string> input_table_names) {
 	auto function_name = GetAlias(ref);
 	auto &column_name_alias = ref.column_name_alias;
-
 	auto bind_index = GenerateTableIndex();
 	// perform the binding
 	unique_ptr<FunctionData> bind_data;
 	vector<LogicalType> return_types;
 	vector<string> return_names;
+	auto constexpr ordinality_name = "ordinality";
+	string ordinality_column_name = ordinality_name;
+	idx_t ordinality_column_id;
 	if (table_function.bind || table_function.bind_replace || table_function.bind_operator) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
 		                                  table_function.function_info.get(), this, table_function, ref);
@@ -236,6 +242,27 @@ unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &tab
 			                      table_function.name);
 		}
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
+		if (ref.with_ordinality == OrdinalityType::WITH_ORDINALITY) {
+			// check if column name 'ordinality' already exists and if so, replace it iteratively until free name is
+			// found
+			case_insensitive_set_t ci_return_names;
+			idx_t ordinality_name_suffix = 0;
+			for (auto &n : return_names) {
+				ci_return_names.insert(n);
+			}
+			for (auto &n : column_name_alias) {
+				ci_return_names.insert(n);
+			}
+			while (ci_return_names.find(ordinality_column_name) != ci_return_names.end()) {
+				ordinality_column_name = ordinality_name + to_string(ordinality_name_suffix++);
+			}
+			if (!correlated_columns.empty()) {
+				return_types.emplace_back(LogicalType::BIGINT);
+				return_names.emplace_back(ordinality_column_name);
+				D_ASSERT(return_names.size() == return_types.size());
+				ordinality_column_id = return_types.size() - 1;
+			}
+		}
 	} else {
 		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
 		                            table_function.name);
@@ -270,11 +297,55 @@ unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &tab
 	get->named_parameters = named_parameters;
 	get->input_table_types = input_table_types;
 	get->input_table_names = input_table_names;
+	if (ref.with_ordinality == OrdinalityType::WITH_ORDINALITY && !correlated_columns.empty()) {
+		get->ordinality_idx = ordinality_column_id;
+	}
 	if (table_function.in_out_function) {
 		for (idx_t i = 0; i < return_types.size(); i++) {
 			get->AddColumnId(i);
 		}
 	}
+
+	if (ref.with_ordinality == OrdinalityType::WITH_ORDINALITY && correlated_columns.empty()) {
+		auto window_index = GenerateTableIndex();
+		auto window = make_uniq<duckdb::LogicalWindow>(window_index);
+		auto row_number =
+		    make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT, nullptr, nullptr);
+		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
+		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
+		if (return_names.size() < column_name_alias.size()) {
+			row_number->alias = column_name_alias[return_names.size()];
+		} else {
+			row_number->alias = ordinality_column_name;
+		}
+		window->expressions.push_back(std::move(row_number));
+		for (idx_t i = 0; i < return_types.size(); i++) {
+			get->AddColumnId(i);
+		}
+		window->children.push_back(std::move(get));
+
+		vector<unique_ptr<Expression>> select_list;
+		for (idx_t i = 0; i < return_types.size(); i++) {
+			auto expression = make_uniq<BoundColumnRefExpression>(return_types[i], ColumnBinding(bind_index, i));
+			select_list.push_back(std::move(expression));
+		}
+		select_list.push_back(make_uniq<BoundColumnRefExpression>(LogicalType::BIGINT, ColumnBinding(window_index, 0)));
+
+		auto projection_index = GenerateTableIndex();
+		auto projection = make_uniq<LogicalProjection>(projection_index, std::move(select_list));
+
+		projection->children.push_back(std::move(window));
+		if (return_names.size() < column_name_alias.size()) {
+			return_names.push_back(column_name_alias[return_names.size()]);
+		} else {
+			return_names.push_back(ordinality_column_name);
+		}
+
+		return_types.push_back(LogicalType::BIGINT);
+		bind_context.AddGenericBinding(projection_index, function_name, return_names, return_types);
+		return std::move(projection);
+	}
+
 	// now add the table function to the bind context so its columns can be bound
 	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->GetMutableColumnIds(),
 	                              get->GetTable().get(), std::move(virtual_columns));

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

@@ -267,19 +267,14 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(ClientContext &con
 	}
 }
 
-static bool HasCorrelatedColumns(Expression &expression) {
-	if (expression.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = expression.Cast<BoundColumnRefExpression>();
-		if (colref.depth > 0) {
-			return true;
-		}
-	}
+static bool HasCorrelatedColumns(const Expression &root_expr) {
 	bool has_correlated_columns = false;
-	ExpressionIterator::EnumerateChildren(expression, [&](Expression &child) {
-		if (HasCorrelatedColumns(child)) {
-			has_correlated_columns = true;
-		}
-	});
+	ExpressionIterator::VisitExpression<BoundColumnRefExpression>(root_expr,
+	                                                              [&](const BoundColumnRefExpression &colref) {
+		                                                              if (colref.depth > 0) {
+			                                                              has_correlated_columns = true;
+		                                                              }
+	                                                              });
 	return has_correlated_columns;
 }
 

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

@@ -6,7 +6,21 @@ namespace duckdb {
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 	if (ref.subquery) {
 		auto child_node = CreatePlan(*ref.subquery);
-		ref.get->children.push_back(std::move(child_node));
+
+		reference<LogicalOperator> node = *ref.get;
+
+		while (!node.get().children.empty()) {
+			D_ASSERT(node.get().children.size() == 1);
+			if (node.get().children.size() != 1) {
+				throw InternalException(
+				    "Binder::CreatePlan<BoundTableFunction>: linear path expected, but found node with %d children",
+				    node.get().children.size());
+			}
+			node = *node.get().children[0];
+		}
+
+		D_ASSERT(node.get().type == LogicalOperatorType::LOGICAL_GET);
+		node.get().children.push_back(std::move(child_node));
 	}
 	return std::move(ref.get);
 }