duckdb 0.8.1-dev65.0 → 0.8.1

package/src/duckdb/src/parallel/executor.cpp

@@ -95,26 +95,50 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 
 		// create events/stack for this pipeline
 		auto pipeline_event = make_shared<PipelineEvent>(pipeline);
-		optional_ptr<Event> pipeline_finish_event_ptr;
-		if (meta_pipeline->HasFinishEvent(pipeline.get())) {
+
+		auto finish_group = meta_pipeline->GetFinishGroup(pipeline.get());
+		if (finish_group) {
+			// this pipeline is part of a finish group
+			const auto group_entry = event_map.find(*finish_group.get());
+			D_ASSERT(group_entry != event_map.end());
+			auto &group_stack = group_entry->second;
+			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
+			                                  group_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
+
+			// dependencies: base_finish -> pipeline_event -> group_finish
+			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_event);
+			group_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
+
+			// add pipeline stack to event map
+			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
+		} else if (meta_pipeline->HasFinishEvent(pipeline.get())) {
 			// this pipeline has its own finish event (despite going into the same sink - Finalize twice!)
 			auto pipeline_finish_event = make_shared<PipelineFinishEvent>(pipeline);
-			pipeline_finish_event_ptr = pipeline_finish_event.get();
+			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
+			                                  *pipeline_finish_event, base_stack.pipeline_complete_event);
 			events.push_back(std::move(pipeline_finish_event));
-			base_stack.pipeline_complete_event.AddDependency(*pipeline_finish_event_ptr);
+
+			// dependencies: base_finish -> pipeline_event -> pipeline_finish -> base_complete
+			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_finish_event);
+			pipeline_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
+			base_stack.pipeline_complete_event.AddDependency(pipeline_stack.pipeline_finish_event);
+
+			// add pipeline stack to event map
+			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
+
 		} else {
-			pipeline_finish_event_ptr = &base_stack.pipeline_finish_event;
-		}
-		PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
-		                                  *pipeline_finish_event_ptr, base_stack.pipeline_complete_event);
-		events.push_back(std::move(pipeline_event));
+			// no additional finish event
+			PipelineEventStack pipeline_stack(base_stack.pipeline_initialize_event, *pipeline_event,
+			                                  base_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
 
-		// dependencies: base_initialize -> pipeline_event -> base_finish
-		pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_initialize_event);
-		pipeline_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
+			// dependencies: base_initialize -> pipeline_event -> base_finish
+			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_initialize_event);
+			base_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
 
-		// add pipeline stack to event map
-		event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
+			// add pipeline stack to event map
+			event_map.insert(make_pair(reference<Pipeline>(*pipeline), pipeline_stack));
+		}
+		events.push_back(std::move(pipeline_event));
 	}
 
 	// add base stack to the event data too
