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

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

@@ -6,15 +6,16 @@
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/list.hpp"
-#include "duckdb/parser/tableref/joinref.hpp"
+#include "duckdb/parser/tableref/list.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/bound_tableref.hpp"
+#include "duckdb/planner/tableref/list.hpp"
+#include "duckdb/planner/query_node/list.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/planner/expression_binder/returning_binder.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
+#include "duckdb/parser/query_node/list.hpp"
 
 #include <algorithm>
 
@@ -46,53 +47,53 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 	root_statement = &statement;
 	switch (statement.type) {
 	case StatementType::SELECT_STATEMENT:
-		return Bind((SelectStatement &)statement);
+		return Bind(statement.Cast<SelectStatement>());
 	case StatementType::INSERT_STATEMENT:
-		return Bind((InsertStatement &)statement);
+		return Bind(statement.Cast<InsertStatement>());
 	case StatementType::COPY_STATEMENT:
-		return Bind((CopyStatement &)statement);
+		return Bind(statement.Cast<CopyStatement>());
 	case StatementType::DELETE_STATEMENT:
-		return Bind((DeleteStatement &)statement);
+		return Bind(statement.Cast<DeleteStatement>());
 	case StatementType::UPDATE_STATEMENT:
-		return Bind((UpdateStatement &)statement);
+		return Bind(statement.Cast<UpdateStatement>());
 	case StatementType::RELATION_STATEMENT:
-		return Bind((RelationStatement &)statement);
+		return Bind(statement.Cast<RelationStatement>());
 	case StatementType::CREATE_STATEMENT:
-		return Bind((CreateStatement &)statement);
+		return Bind(statement.Cast<CreateStatement>());
 	case StatementType::DROP_STATEMENT:
-		return Bind((DropStatement &)statement);
+		return Bind(statement.Cast<DropStatement>());
 	case StatementType::ALTER_STATEMENT:
-		return Bind((AlterStatement &)statement);
+		return Bind(statement.Cast<AlterStatement>());
 	case StatementType::TRANSACTION_STATEMENT:
-		return Bind((TransactionStatement &)statement);
+		return Bind(statement.Cast<TransactionStatement>());
 	case StatementType::PRAGMA_STATEMENT:
-		return Bind((PragmaStatement &)statement);
+		return Bind(statement.Cast<PragmaStatement>());
 	case StatementType::EXPLAIN_STATEMENT:
-		return Bind((ExplainStatement &)statement);
+		return Bind(statement.Cast<ExplainStatement>());
 	case StatementType::VACUUM_STATEMENT:
-		return Bind((VacuumStatement &)statement);
+		return Bind(statement.Cast<VacuumStatement>());
 	case StatementType::SHOW_STATEMENT:
-		return Bind((ShowStatement &)statement);
+		return Bind(statement.Cast<ShowStatement>());
 	case StatementType::CALL_STATEMENT:
-		return Bind((CallStatement &)statement);
+		return Bind(statement.Cast<CallStatement>());
 	case StatementType::EXPORT_STATEMENT:
-		return Bind((ExportStatement &)statement);
+		return Bind(statement.Cast<ExportStatement>());
 	case StatementType::SET_STATEMENT:
-		return Bind((SetStatement &)statement);
+		return Bind(statement.Cast<SetStatement>());
 	case StatementType::LOAD_STATEMENT:
-		return Bind((LoadStatement &)statement);
+		return Bind(statement.Cast<LoadStatement>());
 	case StatementType::EXTENSION_STATEMENT:
-		return Bind((ExtensionStatement &)statement);
+		return Bind(statement.Cast<ExtensionStatement>());
 	case StatementType::PREPARE_STATEMENT:
-		return Bind((PrepareStatement &)statement);
+		return Bind(statement.Cast<PrepareStatement>());
 	case StatementType::EXECUTE_STATEMENT:
-		return Bind((ExecuteStatement &)statement);
+		return Bind(statement.Cast<ExecuteStatement>());
 	case StatementType::LOGICAL_PLAN_STATEMENT:
-		return Bind((LogicalPlanStatement &)statement);
+		return Bind(statement.Cast<LogicalPlanStatement>());
 	case StatementType::ATTACH_STATEMENT:
-		return Bind((AttachStatement &)statement);
+		return Bind(statement.Cast<AttachStatement>());
 	case StatementType::DETACH_STATEMENT:
-		return Bind((DetachStatement &)statement);
+		return Bind(statement.Cast<DetachStatement>());
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));
@@ -112,14 +113,14 @@ unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
 	unique_ptr<BoundQueryNode> result;
 	switch (node.type) {
 	case QueryNodeType::SELECT_NODE:
-		result = BindNode((SelectNode &)node);
+		result = BindNode(node.Cast<SelectNode>());
 		break;
 	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = BindNode((RecursiveCTENode &)node);
+		result = BindNode(node.Cast<RecursiveCTENode>());
 		break;
 	default:
 		D_ASSERT(node.type == QueryNodeType::SET_OPERATION_NODE);
-		result = BindNode((SetOperationNode &)node);
+		result = BindNode(node.Cast<SetOperationNode>());
 		break;
 	}
 	return result;
