duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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

@@ -22,24 +22,29 @@ 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);
 		}
 		if (aggr_expr.filter) {
 			callback(aggr_expr.filter);
 		}
+		if (aggr_expr.order_bys) {
+			for (auto &order : aggr_expr.order_bys->orders) {
+				callback(order.expression);
+			}
+		}
 		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);
@@ -48,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);
 		}
@@ -115,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;
 	}
@@ -146,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);
@@ -155,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);
 		}
@@ -164,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;
 	}
@@ -182,35 +187,37 @@ 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;
-		for (idx_t i = 0; i < bound_select.select_list.size(); i++) {
-			EnumerateExpression(bound_select.select_list[i], callback);
+		auto &bound_select = node.Cast<BoundSelectNode>();
+		for (auto &expr : bound_select.select_list) {
+			EnumerateExpression(expr, callback);
 		}
 		EnumerateExpression(bound_select.where_clause, callback);
-		for (idx_t i = 0; i < bound_select.groups.group_expressions.size(); i++) {
-			EnumerateExpression(bound_select.groups.group_expressions[i], callback);
+		for (auto &expr : bound_select.groups.group_expressions) {
+			EnumerateExpression(expr, callback);
 		}
 		EnumerateExpression(bound_select.having, callback);
-		for (idx_t i = 0; i < bound_select.aggregates.size(); i++) {
-			EnumerateExpression(bound_select.aggregates[i], callback);
+		for (auto &expr : bound_select.aggregates) {
+			EnumerateExpression(expr, callback);
 		}
-		for (idx_t i = 0; i < bound_select.unnests.size(); i++) {
-			EnumerateExpression(bound_select.unnests[i], callback);
+		for (auto &entry : bound_select.unnests) {
+			for (auto &expr : entry.second.expressions) {
+				EnumerateExpression(expr, callback);
+			}
 		}
-		for (idx_t i = 0; i < bound_select.windows.size(); i++) {
-			EnumerateExpression(bound_select.windows[i], callback);
+		for (auto &expr : bound_select.windows) {
+			EnumerateExpression(expr, callback);
 		}
 		if (bound_select.from_table) {
 			EnumerateTableRefChildren(*bound_select.from_table, callback);

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

@@ -52,7 +52,7 @@ void ConjunctionOrFilter::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<TableFilter> ConjunctionOrFilter::Deserialize(FieldReader &source) {
-	auto res = make_unique<ConjunctionOrFilter>();
+	auto res = make_uniq<ConjunctionOrFilter>();
 	res->child_filters = source.ReadRequiredSerializableList<TableFilter>();
 	return std::move(res);
 }
@@ -107,7 +107,7 @@ void ConjunctionAndFilter::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<TableFilter> ConjunctionAndFilter::Deserialize(FieldReader &source) {
-	auto res = make_unique<ConjunctionAndFilter>();
+	auto res = make_uniq<ConjunctionAndFilter>();
 	res->child_filters = source.ReadRequiredSerializableList<TableFilter>();
 	return std::move(res);
 }

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

@@ -1,8 +1,6 @@
 #include "duckdb/planner/filter/constant_filter.hpp"
-
+#include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/common/field_writer.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
 
 namespace duckdb {
 
@@ -12,7 +10,7 @@ ConstantFilter::ConstantFilter(ExpressionType comparison_type_p, Value constant_
 }
 
 FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
-	D_ASSERT(constant.type().id() == stats.type.id());
+	D_ASSERT(constant.type().id() == stats.GetType().id());
 	switch (constant.type().InternalType()) {
 	case PhysicalType::UINT8:
 	case PhysicalType::UINT16:
@@ -25,9 +23,9 @@ FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
-		return ((NumericStatistics &)stats).CheckZonemap(comparison_type, constant);
+		return NumericStats::CheckZonemap(stats, comparison_type, constant);
 	case PhysicalType::VARCHAR:
-		return ((StringStatistics &)stats).CheckZonemap(comparison_type, StringValue::Get(constant));
+		return StringStats::CheckZonemap(stats, comparison_type, StringValue::Get(constant));
 	default:
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	}
@@ -53,7 +51,7 @@ void ConstantFilter::Serialize(FieldWriter &writer) const {
 unique_ptr<TableFilter> ConstantFilter::Deserialize(FieldReader &source) {
 	auto comparision_type = source.ReadRequired<ExpressionType>();
 	auto constant = source.ReadRequiredSerializable<Value, Value>();
-	return make_unique<ConstantFilter>(comparision_type, constant);
+	return make_uniq<ConstantFilter>(comparision_type, constant);
 }
 
 } // namespace duckdb

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

@@ -45,14 +45,14 @@ void IsNotNullFilter::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<TableFilter> IsNotNullFilter::Deserialize(FieldReader &source) {
-	return make_unique<IsNotNullFilter>();
+	return make_uniq<IsNotNullFilter>();
 }
 
 void IsNullFilter::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<TableFilter> IsNullFilter::Deserialize(FieldReader &source) {
-	return make_unique<IsNullFilter>();
+	return make_uniq<IsNullFilter>();
 }
 
 } // namespace duckdb

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

@@ -11,7 +11,7 @@ namespace duckdb {
 
 unique_ptr<Expression> JoinCondition::CreateExpression(JoinCondition cond) {
 	auto bound_comparison =
-	    make_unique<BoundComparisonExpression>(cond.comparison, std::move(cond.left), std::move(cond.right));
+	    make_uniq<BoundComparisonExpression>(cond.comparison, std::move(cond.left), std::move(cond.right));
 	return std::move(bound_comparison);
 }
 
@@ -22,8 +22,8 @@ unique_ptr<Expression> JoinCondition::CreateExpression(vector<JoinCondition> con
 		if (!result) {
 			result = std::move(expr);
 		} else {
-			auto conj = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
-			                                                    std::move(result));
+			auto conj = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+			                                                  std::move(result));
 			result = std::move(conj);
 		}
 	}
@@ -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

@@ -128,6 +128,8 @@ void LogicalOperator::Verify(ClientContext &context) {
 			continue;
 		}
 		BufferedSerializer serializer;
+		// We are serializing a query plan
+		serializer.is_query_plan = true;
 		try {
 			expressions[expr_idx]->Serialize(serializer);
 		} catch (NotImplementedException &ex) {
@@ -136,7 +138,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 		}
 
 		auto data = serializer.GetData();
-		auto deserializer = BufferedDeserializer(data.data.get(), data.size);
+		auto deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
 
 		PlanDeserializationState state(context);
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
@@ -255,6 +257,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		result = LogicalDelimJoin::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		result = LogicalAsOfJoin::Deserialize(state, reader);
+		break;
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		result = LogicalComparisonJoin::Deserialize(state, reader);
 		break;
@@ -346,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");
@@ -371,7 +379,7 @@ unique_ptr<LogicalOperator> LogicalOperator::Copy(ClientContext &context) const
 		                              std::string(ex.what()));
 	}
 	auto data = logical_op_serializer.GetData();
-	auto logical_op_deserializer = BufferedDeserializer(data.data.get(), data.size);
+	auto logical_op_deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
 	PlanDeserializationState state(context);
 	auto op_copy = LogicalOperator::Deserialize(logical_op_deserializer, state);
 	return op_copy;

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,28 +30,33 @@ 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);
 		}
+		if (distinct.order_by) {
+			for (auto &order : distinct.order_by->orders) {
+				callback(&order.expression);
+			}
+		}
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_INSERT: {
-		auto &insert = (LogicalInsert &)op;
+		auto &insert = op.Cast<LogicalInsert>();
 		if (insert.on_conflict_condition) {
 			callback(&insert.on_conflict_condition);
 		}
@@ -60,15 +65,16 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		}
 		break;
 	}
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	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);
@@ -76,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);
 		}
