duckdb 1.1.4-dev11.0 → 1.1.4-dev14.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/optimizer/optimizer.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_aggregate.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/operator/logical_join.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
@@ -20,7 +21,8 @@ void FilterPushdown::CheckMarkToSemi(LogicalOperator &op, unordered_set<idx_t> &
 		if (join.join_type != JoinType::MARK) {
 			break;
 		}
-		// if the projected table bindings include the mark join index,
+		// if an operator above the mark join includes the mark join index,
+		// then the mark join cannot be converted to a semi join
 		if (table_bindings.find(join.mark_index) != table_bindings.end()) {
 			join.convert_mark_to_semi = false;
 		}
@@ -38,20 +40,45 @@ void FilterPushdown::CheckMarkToSemi(LogicalOperator &op, unordered_set<idx_t> &
 		for (auto &binding : proj_bindings) {
 			auto col_index = binding.column_index;
 			auto &expr = proj.expressions.at(col_index);
-			vector<ColumnBinding> bindings_to_keep;
 			ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) {
 				if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
 					auto &col_ref = child.Cast<BoundColumnRefExpression>();
-					bindings_to_keep.push_back(col_ref.binding);
+					new_table_bindings.insert(col_ref.binding.table_index);
 				}
 			});
-			for (auto &expr_binding : bindings_to_keep) {
-				new_table_bindings.insert(expr_binding.table_index);
-			}
 			table_bindings = new_table_bindings;
 		}
 		break;
 	}
+	// It's possible a mark join index makes its way into a group by as the grouping index
+	// when that happens we need to keep track of it to make sure we do not convert a mark join to semi.
+	// see filter_pushdown_into_subquery.
+	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
+		auto &aggr = op.Cast<LogicalAggregate>();
+		auto aggr_bindings = aggr.GetColumnBindings();
+		vector<ColumnBinding> bindings_to_keep;
+		for (auto &expr : aggr.groups) {
+			ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) {
+				if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
+					auto &col_ref = child.Cast<BoundColumnRefExpression>();
+					bindings_to_keep.push_back(col_ref.binding);
+				}
+			});
+		}
+		for (auto &expr : aggr.expressions) {
+			ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) {
+				if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) {
+					auto &col_ref = child.Cast<BoundColumnRefExpression>();
+					bindings_to_keep.push_back(col_ref.binding);
+				}
+			});
+		}
+		table_bindings = unordered_set<idx_t>();
+		for (auto &expr_binding : bindings_to_keep) {
+			table_bindings.insert(expr_binding.table_index);
+		}
+		break;
+	}
 	default:
 		break;
 	}

package/src/duckdb/src/optimizer/late_materialization.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/optimizer/late_materialization.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
@@ -61,6 +62,8 @@ ColumnBinding LateMaterialization::ConstructRHS(unique_ptr<LogicalOperator> &op)
 	// we have reached the logical get - now we need to push the row-id column (if it is not yet projected out)
 	auto &get = child.get().Cast<LogicalGet>();
 	auto row_id_idx = GetOrInsertRowId(get);
+	idx_t column_count = get.projection_ids.empty() ? get.GetColumnIds().size() : get.projection_ids.size();
+	D_ASSERT(column_count == get.GetColumnBindings().size());
 
 	// the row id has been projected - now project it up the stack
 	ColumnBinding row_id_binding(get.table_index, row_id_idx);
@@ -74,11 +77,18 @@ ColumnBinding LateMaterialization::ConstructRHS(unique_ptr<LogicalOperator> &op)
 			    make_uniq<BoundColumnRefExpression>("rowid", get.GetRowIdType(), row_id_binding));
 			// modify the row-id-binding to push to the new projection
 			row_id_binding = ColumnBinding(proj.table_index, proj.expressions.size() - 1);
+			column_count = proj.expressions.size();
 			break;
 		}
