duckdb 0.7.2-dev1457.0 → 0.7.2-dev1533.0

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

@@ -113,43 +113,43 @@ bool SelectNode::Equals(const QueryNode *other_p) const {
 	if (this == other_p) {
 		return true;
 	}
-	auto other = (SelectNode *)other_p;
+	auto &other = other_p->Cast<SelectNode>();
 
 	// SELECT
-	if (!ExpressionUtil::ListEquals(select_list, other->select_list)) {
+	if (!ExpressionUtil::ListEquals(select_list, other.select_list)) {
 		return false;
 	}
 	// FROM
 	if (from_table) {
 		// we have a FROM clause, compare to the other one
-		if (!from_table->Equals(other->from_table.get())) {
+		if (!from_table->Equals(other.from_table.get())) {
 			return false;
 		}
-	} else if (other->from_table) {
+	} else if (other.from_table) {
 		// we don't have a FROM clause, if the other statement has one they are
 		// not equal
 		return false;
 	}
 	// WHERE
-	if (!BaseExpression::Equals(where_clause.get(), other->where_clause.get())) {
+	if (!BaseExpression::Equals(where_clause.get(), other.where_clause.get())) {
 		return false;
 	}
 	// GROUP BY
-	if (!ExpressionUtil::ListEquals(groups.group_expressions, other->groups.group_expressions)) {
+	if (!ExpressionUtil::ListEquals(groups.group_expressions, other.groups.group_expressions)) {
 		return false;
 	}
-	if (groups.grouping_sets != other->groups.grouping_sets) {
+	if (groups.grouping_sets != other.groups.grouping_sets) {
 		return false;
 	}
-	if (!SampleOptions::Equals(sample.get(), other->sample.get())) {
+	if (!SampleOptions::Equals(sample.get(), other.sample.get())) {
 		return false;
 	}
 	// HAVING
-	if (!BaseExpression::Equals(having.get(), other->having.get())) {
+	if (!BaseExpression::Equals(having.get(), other.having.get())) {
 		return false;
 	}
 	// QUALIFY
-	if (!BaseExpression::Equals(qualify.get(), other->qualify.get())) {
+	if (!BaseExpression::Equals(qualify.get(), other.qualify.get())) {
 		return false;
 	}
 	return true;

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

@@ -47,14 +47,14 @@ bool SetOperationNode::Equals(const QueryNode *other_p) const {
 	if (this == other_p) {
 		return true;
 	}
-	auto other = (SetOperationNode *)other_p;
-	if (setop_type != other->setop_type) {
+	auto &other = other_p->Cast<SetOperationNode>();
+	if (setop_type != other.setop_type) {
 		return false;
 	}
-	if (!left->Equals(other->left.get())) {
+	if (!left->Equals(other.left.get())) {
 		return false;
 	}
-	if (!right->Equals(other->right.get())) {
+	if (!right->Equals(other.right.get())) {
 		return false;
 	}
 	return true;

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

@@ -159,7 +159,7 @@ ExpressionListRef *InsertStatement::GetValuesList() const {
 	if (select_statement->node->type != QueryNodeType::SELECT_NODE) {
 		return nullptr;
 	}
-	auto &node = (SelectNode &)*select_statement->node;
+	auto &node = select_statement->node->Cast<SelectNode>();
 	if (node.where_clause || node.qualify || node.having) {
 		return nullptr;
 	}

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

@@ -37,8 +37,8 @@ bool SelectStatement::Equals(const SQLStatement *other_p) const {
 	if (type != other_p->type) {
 		return false;
 	}
-	auto other = (SelectStatement *)other_p;
-	return node->Equals(other->node.get());
+	auto &other = other_p->Cast<SelectStatement>();
+	return node->Equals(other.node.get());
 }
 
 string SelectStatement::ToString() const {

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

@@ -55,7 +55,7 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			if (function->type != ExpressionType::FUNCTION) {
 				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
 			}
-			auto &f = (FunctionExpression &)*function;
+			auto &f = function->Cast<FunctionExpression>();
 			f.children.insert(f.children.begin(), std::move(result));
 			result = std::move(function);
 			break;

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

@@ -44,9 +44,9 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 		D_ASSERT(result->replace_list.empty());
 		result->expr = TransformExpression(star->expr);
 		if (result->expr->type == ExpressionType::STAR) {
-			auto child_star = (StarExpression *)result->expr.get();
-			result->exclude_list = std::move(child_star->exclude_list);
-			result->replace_list = std::move(child_star->replace_list);
+			auto &child_star = result->expr->Cast<StarExpression>();
+			result->exclude_list = std::move(child_star.exclude_list);
+			result->replace_list = std::move(child_star.replace_list);
 			result->expr.reset();
 		} else if (result->expr->type == ExpressionType::LAMBDA) {
 			vector<unique_ptr<ParsedExpression>> children;

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

@@ -72,7 +72,7 @@ bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {
 	if (expr.expression_class != ExpressionClass::STAR) {
 		return false;
 	}
-	auto &star = (StarExpression &)expr;
+	auto &star = expr.Cast<StarExpression>();
 	if (!star.columns && star.exclude_list.empty() && star.replace_list.empty()) {
 		return true;
 	}
@@ -316,48 +316,8 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 	return std::move(function);
 }
 
-static string SQLValueOpToString(duckdb_libpgquery::PGSQLValueFunctionOp op) {
-	switch (op) {
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_DATE:
-		return "current_date";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIME:
-		return "get_current_time";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIME_N:
-		return "current_time_n";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIMESTAMP:
-		return "get_current_timestamp";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_TIMESTAMP_N:
-		return "current_timestamp_n";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIME:
-		return "current_localtime";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIME_N:
-		return "current_localtime_n";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIMESTAMP:
-		return "current_localtimestamp";
-	case duckdb_libpgquery::PG_SVFOP_LOCALTIMESTAMP_N:
-		return "current_localtimestamp_n";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_ROLE:
-		return "current_role";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_USER:
-		return "current_user";
-	case duckdb_libpgquery::PG_SVFOP_USER:
-		return "user";
-	case duckdb_libpgquery::PG_SVFOP_SESSION_USER:
-		return "session_user";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_CATALOG:
-		return "current_catalog";
-	case duckdb_libpgquery::PG_SVFOP_CURRENT_SCHEMA:
-		return "current_schema";
-	default:
-		throw InternalException("Could not find named SQL value function specification " + to_string((int)op));
-	}
-}
-
 unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node) {
-	D_ASSERT(node);
-	vector<unique_ptr<ParsedExpression>> children;
-	auto fname = SQLValueOpToString(node->op);
-	return make_uniq<FunctionExpression>(fname, std::move(children));
+	throw InternalException("SQL value functions should not be emitted by the parser");
 }
 
 } // namespace duckdb

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

@@ -149,7 +149,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		if (similar_func.children[1]->type != ExpressionType::VALUE_CONSTANT) {
 			throw NotImplementedException("Custom escape in SIMILAR TO");
 		}
-		auto &constant = (ConstantExpression &)*similar_func.children[1];
+		auto &constant = similar_func.children[1]->Cast<ConstantExpression>();
 		if (!constant.value.IsNull()) {
 			throw NotImplementedException("Custom escape in SIMILAR TO");
 		}

package/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp

@@ -41,7 +41,7 @@ static void MergeGroupingSet(GroupingSet &result, GroupingSet &other) {
 void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression, GroupingExpressionMap &map,
                                        GroupByNode &result, vector<idx_t> &result_set) {
 	if (expression->type == ExpressionType::FUNCTION) {
-		auto &func = (FunctionExpression &)*expression;
+		auto &func = expression->Cast<FunctionExpression>();
 		if (func.function_name == "row") {
 			for (auto &child : func.children) {
 				AddGroupByExpression(std::move(child), map, result, result_set);

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

@@ -64,7 +64,6 @@ unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::
 
 	case duckdb_libpgquery::PG_NEWTYPE_ALIAS: {
 		LogicalType target_type = TransformTypeName(stmt->ofType);
-		target_type.SetAlias(info->name);
 		info->type = target_type;
 	} break;
 

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

@@ -10,6 +10,7 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/parser/parsed_data/drop_info.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/result_modifier.hpp"
@@ -58,15 +59,17 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 	// generate the query that will result in the enum creation
 	auto select_node = std::move(entry->base);
 	auto columnref = entry->column->Copy();
-	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, columnref->Copy());
+	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
 	select_node->select_list.push_back(std::move(cast));
 
 	auto is_not_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
 	select_node->where_clause = std::move(is_not_null);
 
 	// order by the column
+	select_node->modifiers.push_back(make_uniq<DistinctModifier>());
 	auto modifier = make_uniq<OrderModifier>();
-	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(columnref));
+	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
+	                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
 	select_node->modifiers.push_back(std::move(modifier));
 
 	auto select = make_uniq<SelectStatement>();

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

@@ -23,21 +23,21 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode
 			auto expr = TransformExpression(node);
 
 			if (expr->type == ExpressionType::COMPARE_EQUAL) {
-				auto &comp = (ComparisonExpression &)*expr;
+				auto &comp = expr->Cast<ComparisonExpression>();
 				if (comp.right->type != ExpressionType::VALUE_CONSTANT) {
 					throw ParserException("Named parameter requires a constant on the RHS");
 				}
 				if (comp.left->type != ExpressionType::COLUMN_REF) {
 					throw ParserException("Named parameter requires a column reference on the LHS");
 				}
-				auto &columnref = (ColumnRefExpression &)*comp.left;
-				auto &constant = (ConstantExpression &)*comp.right;
+				auto &columnref = comp.left->Cast<ColumnRefExpression>();
+				auto &constant = comp.right->Cast<ConstantExpression>();
 				info.named_parameters[columnref.GetName()] = constant.value;
 			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
 				auto constant = TransformConstant((duckdb_libpgquery::PGAConst *)node);
-				info.parameters.push_back(((ConstantExpression &)*constant).value);
+				info.parameters.push_back((constant->Cast<ConstantExpression>()).value);
 			} else if (expr->type == ExpressionType::COLUMN_REF) {
-				auto &colref = (ColumnRefExpression &)*expr;
+				auto &colref = expr->Cast<ColumnRefExpression>();
 				if (!colref.IsQualified()) {
 					info.parameters.emplace_back(colref.GetColumnName());
 				} else {

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

@@ -17,7 +17,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	switch (stmt->op) {
 	case duckdb_libpgquery::PG_SETOP_NONE: {
 		node = make_uniq<SelectNode>();
-		auto result = (SelectNode *)node.get();
+		auto &result = node->Cast<SelectNode>();
 		if (stmt->withClause) {
 			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
 		}
@@ -44,34 +44,34 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 				//  add the columns defined in the ON clause to the select list
 				TransformExpressionList(*stmt->distinctClause, modifier->distinct_on_targets);
 			}
-			result->modifiers.push_back(std::move(modifier));
+			result.modifiers.push_back(std::move(modifier));
 		}
 
 		// do this early so the value lists also have a `FROM`
 		if (stmt->valuesLists) {
 			// VALUES list, create an ExpressionList
 			D_ASSERT(!stmt->fromClause);
-			result->from_table = TransformValuesList(stmt->valuesLists);
-			result->select_list.push_back(make_uniq<StarExpression>());
+			result.from_table = TransformValuesList(stmt->valuesLists);
+			result.select_list.push_back(make_uniq<StarExpression>());
 		} else {
 			if (!stmt->targetList) {
 				throw ParserException("SELECT clause without selection list");
 			}
 			// select list
-			TransformExpressionList(*stmt->targetList, result->select_list);
-			result->from_table = TransformFrom(stmt->fromClause);
+			TransformExpressionList(*stmt->targetList, result.select_list);
+			result.from_table = TransformFrom(stmt->fromClause);
 		}
 
 		// where
-		result->where_clause = TransformExpression(stmt->whereClause);
+		result.where_clause = TransformExpression(stmt->whereClause);
 		// group by
-		TransformGroupBy(stmt->groupClause, *result);
+		TransformGroupBy(stmt->groupClause, result);
 		// having
-		result->having = TransformExpression(stmt->havingClause);
+		result.having = TransformExpression(stmt->havingClause);
 		// qualify
-		result->qualify = TransformExpression(stmt->qualifyClause);
+		result.qualify = TransformExpression(stmt->qualifyClause);
 		// sample
-		result->sample = TransformSampleOptions(stmt->sampleOptions);
+		result.sample = TransformSampleOptions(stmt->sampleOptions);
 		break;
 	}
 	case duckdb_libpgquery::PG_SETOP_UNION:
@@ -79,13 +79,13 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	case duckdb_libpgquery::PG_SETOP_INTERSECT:
 	case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME: {
 		node = make_uniq<SetOperationNode>();
-		auto result = (SetOperationNode *)node.get();
+		auto &result = node->Cast<SetOperationNode>();
 		if (stmt->withClause) {
 			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
 		}
-		result->left = TransformSelectNode(stmt->larg);
-		result->right = TransformSelectNode(stmt->rarg);
-		if (!result->left || !result->right) {
+		result.left = TransformSelectNode(stmt->larg);
+		result.right = TransformSelectNode(stmt->rarg);
+		if (!result.left || !result.right) {
 			throw Exception("Failed to transform setop children.");
 		}
 
@@ -93,23 +93,23 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 		switch (stmt->op) {
 		case duckdb_libpgquery::PG_SETOP_UNION:
 			select_distinct = !stmt->all;
-			result->setop_type = SetOperationType::UNION;
+			result.setop_type = SetOperationType::UNION;
 			break;
 		case duckdb_libpgquery::PG_SETOP_EXCEPT:
-			result->setop_type = SetOperationType::EXCEPT;
+			result.setop_type = SetOperationType::EXCEPT;
 			break;
 		case duckdb_libpgquery::PG_SETOP_INTERSECT:
-			result->setop_type = SetOperationType::INTERSECT;
+			result.setop_type = SetOperationType::INTERSECT;
 			break;
 		case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME:
 			select_distinct = !stmt->all;
-			result->setop_type = SetOperationType::UNION_BY_NAME;
+			result.setop_type = SetOperationType::UNION_BY_NAME;
 			break;
 		default:
 			throw Exception("Unexpected setop type");
 		}
 		if (select_distinct) {
-			result->modifiers.push_back(make_uniq<DistinctModifier>());
+			result.modifiers.push_back(make_uniq<DistinctModifier>());
 		}
 		if (stmt->sampleOptions) {
 			throw ParserException("SAMPLE clause is only allowed in regular SELECT statements");

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -9,16 +9,16 @@ namespace duckdb {
 
 static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry = true) {
 	if (expr->type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		if (colref.IsQualified()) {
 			throw ParserException("PIVOT IN list cannot contain qualified column references");
 		}
 		entry.values.emplace_back(colref.GetColumnName());
 	} else if (expr->type == ExpressionType::VALUE_CONSTANT) {
-		auto &constant_expr = (ConstantExpression &)*expr;
+		auto &constant_expr = expr->Cast<ConstantExpression>();
 		entry.values.push_back(std::move(constant_expr.value));
 	} else if (root_entry && expr->type == ExpressionType::FUNCTION) {
-		auto &function = (FunctionExpression &)*expr;
+		auto &function = expr->Cast<FunctionExpression>();
 		if (function.function_name != "row") {
 			throw ParserException("PIVOT IN list must contain columns or lists of columns");
 		}

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

@@ -421,6 +421,17 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 	}
 }
 
+void BindContext::GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types) {
+	for (auto &binding_entry : bindings_list) {
+		auto &binding = *binding_entry.second;
+		D_ASSERT(binding.names.size() == binding.types.size());
+		for (idx_t i = 0; i < binding.names.size(); i++) {
+			result_names.push_back(binding.names[i]);
+			result_types.push_back(binding.types[i]);
+		}
+	}
+}
+
 void BindContext::AddBinding(const string &alias, unique_ptr<Binding> binding) {
 	if (bindings.find(alias) != bindings.end()) {
 		throw BinderException("Duplicate alias \"%s\" in query!", alias);

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

@@ -17,6 +17,44 @@
 
 namespace duckdb {
 
+string GetSQLValueFunctionName(const string &column_name) {
+	auto lcase = StringUtil::Lower(column_name);
+	if (lcase == "current_catalog") {
+		return "current_catalog";
+	} else if (lcase == "current_date") {
+		return "current_date";
+	} else if (lcase == "current_schema") {
+		return "current_schema";
+	} else if (lcase == "current_role") {
+		return "current_role";
+	} else if (lcase == "current_time") {
+		return "get_current_time";
+	} else if (lcase == "current_timestamp") {
+		return "get_current_timestamp";
+	} else if (lcase == "current_user") {
+		return "current_user";
+	} else if (lcase == "localtime") {
+		return "current_localtime";
+	} else if (lcase == "localtimestamp") {
+		return "current_localtimestamp";
+	} else if (lcase == "session_user") {
+		return "session_user";
+	} else if (lcase == "user") {
+		return "user";
+	}
+	return string();
+}
+
+unique_ptr<ParsedExpression> ExpressionBinder::GetSQLValueFunction(const string &column_name) {
+	auto value_function = GetSQLValueFunctionName(column_name);
+	if (value_function.empty()) {
+		return nullptr;
+	}
+
+	vector<unique_ptr<ParsedExpression>> children;
+	return make_uniq<FunctionExpression>(value_function, std::move(children));
+}
+
 unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &column_name, string &error_message) {
 	auto using_binding = binder.bind_context.GetUsingBinding(column_name);
 	if (using_binding) {
@@ -70,6 +108,11 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &c
 	}
 	// see if it's a column
 	if (table_name.empty()) {
+		// column was not found - check if it is a SQL value function
+		auto value_function = GetSQLValueFunction(column_name);
+		if (value_function) {
+			return value_function;
+		}
 		// it's not, find candidates and error
 		auto similar_bindings = binder.bind_context.GetSimilarBindings(column_name);
 		string candidate_str = StringUtil::CandidatesMessage(similar_bindings, "Candidate bindings");
@@ -83,7 +126,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &c
 void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr) {
 	switch (expr->type) {
 	case ExpressionType::COLUMN_REF: {
-		auto &colref = (ColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		string error_message;
 		auto new_expr = QualifyColumnName(colref, error_message);
 		if (new_expr) {
@@ -96,7 +139,7 @@ void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr) {
 		break;
 	}
 	case ExpressionType::POSITIONAL_REFERENCE: {
-		auto &ref = (PositionalReferenceExpression &)*expr;
+		auto &ref = expr->Cast<PositionalReferenceExpression>();
 		if (ref.alias.empty()) {
 			string table_name, column_name;
 			auto error = binder.bind_context.BindColumn(ref, table_name, column_name);
@@ -124,7 +167,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<Pa
 	// we need to transform the struct extract if it is inside a lambda expression
 	// because we cannot bind to an existing table, so we remove the dummy table also
 	if (lambda_bindings && base->type == ExpressionType::COLUMN_REF) {
-		auto &lambda_column_ref = (ColumnRefExpression &)*base;
+		auto &lambda_column_ref = base->Cast<ColumnRefExpression>();
 		D_ASSERT(!lambda_column_ref.column_names.empty());
 
 		if (lambda_column_ref.column_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
@@ -304,7 +347,7 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 		return result;
 	}
 
-	auto &colref = (ColumnRefExpression &)*expr;
+	auto &colref = expr->Cast<ColumnRefExpression>();
 	D_ASSERT(colref.IsQualified());
 	auto &table_name = colref.GetTableName();
 

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

@@ -155,7 +155,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	}
 
 	// bind the lambda parameter
-	auto &lambda_expr = (LambdaExpression &)*function.children[1];
+	auto &lambda_expr = function.children[1]->Cast<LambdaExpression>();
 	BindResult bind_lambda_result = BindExpression(lambda_expr, depth, true, list_child_type);
 
 	if (bind_lambda_result.HasError()) {
@@ -164,11 +164,10 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 		// successfully bound: replace the node with a BoundExpression
 		auto alias = function.children[1]->alias;
 		function.children[1] = make_uniq<BoundExpression>(std::move(bind_lambda_result.expression));
-		auto be = (BoundExpression *)function.children[1].get();
-		D_ASSERT(be);
-		be->alias = alias;
+		auto &be = function.children[1]->Cast<BoundExpression>();
+		be.alias = alias;
 		if (!alias.empty()) {
-			be->expr->alias = alias;
+			be.expr->alias = alias;
 		}
 	}
 
@@ -199,7 +198,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 		throw BinderException(binder.FormatError(function, error));
 	}
 
-	auto &bound_function_expr = (BoundFunctionExpression &)*result;
+	auto &bound_function_expr = result->Cast<BoundFunctionExpression>();
 	D_ASSERT(bound_function_expr.children.size() == 2);
 
 	// remove the lambda expression from the children

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

@@ -34,7 +34,7 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	if (expr.lhs->expression_class == ExpressionClass::COLUMN_REF) {
 		expr.params.push_back(std::move(expr.lhs));
 	} else {
-		auto &func_expr = (FunctionExpression &)*expr.lhs;
+		auto &func_expr = expr.lhs->Cast<FunctionExpression>();
 		for (idx_t i = 0; i < func_expr.children.size(); i++) {
 			expr.params.push_back(std::move(func_expr.children[i]));
 		}
@@ -52,7 +52,7 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 			throw BinderException("Parameter must be a column name.");
 		}
 
-		auto column_ref = (ColumnRefExpression &)*expr.params[i];
+		auto column_ref = expr.params[i]->Cast<ColumnRefExpression>();
 		if (column_ref.IsQualified()) {
 			throw BinderException("Invalid parameter name '%s': must be unqualified", column_ref.ToString());
 		}

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

@@ -13,7 +13,7 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF: {
 		// if expr is a parameter, replace it with its argument
-		auto &colref = (ColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		bool bind_macro_parameter = false;
 		if (colref.IsQualified()) {
 			bind_macro_parameter = false;
@@ -31,7 +31,7 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	}
 	case ExpressionClass::SUBQUERY: {
 		// replacing parameters within a subquery is slightly different
-		auto &sq = ((SubqueryExpression &)*expr).subquery;
+		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
 		ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 		break;
@@ -65,7 +65,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	// positional parameters
 	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
 		types.emplace_back(LogicalType::SQLNULL);
-		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
+		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
 		names.push_back(param.GetColumnName());
 	}
 	// default parameters

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

@@ -12,10 +12,10 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
                                 bool in_columns) {
 	bool has_star = false;
 	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
-		auto current_star = (StarExpression *)expr.get();
-		if (!current_star->columns) {
+		auto &current_star = expr->Cast<StarExpression>();
+		if (!current_star.columns) {
 			if (is_root) {
-				*star = current_star;
+				*star = &current_star;
 				return true;
 			}
 			if (!in_columns) {
@@ -23,12 +23,12 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 				    "STAR expression is only allowed as the root element of an expression. Use COLUMNS(*) instead.");
 			}
 			// star expression inside a COLUMNS - convert to a constant list
-			if (!current_star->replace_list.empty()) {
+			if (!current_star.replace_list.empty()) {
 				throw BinderException(
 				    "STAR expression with REPLACE list is only allowed as the root element of COLUMNS");
 			}
 			vector<unique_ptr<ParsedExpression>> star_list;
-			bind_context.GenerateAllColumnExpressions(*current_star, star_list);
+			bind_context.GenerateAllColumnExpressions(current_star, star_list);
 
 			vector<Value> values;
 			values.reserve(star_list.size());
@@ -46,13 +46,13 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 		in_columns = true;
 		if (*star) {
 			// we can have multiple
-			if (!StarExpression::Equal(*star, current_star)) {
+			if (!StarExpression::Equal(*star, &current_star)) {
 				throw BinderException(
 				    FormatError(*expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
 			}
 			return true;
 		}
-		*star = current_star;
+		*star = &current_star;
 		has_star = true;
 	}
 	ParsedExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<ParsedExpression> &child_expr) {
@@ -118,7 +118,7 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			}
 			vector<unique_ptr<ParsedExpression>> new_list;
 			for (idx_t i = 0; i < star_list.size(); i++) {
-				auto &colref = (ColumnRefExpression &)*star_list[i];
+				auto &colref = star_list[i]->Cast<ColumnRefExpression>();
 				if (!RE2::PartialMatch(colref.GetColumnName(), regex)) {
 					continue;
 				}