@@ -101,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);
 		}
@@ -124,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_aggregate.cpp

@@ -92,7 +92,7 @@ unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(LogicalDeserialization
 	for (idx_t i = 0; i < grouping_functions_size; i++) {
 		grouping_functions.push_back(reader.ReadRequiredList<idx_t>());
 	}
-	auto result = make_unique<LogicalAggregate>(group_index, aggregate_index, std::move(expressions));
+	auto result = make_uniq<LogicalAggregate>(group_index, aggregate_index, std::move(expressions));
 	result->groupings_index = groupings_index;
 	result->groups = std::move(groups);
 	result->grouping_functions = std::move(grouping_functions);

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

@@ -18,7 +18,7 @@ void LogicalAnyJoin::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalAnyJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto join_type = reader.ReadRequired<JoinType>();
 	auto condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto result = make_unique<LogicalAnyJoin>(join_type);
+	auto result = make_uniq<LogicalAnyJoin>(join_type);
 	result->condition = std::move(condition);
 	return std::move(result);
 }

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

@@ -0,0 +1,14 @@
+#include "duckdb/planner/operator/logical_asof_join.hpp"
+
+namespace duckdb {
+
+LogicalAsOfJoin::LogicalAsOfJoin(JoinType type) : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_ASOF_JOIN) {
+}
+
+unique_ptr<LogicalOperator> LogicalAsOfJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
+	auto result = make_uniq<LogicalAsOfJoin>(JoinType::INVALID);
+	LogicalComparisonJoin::Deserialize(*result, state, reader);
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -29,13 +29,13 @@ unique_ptr<LogicalOperator> LogicalColumnDataGet::Deserialize(LogicalDeserializa
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	auto chunk_count = reader.ReadRequired<idx_t>();
-	auto collection = make_unique<ColumnDataCollection>(state.gstate.context, chunk_types);
+	auto collection = make_uniq<ColumnDataCollection>(state.gstate.context, chunk_types);
 	for (idx_t i = 0; i < chunk_count; i++) {
 		DataChunk chunk;
 		chunk.Deserialize(reader.GetSource());
 		collection->Append(chunk);
 	}
-	return make_unique<LogicalColumnDataGet>(table_index, std::move(chunk_types), std::move(collection));
+	return make_uniq<LogicalColumnDataGet>(table_index, std::move(chunk_types), std::move(collection));
 }
 
 vector<idx_t> LogicalColumnDataGet::GetTableIndex() const {

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

@@ -13,8 +13,8 @@ string LogicalComparisonJoin::ParamsToString() const {
 	string result = JoinTypeToString(join_type);
 	for (auto &condition : conditions) {
 		result += "\n";
-		auto expr = make_unique<BoundComparisonExpression>(condition.comparison, condition.left->Copy(),
-		                                                   condition.right->Copy());
+		auto expr =
+		    make_uniq<BoundComparisonExpression>(condition.comparison, condition.left->Copy(), condition.right->Copy());
 		result += expr->ToString();
 	}
 
@@ -36,7 +36,7 @@ void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join,
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,
                                                                FieldReader &reader) {
-	auto result = make_unique<LogicalComparisonJoin>(JoinType::INVALID, state.type);
+	auto result = make_uniq<LogicalComparisonJoin>(JoinType::INVALID, state.type);
 	LogicalComparisonJoin::Deserialize(*result, state, reader);
 	return std::move(result);
 }

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

@@ -11,7 +11,7 @@ namespace duckdb {
 void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
 	writer.WriteString(file_path);
 	writer.WriteField(use_tmp_file);
-	writer.WriteField(allow_overwrite);
+	writer.WriteField(overwrite_or_ignore);
 	writer.WriteField(per_thread_output);
 	writer.WriteList<idx_t>(partition_columns);
 
@@ -29,7 +29,7 @@ void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto file_path = reader.ReadRequired<string>();
 	auto use_tmp_file = reader.ReadRequired<bool>();
-	auto allow_overwrite = reader.ReadRequired<bool>();
+	auto overwrite_or_ignore = reader.ReadRequired<bool>();
 	auto per_thread_output = reader.ReadRequired<bool>();
 	auto partition_columns = reader.ReadRequiredList<idx_t>();
 
@@ -53,10 +53,10 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 		bind_data = copy_func.deserialize(context, reader, copy_func);
 	}
 
-	auto result = make_unique<LogicalCopyToFile>(copy_func, std::move(bind_data));
+	auto result = make_uniq<LogicalCopyToFile>(copy_func, std::move(bind_data));
 	result->file_path = file_path;
 	result->use_tmp_file = use_tmp_file;
-	result->allow_overwrite = allow_overwrite;
+	result->overwrite_or_ignore = overwrite_or_ignore;
 	result->per_thread_output = per_thread_output;
 	result->partition_columns = std::move(partition_columns);
 	return std::move(result);

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

@@ -11,7 +11,7 @@ unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationSta
 	auto info = CreateInfo::Deserialize(reader.GetSource());
 
 	auto schema_catalog_entry = Catalog::GetSchema(context, INVALID_CATALOG, info->schema, true);
-	return make_unique<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
+	return make_uniq<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
 }
 
 idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {

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

@@ -42,8 +42,8 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
 
 	reader.Finalize();
-	return make_unique<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions),
-	                                       *table, std::move(function));
+	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions), *table,
+	                                     std::move(function));
 }
 
 } // namespace duckdb

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

@@ -8,8 +8,8 @@ void LogicalCreateTable::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto info = reader.ReadRequiredSerializable<BoundCreateTableInfo>(state.gstate);
-	auto schema = info->schema;
-	return make_unique<LogicalCreateTable>(schema, std::move(info));
+	auto &schema = info->schema;
+	return make_uniq<LogicalCreateTable>(schema, std::move(info));
 }
 
 idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {

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

@@ -14,7 +14,7 @@ unique_ptr<LogicalOperator> LogicalCrossProduct::Create(unique_ptr<LogicalOperat
 	if (right->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
 		return left;
 	}
-	return make_unique<LogicalCrossProduct>(std::move(left), std::move(right));
+	return make_uniq<LogicalCrossProduct>(std::move(left), std::move(right));
 }
 
 void LogicalCrossProduct::Serialize(FieldWriter &writer) const {

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

@@ -15,7 +15,7 @@ unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(LogicalDeserializationSta
 	auto cte_index = reader.ReadRequired<idx_t>();
 	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	auto bound_columns = reader.ReadRequiredList<string>();
-	return make_unique<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns);
+	return make_uniq<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns);
 }
 
 vector<idx_t> LogicalCTERef::GetTableIndex() const {