-		case LogicalOperatorType::LOGICAL_FILTER:
-			// column bindings pass-through this operator as-is
+		case LogicalOperatorType::LOGICAL_FILTER: {
+			auto &filter = op.Cast<LogicalFilter>();
+			// column bindings pass-through this operator as-is UNLESS the filter has a projection map
+			if (filter.HasProjectionMap()) {
+				// if the filter has a projection map, we need to project the new column
+				filter.projection_map.push_back(column_count - 1);
+			}
 			break;
+		}
 		default:
 			throw InternalException("Unsupported logical operator in LateMaterialization::ConstructRHS");
 		}
@@ -212,12 +222,13 @@ bool LateMaterialization::TryLateMaterialization(unique_ptr<LogicalOperator> &op
 			child = *child.get().children[0];
 			break;
 		}
-		case LogicalOperatorType::LOGICAL_FILTER:
+		case LogicalOperatorType::LOGICAL_FILTER: {
 			// visit filter expressions - we need these columns
 			VisitOperatorExpressions(child.get());
 			// continue into child
 			child = *child.get().children[0];
 			break;
+		}
 		default:
 			// unsupported operator for late materialization
 			return false;

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

@@ -261,9 +261,6 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 				if (entry == column_references.end()) {
 					throw InternalException("RemoveUnusedColumns - could not find referenced column");
 				}
-				if (final_column_ids[col_sel_idx].HasChildren()) {
-					throw InternalException("RemoveUnusedColumns - LogicalGet::column_ids already has children");
-				}
 				ColumnIndex new_index(final_column_ids[col_sel_idx].GetPrimaryIndex(), entry->second.child_columns);
 				column_ids.emplace_back(new_index);
 			}

package/src/duckdb/src/parser/parsed_data/attach_info.cpp

@@ -3,6 +3,7 @@
 
 #include "duckdb/storage/storage_info.hpp"
 #include "duckdb/common/optional_idx.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -15,6 +16,9 @@ StorageOptions AttachInfo::GetStorageOptions() const {
 			storage_options.block_alloc_size = entry.second.GetValue<uint64_t>();
 		} else if (entry.first == "row_group_size") {
 			storage_options.row_group_size = entry.second.GetValue<uint64_t>();
+		} else if (entry.first == "storage_version") {
+			storage_options.storage_version =
+			    SerializationCompatibility::FromString(entry.second.ToString()).serialization_version;
 		}
 	}
 	return storage_options;
@@ -36,7 +40,7 @@ string AttachInfo::ToString() const {
 		result += " IF NOT EXISTS";
 	}
 	result += " DATABASE";
-	result += StringUtil::Format(" '%s'", path);
+	result += KeywordHelper::WriteQuoted(path, '\'');
 	if (!name.empty()) {
 		result += " AS " + KeywordHelper::WriteOptionallyQuoted(name);
 	}

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -82,7 +82,8 @@ unique_ptr<CreateViewInfo> CreateViewInfo::FromSelect(ClientContext &context, un
 	return info;
 }
 
-unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context, const string &sql) {
+unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context, SchemaCatalogEntry &schema,
+                                                          const string &sql) {
 	D_ASSERT(!sql.empty());
 
 	// parse the SQL statement
@@ -101,9 +102,11 @@ unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context
 	}
 
 	auto result = unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(create_statement.info));
+	result->catalog = schema.ParentCatalog().GetName();
+	result->schema = schema.name;
 
-	auto binder = Binder::CreateBinder(context);
-	binder->BindCreateViewInfo(*result);
+	auto view_binder = Binder::CreateBinder(context);
+	view_binder->BindCreateViewInfo(*result);
 
 	return result;
 }

package/src/duckdb/src/parser/query_node/set_operation_node.cpp