@@ -562,7 +586,7 @@ bool Executor::HasResultCollector() {
 
 unique_ptr<QueryResult> Executor::GetResult() {
 	D_ASSERT(HasResultCollector());
-	auto &result_collector = (PhysicalResultCollector &)*physical_plan;
+	auto &result_collector = physical_plan->Cast<PhysicalResultCollector>();
 	D_ASSERT(result_collector.sink_state);
 	return result_collector.GetResult(*result_collector.sink_state);
 }

package/src/duckdb/src/parallel/meta_pipeline.cpp

@@ -70,7 +70,6 @@ void MetaPipeline::AssignNextBatchIndex(Pipeline *pipeline) {
 void MetaPipeline::Build(PhysicalOperator &op) {
 	D_ASSERT(pipelines.size() == 1);
 	D_ASSERT(children.empty());
-	D_ASSERT(final_pipelines.empty());
 	op.BuildPipelines(*pipelines.back(), *this);
 }
 
@@ -125,13 +124,28 @@ void MetaPipeline::AddDependenciesFrom(Pipeline *dependant, Pipeline *start, boo
 }
 
 void MetaPipeline::AddFinishEvent(Pipeline *pipeline) {
+	D_ASSERT(finish_pipelines.find(pipeline) == finish_pipelines.end());
 	finish_pipelines.insert(pipeline);
+
+	// add all pipelines that were added since 'pipeline' was added (including 'pipeline') to the finish group
+	auto it = pipelines.begin();
+	for (; it->get() != pipeline; it++) {
+	}
+	it++;
+	for (; it != pipelines.end(); it++) {
+		finish_map.emplace(it->get(), pipeline);
+	}
 }
 
-bool MetaPipeline::HasFinishEvent(Pipeline *pipeline) {
+bool MetaPipeline::HasFinishEvent(Pipeline *pipeline) const {
 	return finish_pipelines.find(pipeline) != finish_pipelines.end();
 }
 
+optional_ptr<Pipeline> MetaPipeline::GetFinishGroup(Pipeline *pipeline) const {
+	auto it = finish_map.find(pipeline);
+	return it == finish_map.end() ? nullptr : it->second;
+}
+
 Pipeline *MetaPipeline::CreateUnionPipeline(Pipeline &current, bool order_matters) {
 	// create the union pipeline (batch index 0, should be set correctly afterwards)
 	auto union_pipeline = CreatePipeline();
@@ -162,7 +176,7 @@ void MetaPipeline::CreateChildPipeline(Pipeline &current, PhysicalOperator &op,
 	auto child_pipeline = pipelines.back().get();
 	child_pipeline->base_batch_index = current.base_batch_index;
 
-	// child pipeline has a depency (within this MetaPipeline on all pipelines that were scheduled
+	// child pipeline has a dependency (within this MetaPipeline on all pipelines that were scheduled
 	// between 'current' and now (including 'current') - set them up
 	dependencies[child_pipeline].push_back(&current);
 	AddDependenciesFrom(child_pipeline, last_pipeline, false);

package/src/duckdb/src/parser/base_expression.cpp

@@ -18,11 +18,8 @@ string BaseExpression::GetName() const {
 	return !alias.empty() ? alias : ToString();
 }
 
-bool BaseExpression::Equals(const BaseExpression *other) const {
-	if (!other) {
-		return false;
-	}
-	if (this->expression_class != other->expression_class || this->type != other->type) {
+bool BaseExpression::Equals(const BaseExpression &other) const {
+	if (expression_class != other.expression_class || type != other.type) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/column_definition.cpp

@@ -50,6 +50,7 @@ void ColumnDefinition::Serialize(Serializer &serializer) const {
 		writer.WriteOptional(default_value);
 	}
 	writer.WriteField<TableColumnType>(category);
+	writer.WriteField<duckdb::CompressionType>(compression_type);
 	writer.Finalize();
 }
 
@@ -59,16 +60,12 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
 	auto category = reader.ReadField<TableColumnType>(TableColumnType::STANDARD);
+	auto compression_type = reader.ReadField<duckdb::CompressionType>(duckdb::CompressionType::COMPRESSION_AUTO);
 	reader.Finalize();
 
-	switch (category) {
-	case TableColumnType::STANDARD:
-		return ColumnDefinition(column_name, column_type, std::move(expression), TableColumnType::STANDARD);
-	case TableColumnType::GENERATED:
-		return ColumnDefinition(column_name, column_type, std::move(expression), TableColumnType::GENERATED);
-	default:
-		throw NotImplementedException("Type not implemented for TableColumnType");
-	}
+	ColumnDefinition result(column_name, column_type, std::move(expression), category);
+	result.compression_type = compression_type;
+	return result;
 }
 
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {

package/src/duckdb/src/parser/expression/between_expression.cpp

@@ -15,14 +15,14 @@ string BetweenExpression::ToString() const {
 	return ToString<BetweenExpression, ParsedExpression>(*this);
 }
 
-bool BetweenExpression::Equal(const BetweenExpression *a, const BetweenExpression *b) {
-	if (!a->input->Equals(b->input.get())) {
+bool BetweenExpression::Equal(const BetweenExpression &a, const BetweenExpression &b) {
+	if (!a.input->Equals(*b.input)) {
 		return false;
 	}
-	if (!a->lower->Equals(b->lower.get())) {
+	if (!a.lower->Equals(*b.lower)) {
 		return false;
 	}
-	if (!a->upper->Equals(b->upper.get())) {
+	if (!a.upper->Equals(*b.upper)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -27,19 +27,19 @@ string CaseExpression::ToString() const {
 	return ToString<CaseExpression, ParsedExpression>(*this);
 }
 
-bool CaseExpression::Equal(const CaseExpression *a, const CaseExpression *b) {
-	if (a->case_checks.size() != b->case_checks.size()) {
+bool CaseExpression::Equal(const CaseExpression &a, const CaseExpression &b) {
+	if (a.case_checks.size() != b.case_checks.size()) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->case_checks.size(); i++) {
-		if (!a->case_checks[i].when_expr->Equals(b->case_checks[i].when_expr.get())) {
+	for (idx_t i = 0; i < a.case_checks.size(); i++) {
+		if (!a.case_checks[i].when_expr->Equals(*b.case_checks[i].when_expr)) {
 			return false;
 		}
-		if (!a->case_checks[i].then_expr->Equals(b->case_checks[i].then_expr.get())) {
+		if (!a.case_checks[i].then_expr->Equals(*b.case_checks[i].then_expr)) {
 			return false;
 		}
 	}
-	if (!a->else_expr->Equals(b->else_expr.get())) {
+	if (!a.else_expr->Equals(*b.else_expr)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/cast_expression.cpp

@@ -19,14 +19,14 @@ string CastExpression::ToString() const {
 	return ToString<CastExpression, ParsedExpression>(*this);
 }
 
-bool CastExpression::Equal(const CastExpression *a, const CastExpression *b) {
-	if (!a->child->Equals(b->child.get())) {
+bool CastExpression::Equal(const CastExpression &a, const CastExpression &b) {
+	if (!a.child->Equals(*b.child)) {
 		return false;
 	}
-	if (a->cast_type != b->cast_type) {
+	if (a.cast_type != b.cast_type) {
 		return false;
 	}
-	if (a->try_cast != b->try_cast) {
+	if (a.try_cast != b.try_cast) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/collate_expression.cpp

@@ -18,11 +18,11 @@ string CollateExpression::ToString() const {
 	return StringUtil::Format("%s COLLATE %s", child->ToString(), SQLIdentifier(collation));
 }
 
-bool CollateExpression::Equal(const CollateExpression *a, const CollateExpression *b) {
-	if (!a->child->Equals(b->child.get())) {
+bool CollateExpression::Equal(const CollateExpression &a, const CollateExpression &b) {
+	if (!a.child->Equals(*b.child)) {
 		return false;
 	}
-	if (a->collation != b->collation) {
+	if (a.collation != b.collation) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -64,12 +64,12 @@ string ColumnRefExpression::ToString() const {
 	return result;
 }
 
-bool ColumnRefExpression::Equal(const ColumnRefExpression *a, const ColumnRefExpression *b) {
-	if (a->column_names.size() != b->column_names.size()) {
+bool ColumnRefExpression::Equal(const ColumnRefExpression &a, const ColumnRefExpression &b) {
+	if (a.column_names.size() != b.column_names.size()) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->column_names.size(); i++) {
-		if (!StringUtil::CIEquals(a->column_names[i], b->column_names[i])) {
+	for (idx_t i = 0; i < a.column_names.size(); i++) {
+		if (!StringUtil::CIEquals(a.column_names[i], b.column_names[i])) {
 			return false;
 		}
 	}

package/src/duckdb/src/parser/expression/comparison_expression.cpp

@@ -18,11 +18,11 @@ string ComparisonExpression::ToString() const {
 	return ToString<ComparisonExpression, ParsedExpression>(*this);
 }
 
-bool ComparisonExpression::Equal(const ComparisonExpression *a, const ComparisonExpression *b) {
-	if (!a->left->Equals(b->left.get())) {
+bool ComparisonExpression::Equal(const ComparisonExpression &a, const ComparisonExpression &b) {
+	if (!a.left->Equals(*b.left)) {
 		return false;
 	}
-	if (!a->right->Equals(b->right.get())) {
+	if (!a.right->Equals(*b.right)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -42,8 +42,8 @@ string ConjunctionExpression::ToString() const {
 	return ToString<ConjunctionExpression, ParsedExpression>(*this);
 }
 
-bool ConjunctionExpression::Equal(const ConjunctionExpression *a, const ConjunctionExpression *b) {
-	return ExpressionUtil::SetEquals(a->children, b->children);
+bool ConjunctionExpression::Equal(const ConjunctionExpression &a, const ConjunctionExpression &b) {
+	return ExpressionUtil::SetEquals(a.children, b.children);
 }
 
 unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -18,8 +18,8 @@ string ConstantExpression::ToString() const {
 	return value.ToSQLString();
 }
 
-bool ConstantExpression::Equal(const ConstantExpression *a, const ConstantExpression *b) {
-	return a->value.type() == b->value.type() && !ValueOperations::DistinctFrom(a->value, b->value);
+bool ConstantExpression::Equal(const ConstantExpression &a, const ConstantExpression &b) {
+	return a.value.type() == b.value.type() && !ValueOperations::DistinctFrom(a.value, b.value);
 }
 
 hash_t ConstantExpression::Hash() const {

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -37,26 +37,26 @@ string FunctionExpression::ToString() const {
 	                                                      filter.get(), order_bys.get(), export_state, true);
 }
 
-bool FunctionExpression::Equal(const FunctionExpression *a, const FunctionExpression *b) {
-	if (a->catalog != b->catalog || a->schema != b->schema || a->function_name != b->function_name ||
-	    b->distinct != a->distinct) {
+bool FunctionExpression::Equal(const FunctionExpression &a, const FunctionExpression &b) {
+	if (a.catalog != b.catalog || a.schema != b.schema || a.function_name != b.function_name ||
+	    b.distinct != a.distinct) {
 		return false;
 	}
-	if (b->children.size() != a->children.size()) {
+	if (b.children.size() != a.children.size()) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
+	for (idx_t i = 0; i < a.children.size(); i++) {
+		if (!a.children[i]->Equals(*b.children[i])) {
 			return false;
 		}
 	}
-	if (!BaseExpression::Equals(a->filter.get(), b->filter.get())) {
+	if (!ParsedExpression::Equals(a.filter, b.filter)) {
 		return false;
 	}
-	if (!a->order_bys->Equals(b->order_bys.get())) {
+	if (!OrderModifier::Equals(a.order_bys, b.order_bys)) {
 		return false;
 	}
-	if (a->export_state != b->export_state) {
+	if (a.export_state != b.export_state) {
 		return false;
 	}
 	return true;
@@ -81,11 +81,7 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 	if (filter) {
 		filter_copy = filter->Copy();
 	}
-	unique_ptr<OrderModifier> order_copy;
-	if (order_bys) {
-		order_copy.reset(static_cast<OrderModifier *>(order_bys->Copy().release()));
-	}
-
+	auto order_copy = order_bys ? unique_ptr_cast<ResultModifier, OrderModifier>(order_bys->Copy()) : nullptr;
 	auto copy =
 	    make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(copy_children), std::move(filter_copy),
 	                                  std::move(order_copy), distinct, is_operator, export_state);

package/src/duckdb/src/parser/expression/lambda_expression.cpp

@@ -16,8 +16,8 @@ string LambdaExpression::ToString() const {
 	return lhs->ToString() + " -> " + expr->ToString();
 }
 
-bool LambdaExpression::Equal(const LambdaExpression *a, const LambdaExpression *b) {
-	return a->lhs->Equals(b->lhs.get()) && a->expr->Equals(b->expr.get());
+bool LambdaExpression::Equal(const LambdaExpression &a, const LambdaExpression &b) {
+	return a.lhs->Equals(*b.lhs) && a.expr->Equals(*b.expr);
 }
 
 hash_t LambdaExpression::Hash() const {

package/src/duckdb/src/parser/expression/operator_expression.cpp

@@ -27,12 +27,12 @@ string OperatorExpression::ToString() const {
 	return ToString<OperatorExpression, ParsedExpression>(*this);
 }
 
-bool OperatorExpression::Equal(const OperatorExpression *a, const OperatorExpression *b) {
-	if (a->children.size() != b->children.size()) {
+bool OperatorExpression::Equal(const OperatorExpression &a, const OperatorExpression &b) {
+	if (a.children.size() != b.children.size()) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
+	for (idx_t i = 0; i < a.children.size(); i++) {
+		if (!a.children[i]->Equals(*b.children[i])) {
 			return false;
 		}
 	}

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -25,8 +25,8 @@ unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
 	return std::move(copy);
 }
 
-bool ParameterExpression::Equal(const ParameterExpression *a, const ParameterExpression *b) {
-	return a->parameter_nr == b->parameter_nr;
+bool ParameterExpression::Equal(const ParameterExpression &a, const ParameterExpression &b) {
+	return a.parameter_nr == b.parameter_nr;
 }
 
 hash_t ParameterExpression::Hash() const {

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -18,9 +18,9 @@ string PositionalReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression *a,
-                                          const PositionalReferenceExpression *b) {
-	return a->index == b->index;
+bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression &a,
+                                          const PositionalReferenceExpression &b) {
+	return a.index == b.index;
 }
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::Copy() const {

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -54,26 +54,26 @@ string StarExpression::ToString() const {
 	return result;
 }
 
-bool StarExpression::Equal(const StarExpression *a, const StarExpression *b) {
-	if (a->relation_name != b->relation_name || a->exclude_list != b->exclude_list) {
+bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
+	if (a.relation_name != b.relation_name || a.exclude_list != b.exclude_list) {
 		return false;
 	}
-	if (a->columns != b->columns) {
+	if (a.columns != b.columns) {
 		return false;
 	}
-	if (a->replace_list.size() != b->replace_list.size()) {
+	if (a.replace_list.size() != b.replace_list.size()) {
 		return false;
 	}
-	for (auto &entry : a->replace_list) {
-		auto other_entry = b->replace_list.find(entry.first);
-		if (other_entry == b->replace_list.end()) {
+	for (auto &entry : a.replace_list) {
+		auto other_entry = b.replace_list.find(entry.first);
+		if (other_entry == b.replace_list.end()) {
 			return false;
 		}
-		if (!entry.second->Equals(other_entry->second.get())) {
+		if (!entry.second->Equals(*other_entry->second)) {
 			return false;
 		}
 	}
-	if (!BaseExpression::Equals(a->expr.get(), b->expr.get())) {
+	if (!ParsedExpression::Equals(a.expr, b.expr)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -28,15 +28,15 @@ string SubqueryExpression::ToString() const {
 	}
 }
 
-bool SubqueryExpression::Equal(const SubqueryExpression *a, const SubqueryExpression *b) {
-	if (!a->subquery || !b->subquery) {
+bool SubqueryExpression::Equal(const SubqueryExpression &a, const SubqueryExpression &b) {
+	if (!a.subquery || !b.subquery) {
 		return false;
 	}
-	if (!BaseExpression::Equals(a->child.get(), b->child.get())) {
+	if (!ParsedExpression::Equals(a.child, b.child)) {
 		return false;
 	}
-	return a->comparison_type == b->comparison_type && a->subquery_type == b->subquery_type &&
-	       a->subquery->Equals(b->subquery.get());
+	return a.comparison_type == b.comparison_type && a.subquery_type == b.subquery_type &&
+	       a.subquery->Equals(*b.subquery);
 }
 
 unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -63,53 +63,42 @@ string WindowExpression::ToString() const {
 	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
 }
 
-bool WindowExpression::Equal(const WindowExpression *a, const WindowExpression *b) {
+bool WindowExpression::Equal(const WindowExpression &a, const WindowExpression &b) {
 	// check if the child expressions are equivalent
-	if (b->children.size() != a->children.size()) {
+	if (a.ignore_nulls != b.ignore_nulls) {
 		return false;
 	}
-	if (a->ignore_nulls != b->ignore_nulls) {
+	if (!ParsedExpression::ListEquals(a.children, b.children)) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
-			return false;
-		}
-	}
-	if (a->start != b->start || a->end != b->end) {
+	if (a.start != b.start || a.end != b.end) {
 		return false;
 	}
 	// check if the framing expressions are equivalentbind_
-	if (!BaseExpression::Equals(a->start_expr.get(), b->start_expr.get()) ||
-	    !BaseExpression::Equals(a->end_expr.get(), b->end_expr.get()) ||
-	    !BaseExpression::Equals(a->offset_expr.get(), b->offset_expr.get()) ||
-	    !BaseExpression::Equals(a->default_expr.get(), b->default_expr.get())) {
+	if (!ParsedExpression::Equals(a.start_expr, b.start_expr) || !ParsedExpression::Equals(a.end_expr, b.end_expr) ||
+	    !ParsedExpression::Equals(a.offset_expr, b.offset_expr) ||
+	    !ParsedExpression::Equals(a.default_expr, b.default_expr)) {
 		return false;
 	}
 
 	// check if the partitions are equivalent
-	if (a->partitions.size() != b->partitions.size()) {
+	if (!ParsedExpression::ListEquals(a.partitions, b.partitions)) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->partitions.size(); i++) {
-		if (!a->partitions[i]->Equals(b->partitions[i].get())) {
-			return false;
-		}
-	}
 	// check if the orderings are equivalent
-	if (a->orders.size() != b->orders.size()) {
+	if (a.orders.size() != b.orders.size()) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->orders.size(); i++) {
-		if (a->orders[i].type != b->orders[i].type) {
+	for (idx_t i = 0; i < a.orders.size(); i++) {
+		if (a.orders[i].type != b.orders[i].type) {
 			return false;
 		}
-		if (!a->orders[i].expression->Equals(b->orders[i].expression.get())) {
+		if (!a.orders[i].expression->Equals(*b.orders[i].expression)) {
 			return false;
 		}
 	}
 	// check if the filter clauses are equivalent
-	if (!BaseExpression::Equals(a->filter_expr.get(), b->filter_expr.get())) {
+	if (!ParsedExpression::Equals(a.filter_expr, b.filter_expr)) {
 		return false;
 	}
 

package/src/duckdb/src/parser/parsed_data/create_info.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
@@ -43,8 +42,6 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateSchemaInfo::Deserialize(deserializer);
 	case CatalogType::VIEW_ENTRY:
 		return CreateViewInfo::Deserialize(deserializer);
-	case CatalogType::DATABASE_ENTRY:
-		return CreateDatabaseInfo::Deserialize(deserializer);
 	case CatalogType::TYPE_ENTRY:
 		return CreateTypeInfo::Deserialize(deserializer);
 	case CatalogType::MACRO_ENTRY: