duckdb 0.8.1-dev65.0 → 0.8.1

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

@@ -22,23 +22,23 @@ string BoundCaseExpression::ToString() const {
 	return CaseExpression::ToString<BoundCaseExpression, Expression>(*this);
 }
 
-bool BoundCaseExpression::Equals(const BaseExpression *other_p) const {
+bool BoundCaseExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundCaseExpression>();
+	auto &other = other_p.Cast<BoundCaseExpression>();
 	if (case_checks.size() != other.case_checks.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < case_checks.size(); i++) {
-		if (!Expression::Equals(case_checks[i].when_expr.get(), other.case_checks[i].when_expr.get())) {
+		if (!Expression::Equals(*case_checks[i].when_expr, *other.case_checks[i].when_expr)) {
 			return false;
 		}
-		if (!Expression::Equals(case_checks[i].then_expr.get(), other.case_checks[i].then_expr.get())) {
+		if (!Expression::Equals(*case_checks[i].then_expr, *other.case_checks[i].then_expr)) {
 			return false;
 		}
 	}
-	if (!Expression::Equals(else_expr.get(), other.else_expr.get())) {
+	if (!Expression::Equals(*else_expr, *other.else_expr)) {
 		return false;
 	}
 	return true;

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

@@ -169,12 +169,12 @@ string BoundCastExpression::ToString() const {
 	return (try_cast ? "TRY_CAST(" : "CAST(") + child->GetName() + " AS " + return_type.ToString() + ")";
 }
 
-bool BoundCastExpression::Equals(const BaseExpression *other_p) const {
+bool BoundCastExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundCastExpression>();
-	if (!Expression::Equals(child.get(), other.child.get())) {
+	auto &other = other_p.Cast<BoundCastExpression>();
+	if (!Expression::Equals(*child, *other.child)) {
 		return false;
 	}
 	if (try_cast != other.try_cast) {

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

@@ -27,11 +27,11 @@ hash_t BoundColumnRefExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
 }
 
-bool BoundColumnRefExpression::Equals(const BaseExpression *other_p) const {
+bool BoundColumnRefExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundColumnRefExpression>();
+	auto &other = other_p.Cast<BoundColumnRefExpression>();
 	return other.binding == binding && other.depth == depth;
 }
 

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

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

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

@@ -20,11 +20,11 @@ string BoundConjunctionExpression::ToString() const {
 	return ConjunctionExpression::ToString<BoundConjunctionExpression, Expression>(*this);
 }
 
-bool BoundConjunctionExpression::Equals(const BaseExpression *other_p) const {
+bool BoundConjunctionExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundConjunctionExpression>();
+	auto &other = other_p.Cast<BoundConjunctionExpression>();
 	return ExpressionUtil::SetEquals(children, other.children);
 }
 

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

@@ -14,11 +14,11 @@ string BoundConstantExpression::ToString() const {
 	return value.ToSQLString();
 }
 
-bool BoundConstantExpression::Equals(const BaseExpression *other_p) const {
+bool BoundConstantExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundConstantExpression>();
+	auto &other = other_p.Cast<BoundConstantExpression>();
 	return value.type() == other.value.type() && !ValueOperations::DistinctFrom(value, other.value);
 }
 

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

@@ -1,10 +1,16 @@
 #include "duckdb/planner/expression/bound_default_expression.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
 void BoundDefaultExpression::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(ExpressionTypeToString(type));
+	writer.WriteSerializable(return_type);
+}
+
+unique_ptr<Expression> BoundDefaultExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
+	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	return make_uniq<BoundDefaultExpression>(return_type);
 }
 
 } // namespace duckdb

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

@@ -22,7 +22,7 @@ string BoundExpression::ToString() const {
 	return expr->ToString();
 }
 
-bool BoundExpression::Equals(const BaseExpression *other) const {
+bool BoundExpression::Equals(const BaseExpression &other) const {
 	return false;
 }
 hash_t BoundExpression::Hash() const {

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

@@ -2,7 +2,6 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
-#include "duckdb/parser/expression_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 
 namespace duckdb {
@@ -39,15 +38,15 @@ hash_t BoundFunctionExpression::Hash() const {
 	return CombineHash(result, function.Hash());
 }
 
-bool BoundFunctionExpression::Equals(const BaseExpression *other_p) const {
+bool BoundFunctionExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundFunctionExpression>();
+	auto &other = other_p.Cast<BoundFunctionExpression>();
 	if (other.function != function) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(children, other.children)) {
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
 	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -14,15 +13,15 @@ string BoundLambdaExpression::ToString() const {
 	return lambda_expr->ToString();
 }
 
-bool BoundLambdaExpression::Equals(const BaseExpression *other_p) const {
+bool BoundLambdaExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundLambdaExpression>();
-	if (!Expression::Equals(lambda_expr.get(), other.lambda_expr.get())) {
+	auto &other = other_p.Cast<BoundLambdaExpression>();
+	if (!Expression::Equals(*lambda_expr, *other.lambda_expr)) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(captures, other.captures)) {
+	if (!Expression::ListEquals(captures, other.captures)) {
 		return false;
 	}
 	if (parameter_count != other.parameter_count) {

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

@@ -30,11 +30,11 @@ hash_t BoundLambdaRefExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
 }
 
-bool BoundLambdaRefExpression::Equals(const BaseExpression *other_p) const {
+bool BoundLambdaRefExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundLambdaRefExpression>();
+	auto &other = other_p.Cast<BoundLambdaRefExpression>();
 	return other.binding == binding && other.lambda_index == lambda_index && other.depth == depth;
 }
 

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression_util.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/common/field_writer.hpp"
 
@@ -14,12 +13,12 @@ string BoundOperatorExpression::ToString() const {
 	return OperatorExpression::ToString<BoundOperatorExpression, Expression>(*this);
 }
 
-bool BoundOperatorExpression::Equals(const BaseExpression *other_p) const {
+bool BoundOperatorExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundOperatorExpression>();
-	if (!ExpressionUtil::ListEquals(children, other.children)) {
+	auto &other = other_p.Cast<BoundOperatorExpression>();
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
 	return true;

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

@@ -43,11 +43,11 @@ string BoundParameterExpression::ToString() const {
 	return "$" + to_string(parameter_nr);
 }
 
-bool BoundParameterExpression::Equals(const BaseExpression *other_p) const {
+bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundParameterExpression>();
+	auto &other = other_p.Cast<BoundParameterExpression>();
 	return parameter_nr == other.parameter_nr;
 }
 

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

@@ -28,11 +28,11 @@ string BoundReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool BoundReferenceExpression::Equals(const BaseExpression *other_p) const {
+bool BoundReferenceExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundReferenceExpression>();
+	auto &other = other_p.Cast<BoundReferenceExpression>();
 	return other.index == index;
 }
 

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

@@ -12,7 +12,7 @@ string BoundSubqueryExpression::ToString() const {
 	return "SUBQUERY";
 }
 
-bool BoundSubqueryExpression::Equals(const BaseExpression *other_p) const {
+bool BoundSubqueryExpression::Equals(const BaseExpression &other_p) const {
 	// equality between bound subqueries not implemented currently
 	return false;
 }

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

@@ -23,12 +23,12 @@ hash_t BoundUnnestExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash("unnest"));
 }
 
-bool BoundUnnestExpression::Equals(const BaseExpression *other_p) const {
+bool BoundUnnestExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundUnnestExpression>();
-	if (!Expression::Equals(child.get(), other.child.get())) {
+	auto &other = other_p.Cast<BoundUnnestExpression>();
+	if (!Expression::Equals(*child, *other.child)) {
 		return false;
 	}
 	return true;

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

@@ -21,11 +21,11 @@ string BoundWindowExpression::ToString() const {
 	                                                                                       function_name);
 }
 
-bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
+bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundWindowExpression>();
+	auto &other = other_p.Cast<BoundWindowExpression>();
 
 	if (ignore_nulls != other.ignore_nulls) {
 		return false;
@@ -34,24 +34,17 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 		return false;
 	}
 	// check if the child expressions are equivalent
-	if (other.children.size() != children.size()) {
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
-	for (idx_t i = 0; i < children.size(); i++) {
-		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, other.filter_expr)) {
 		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, other.start_expr) || !Expression::Equals(end_expr, other.end_expr) ||
+	    !Expression::Equals(offset_expr, other.offset_expr) || !Expression::Equals(default_expr, other.default_expr)) {
 		return false;
 	}
 
@@ -60,14 +53,9 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 
 bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const {
 	// check if the partitions are equivalent
-	if (partitions.size() != other.partitions.size()) {
+	if (!Expression::ListEquals(partitions, other.partitions)) {
 		return false;
 	}
-	for (idx_t i = 0; i < partitions.size(); i++) {
-		if (!Expression::Equals(partitions[i].get(), other.partitions[i].get())) {
-			return false;
-		}
-	}
 	// check if the orderings are equivalent
 	if (orders.size() != other.orders.size()) {
 		return false;
@@ -76,8 +64,7 @@ bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other
 		if (orders[i].type != other.orders[i].type) {
 			return false;
 		}
-		if (!BaseExpression::Equals((BaseExpression *)orders[i].expression.get(),
-		                            (BaseExpression *)other.orders[i].expression.get())) {
+		if (!Expression::Equals(*orders[i].expression, *other.orders[i].expression)) {
 			return false;
 		}
 	}

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

@@ -6,6 +6,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/planner/expression/list.hpp"
+#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -129,6 +130,9 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeseria
 	case ExpressionClass::BOUND_CONSTANT:
 		result = BoundConstantExpression::Deserialize(state, reader);
 		break;
+	case ExpressionClass::BOUND_DEFAULT:
+		result = BoundDefaultExpression::Deserialize(state, reader);
+		break;
 	case ExpressionClass::BOUND_FUNCTION:
 		result = BoundFunctionExpression::Deserialize(state, reader);
 		break;
@@ -165,4 +169,18 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeseria
 	return result;
 }
 
+bool Expression::Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
+bool Expression::ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right) {
+	return ExpressionUtil::ListEquals(left, right);
+}
+
 } // namespace duckdb

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

@@ -62,8 +62,8 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	}
 #ifdef DEBUG
 	for (auto entry : info.map) {
-		D_ASSERT(!entry.first.get().Equals(&expr));
-		D_ASSERT(!expr.Equals(&entry.first.get()));
+		D_ASSERT(!entry.first.get().Equals(expr));
+		D_ASSERT(!expr.Equals(entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;

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

@@ -64,8 +64,9 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindExpression(expr_ref.Cast<SubqueryExpression>(), depth);
 	case ExpressionClass::PARAMETER:
 		return BindExpression(expr_ref.Cast<ParameterExpression>(), depth);
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindExpression(expr_ref.Cast<PositionalReferenceExpression>(), depth);
+	case ExpressionClass::POSITIONAL_REFERENCE: {
+		return BindPositionalReference(expr, depth, root_expression);
+	}
 	case ExpressionClass::STAR:
 		return BindResult(binder.FormatError(expr_ref, "STAR expression is not supported here"));
 	default:

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

@@ -230,12 +230,12 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 	for (idx_t i = 0; i < node.modifiers.size(); i++) {
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:
-			for (auto &expr : ((BoundDistinctModifier &)*node.modifiers[i]).target_distincts) {
+			for (auto &expr : node.modifiers[i]->Cast<BoundDistinctModifier>().target_distincts) {
 				EnumerateExpression(expr, callback);
 			}
 			break;
 		case ResultModifierType::ORDER_MODIFIER:
-			for (auto &order : ((BoundOrderModifier &)*node.modifiers[i]).orders) {
+			for (auto &order : node.modifiers[i]->Cast<BoundOrderModifier>().orders) {
 				EnumerateExpression(order.expression, callback);
 			}
 			break;

package/src/duckdb/src/planner/filter/conjunction_filter.cpp

@@ -35,7 +35,7 @@ bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
 	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConjunctionOrFilter &)other_p;
+	auto &other = other_p.Cast<ConjunctionOrFilter>();
 	if (other.child_filters.size() != child_filters.size()) {
 		return false;
 	}
@@ -90,7 +90,7 @@ bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
 	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConjunctionAndFilter &)other_p;
+	auto &other = other_p.Cast<ConjunctionAndFilter>();
 	if (other.child_filters.size() != child_filters.size()) {
 		return false;
 	}

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -39,7 +39,7 @@ bool ConstantFilter::Equals(const TableFilter &other_p) const {
 	if (!TableFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConstantFilter &)other_p;
+	auto &other = other_p.Cast<ConstantFilter>();
 	return other.comparison_type == comparison_type && other.constant == constant;
 }
 

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

@@ -109,13 +109,12 @@ void LogicalOperator::Verify(ClientContext &context) {
 		// copy should be identical to original
 		D_ASSERT(expressions[expr_idx]->ToString() == copy->ToString());
 		D_ASSERT(original_hash == copy_hash);
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), copy.get()));
+		D_ASSERT(Expression::Equals(expressions[expr_idx], copy));
 
-		D_ASSERT(!Expression::Equals(expressions[expr_idx].get(), nullptr));
 		for (idx_t other_idx = 0; other_idx < expr_idx; other_idx++) {
 			// comparison with other expressions
 			auto other_hash = expressions[other_idx]->Hash();
-			bool expr_equal = Expression::Equals(expressions[expr_idx].get(), expressions[other_idx].get());
+			bool expr_equal = Expression::Equals(expressions[expr_idx], expressions[other_idx]);
 			if (original_hash != other_hash) {
 				// if the hashes are not equal the expressions should not be equal either
 				D_ASSERT(!expr_equal);
@@ -144,7 +143,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
 		// FIXME: expressions might not be equal yet because of statistics propagation
 		continue;
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), deserialized_expression.get()));
+		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));
 		D_ASSERT(expressions[expr_idx]->Hash() == deserialized_expression->Hash());
 	}
 	D_ASSERT(!ToString().empty());

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

@@ -97,7 +97,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		auto &limit = (LogicalLimitPercent &)op;
+		auto &limit = op.Cast<LogicalLimitPercent>();
 		if (limit.limit) {
 			callback(&limit.limit);
 		}

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

@@ -16,15 +16,16 @@ string LogicalDistinct::ParamsToString() const {
 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");
-	}
+	writer.WriteOptional(order_by);
 }
 
 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), distinct_type);
+	auto order_by = reader.ReadOptional<BoundOrderModifier>(nullptr, state.gstate);
+	auto ret = make_uniq<LogicalDistinct>(std::move(distinct_targets), distinct_type);
+	ret->order_by = std::move(order_by);
+	return std::move(ret);
 }
 
 } // namespace duckdb

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

@@ -19,11 +19,23 @@ vector<ColumnBinding> LogicalPivot::GetColumnBindings() {
 }
 
 void LogicalPivot::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException("Serializing pivot is not supported yet");
+	writer.WriteField(pivot_index);
+	writer.WriteOptional<LogicalOperator>(children.back());
+	writer.WriteField(bound_pivot.group_count);
+	writer.WriteRegularSerializableList<LogicalType>(bound_pivot.types);
+	writer.WriteList<string>(bound_pivot.pivot_values);
+	writer.WriteSerializableList<Expression>(bound_pivot.aggregates);
 }
 
 unique_ptr<LogicalOperator> LogicalPivot::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException("Deserializing pivot is not supported yet");
+	auto pivot_index = reader.ReadRequired<idx_t>();
+	auto plan = reader.ReadOptional<LogicalOperator>(nullptr, state.gstate);
+	BoundPivotInfo info;
+	info.group_count = reader.ReadRequired<idx_t>();
+	info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	info.pivot_values = reader.ReadRequiredList<string>();
+	info.aggregates = reader.ReadRequiredSerializableList<Expression>(state.gstate);
+	return make_uniq<LogicalPivot>(pivot_index, std::move(plan), std::move(info));
 }
 
 vector<idx_t> LogicalPivot::GetTableIndex() const {

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

@@ -1,14 +1,15 @@
 #include "duckdb/planner/planner.hpp"
-#include "duckdb/main/query_profiler.hpp"
+
 #include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
+#include "duckdb/main/query_profiler.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
 
 namespace duckdb {
@@ -142,23 +143,12 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 }
 
 static bool OperatorSupportsSerialization(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_PREPARE:
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		// unsupported (for now)
-		return false;
-	default:
-		break;
-	}
 	for (auto &child : op.children) {
 		if (!OperatorSupportsSerialization(*child)) {
 			return false;
 		}
 	}
-	return true;
+	return op.SupportSerialization();
 }
 
 void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op, bound_parameter_map_t *map) {

package/src/duckdb/src/planner/table_filter.cpp

@@ -14,7 +14,7 @@ void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filt
 	} else {
 		// there is already a filter: AND it together
 		if (entry->second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &and_filter = (ConjunctionAndFilter &)*entry->second;
+			auto &and_filter = entry->second->Cast<ConjunctionAndFilter>();
 			and_filter.child_filters.push_back(std::move(filter));
 		} else {
 			auto and_filter = make_uniq<ConjunctionAndFilter>();

package/src/duckdb/src/storage/arena_allocator.cpp

@@ -31,7 +31,7 @@ struct ArenaAllocatorData : public PrivateAllocatorData {
 };
 
 static data_ptr_t ArenaAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &allocator_data = (ArenaAllocatorData &)*private_data;
+	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
 	return allocator_data.allocator.Allocate(size);
 }
 
@@ -41,7 +41,7 @@ static void ArenaAllocatorFree(PrivateAllocatorData *, data_ptr_t, idx_t) {
 
 static data_ptr_t ArenaAllocateReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
                                           idx_t size) {
-	auto &allocator_data = (ArenaAllocatorData &)*private_data;
+	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
 	return allocator_data.allocator.Reallocate(pointer, old_size, size);
 }
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -49,7 +49,7 @@ unique_ptr<Block> AllocateBlock(BlockManager &block_manager, unique_ptr<FileBuff
 		// re-usable buffer: re-use it
 		if (reusable_buffer->type == FileBufferType::BLOCK) {
 			// we can reuse the buffer entirely
-			auto &block = (Block &)*reusable_buffer;
+			auto &block = reinterpret_cast<Block &>(*reusable_buffer);
 			block.id = block_id;
 			return unique_ptr_cast<FileBuffer, Block>(std::move(reusable_buffer));
 		}