@@ -5,6 +5,9 @@
 
 namespace duckdb {
 
+SetOperationNode::SetOperationNode() : QueryNode(QueryNodeType::SET_OPERATION_NODE) {
+}
+
 string SetOperationNode::ToString() const {
 	string result;
 	result = cte_map.ToString();
@@ -63,4 +66,50 @@ unique_ptr<QueryNode> SetOperationNode::Copy() const {
 	return std::move(result);
 }
 
+SetOperationNode::SetOperationNode(SetOperationType setop_type, unique_ptr<QueryNode> left, unique_ptr<QueryNode> right,
+                                   vector<unique_ptr<QueryNode>> children, bool setop_all)
+    : QueryNode(QueryNodeType::SET_OPERATION_NODE), setop_type(setop_type), setop_all(setop_all) {
+	if (left && right) {
+		// simple case - left/right are supplied
+		this->left = std::move(left);
+		this->right = std::move(right);
+		return;
+	}
+	if (children.size() == 2) {
+		this->left = std::move(children[0]);
+		this->right = std::move(children[1]);
+	}
+	// we have multiple children - we need to construct a tree of set operation nodes
+	if (children.size() <= 1) {
+		throw SerializationException("Set Operation requires at least 2 children");
+	}
+	if (setop_type != SetOperationType::UNION) {
+		throw SerializationException("Multiple children in set-operations are only supported for UNION");
+	}
+	// construct a balanced tree from the union
+	while (children.size() > 2) {
+		vector<unique_ptr<QueryNode>> new_children;
+		for (idx_t i = 0; i < children.size(); i += 2) {
+			if (i + 1 == children.size()) {
+				new_children.push_back(std::move(children[i]));
+			} else {
+				vector<unique_ptr<QueryNode>> empty_children;
+				auto setop_node =
+				    make_uniq<SetOperationNode>(setop_type, std::move(children[i]), std::move(children[i + 1]),
+				                                std::move(empty_children), setop_all);
+				new_children.push_back(std::move(setop_node));
+			}
+		}
+		children = std::move(new_children);
+	}
+	// two children left - fill in the left/right of this node
+	this->left = std::move(children[0]);
+	this->right = std::move(children[1]);
+}
+
+vector<unique_ptr<QueryNode>> SetOperationNode::SerializeChildNodes() const {
+	// we always serialize children as left/right currently
+	return vector<unique_ptr<QueryNode>>();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_columnref.cpp

@@ -96,6 +96,7 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			result->relation_name = child_star.relation_name;
 			result->exclude_list = std::move(child_star.exclude_list);
 			result->replace_list = std::move(child_star.replace_list);
+			result->rename_list = std::move(child_star.rename_list);
 			result->expr.reset();
 		} else if (result->expr->GetExpressionType() == ExpressionType::LAMBDA) {
 			vector<unique_ptr<ParsedExpression>> children;

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -1,8 +1,6 @@
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/to_string.hpp"
 #include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/parser/expression/cast_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 
@@ -35,6 +33,39 @@ void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec
 	}
 }
 
+static inline WindowBoundary TransformFrameOption(const int frameOptions, const WindowBoundary rows,
+                                                  const WindowBoundary range, const WindowBoundary groups) {
+
+	if (frameOptions & FRAMEOPTION_RANGE) {
+		return range;
+	} else if (frameOptions & FRAMEOPTION_GROUPS) {
+		return groups;
+	} else {
+		return rows;
+	}
+}
+
+static bool IsExcludableWindowFunction(ExpressionType type) {
+	switch (type) {
+	case ExpressionType::WINDOW_FIRST_VALUE:
+	case ExpressionType::WINDOW_LAST_VALUE:
+	case ExpressionType::WINDOW_NTH_VALUE:
+	case ExpressionType::WINDOW_AGGREGATE:
+		return true;
+	case ExpressionType::WINDOW_RANK_DENSE:
+	case ExpressionType::WINDOW_RANK:
+	case ExpressionType::WINDOW_PERCENT_RANK:
+	case ExpressionType::WINDOW_ROW_NUMBER:
+	case ExpressionType::WINDOW_NTILE:
+	case ExpressionType::WINDOW_CUME_DIST:
+	case ExpressionType::WINDOW_LEAD:
+	case ExpressionType::WINDOW_LAG:
+		return false;
+	default:
+		throw InternalException("Unknown excludable window type %s", ExpressionTypeToString(type).c_str());
+	}
+}
+
 void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr) {
 	// finally: specifics of bounds
 	expr.start_expr = TransformExpression(window_spec.startOffset);
@@ -46,28 +77,30 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_sp
 		    "Window frames starting with unbounded following or ending in unbounded preceding make no sense");
 	}
 
-	if (window_spec.frameOptions & FRAMEOPTION_GROUPS) {
-		throw ParserException("GROUPS mode for window functions is not implemented yet");
-	}
-	const bool rangeMode = (window_spec.frameOptions & FRAMEOPTION_RANGE) != 0;
 	if (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
 		expr.start = WindowBoundary::UNBOUNDED_PRECEDING;
 	} else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING) {
-		expr.start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
+		expr.start = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_PRECEDING_ROWS,
+		                                  WindowBoundary::EXPR_PRECEDING_RANGE, WindowBoundary::EXPR_PRECEDING_GROUPS);
 	} else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) {
-		expr.start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
+		expr.start = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_FOLLOWING_ROWS,
+		                                  WindowBoundary::EXPR_FOLLOWING_RANGE, WindowBoundary::EXPR_FOLLOWING_GROUPS);
 	} else if (window_spec.frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
-		expr.start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
+		expr.start = TransformFrameOption(window_spec.frameOptions, WindowBoundary::CURRENT_ROW_ROWS,
+		                                  WindowBoundary::CURRENT_ROW_RANGE, WindowBoundary::CURRENT_ROW_GROUPS);
 	}
 
 	if (window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
 		expr.end = WindowBoundary::UNBOUNDED_FOLLOWING;
 	} else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING) {
-		expr.end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
+		expr.end = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_PRECEDING_ROWS,
+		                                WindowBoundary::EXPR_PRECEDING_RANGE, WindowBoundary::EXPR_PRECEDING_GROUPS);
 	} else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING) {
-		expr.end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
+		expr.end = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_FOLLOWING_ROWS,
+		                                WindowBoundary::EXPR_FOLLOWING_RANGE, WindowBoundary::EXPR_FOLLOWING_GROUPS);
 	} else if (window_spec.frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
-		expr.end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
+		expr.end = TransformFrameOption(window_spec.frameOptions, WindowBoundary::CURRENT_ROW_ROWS,
+		                                WindowBoundary::CURRENT_ROW_RANGE, WindowBoundary::CURRENT_ROW_GROUPS);
 	}
 
 	D_ASSERT(expr.start != WindowBoundary::INVALID && expr.end != WindowBoundary::INVALID);
@@ -87,6 +120,11 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_sp
 	} else {
 		expr.exclude_clause = WindowExcludeMode::NO_OTHER;
 	}
+
+	if (expr.exclude_clause != WindowExcludeMode::NO_OTHER && !expr.arg_orders.empty() &&
+	    !IsExcludableWindowFunction(expr.type)) {
+		throw ParserException("EXCLUDE is not supported for the window function \"%s\"", expr.function_name.c_str());
+	}
 }
 
 bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {

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

@@ -436,11 +436,13 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &col_ref_p, idx_
 			if (found_alias) {
 				return alias_result;
 			}
-
-			// column was not found - check if it is a SQL value function
-			auto value_function = GetSQLValueFunction(col_ref_p.GetColumnName());
-			if (value_function) {
-				return BindExpression(value_function, depth);
+			found_alias = QualifyColumnAlias(col_ref_p);
+			if (!found_alias) {
+				// column was not found - check if it is a SQL value function
+				auto value_function = GetSQLValueFunction(col_ref_p.GetColumnName());
+				if (value_function) {
+					return BindExpression(value_function, depth);
+				}
 			}
 		}
 		error.AddQueryLocation(col_ref_p);

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

@@ -28,6 +28,7 @@ void ExpressionBinder::TestCollation(ClientContext &context, const string &colla
 
 static bool SwitchVarcharComparison(const LogicalType &type) {
 	switch (type.id()) {
+	case LogicalTypeId::BOOLEAN:
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:

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

@@ -109,7 +109,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		auto &b_exp = BoundExpression::GetExpression(*op.children[0]);
 		const auto &b_exp_type = b_exp->return_type;
 		if (b_exp_type.id() == LogicalTypeId::MAP) {
-			function_name = "map_extract";
+			function_name = "map_extract_value";
 		} else if (b_exp_type.IsJSONType() && op.children.size() == 2) {
 			function_name = "json_extract";
 			// Make sure we only extract array elements, not fields, by adding the $[] syntax
@@ -149,7 +149,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		if (extract_expr_type.id() == LogicalTypeId::UNION) {
 			function_name = "union_extract";
 		} else if (extract_expr_type.id() == LogicalTypeId::MAP) {
-			function_name = "map_extract";
+			function_name = "map_extract_value";
 		} else if (extract_expr_type.IsJSONType()) {
 			function_name = "json_extract";
 			// Make sure we only extract fields, not array elements, by adding $. syntax

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

@@ -145,7 +145,7 @@ void TryTransformStarLike(unique_ptr<ParsedExpression> &root) {
 		return;
 	}
 	auto &function = root->Cast<FunctionExpression>();
-	if (function.children.size() != 2) {
+	if (function.children.size() < 2 || function.children.size() > 3) {
 		return;
 	}
 	auto &left = function.children[0];
@@ -158,7 +158,17 @@ void TryTransformStarLike(unique_ptr<ParsedExpression> &root) {
 		// COLUMNS(*) has different semantics
 		return;
 	}
-	unordered_set<string> supported_ops {"~~", "!~~", "~~~", "!~~~", "~~*", "!~~*", "regexp_full_match"};
+	unordered_set<string> supported_ops {"~~",
+	                                     "!~~",
+	                                     "~~~",
+	                                     "!~~~",
+	                                     "~~*",
+	                                     "!~~*",
+	                                     "regexp_full_match",
+	                                     "not_like_escape",
+	                                     "ilike_escape",
+	                                     "not_ilike_escape",
+	                                     "like_escape"};
 	if (supported_ops.count(function.function_name) == 0) {
 		// unsupported op for * expression
 		throw BinderException(*root, "Function \"%s\" cannot be applied to a star expression", function.function_name);

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

@@ -43,7 +43,6 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(Catalog &from_databas
 		info->entries.push_back(std::move(create_info));
 	}
 
-	// FIXME: copy indexes
 	return make_uniq<LogicalCopyDatabase>(std::move(info));
 }
 

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

@@ -41,6 +41,7 @@
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/common/extension_type_info.hpp"
+#include "duckdb/common/type_visitor.hpp"
 
 namespace duckdb {
 
@@ -97,7 +98,7 @@ SchemaCatalogEntry &Binder::BindSchema(CreateInfo &info) {
 		info.catalog = default_entry.catalog;
 		info.schema = default_entry.schema;
 	} else if (IsInvalidSchema(info.schema)) {
-		info.schema = search_path->GetDefaultSchema(info.catalog);
+		info.schema = search_path->GetDefaultSchema(context, info.catalog);
 	} else if (IsInvalidCatalog(info.catalog)) {
 		info.catalog = search_path->GetDefaultCatalog(info.schema);
 	}
@@ -157,6 +158,9 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	}
 	view_binder->can_contain_nulls = true;
 
+	auto view_search_path = GetSearchPath(catalog, base.schema);
+	view_binder->entry_retriever.SetSearchPath(std::move(view_search_path));
+
 	auto copy = base.query->Copy();
 	auto query_node = view_binder->Bind(*base.query);
 	base.query = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(copy));
@@ -253,54 +257,56 @@ static bool IsValidUserType(optional_ptr<CatalogEntry> entry) {
 	return entry->Cast<TypeCatalogEntry>().user_type.id() != LogicalTypeId::INVALID;
 }
 
-void Binder::BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog, const string &schema) {
+LogicalType Binder::BindLogicalTypeInternal(const LogicalType &type, optional_ptr<Catalog> catalog,
+                                            const string &schema) {
 	if (type.id() != LogicalTypeId::USER) {
-		// Recursive types, make sure to bind any nested user types recursively
-		auto alias = type.GetAlias();
-		auto ext_info = type.HasExtensionInfo() ? make_uniq<ExtensionTypeInfo>(*type.GetExtensionInfo()) : nullptr;
-
+		// Nested type, make sure to bind any nested user types recursively
+		LogicalType result;
 		switch (type.id()) {
 		case LogicalTypeId::LIST: {
-			auto child_type = ListType::GetChildType(type);
-			BindLogicalType(child_type, catalog, schema);
-			type = LogicalType::LIST(child_type);
-		} break;
+			auto child_type = BindLogicalTypeInternal(ListType::GetChildType(type), catalog, schema);
+			result = LogicalType::LIST(child_type);
+			break;
+		}
 		case LogicalTypeId::MAP: {
-			auto key_type = MapType::KeyType(type);
-			BindLogicalType(key_type, catalog, schema);
-			auto value_type = MapType::ValueType(type);
-			BindLogicalType(value_type, catalog, schema);
-			type = LogicalType::MAP(key_type, value_type);
-		} break;
+			auto key_type = BindLogicalTypeInternal(MapType::KeyType(type), catalog, schema);
+			auto value_type = BindLogicalTypeInternal(MapType::ValueType(type), catalog, schema);
+			result = LogicalType::MAP(std::move(key_type), std::move(value_type));
+			break;
+		}
 		case LogicalTypeId::ARRAY: {
-			auto child_type = ArrayType::GetChildType(type);
+			auto child_type = BindLogicalTypeInternal(ArrayType::GetChildType(type), catalog, schema);
 			auto array_size = ArrayType::GetSize(type);
-			BindLogicalType(child_type, catalog, schema);
-			type = LogicalType::ARRAY(child_type, array_size);
-		} break;
+			result = LogicalType::ARRAY(child_type, array_size);
+			break;
+		}
 		case LogicalTypeId::STRUCT: {
 			auto child_types = StructType::GetChildTypes(type);
-			for (auto &child_type : child_types) {
-				BindLogicalType(child_type.second, catalog, schema);
+			child_list_t<LogicalType> new_child_types;
+			for (auto &entry : child_types) {
+				new_child_types.emplace_back(entry.first, BindLogicalTypeInternal(entry.second, catalog, schema));
 			}
-			type = LogicalType::STRUCT(child_types);
-		} break;
+			result = LogicalType::STRUCT(std::move(new_child_types));
+			break;
+		}
 		case LogicalTypeId::UNION: {
-			auto member_types = UnionType::CopyMemberTypes(type);
-			for (auto &member_type : member_types) {
-				BindLogicalType(member_type.second, catalog, schema);
+			child_list_t<LogicalType> member_types;
+			for (idx_t i = 0; i < UnionType::GetMemberCount(type); i++) {
+				auto child_type = BindLogicalTypeInternal(UnionType::GetMemberType(type, i), catalog, schema);
+				member_types.emplace_back(UnionType::GetMemberName(type, i), std::move(child_type));
 			}
-			type = LogicalType::UNION(member_types);
-		} break;
-		default:
+			result = LogicalType::UNION(std::move(member_types));
 			break;
 		}
+		default:
+			return type;
+		}
 
 		// Set the alias and extension info back
-		type.SetAlias(alias);
-		type.SetExtensionInfo(std::move(ext_info));
-
-		return;
+		result.SetAlias(type.GetAlias());
+		auto ext_info = type.HasExtensionInfo() ? make_uniq<ExtensionTypeInfo>(*type.GetExtensionInfo()) : nullptr;
+		result.SetExtensionInfo(std::move(ext_info));
+		return result;
 	}
 
 	// User type, bind the user type
@@ -310,6 +316,7 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog, c
 
 	bind_logical_type_function_t user_bind_modifiers_func = nullptr;
 
+	LogicalType result;
 	if (catalog) {
 		// The search order is:
 		// 1) In the explicitly set schema (my_schema.my_type)
@@ -335,7 +342,7 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog, c
 			                                 OnEntryNotFound::THROW_EXCEPTION);
 		}
 		auto &type_entry = entry->Cast<TypeCatalogEntry>();
-		type = type_entry.user_type;
+		result = type_entry.user_type;
 		user_bind_modifiers_func = type_entry.bind_function;
 	} else {
 		string type_catalog = UserType::GetCatalog(type);
@@ -344,24 +351,33 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog, c
 		BindSchemaOrCatalog(context, type_catalog, type_schema);
 		auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, type_catalog, type_schema, user_type_name);
 		auto &type_entry = entry->Cast<TypeCatalogEntry>();
-		type = type_entry.user_type;
+		result = type_entry.user_type;
 		user_bind_modifiers_func = type_entry.bind_function;
 	}
 
 	// Now we bind the inner user type
-	BindLogicalType(type, catalog, schema);
+	BindLogicalType(result, catalog, schema);
 
 	// Apply the type modifiers (if any)
 	if (user_bind_modifiers_func) {
 		// If an explicit bind_modifiers function was provided, use that to construct the type
 
-		BindLogicalTypeInput input {context, type, user_type_mods};
-		type = user_bind_modifiers_func(input);
+		BindLogicalTypeInput input {context, result, user_type_mods};
+		result = user_bind_modifiers_func(input);
 	} else {
 		if (!user_type_mods.empty()) {
 			throw BinderException("Type '%s' does not take any type modifiers", user_type_name);
 		}
 	}
+	return result;
+}
+
+void Binder::BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog, const string &schema) {
+	// check if we need to bind this type at all
+	if (!TypeVisitor::Contains(type, LogicalTypeId::USER)) {
+		return;
+	}
+	type = BindLogicalTypeInternal(type, catalog, schema);
 }
 
 unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateStatement &stmt,

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

@@ -54,7 +54,8 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 			parameter_data = BoundParameterData(std::move(constant.value), std::move(return_type));
 		} else {
 			auto value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
-			parameter_data = BoundParameterData(std::move(value));
+			auto value_type = value.type();
+			parameter_data = BoundParameterData(std::move(value), std::move(value_type));
 		}
 		bind_values[pair.first] = std::move(parameter_data);
 	}

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

@@ -79,6 +79,19 @@ unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context
 	return nullptr;
 }
 
+vector<CatalogSearchEntry> Binder::GetSearchPath(Catalog &catalog, const string &schema_name) {
+	vector<CatalogSearchEntry> view_search_path;
+	auto &catalog_name = catalog.GetName();
+	if (!schema_name.empty()) {
+		view_search_path.emplace_back(catalog_name, schema_name);
+	}
+	auto default_schema = catalog.GetDefaultSchema();
+	if (schema_name.empty() && schema_name != default_schema) {
+		view_search_path.emplace_back(catalog.GetName(), default_schema);
+	}
+	return view_search_path;
+}
+
 unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	QueryErrorContext error_context(ref.query_location);
 	// CTEs and views are also referred to using BaseTableRefs, hence need to distinguish here
@@ -278,13 +291,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		subquery.column_name_alias = BindContext::AliasColumnNames(ref.table_name, view_names, ref.column_name_alias);
 
 		// when binding a view, we always look into the catalog/schema where the view is stored first
-		vector<CatalogSearchEntry> view_search_path;
-		auto &catalog_name = view_catalog_entry.ParentCatalog().GetName();
-		auto &schema_name = view_catalog_entry.ParentSchema().name;
-		view_search_path.emplace_back(catalog_name, schema_name);
-		if (schema_name != DEFAULT_SCHEMA) {
-			view_search_path.emplace_back(view_catalog_entry.ParentCatalog().GetName(), DEFAULT_SCHEMA);
-		}
+		auto view_search_path =
+		    GetSearchPath(view_catalog_entry.ParentCatalog(), view_catalog_entry.ParentSchema().name);
 		view_binder->entry_retriever.SetSearchPath(std::move(view_search_path));
 		// bind the child subquery
 		view_binder->AddBoundView(view_catalog_entry);