@@ -140,11 +141,11 @@ BoundStatement Binder::Bind(QueryNode &node) {
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundQueryNode &node) {
 	switch (node.type) {
 	case QueryNodeType::SELECT_NODE:
-		return CreatePlan((BoundSelectNode &)node);
+		return CreatePlan(node.Cast<BoundSelectNode>());
 	case QueryNodeType::SET_OPERATION_NODE:
-		return CreatePlan((BoundSetOperationNode &)node);
+		return CreatePlan(node.Cast<BoundSetOperationNode>());
 	case QueryNodeType::RECURSIVE_CTE_NODE:
-		return CreatePlan((BoundRecursiveCTENode &)node);
+		return CreatePlan(node.Cast<BoundRecursiveCTENode>());
 	default:
 		throw InternalException("Unsupported bound query node type");
 	}
@@ -154,25 +155,25 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	unique_ptr<BoundTableRef> result;
 	switch (ref.type) {
 	case TableReferenceType::BASE_TABLE:
-		result = Bind((BaseTableRef &)ref);
+		result = Bind(ref.Cast<BaseTableRef>());
 		break;
 	case TableReferenceType::JOIN:
-		result = Bind((JoinRef &)ref);
+		result = Bind(ref.Cast<JoinRef>());
 		break;
 	case TableReferenceType::SUBQUERY:
-		result = Bind((SubqueryRef &)ref);
+		result = Bind(ref.Cast<SubqueryRef>());
 		break;
 	case TableReferenceType::EMPTY:
-		result = Bind((EmptyTableRef &)ref);
+		result = Bind(ref.Cast<EmptyTableRef>());
 		break;
 	case TableReferenceType::TABLE_FUNCTION:
-		result = Bind((TableFunctionRef &)ref);
+		result = Bind(ref.Cast<TableFunctionRef>());
 		break;
 	case TableReferenceType::EXPRESSION_LIST:
-		result = Bind((ExpressionListRef &)ref);
+		result = Bind(ref.Cast<ExpressionListRef>());
 		break;
 	case TableReferenceType::PIVOT:
-		result = Bind((PivotRef &)ref);
+		result = Bind(ref.Cast<PivotRef>());
 		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
@@ -187,25 +188,28 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	unique_ptr<LogicalOperator> root;
 	switch (ref.type) {
 	case TableReferenceType::BASE_TABLE:
-		root = CreatePlan((BoundBaseTableRef &)ref);
+		root = CreatePlan(ref.Cast<BoundBaseTableRef>());
 		break;
 	case TableReferenceType::SUBQUERY:
-		root = CreatePlan((BoundSubqueryRef &)ref);
+		root = CreatePlan(ref.Cast<BoundSubqueryRef>());
 		break;
 	case TableReferenceType::JOIN:
-		root = CreatePlan((BoundJoinRef &)ref);
+		root = CreatePlan(ref.Cast<BoundJoinRef>());
 		break;
 	case TableReferenceType::TABLE_FUNCTION:
-		root = CreatePlan((BoundTableFunction &)ref);
+		root = CreatePlan(ref.Cast<BoundTableFunction>());
 		break;
 	case TableReferenceType::EMPTY:
-		root = CreatePlan((BoundEmptyTableRef &)ref);
+		root = CreatePlan(ref.Cast<BoundEmptyTableRef>());
 		break;
 	case TableReferenceType::EXPRESSION_LIST:
-		root = CreatePlan((BoundExpressionListRef &)ref);
+		root = CreatePlan(ref.Cast<BoundExpressionListRef>());
 		break;
 	case TableReferenceType::CTE:
-		root = CreatePlan((BoundCTERef &)ref);
+		root = CreatePlan(ref.Cast<BoundCTERef>());
+		break;
+	case TableReferenceType::PIVOT:
+		root = CreatePlan((BoundPivotRef &)ref);
 		break;
 	case TableReferenceType::INVALID:
 	default:
@@ -423,7 +427,7 @@ string Binder::FormatErrorRecursive(idx_t query_location, const string &message,
 // FIXME: this is extremely naive
 void VerifyNotExcluded(ParsedExpression &expr) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)expr;
+		auto &column_ref = expr.Cast<ColumnRefExpression>();
 		if (!column_ref.IsQualified()) {
 			return;
 		}

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -34,28 +34,28 @@ bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundAggregateExpression *)other_p;
-	if (other->aggr_type != aggr_type) {
+	auto &other = other_p->Cast<BoundAggregateExpression>();
+	if (other.aggr_type != aggr_type) {
 		return false;
 	}
-	if (other->function != function) {
+	if (other.function != function) {
 		return false;
 	}
-	if (children.size() != other->children.size()) {
+	if (children.size() != other.children.size()) {
 		return false;
 	}
-	if (!Expression::Equals(other->filter.get(), filter.get())) {
+	if (!Expression::Equals(other.filter.get(), filter.get())) {
 		return false;
 	}
 	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other->children[i].get())) {
+		if (!Expression::Equals(children[i].get(), other.children[i].get())) {
 			return false;
 		}
 	}
-	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
+	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {
 		return false;
 	}
-	if (!BoundOrderModifier::Equals(order_bys.get(), other->order_bys.get())) {
+	if (!BoundOrderModifier::Equals(order_bys.get(), other.order_bys.get())) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_between_expression.cpp

@@ -19,17 +19,17 @@ bool BoundBetweenExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundBetweenExpression *)other_p;
-	if (!Expression::Equals(input.get(), other->input.get())) {
+	auto &other = other_p->Cast<BoundBetweenExpression>();
+	if (!Expression::Equals(input.get(), other.input.get())) {
 		return false;
 	}
-	if (!Expression::Equals(lower.get(), other->lower.get())) {
+	if (!Expression::Equals(lower.get(), other.lower.get())) {
 		return false;
 	}
-	if (!Expression::Equals(upper.get(), other->upper.get())) {
+	if (!Expression::Equals(upper.get(), other.upper.get())) {
 		return false;
 	}
-	return lower_inclusive == other->lower_inclusive && upper_inclusive == other->upper_inclusive;
+	return lower_inclusive == other.lower_inclusive && upper_inclusive == other.upper_inclusive;
 }
 
 unique_ptr<Expression> BoundBetweenExpression::Copy() {

package/src/duckdb/src/planner/expression/bound_case_expression.cpp

@@ -26,7 +26,7 @@ bool BoundCaseExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (BoundCaseExpression &)*other_p;
+	auto &other = other_p->Cast<BoundCaseExpression>();
 	if (case_checks.size() != other.case_checks.size()) {
 		return false;
 	}

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -41,7 +41,7 @@ unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const
                                              bool try_cast) {
 	D_ASSERT(expr);
 	if (expr->expression_class == ExpressionClass::BOUND_PARAMETER) {
-		auto &parameter = (BoundParameterExpression &)*expr;
+		auto &parameter = expr->Cast<BoundParameterExpression>();
 		if (!target_type.IsValid()) {
 			// invalidate the parameter
 			parameter.parameter_data->return_type = LogicalType::INVALID;
@@ -71,7 +71,7 @@ unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const
 		return expr;
 	} else if (expr->expression_class == ExpressionClass::BOUND_DEFAULT) {
 		D_ASSERT(target_type.IsValid());
-		auto &def = (BoundDefaultExpression &)*expr;
+		auto &def = expr->Cast<BoundDefaultExpression>();
 		def.return_type = target_type;
 	}
 	if (!target_type.IsValid()) {
@@ -173,11 +173,11 @@ bool BoundCastExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundCastExpression *)other_p;
-	if (!Expression::Equals(child.get(), other->child.get())) {
+	auto &other = other_p->Cast<BoundCastExpression>();
+	if (!Expression::Equals(child.get(), other.child.get())) {
 		return false;
 	}
-	if (try_cast != other->try_cast) {
+	if (try_cast != other.try_cast) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_columnref_expression.cpp

@@ -31,8 +31,8 @@ bool BoundColumnRefExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundColumnRefExpression *)other_p;
-	return other->binding == binding && other->depth == depth;
+	auto &other = other_p->Cast<BoundColumnRefExpression>();
+	return other.binding == binding && other.depth == depth;
 }
 
 string BoundColumnRefExpression::ToString() const {

package/src/duckdb/src/planner/expression/bound_comparison_expression.cpp

@@ -18,14 +18,13 @@ bool BoundComparisonExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundComparisonExpression *)other_p;
-	if (!Expression::Equals(left.get(), other->left.get())) {
+	auto &other = other_p->Cast<BoundComparisonExpression>();
+	if (!Expression::Equals(left.get(), other.left.get())) {
 		return false;
 	}
-	if (!Expression::Equals(right.get(), other->right.get())) {
+	if (!Expression::Equals(right.get(), other.right.get())) {
 		return false;
 	}
-
 	return true;
 }
 

package/src/duckdb/src/planner/expression/bound_conjunction_expression.cpp

@@ -24,8 +24,8 @@ bool BoundConjunctionExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundConjunctionExpression *)other_p;
-	return ExpressionUtil::SetEquals(children, other->children);
+	auto &other = other_p->Cast<BoundConjunctionExpression>();
+	return ExpressionUtil::SetEquals(children, other.children);
 }
 
 bool BoundConjunctionExpression::PropagatesNullValues() const {

package/src/duckdb/src/planner/expression/bound_constant_expression.cpp

@@ -18,8 +18,8 @@ bool BoundConstantExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundConstantExpression *)other_p;
-	return value.type() == other->value.type() && !ValueOperations::DistinctFrom(value, other->value);
+	auto &other = other_p->Cast<BoundConstantExpression>();
+	return value.type() == other.value.type() && !ValueOperations::DistinctFrom(value, other.value);
 }
 
 hash_t BoundConstantExpression::Hash() const {

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -43,14 +43,14 @@ bool BoundFunctionExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundFunctionExpression *)other_p;
-	if (other->function != function) {
+	auto &other = other_p->Cast<BoundFunctionExpression>();
+	if (other.function != function) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(children, other->children)) {
+	if (!ExpressionUtil::ListEquals(children, other.children)) {
 		return false;
 	}
-	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
+	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_lambda_expression.cpp

@@ -18,14 +18,14 @@ bool BoundLambdaExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundLambdaExpression *)other_p;
-	if (!Expression::Equals(lambda_expr.get(), other->lambda_expr.get())) {
+	auto &other = other_p->Cast<BoundLambdaExpression>();
+	if (!Expression::Equals(lambda_expr.get(), other.lambda_expr.get())) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(captures, other->captures)) {
+	if (!ExpressionUtil::ListEquals(captures, other.captures)) {
 		return false;
 	}
-	if (parameter_count != other->parameter_count) {
+	if (parameter_count != other.parameter_count) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp

@@ -34,8 +34,8 @@ bool BoundLambdaRefExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundLambdaRefExpression *)other_p;
-	return other->binding == binding && other->lambda_index == lambda_index && other->depth == depth;
+	auto &other = other_p->Cast<BoundLambdaRefExpression>();
+	return other.binding == binding && other.lambda_index == lambda_index && other.depth == depth;
 }
 
 string BoundLambdaRefExpression::ToString() const {

package/src/duckdb/src/planner/expression/bound_operator_expression.cpp

@@ -18,8 +18,8 @@ bool BoundOperatorExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundOperatorExpression *)other_p;
-	if (!ExpressionUtil::ListEquals(children, other->children)) {
+	auto &other = other_p->Cast<BoundOperatorExpression>();
+	if (!ExpressionUtil::ListEquals(children, other.children)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp

@@ -16,7 +16,7 @@ void BoundParameterExpression::Invalidate(Expression &expr) {
 	if (expr.type != ExpressionType::VALUE_PARAMETER) {
 		throw InternalException("BoundParameterExpression::Invalidate requires a parameter as input");
 	}
-	auto &bound_parameter = (BoundParameterExpression &)expr;
+	auto &bound_parameter = expr.Cast<BoundParameterExpression>();
 	bound_parameter.return_type = LogicalTypeId::SQLNULL;
 	bound_parameter.parameter_data->return_type = LogicalTypeId::INVALID;
 }
@@ -47,8 +47,8 @@ bool BoundParameterExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundParameterExpression *)other_p;
-	return parameter_nr == other->parameter_nr;
+	auto &other = other_p->Cast<BoundParameterExpression>();
+	return parameter_nr == other.parameter_nr;
 }
 
 hash_t BoundParameterExpression::Hash() const {

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -26,8 +26,8 @@ bool BoundReferenceExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundReferenceExpression *)other_p;
-	return other->index == index;
+	auto &other = other_p->Cast<BoundReferenceExpression>();
+	return other.index == index;
 }
 
 hash_t BoundReferenceExpression::Hash() const {

package/src/duckdb/src/planner/expression/bound_unnest_expression.cpp

@@ -27,8 +27,8 @@ bool BoundUnnestExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundUnnestExpression *)other_p;
-	if (!Expression::Equals(child.get(), other->child.get())) {
+	auto &other = other_p->Cast<BoundUnnestExpression>();
+	if (!Expression::Equals(child.get(), other.child.get())) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -25,59 +25,59 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BoundWindowExpression *)other_p;
+	auto &other = other_p->Cast<BoundWindowExpression>();
 
-	if (ignore_nulls != other->ignore_nulls) {
+	if (ignore_nulls != other.ignore_nulls) {
 		return false;
 	}
-	if (start != other->start || end != other->end) {
+	if (start != other.start || end != other.end) {
 		return false;
 	}
 	// check if the child expressions are equivalent
-	if (other->children.size() != children.size()) {
+	if (other.children.size() != children.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other->children[i].get())) {
+		if (!Expression::Equals(children[i].get(), other.children[i].get())) {
 			return false;
 		}
 	}
 	// check if the filter expressions are equivalent
-	if (!Expression::Equals(filter_expr.get(), other->filter_expr.get())) {
+	if (!Expression::Equals(filter_expr.get(), other.filter_expr.get())) {
 		return false;
 	}
 
 	// check if the framing expressions are equivalent
-	if (!Expression::Equals(start_expr.get(), other->start_expr.get()) ||
-	    !Expression::Equals(end_expr.get(), other->end_expr.get()) ||
-	    !Expression::Equals(offset_expr.get(), other->offset_expr.get()) ||
-	    !Expression::Equals(default_expr.get(), other->default_expr.get())) {
+	if (!Expression::Equals(start_expr.get(), other.start_expr.get()) ||
+	    !Expression::Equals(end_expr.get(), other.end_expr.get()) ||
+	    !Expression::Equals(offset_expr.get(), other.offset_expr.get()) ||
+	    !Expression::Equals(default_expr.get(), other.default_expr.get())) {
 		return false;
 	}
 
 	return KeysAreCompatible(other);
 }
 
-bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression *other) const {
+bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const {
 	// check if the partitions are equivalent
-	if (partitions.size() != other->partitions.size()) {
+	if (partitions.size() != other.partitions.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < partitions.size(); i++) {
-		if (!Expression::Equals(partitions[i].get(), other->partitions[i].get())) {
+		if (!Expression::Equals(partitions[i].get(), other.partitions[i].get())) {
 			return false;
 		}
 	}
 	// check if the orderings are equivalent
-	if (orders.size() != other->orders.size()) {
+	if (orders.size() != other.orders.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < orders.size(); i++) {
-		if (orders[i].type != other->orders[i].type) {
+		if (orders[i].type != other.orders[i].type) {
 			return false;
 		}
 		if (!BaseExpression::Equals((BaseExpression *)orders[i].expression.get(),
-		                            (BaseExpression *)other->orders[i].expression.get())) {
+		                            (BaseExpression *)other.orders[i].expression.get())) {
 			return false;
 		}
 	}

package/src/duckdb/src/planner/expression_binder/alter_binder.cpp

@@ -20,7 +20,7 @@ BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 	case ExpressionClass::SUBQUERY:
 		return BindResult("cannot use subquery in alter statement");
 	case ExpressionClass::COLUMN_REF:
-		return BindColumn((ColumnRefExpression &)expr);
+		return BindColumn(expr.Cast<ColumnRefExpression>());
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -36,7 +36,7 @@ BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_p
 	case ExpressionClass::DEFAULT:
 		return BindResult("SELECT clause cannot contain DEFAULT clause");
 	case ExpressionClass::WINDOW:
-		return BindWindow((WindowExpression &)expr, depth);
+		return BindWindow(expr.Cast<WindowExpression>(), depth);
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth, root_expression);
 	}
@@ -45,7 +45,7 @@ BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_p
 idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	// first check the group alias map, if expr is a ColumnRefExpression
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
+		auto &colref = expr.Cast<ColumnRefExpression>();
 		if (!colref.IsQualified()) {
 			auto alias_entry = info.alias_map.find(colref.column_names[0]);
 			if (alias_entry != info.alias_map.end()) {
@@ -100,7 +100,7 @@ BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_pt
 			}
 			auto result = BindResult(node.select_list[index]->Copy());
 			if (result.expression->type == ExpressionType::BOUND_COLUMN_REF) {
-				auto &result_expr = (BoundColumnRefExpression &)*result.expression;
+				auto &result_expr = result.expression->Cast<BoundColumnRefExpression>();
 				result_expr.depth = depth;
 			}
 			return result;

package/src/duckdb/src/planner/expression_binder/check_binder.cpp

@@ -20,7 +20,7 @@ BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 	case ExpressionClass::SUBQUERY:
 		return BindResult("cannot use subquery in check constraint");
 	case ExpressionClass::COLUMN_REF:
-		return BindCheckColumn((ColumnRefExpression &)expr);
+		return BindCheckColumn(expr.Cast<ColumnRefExpression>());
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/planner/expression_binder/constant_binder.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
 
 namespace duckdb {
 
@@ -9,8 +10,17 @@ ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string cl
 BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
-	case ExpressionClass::COLUMN_REF:
+	case ExpressionClass::COLUMN_REF: {
+		auto &colref = expr.Cast<ColumnRefExpression>();
+		if (!colref.IsQualified()) {
+			auto value_function = GetSQLValueFunction(colref.GetColumnName());
+			if (value_function) {
+				*expr_ptr = std::move(value_function);
+				return BindExpression(expr_ptr, depth, root_expression);
+			}
+		}
 		return BindResult(clause + " cannot contain column names");
+	}
 	case ExpressionClass::SUBQUERY:
 		throw BinderException(clause + " cannot contain subqueries");
 	case ExpressionClass::DEFAULT:

package/src/duckdb/src/planner/expression_binder/group_binder.cpp

@@ -19,9 +19,9 @@ BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 	if (root_expression && depth == 0) {
 		switch (expr.expression_class) {
 		case ExpressionClass::COLUMN_REF:
-			return BindColumnRef((ColumnRefExpression &)expr);
+			return BindColumnRef(expr.Cast<ColumnRefExpression>());
 		case ExpressionClass::CONSTANT:
-			return BindConstant((ConstantExpression &)expr);
+			return BindConstant(expr.Cast<ConstantExpression>());
 		case ExpressionClass::PARAMETER:
 			throw ParameterNotAllowedException("Parameter not supported in GROUP BY clause");
 		default: