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

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

@@ -23,7 +23,7 @@ BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, i
 			// WAL replay
 			// we assume that the parsed expressions have qualified column names
 			// and that the columns exist in the table
-			auto &col_ref = (ColumnRefExpression &)expr;
+			auto &col_ref = expr.Cast<ColumnRefExpression>();
 			auto col_idx = table->GetColumnIndex(col_ref.column_names.back());
 			auto col_type = table->GetColumn(col_idx).GetType();
 

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

@@ -11,7 +11,7 @@ LateralBinder::LateralBinder(Binder &binder, ClientContext &context) : Expressio
 
 void LateralBinder::ExtractCorrelatedColumns(Expression &expr) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)expr;
+		auto &bound_colref = expr.Cast<BoundColumnRefExpression>();
 		if (bound_colref.depth > 0) {
 			// add the correlated column info
 			CorrelatedColumnInfo info(bound_colref);
@@ -122,10 +122,10 @@ protected:
 
 	void ReduceExpressionDepth(Expression &expr) {
 		if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			ReduceColumnRefDepth((BoundColumnRefExpression &)expr);
+			ReduceColumnRefDepth(expr.Cast<BoundColumnRefExpression>());
 		}
 		if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
-			ReduceExpressionSubquery((BoundSubqueryExpression &)expr);
+			ReduceExpressionSubquery(expr.Cast<BoundSubqueryExpression>());
 		}
 	}
 

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

