duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

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

@@ -12,8 +12,8 @@ CreateTableInfo::CreateTableInfo(string catalog_p, string schema_p, string name_
     : CreateInfo(CatalogType::TABLE_ENTRY, std::move(schema_p), std::move(catalog_p)), table(std::move(name_p)) {
 }
 
-CreateTableInfo::CreateTableInfo(SchemaCatalogEntry *schema, string name_p)
-    : CreateTableInfo(schema->catalog->GetName(), schema->name, std::move(name_p)) {
+CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
+    : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
 }
 
 void CreateTableInfo::SerializeInternal(Serializer &serializer) const {

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

@@ -15,8 +15,8 @@ CreateViewInfo::CreateViewInfo(string catalog_p, string schema_p, string view_na
       view_name(std::move(view_name_p)) {
 }
 
-CreateViewInfo::CreateViewInfo(SchemaCatalogEntry *schema, string view_name)
-    : CreateViewInfo(schema->catalog->GetName(), schema->name, std::move(view_name)) {
+CreateViewInfo::CreateViewInfo(SchemaCatalogEntry &schema, string view_name)
+    : CreateViewInfo(schema.catalog.GetName(), schema.name, std::move(view_name)) {
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::Copy() const {

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

@@ -27,9 +27,10 @@ InsertStatement::InsertStatement()
 }
 
 InsertStatement::InsertStatement(const InsertStatement &other)
-    : SQLStatement(other),
-      select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
-      columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog) {
+    : SQLStatement(other), select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(
+                               other.select_statement ? other.select_statement->Copy() : nullptr)),
+      columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog),
+      default_values(other.default_values) {
 	cte_map = other.cte_map.Copy();
 	for (auto &expr : other.returning_list) {
 		returning_list.emplace_back(expr->Copy());
@@ -93,10 +94,15 @@ string InsertStatement::ToString() const {
 	result += " ";
 	auto values_list = GetValuesList();
 	if (values_list) {
+		D_ASSERT(!default_values);
 		values_list->alias = string();
 		result += values_list->ToString();
-	} else {
+	} else if (select_statement) {
+		D_ASSERT(!default_values);
 		result += select_statement->ToString();
+	} else {
+		D_ASSERT(default_values);
+		result += "DEFAULT VALUES";
 	}
 	if (!or_replace_shorthand_set && on_conflict_info) {
 		auto &conflict_info = *on_conflict_info;
@@ -155,7 +161,10 @@ unique_ptr<SQLStatement> InsertStatement::Copy() const {
 	return unique_ptr<InsertStatement>(new InsertStatement(*this));
 }
 
-ExpressionListRef *InsertStatement::GetValuesList() const {
+optional_ptr<ExpressionListRef> InsertStatement::GetValuesList() const {
+	if (!select_statement) {
+		return nullptr;
+	}
 	if (select_statement->node->type != QueryNodeType::SELECT_NODE) {
 		return nullptr;
 	}
@@ -178,7 +187,7 @@ ExpressionListRef *InsertStatement::GetValuesList() const {
 	if (!node.from_table || node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
 		return nullptr;
 	}
-	return (ExpressionListRef *)node.from_table.get();
+	return &node.from_table->Cast<ExpressionListRef>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -108,7 +108,7 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
 			}
 		}
-		if (pk_columns.size() != fk_columns.size()) {
+		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
 			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
 		}
 		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));

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

@@ -13,15 +13,24 @@
 
 namespace duckdb {
 
-void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
+void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr,
+                                     const char *window_name) {
 	D_ASSERT(window_spec);
 	D_ASSERT(expr);
 
 	// next: partitioning/ordering expressions
 	if (window_spec->partitionClause) {
+		if (window_name && !expr->partitions.empty()) {
+			throw ParserException("Cannot override PARTITION BY clause of window \"%s\"", window_name);
+		}
 		TransformExpressionList(*window_spec->partitionClause, expr->partitions);
 	}
-	TransformOrderBy(window_spec->orderClause, expr->orders);
+	if (window_spec->orderClause) {
+		if (window_name && !expr->orders.empty()) {
+			throw ParserException("Cannot override ORDER BY clause of window \"%s\"", window_name);
+		}
+		TransformOrderBy(window_spec->orderClause, expr->orders);
+	}
 }
 
 void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
@@ -198,6 +207,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			D_ASSERT(window_spec);
 		}
 		auto window_ref = window_spec;
+		auto window_name = window_ref->refname;
 		if (window_ref->refname) {
 			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->refname)));
 			if (it == window_clauses.end()) {
@@ -208,6 +218,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		}
 		in_window_definition = true;
 		TransformWindowDef(window_ref, expr.get());
+		if (window_ref != window_spec) {
+			TransformWindowDef(window_spec, expr.get(), window_name);
+		}
 		TransformWindowFrame(window_spec, expr.get());
 		in_window_definition = false;
 		expr->query_location = root->location;
@@ -299,9 +312,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			                                               std::move(filter_expr), std::move(order_bys),
 			                                               root->agg_distinct, false, root->export_state);
 			lowercase_name = "list_sort";
-			order_bys.reset();
-			filter_expr.reset();
-			children.clear();
+			order_bys.reset();   // NOLINT
+			filter_expr.reset(); // NOLINT
+			children.clear();    // NOLINT
 			children.emplace_back(std::move(unordered));
 			children.emplace_back(std::move(sense));
 			children.emplace_back(std::move(nulls));

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

@@ -61,13 +61,14 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 				throw InternalException("Wrong argument for %s. Expected either <schema>.<name> or <name>", opt_name);
 			}
 			auto info = make_uniq<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_catalog, sequence_schema,
-			                                           sequence_name, owner_schema, owner_name, stmt->missing_ok);
+			                                           sequence_name, owner_schema, owner_name,
+			                                           TransformOnEntryNotFound(stmt->missing_ok));
 			result->info = std::move(info);
 		} else {
 			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
 		}
 	}
-	result->info->if_exists = stmt->missing_ok;
+	result->info->if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 	return result;
 }
 } // namespace duckdb

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

@@ -6,6 +6,10 @@
 
 namespace duckdb {
 
+OnEntryNotFound Transformer::TransformOnEntryNotFound(bool missing_ok) {
+	return missing_ok ? OnEntryNotFound::RETURN_NULL : OnEntryNotFound::THROW_EXCEPTION;
+}
+
 unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAlterTableStmt *>(node);
 	D_ASSERT(stmt);
@@ -21,7 +25,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 	// first we check the type of ALTER
 	for (auto c = stmt->cmds->head; c != nullptr; c = c->next) {
 		auto command = reinterpret_cast<duckdb_libpgquery::PGAlterTableCmd *>(lfirst(c));
-		AlterEntryData data(qname.catalog, qname.schema, qname.name, stmt->missing_ok);
+		AlterEntryData data(qname.catalog, qname.schema, qname.name, TransformOnEntryNotFound(stmt->missing_ok));
 		// TODO: Include more options for command->subtype
 		switch (command->subtype) {
 		case duckdb_libpgquery::PG_AT_AddColumn: {

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

@@ -10,7 +10,7 @@ unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGNo
 	auto result = make_uniq<DetachStatement>();
 	auto info = make_uniq<DetachInfo>();
 	info->name = stmt->db_name;
-	info->if_exists = stmt->missing_ok;
+	info->if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 
 	result->info = std::move(info);
 	return result;

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

@@ -80,7 +80,7 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *n
 	}
 	}
 	info.cascade = stmt->behavior == duckdb_libpgquery::PGDropBehavior::PG_DROP_CASCADE;
-	info.if_exists = stmt->missing_ok;
+	info.if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 	return std::move(result);
 }
 

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

@@ -26,12 +26,6 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGInsertStmt *>(node);
 	D_ASSERT(stmt);
 
-	if (!stmt->selectStmt) {
-		// TODO: This should be easy to add, we already support DEFAULT in the values list,
-		// this could probably just be transformed into VALUES (DEFAULT, DEFAULT, DEFAULT, ..) in the Binder
-		throw ParserException("DEFAULT VALUES clause is not supported!");
-	}
-
 	auto result = make_uniq<InsertStatement>();
 	if (stmt->withClause) {
 		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
@@ -49,7 +43,11 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 	if (stmt->returningList) {
 		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
 	}
-	result->select_statement = TransformSelect(stmt->selectStmt, false);
+	if (stmt->selectStmt) {
+		result->select_statement = TransformSelect(stmt->selectStmt, false);
+	} else {
+		result->default_values = true;
+	}
 
 	auto qname = TransformQualifiedName(stmt->relation);
 	result->table = qname.name;

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

@@ -13,7 +13,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 	unique_ptr<AlterInfo> info;
 
 	AlterEntryData data;
-	data.if_exists = stmt->missing_ok;
+	data.if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 	data.catalog = stmt->relation->catalogname ? stmt->relation->catalogname : INVALID_CATALOG;
 	data.schema = stmt->relation->schemaname ? stmt->relation->schemaname : INVALID_SCHEMA;
 	if (stmt->relation->relname) {

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

@@ -60,13 +60,13 @@ static Value NegatePercentileValue(const Value &v, const bool desc) {
 static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedExpression> &fractions, bool desc) {
 	D_ASSERT(fractions.get());
 	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = fractions->Cast<BoundExpression>();
+	auto &bound = BoundExpression::GetExpression(*fractions);
 
-	if (!bound.expr->IsFoldable()) {
+	if (!bound->IsFoldable()) {
 		return;
 	}
 
-	Value value = ExpressionExecutor::EvaluateScalar(context, *bound.expr);
+	Value value = ExpressionExecutor::EvaluateScalar(context, *bound);
 	if (value.type().id() == LogicalTypeId::LIST) {
 		vector<Value> values;
 		for (const auto &element_val : ListValue::GetChildren(value)) {
@@ -75,14 +75,13 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 		if (values.empty()) {
 			throw BinderException("Empty list in percentile not allowed");
 		}
-		bound.expr = make_uniq<BoundConstantExpression>(Value::LIST(values));
+		bound = make_uniq<BoundConstantExpression>(Value::LIST(values));
 	} else {
-		bound.expr = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
+		bound = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
 	}
 }
 
-BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_ptr<AggregateFunctionCatalogEntry> func,
-                                           idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry &func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
@@ -138,8 +137,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = aggr.children[i]->Cast<BoundExpression>();
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+				auto &bound_expr = BoundExpression::GetExpression(*aggr.children[i]);
+				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.filter) {
 				bool success = aggregate_binder.BindCorrelatedColumns(aggr.filter);
@@ -147,8 +146,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = aggr.filter->Cast<BoundExpression>();
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+				auto &bound_expr = BoundExpression::GetExpression(*aggr.filter);
+				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
 				for (auto &order : aggr.order_bys->orders) {
@@ -156,8 +155,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 					if (!success) {
 						throw BinderException(error);
 					}
-					auto &bound_expr = order.expression->Cast<BoundExpression>();
-					ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+					auto &bound_expr = BoundExpression::GetExpression(*order.expression);
+					ExtractCorrelatedExpressions(binder, *bound_expr);
 				}
 			}
 		} else {
@@ -172,8 +171,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 	}
 
 	if (aggr.filter) {
-		auto &child = (BoundExpression &)*aggr.filter;
-		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child.expr), LogicalType::BOOLEAN);
+		auto &child = BoundExpression::GetExpression(*aggr.filter);
+		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN);
 	}
 
 	// all children bound successfully
@@ -184,29 +183,29 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 
 	if (ordered_set_agg) {
 		for (auto &order : aggr.order_bys->orders) {
-			auto &child = (BoundExpression &)*order.expression;
-			types.push_back(child.expr->return_type);
-			arguments.push_back(child.expr->return_type);
-			children.push_back(std::move(child.expr));
+			auto &child = BoundExpression::GetExpression(*order.expression);
+			types.push_back(child->return_type);
+			arguments.push_back(child->return_type);
+			children.push_back(std::move(child));
 		}
 		aggr.order_bys->orders.clear();
 	}
 
 	for (idx_t i = 0; i < aggr.children.size(); i++) {
-		auto &child = (BoundExpression &)*aggr.children[i];
-		types.push_back(child.expr->return_type);
-		arguments.push_back(child.expr->return_type);
-		children.push_back(std::move(child.expr));
+		auto &child = BoundExpression::GetExpression(*aggr.children[i]);
+		types.push_back(child->return_type);
+		arguments.push_back(child->return_type);
+		children.push_back(std::move(child));
 	}
 
 	// bind the aggregate
 	FunctionBinder function_binder(context);
-	idx_t best_function = function_binder.BindFunction(func->name, func->functions, types, error);
+	idx_t best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
 		throw BinderException(binder.FormatError(aggr, error));
 	}
 	// found a matching function!
-	auto bound_function = func->functions.GetFunctionByOffset(best_function);
+	auto bound_function = func.functions.GetFunctionByOffset(best_function);
 
 	// Bind any sort columns, unless the aggregate is order-insensitive
 	unique_ptr<BoundOrderModifier> order_bys;
@@ -214,10 +213,10 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 		order_bys = make_uniq<BoundOrderModifier>();
 		auto &config = DBConfig::GetConfig(context);
 		for (auto &order : aggr.order_bys->orders) {
-			auto &order_expr = (BoundExpression &)*order.expression;
+			auto &order_expr = BoundExpression::GetExpression(*order.expression);
 			const auto sense = config.ResolveOrder(order.type);
 			const auto null_order = config.ResolveNullOrder(sense, order.null_order);
-			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr.expr));
+			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr));
 		}
 	}
 

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

@@ -18,44 +18,44 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 		return BindResult(error);
 	}
 	// the children have been successfully resolved
-	auto &input = (BoundExpression &)*expr.input;
-	auto &lower = (BoundExpression &)*expr.lower;
-	auto &upper = (BoundExpression &)*expr.upper;
+	auto &input = BoundExpression::GetExpression(*expr.input);
+	auto &lower = BoundExpression::GetExpression(*expr.lower);
+	auto &upper = BoundExpression::GetExpression(*expr.upper);
 
-	auto input_sql_type = input.expr->return_type;
-	auto lower_sql_type = lower.expr->return_type;
-	auto upper_sql_type = upper.expr->return_type;
+	auto input_sql_type = input->return_type;
+	auto lower_sql_type = lower->return_type;
+	auto upper_sql_type = upper->return_type;
 
 	// cast the input types to the same type
 	// now obtain the result type of the input types
 	auto input_type = BoundComparisonExpression::BindComparison(input_sql_type, lower_sql_type);
 	input_type = BoundComparisonExpression::BindComparison(input_type, upper_sql_type);
 	// add casts (if necessary)
-	input.expr = BoundCastExpression::AddCastToType(context, std::move(input.expr), input_type);
-	lower.expr = BoundCastExpression::AddCastToType(context, std::move(lower.expr), input_type);
-	upper.expr = BoundCastExpression::AddCastToType(context, std::move(upper.expr), input_type);
+	input = BoundCastExpression::AddCastToType(context, std::move(input), input_type);
+	lower = BoundCastExpression::AddCastToType(context, std::move(lower), input_type);
+	upper = BoundCastExpression::AddCastToType(context, std::move(upper), input_type);
 	if (input_type.id() == LogicalTypeId::VARCHAR) {
 		// handle collation
 		auto collation = StringType::GetCollation(input_type);
-		input.expr = PushCollation(context, std::move(input.expr), collation, false);
-		lower.expr = PushCollation(context, std::move(lower.expr), collation, false);
-		upper.expr = PushCollation(context, std::move(upper.expr), collation, false);
+		input = PushCollation(context, std::move(input), collation, false);
+		lower = PushCollation(context, std::move(lower), collation, false);
+		upper = PushCollation(context, std::move(upper), collation, false);
 	}
-	if (!input.expr->HasSideEffects() && !input.expr->HasParameter() && !input.expr->HasSubquery()) {
+	if (!input->HasSideEffects() && !input->HasParameter() && !input->HasSubquery()) {
 		// the expression does not have side effects and can be copied: create two comparisons
 		// the reason we do this is that individual comparisons are easier to handle in optimizers
 		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer
 		auto left_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-		                                                         input.expr->Copy(), std::move(lower.expr));
+		                                                         input->Copy(), std::move(lower));
 		auto right_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-		                                                          std::move(input.expr), std::move(upper.expr));
+		                                                          std::move(input), std::move(upper));
 		return BindResult(make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
 		                                                        std::move(left_compare), std::move(right_compare)));
 	} else {
 		// expression has side effects: we cannot duplicate it
 		// create a bound_between directly
-		return BindResult(make_uniq<BoundBetweenExpression>(std::move(input.expr), std::move(lower.expr),
-		                                                    std::move(upper.expr), true, true));
+		return BindResult(
+		    make_uniq<BoundBetweenExpression>(std::move(input), std::move(lower), std::move(upper), true, true));
 	}
 }
 

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

@@ -18,26 +18,26 @@ BindResult ExpressionBinder::BindExpression(CaseExpression &expr, idx_t depth) {
 	}
 	// the children have been successfully resolved
 	// figure out the result type of the CASE expression
-	auto return_type = ((BoundExpression &)*expr.else_expr).expr->return_type;
+	auto &else_expr = BoundExpression::GetExpression(*expr.else_expr);
+	auto return_type = else_expr->return_type;
 	for (auto &check : expr.case_checks) {
-		auto &then_expr = (BoundExpression &)*check.then_expr;
-		return_type = LogicalType::MaxLogicalType(return_type, then_expr.expr->return_type);
+		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
+		return_type = LogicalType::MaxLogicalType(return_type, then_expr->return_type);
 	}
 
 	// bind all the individual components of the CASE statement
 	auto result = make_uniq<BoundCaseExpression>(return_type);
 	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
 		auto &check = expr.case_checks[i];
-		auto &when_expr = (BoundExpression &)*check.when_expr;
-		auto &then_expr = (BoundExpression &)*check.then_expr;
+		auto &when_expr = BoundExpression::GetExpression(*check.when_expr);
+		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
 		BoundCaseCheck result_check;
 		result_check.when_expr =
-		    BoundCastExpression::AddCastToType(context, std::move(when_expr.expr), LogicalType::BOOLEAN);
-		result_check.then_expr = BoundCastExpression::AddCastToType(context, std::move(then_expr.expr), return_type);
+		    BoundCastExpression::AddCastToType(context, std::move(when_expr), LogicalType::BOOLEAN);
+		result_check.then_expr = BoundCastExpression::AddCastToType(context, std::move(then_expr), return_type);
 		result->case_checks.push_back(std::move(result_check));
 	}
-	auto &else_expr = (BoundExpression &)*expr.else_expr;
-	result->else_expr = BoundCastExpression::AddCastToType(context, std::move(else_expr.expr), return_type);
+	result->else_expr = BoundCastExpression::AddCastToType(context, std::move(else_expr), return_type);
 	return BindResult(std::move(result));
 }
 } // namespace duckdb

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

@@ -16,17 +16,17 @@ BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	// Right now just considering its DEFAULT_SCHEMA always
 	Binder::BindLogicalType(context, expr.cast_type);
 	// the children have been successfully resolved
-	auto &child = (BoundExpression &)*expr.child;
+	auto &child = BoundExpression::GetExpression(*expr.child);
 	if (expr.try_cast) {
-		if (child.expr->return_type == expr.cast_type) {
+		if (child->return_type == expr.cast_type) {
 			// no cast required: type matches
-			return BindResult(std::move(child.expr));
+			return BindResult(std::move(child));
 		}
-		child.expr = BoundCastExpression::AddCastToType(context, std::move(child.expr), expr.cast_type, true);
+		child = BoundCastExpression::AddCastToType(context, std::move(child), expr.cast_type, true);
 	} else {
 		// otherwise add a cast to the target type
-		child.expr = BoundCastExpression::AddCastToType(context, std::move(child.expr), expr.cast_type);
+		child = BoundCastExpression::AddCastToType(context, std::move(child), expr.cast_type);
 	}
-	return BindResult(std::move(child.expr));
+	return BindResult(std::move(child));
 }
 } // namespace duckdb

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

@@ -10,17 +10,17 @@ BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth
 	if (!error.empty()) {
 		return BindResult(error);
 	}
-	auto &child = expr.child->Cast<BoundExpression>();
-	if (child.expr->HasParameter()) {
+	auto &child = BoundExpression::GetExpression(*expr.child);
+	if (child->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}
-	if (child.expr->return_type.id() != LogicalTypeId::VARCHAR) {
+	if (child->return_type.id() != LogicalTypeId::VARCHAR) {
 		throw BinderException("collations are only supported for type varchar");
 	}
 	// Validate the collation, but don't use it
-	PushCollation(context, child.expr->Copy(), expr.collation, false);
-	child.expr->return_type = LogicalType::VARCHAR_COLLATION(expr.collation);
-	return BindResult(std::move(child.expr));
+	PushCollation(context, child->Copy(), expr.collation, false);
+	child->return_type = LogicalType::VARCHAR_COLLATION(expr.collation);
+	return BindResult(std::move(child));
 }
 
 } // namespace duckdb

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

@@ -204,13 +204,13 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpress
 		}
 		if (colref.column_names.size() == 2) {
 			auto &qualifier = colref.column_names[0];
-			if (catalog_entry->catalog->GetName() != qualifier && catalog_entry->schema->name != qualifier) {
+			if (catalog_entry->catalog.GetName() != qualifier && catalog_entry->schema.name != qualifier) {
 				return nullptr;
 			}
 		} else if (colref.column_names.size() == 3) {
 			auto &catalog_name = colref.column_names[0];
 			auto &schema_name = colref.column_names[1];
-			if (catalog_entry->catalog->GetName() != catalog_name || catalog_entry->schema->name != schema_name) {
+			if (catalog_entry->catalog.GetName() != catalog_name || catalog_entry->schema.name != schema_name) {
 				return nullptr;
 			}
 		} else {

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

@@ -35,28 +35,29 @@ unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, u
 	}
 	auto &catalog = Catalog::GetSystemCatalog(context);
 	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
-	vector<CollateCatalogEntry *> entries;
+	vector<reference<CollateCatalogEntry>> entries;
 	for (auto &collation_argument : splits) {
-		auto collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
-		if (collation_entry->combinable) {
+		auto &collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
+		if (collation_entry.combinable) {
 			entries.insert(entries.begin(), collation_entry);
 		} else {
-			if (!entries.empty() && !entries.back()->combinable) {
-				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back()->name,
-				                      collation_entry->name);
+			if (!entries.empty() && !entries.back().get().combinable) {
+				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back().get().name,
+				                      collation_entry.name);
 			}
 			entries.push_back(collation_entry);
 		}
 	}
-	for (auto &collation_entry : entries) {
-		if (equality_only && collation_entry->not_required_for_equality) {
+	for (auto &entry : entries) {
+		auto &collation_entry = entry.get();
+		if (equality_only && collation_entry.not_required_for_equality) {
 			continue;
 		}
 		vector<unique_ptr<Expression>> children;
 		children.push_back(std::move(source));
 
 		FunctionBinder function_binder(context);
-		auto function = function_binder.BindScalarFunction(collation_entry->function, std::move(children));
+		auto function = function_binder.BindScalarFunction(collation_entry.function, std::move(children));
 		source = std::move(function);
 	}
 	return source;
@@ -119,28 +120,27 @@ BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t de
 		return BindResult(error);
 	}
 	// the children have been successfully resolved
-	auto &left = (BoundExpression &)*expr.left;
-	auto &right = (BoundExpression &)*expr.right;
-	auto left_sql_type = left.expr->return_type;
-	auto right_sql_type = right.expr->return_type;
+	auto &left = BoundExpression::GetExpression(*expr.left);
+	auto &right = BoundExpression::GetExpression(*expr.right);
+	auto left_sql_type = left->return_type;
+	auto right_sql_type = right->return_type;
 	// cast the input types to the same type
 	// now obtain the result type of the input types
 	auto input_type = BoundComparisonExpression::BindComparison(left_sql_type, right_sql_type);
 	// add casts (if necessary)
-	left.expr = BoundCastExpression::AddCastToType(context, std::move(left.expr), input_type,
-	                                               input_type.id() == LogicalTypeId::ENUM);
-	right.expr = BoundCastExpression::AddCastToType(context, std::move(right.expr), input_type,
-	                                                input_type.id() == LogicalTypeId::ENUM);
+	left = BoundCastExpression::AddCastToType(context, std::move(left), input_type,
+	                                          input_type.id() == LogicalTypeId::ENUM);
+	right = BoundCastExpression::AddCastToType(context, std::move(right), input_type,
+	                                           input_type.id() == LogicalTypeId::ENUM);
 
 	if (input_type.id() == LogicalTypeId::VARCHAR) {
 		// handle collation
 		auto collation = StringType::GetCollation(input_type);
-		left.expr = PushCollation(context, std::move(left.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
-		right.expr =
-		    PushCollation(context, std::move(right.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
+		left = PushCollation(context, std::move(left), collation, expr.type == ExpressionType::COMPARE_EQUAL);
+		right = PushCollation(context, std::move(right), collation, expr.type == ExpressionType::COMPARE_EQUAL);
 	}
 	// now create the bound comparison expression
-	return BindResult(make_uniq<BoundComparisonExpression>(expr.type, std::move(left.expr), std::move(right.expr)));
+	return BindResult(make_uniq<BoundComparisonExpression>(expr.type, std::move(left), std::move(right)));
 }
 
 } // namespace duckdb

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

@@ -19,9 +19,8 @@ BindResult ExpressionBinder::BindExpression(ConjunctionExpression &expr, idx_t d
 	// and construct the bound conjunction expression
 	auto result = make_uniq<BoundConjunctionExpression>(expr.type);
 	for (auto &child_expr : expr.children) {
-		auto &child = (BoundExpression &)*child_expr;
-		result->children.push_back(
-		    BoundCastExpression::AddCastToType(context, std::move(child.expr), LogicalType::BOOLEAN));
+		auto &child = BoundExpression::GetExpression(*child_expr);
+		result->children.push_back(BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN));
 	}
 	// now create the bound conjunction expression
 	return BindResult(std::move(result));