@@ -73,13 +73,13 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 	case ExpressionClass::CONSTANT: {
 		// ORDER BY constant
 		// is the ORDER BY expression a constant integer? (e.g. ORDER BY 1)
-		auto &constant = (ConstantExpression &)*expr;
+		auto &constant = expr->Cast<ConstantExpression>();
 		return BindConstant(*expr, constant.value);
 	}
 	case ExpressionClass::COLUMN_REF: {
 		// COLUMN REF expression
 		// check if we can bind it to an alias in the select list
-		auto &colref = (ColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		// if there is an explicit table name we can't bind to an alias
 		if (colref.IsQualified()) {
 			break;
@@ -93,7 +93,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		break;
 	}
 	case ExpressionClass::POSITIONAL_REFERENCE: {
-		auto &posref = (PositionalReferenceExpression &)*expr;
+		auto &posref = expr->Cast<PositionalReferenceExpression>();
 		if (posref.index < 1 || posref.index > max_count) {
 			throw BinderException("ORDER term out of range - should be between 1 and %lld", (idx_t)max_count);
 		}

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

@@ -5,6 +5,7 @@
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/parser/expression/window_expression.hpp"
 
 namespace duckdb {
 
@@ -39,7 +40,7 @@ BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr,
 	}
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
-		return BindWindow((WindowExpression &)expr, depth);
+		return BindWindow(expr.Cast<WindowExpression>(), depth);
 	case ExpressionClass::COLUMN_REF:
 		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:

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

@@ -8,18 +8,22 @@ namespace duckdb {
 TableFunctionBinder::TableFunctionBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr, idx_t depth) {
+BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr, idx_t depth, bool root_expression) {
 
 	// if this is a lambda parameters, then we temporarily add a BoundLambdaRef,
 	// which we capture and remove later
 	if (lambda_bindings) {
-		auto &colref = (ColumnRefExpression &)expr;
+		auto &colref = expr.Cast<ColumnRefExpression>();
 		for (idx_t i = 0; i < lambda_bindings->size(); i++) {
 			if (colref.GetColumnName() == (*lambda_bindings)[i].dummy_name) {
 				return (*lambda_bindings)[i].Bind(colref, i, depth);
 			}
 		}
 	}
+	auto value_function = ExpressionBinder::GetSQLValueFunction(expr.GetColumnName());
+	if (value_function) {
+		return BindExpression(&value_function, depth, root_expression);
+	}
 
 	auto result_name = StringUtil::Join(expr.column_names, ".");
 	return BindResult(make_uniq<BoundConstantExpression>(Value(result_name)));
@@ -30,7 +34,7 @@ BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> *exp
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF:
-		return BindColumnReference((ColumnRefExpression &)expr, depth);
+		return BindColumnReference(expr.Cast<ColumnRefExpression>(), depth, root_expression);
 	case ExpressionClass::SUBQUERY:
 		throw BinderException("Table function cannot contain subqueries");
 	case ExpressionClass::DEFAULT:

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

@@ -1,15 +1,9 @@
 #include "duckdb/planner/expression_binder.hpp"
 
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/expression/positional_reference_expression.hpp"
-#include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/planner/expression/bound_subquery_expression.hpp"
+#include "duckdb/planner/expression/list.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 
 namespace duckdb {
@@ -38,23 +32,23 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> *expr,
 	auto &expr_ref = **expr;
 	switch (expr_ref.expression_class) {
 	case ExpressionClass::BETWEEN:
-		return BindExpression((BetweenExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<BetweenExpression>(), depth);
 	case ExpressionClass::CASE:
-		return BindExpression((CaseExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<CaseExpression>(), depth);
 	case ExpressionClass::CAST:
-		return BindExpression((CastExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<CastExpression>(), depth);
 	case ExpressionClass::COLLATE:
-		return BindExpression((CollateExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<CollateExpression>(), depth);
 	case ExpressionClass::COLUMN_REF:
-		return BindExpression((ColumnRefExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<ColumnRefExpression>(), depth);
 	case ExpressionClass::COMPARISON:
-		return BindExpression((ComparisonExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<ComparisonExpression>(), depth);
 	case ExpressionClass::CONJUNCTION:
-		return BindExpression((ConjunctionExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<ConjunctionExpression>(), depth);
 	case ExpressionClass::CONSTANT:
-		return BindExpression((ConstantExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<ConstantExpression>(), depth);
 	case ExpressionClass::FUNCTION: {
-		auto &function = (FunctionExpression &)expr_ref;
+		auto &function = expr_ref.Cast<FunctionExpression>();
 		if (function.function_name == "unnest" || function.function_name == "unlist") {
 			// special case, not in catalog
 			return BindUnnest(function, depth, root_expression);
@@ -63,15 +57,15 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> *expr,
 		return BindExpression(function, depth, expr);
 	}
 	case ExpressionClass::LAMBDA:
-		return BindExpression((LambdaExpression &)expr_ref, depth, false, LogicalTypeId::INVALID);
+		return BindExpression(expr_ref.Cast<LambdaExpression>(), depth, false, LogicalTypeId::INVALID);
 	case ExpressionClass::OPERATOR:
-		return BindExpression((OperatorExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<OperatorExpression>(), depth);
 	case ExpressionClass::SUBQUERY:
-		return BindExpression((SubqueryExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<SubqueryExpression>(), depth);
 	case ExpressionClass::PARAMETER:
-		return BindExpression((ParameterExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<ParameterExpression>(), depth);
 	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindExpression((PositionalReferenceExpression &)expr_ref, depth);
+		return BindExpression(expr_ref.Cast<PositionalReferenceExpression>(), depth);
 	case ExpressionClass::STAR:
 		return BindResult(binder.FormatError(expr_ref, "STAR expression is not supported here"));
 	default:
@@ -113,7 +107,7 @@ void ExpressionBinder::BindChild(unique_ptr<ParsedExpression> &expr, idx_t depth
 
 void ExpressionBinder::ExtractCorrelatedExpressions(Binder &binder, Expression &expr) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)expr;
+		auto &bound_colref = expr.Cast<BoundColumnRefExpression>();
 		if (bound_colref.depth > 0) {
 			binder.AddCorrelatedColumn(CorrelatedColumnInfo(bound_colref));
 		}
@@ -200,12 +194,11 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
 		if (!success) {
 			throw BinderException(error_msg);
 		}
-		auto bound_expr = (BoundExpression *)expr.get();
-		ExtractCorrelatedExpressions(binder, *bound_expr->expr);
+		auto &bound_expr = expr->Cast<BoundExpression>();
+		ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 	}
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto bound_expr = (BoundExpression *)expr.get();
-	unique_ptr<Expression> result = std::move(bound_expr->expr);
+	auto &bound_expr = expr->Cast<BoundExpression>();
+	unique_ptr<Expression> result = std::move(bound_expr.expr);
 	if (target_type.id() != LogicalTypeId::INVALID) {
 		// the binder has a specific target type: add a cast to that type
 		result = BoundCastExpression::AddCastToType(context, std::move(result), target_type);
@@ -243,11 +236,10 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 	}
 	// successfully bound: replace the node with a BoundExpression
 	*expr = make_uniq<BoundExpression>(std::move(result.expression));
-	auto be = (BoundExpression *)expr->get();
-	D_ASSERT(be);
-	be->alias = alias;
+	auto &be = (*expr)->Cast<BoundExpression>();
+	be.alias = alias;
 	if (!alias.empty()) {
-		be->expr->alias = alias;
+		be.expr->alias = alias;
 	}
 	return string();
 }

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -22,7 +22,7 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
                                            const std::function<void(unique_ptr<Expression> &child)> &callback) {
 	switch (expr.expression_class) {
 	case ExpressionClass::BOUND_AGGREGATE: {
-		auto &aggr_expr = (BoundAggregateExpression &)expr;
+		auto &aggr_expr = expr.Cast<BoundAggregateExpression>();
 		for (auto &child : aggr_expr.children) {
 			callback(child);
 		}
@@ -37,14 +37,14 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		break;
 	}
 	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between_expr = (BoundBetweenExpression &)expr;
+		auto &between_expr = expr.Cast<BoundBetweenExpression>();
 		callback(between_expr.input);
 		callback(between_expr.lower);
 		callback(between_expr.upper);
 		break;
 	}
 	case ExpressionClass::BOUND_CASE: {
-		auto &case_expr = (BoundCaseExpression &)expr;
+		auto &case_expr = expr.Cast<BoundCaseExpression>();
 		for (auto &case_check : case_expr.case_checks) {
 			callback(case_check.when_expr);
 			callback(case_check.then_expr);
@@ -53,46 +53,46 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		break;
 	}
 	case ExpressionClass::BOUND_CAST: {
-		auto &cast_expr = (BoundCastExpression &)expr;
+		auto &cast_expr = expr.Cast<BoundCastExpression>();
 		callback(cast_expr.child);
 		break;
 	}
 	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comp_expr = (BoundComparisonExpression &)expr;
+		auto &comp_expr = expr.Cast<BoundComparisonExpression>();
 		callback(comp_expr.left);
 		callback(comp_expr.right);
 		break;
 	}
 	case ExpressionClass::BOUND_CONJUNCTION: {
-		auto &conj_expr = (BoundConjunctionExpression &)expr;
+		auto &conj_expr = expr.Cast<BoundConjunctionExpression>();
 		for (auto &child : conj_expr.children) {
 			callback(child);
 		}
 		break;
 	}
 	case ExpressionClass::BOUND_FUNCTION: {
-		auto &func_expr = (BoundFunctionExpression &)expr;
+		auto &func_expr = expr.Cast<BoundFunctionExpression>();
 		for (auto &child : func_expr.children) {
 			callback(child);
 		}
 		break;
 	}
 	case ExpressionClass::BOUND_OPERATOR: {
-		auto &op_expr = (BoundOperatorExpression &)expr;
+		auto &op_expr = expr.Cast<BoundOperatorExpression>();
 		for (auto &child : op_expr.children) {
 			callback(child);
 		}
 		break;
 	}
 	case ExpressionClass::BOUND_SUBQUERY: {
-		auto &subquery_expr = (BoundSubqueryExpression &)expr;
+		auto &subquery_expr = expr.Cast<BoundSubqueryExpression>();
 		if (subquery_expr.child) {
 			callback(subquery_expr.child);
 		}
 		break;
 	}
 	case ExpressionClass::BOUND_WINDOW: {
-		auto &window_expr = (BoundWindowExpression &)expr;
+		auto &window_expr = expr.Cast<BoundWindowExpression>();
 		for (auto &partition : window_expr.partitions) {
 			callback(partition);
 		}
@@ -120,7 +120,7 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		break;
 	}
 	case ExpressionClass::BOUND_UNNEST: {
-		auto &unnest_expr = (BoundUnnestExpression &)expr;
+		auto &unnest_expr = expr.Cast<BoundUnnestExpression>();
 		callback(unnest_expr.child);
 		break;
 	}
@@ -151,7 +151,7 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
                                                    const std::function<void(Expression &child)> &callback) {
 	switch (ref.type) {
 	case TableReferenceType::EXPRESSION_LIST: {
-		auto &bound_expr_list = (BoundExpressionListRef &)ref;
+		auto &bound_expr_list = ref.Cast<BoundExpressionListRef>();
 		for (auto &expr_list : bound_expr_list.values) {
 			for (auto &expr : expr_list) {
 				EnumerateExpression(expr, callback);
@@ -160,7 +160,7 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
 		break;
 	}
 	case TableReferenceType::JOIN: {
-		auto &bound_join = (BoundJoinRef &)ref;
+		auto &bound_join = ref.Cast<BoundJoinRef>();
 		if (bound_join.condition) {
 			EnumerateExpression(bound_join.condition, callback);
 		}
@@ -169,7 +169,7 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
 		break;
 	}
 	case TableReferenceType::SUBQUERY: {
-		auto &bound_subquery = (BoundSubqueryRef &)ref;
+		auto &bound_subquery = ref.Cast<BoundSubqueryRef>();
 		EnumerateQueryNodeChildren(*bound_subquery.subquery, callback);
 		break;
 	}
@@ -187,19 +187,19 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
                                                     const std::function<void(Expression &child)> &callback) {
 	switch (node.type) {
 	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &bound_setop = (BoundSetOperationNode &)node;
+		auto &bound_setop = node.Cast<BoundSetOperationNode>();
 		EnumerateQueryNodeChildren(*bound_setop.left, callback);
 		EnumerateQueryNodeChildren(*bound_setop.right, callback);
 		break;
 	}
 	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &cte_node = (BoundRecursiveCTENode &)node;
+		auto &cte_node = node.Cast<BoundRecursiveCTENode>();
 		EnumerateQueryNodeChildren(*cte_node.left, callback);
 		EnumerateQueryNodeChildren(*cte_node.right, callback);
 		break;
 	}
 	case QueryNodeType::SELECT_NODE: {
-		auto &bound_select = (BoundSelectNode &)node;
+		auto &bound_select = node.Cast<BoundSelectNode>();
 		for (auto &expr : bound_select.select_list) {
 			EnumerateExpression(expr, callback);
 		}

package/src/duckdb/src/planner/joinside.cpp

@@ -82,7 +82,7 @@ JoinSide JoinSide::GetJoinSide(idx_t table_binding, const unordered_set<idx_t> &
 JoinSide JoinSide::GetJoinSide(Expression &expression, const unordered_set<idx_t> &left_bindings,
                                const unordered_set<idx_t> &right_bindings) {
 	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expression;
+		auto &colref = expression.Cast<BoundColumnRefExpression>();
 		if (colref.depth > 0) {
 			throw Exception("Non-inner join on correlated columns not supported");
 		}
@@ -91,7 +91,7 @@ JoinSide JoinSide::GetJoinSide(Expression &expression, const unordered_set<idx_t
 	D_ASSERT(expression.type != ExpressionType::BOUND_REF);
 	if (expression.type == ExpressionType::SUBQUERY) {
 		D_ASSERT(expression.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY);
-		auto &subquery = (BoundSubqueryExpression &)expression;
+		auto &subquery = expression.Cast<BoundSubqueryExpression>();
 		JoinSide side = JoinSide::NONE;
 		if (subquery.child) {
 			side = GetJoinSide(*subquery.child, left_bindings, right_bindings);

package/src/duckdb/src/planner/logical_operator.cpp

@@ -351,6 +351,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		result = LogicalExtensionOperator::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_PIVOT:
+		result = LogicalPivot::Deserialize(state, reader);
+		break;
 	case LogicalOperatorType::LOGICAL_INVALID:
 		/* no default here to trigger a warning if we forget to implement deserialize for a new operator */
 		throw SerializationException("Invalid type for operator deserialization");

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -21,7 +21,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
                                                   const std::function<void(unique_ptr<Expression> *child)> &callback) {
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
-		auto &get = (LogicalExpressionGet &)op;
+		auto &get = op.Cast<LogicalExpressionGet>();
 		for (auto &expr_list : get.expressions) {
 			for (auto &expr : expr_list) {
 				callback(&expr);
@@ -30,21 +30,21 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_ORDER_BY: {
-		auto &order = (LogicalOrder &)op;
+		auto &order = op.Cast<LogicalOrder>();
 		for (auto &node : order.orders) {
 			callback(&node.expression);
 		}
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_TOP_N: {
-		auto &order = (LogicalTopN &)op;
+		auto &order = op.Cast<LogicalTopN>();
 		for (auto &node : order.orders) {
 			callback(&node.expression);
 		}
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		auto &distinct = (LogicalDistinct &)op;
+		auto &distinct = op.Cast<LogicalDistinct>();
 		for (auto &target : distinct.distinct_targets) {
 			callback(&target);
 		}
@@ -56,7 +56,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_INSERT: {
-		auto &insert = (LogicalInsert &)op;
+		auto &insert = op.Cast<LogicalInsert>();
 		if (insert.on_conflict_condition) {
 			callback(&insert.on_conflict_condition);
 		}
@@ -69,12 +69,12 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			auto &delim_join = (LogicalDelimJoin &)op;
+			auto &delim_join = op.Cast<LogicalDelimJoin>();
 			for (auto &expr : delim_join.duplicate_eliminated_columns) {
 				callback(&expr);
 			}
 		}
-		auto &join = (LogicalComparisonJoin &)op;
+		auto &join = op.Cast<LogicalComparisonJoin>();
 		for (auto &cond : join.conditions) {
 			callback(&cond.left);
 			callback(&cond.right);
@@ -82,12 +82,12 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &join = (LogicalAnyJoin &)op;
+		auto &join = op.Cast<LogicalAnyJoin>();
 		callback(&join.condition);
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT: {
-		auto &limit = (LogicalLimit &)op;
+		auto &limit = op.Cast<LogicalLimit>();
 		if (limit.limit) {
 			callback(&limit.limit);
 		}
@@ -107,7 +107,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		auto &aggr = (LogicalAggregate &)op;
+		auto &aggr = op.Cast<LogicalAggregate>();
 		for (auto &group : aggr.groups) {
 			callback(&group);
 		}
@@ -130,52 +130,52 @@ void LogicalOperatorVisitor::VisitExpression(unique_ptr<Expression> *expression)
 	unique_ptr<Expression> result;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::BOUND_AGGREGATE:
-		result = VisitReplace((BoundAggregateExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundAggregateExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_BETWEEN:
-		result = VisitReplace((BoundBetweenExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundBetweenExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_CASE:
-		result = VisitReplace((BoundCaseExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundCaseExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_CAST:
-		result = VisitReplace((BoundCastExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundCastExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_COLUMN_REF:
-		result = VisitReplace((BoundColumnRefExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundColumnRefExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_COMPARISON:
-		result = VisitReplace((BoundComparisonExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundComparisonExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_CONJUNCTION:
-		result = VisitReplace((BoundConjunctionExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundConjunctionExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_CONSTANT:
-		result = VisitReplace((BoundConstantExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundConstantExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_FUNCTION:
-		result = VisitReplace((BoundFunctionExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundFunctionExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_SUBQUERY:
-		result = VisitReplace((BoundSubqueryExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundSubqueryExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_OPERATOR:
-		result = VisitReplace((BoundOperatorExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundOperatorExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_PARAMETER:
-		result = VisitReplace((BoundParameterExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundParameterExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_REF:
-		result = VisitReplace((BoundReferenceExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundReferenceExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_DEFAULT:
-		result = VisitReplace((BoundDefaultExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundDefaultExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_WINDOW:
-		result = VisitReplace((BoundWindowExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundWindowExpression>(), expression);
 		break;
 	case ExpressionClass::BOUND_UNNEST:
-		result = VisitReplace((BoundUnnestExpression &)expr, expression);
+		result = VisitReplace(expr.Cast<BoundUnnestExpression>(), expression);
 		break;
 	default:
 		throw InternalException("Unrecognized expression type in logical operator visitor");

package/src/duckdb/src/planner/operator/logical_distinct.cpp

@@ -14,6 +14,7 @@ string LogicalDistinct::ParamsToString() const {
 	return result;
 }
 void LogicalDistinct::Serialize(FieldWriter &writer) const {
+	writer.WriteField<DistinctType>(distinct_type);
 	writer.WriteSerializableList(distinct_targets);
 	if (order_by) {
 		throw NotImplementedException("Serializing ORDER BY not yet supported");
@@ -21,8 +22,9 @@ void LogicalDistinct::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
+	auto distinct_type = reader.ReadRequired<DistinctType>();
 	auto distinct_targets = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_uniq<LogicalDistinct>(std::move(distinct_targets));
+	return make_uniq<LogicalDistinct>(std::move(distinct_targets), distinct_type);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_filter.cpp

@@ -27,7 +27,7 @@ bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions)
 	bool found_conjunction = false;
 	for (idx_t i = 0; i < expressions.size(); i++) {
 		if (expressions[i]->type == ExpressionType::CONJUNCTION_AND) {
-			auto &conjunction = (BoundConjunctionExpression &)*expressions[i];
+			auto &conjunction = expressions[i]->Cast<BoundConjunctionExpression>();
 			found_conjunction = true;
 			// AND expression, append the other children
 			for (idx_t k = 1; k < conjunction.children.size(); k++) {

package/src/duckdb/src/planner/operator/logical_join.cpp

@@ -52,7 +52,7 @@ void LogicalJoin::GetTableReferences(LogicalOperator &op, unordered_set<idx_t> &
 
 void LogicalJoin::GetExpressionBindings(Expression &expr, unordered_set<idx_t> &bindings) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
+		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.depth == 0);
 		bindings.insert(colref.binding.table_index);
 	}

package/src/duckdb/src/planner/operator/logical_pivot.cpp

@@ -0,0 +1,35 @@
+#include "duckdb/planner/operator/logical_pivot.hpp"
+
+namespace duckdb {
+
+LogicalPivot::LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT), pivot_index(pivot_idx), bound_pivot(std::move(info_p)) {
+	D_ASSERT(plan);
+	children.push_back(std::move(plan));
+}
+
+vector<ColumnBinding> LogicalPivot::GetColumnBindings() {
+	vector<ColumnBinding> result;
+	for (idx_t i = 0; i < bound_pivot.types.size(); i++) {
+		result.emplace_back(pivot_index, i);
+	}
+	return result;
+}
+
+void LogicalPivot::Serialize(FieldWriter &writer) const {
+	throw NotImplementedException("Serializing pivot is not supported yet");
+}
+
+unique_ptr<LogicalOperator> LogicalPivot::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
+	throw NotImplementedException("Deserializing pivot is not supported yet");
+}
+
+vector<idx_t> LogicalPivot::GetTableIndex() const {
+	return vector<idx_t> {pivot_index};
+}
+
+void LogicalPivot::ResolveTypes() {
+	this->types = bound_pivot.types;
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_recursive_cte.cpp

@@ -14,7 +14,7 @@ unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(LogicalDeserializat
 	auto column_count = reader.ReadRequired<idx_t>();
 	auto union_all = reader.ReadRequired<bool>();
 	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	return unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE(table_index, column_count, union_all, state.type));
+	return unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE(table_index, column_count, union_all));
 }
 
 vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -23,7 +23,7 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 	vector<unique_ptr<SQLStatement>> new_statements;
 	for (idx_t i = 0; i < statements.size(); i++) {
 		if (statements[i]->type == StatementType::MULTI_STATEMENT) {
-			auto &multi_statement = (MultiStatement &)*statements[i];
+			auto &multi_statement = statements[i]->Cast<MultiStatement>();
 			for (auto &stmt : multi_statement.statements) {
 				statements.push_back(std::move(stmt));
 			}
@@ -68,7 +68,7 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 }
 
 string PragmaHandler::HandlePragma(SQLStatement *statement) { // PragmaInfo &info
-	auto info = *((PragmaStatement &)*statement).info;
+	auto info = *(statement->Cast<PragmaStatement>()).info;
 	auto entry =
 	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name, false);
 	string error;