duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -67,7 +67,7 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 	VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN && DelimGetCount(op) == 0) {
 		auto &delim_join = op.Cast<LogicalDelimJoin>();
-		auto decs = &delim_join.duplicate_eliminated_columns;
+		auto &decs = delim_join.duplicate_eliminated_columns;
 		for (auto &cond : delim_join.conditions) {
 			if (!IsEqualityJoinCondition(cond)) {
 				continue;
@@ -83,10 +83,10 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 			auto &colref = rhs->Cast<BoundColumnRefExpression>();
 			if (projection_map.find(colref.binding) != projection_map.end()) {
 				// value on the right is a projection of removed DelimGet
-				for (idx_t i = 0; i < decs->size(); i++) {
-					if (decs->at(i)->Equals(cond.left.get())) {
+				for (idx_t i = 0; i < decs.size(); i++) {
+					if (decs[i]->Equals(*cond.left)) {
 						// the value on the left no longer needs to be a duplicate-eliminated column
-						decs->erase(decs->begin() + i);
+						decs.erase(decs.begin() + i);
 						break;
 					}
 				}
@@ -95,7 +95,7 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 			}
 		}
 		// change type if there are no more duplicate-eliminated columns
-		if (decs->empty()) {
+		if (decs.empty()) {
 			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
 			// sub-plans with DelimGets are not re-orderable (yet), however, we removed all DelimGet of this DelimJoin
 			// the DelimGets are on the RHS of the DelimJoin, so we can call the JoinOrderOptimizer on the RHS now
@@ -198,9 +198,9 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 	idx_t delim_idx = OperatorIsDelimGet(*join.children[0]) ? 0 : 1;
 	D_ASSERT(OperatorIsDelimGet(*join.children[delim_idx]));
 	// get the filter (if any)
-	LogicalFilter *filter = nullptr;
+	optional_ptr<LogicalFilter> filter;
 	if (join.children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
-		filter = (LogicalFilter *)join.children[delim_idx].get();
+		filter = &join.children[delim_idx]->Cast<LogicalFilter>();
 	}
 	auto &delim_get = (filter ? filter->children[0] : join.children[delim_idx])->Cast<LogicalDelimGet>();
 	if (join.conditions.size() != delim_get.chunk_types.size()) {
@@ -231,7 +231,7 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 			updater.projection_map[cb] = true;
 			updater.reverse_proj_or_agg_map[cb] = proj_or_agg.expressions[cb.column_index].get();
 			for (auto &expr : nulls_are_not_equal_exprs) {
-				if (proj_or_agg.expressions[cb.column_index]->Equals(&expr.get())) {
+				if (proj_or_agg.expressions[cb.column_index]->Equals(expr.get())) {
 					updater.projection_map[cb] = false;
 					break;
 				}
@@ -254,8 +254,8 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 			updater.projection_map[cb] = true;
 			updater.reverse_proj_or_agg_map[cb] = all_agg_exprs[cb.column_index];
 			for (auto &expr : nulls_are_not_equal_exprs) {
-				if ((cb.table_index == agg.group_index && agg.groups[cb.column_index]->Equals(&expr.get())) ||
-				    (cb.table_index == agg.aggregate_index && agg.expressions[cb.column_index]->Equals(&expr.get()))) {
+				if ((cb.table_index == agg.group_index && agg.groups[cb.column_index]->Equals(expr.get())) ||
+				    (cb.table_index == agg.aggregate_index && agg.expressions[cb.column_index]->Equals(expr.get()))) {
 					updater.projection_map[cb] = false;
 					break;
 				}
@@ -386,7 +386,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 		}
 		// try to find the corresponding child condition
 		// TODO: can be more flexible - allow CAST
-		auto child_expr = it->second;
+		auto &child_expr = *it->second;
 		bool found = false;
 		for (auto &child_cond : join.conditions) {
 			if (child_cond.left->Equals(child_expr) || child_cond.right->Equals(child_expr)) {
@@ -418,7 +418,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 		auto &parent_expr = parent_delim_get_side == 0 ? parent_cond.left : parent_cond.right;
 		auto &parent_colref = parent_expr->Cast<BoundColumnRefExpression>();
 		auto it = updater.reverse_proj_or_agg_map.find(parent_colref.binding);
-		auto child_expr = it->second;
+		auto &child_expr = *it->second;
 		for (auto &child_cond : join.conditions) {
 			if (!child_cond.left->Equals(child_expr) && !child_cond.right->Equals(child_expr)) {
 				continue;

package/src/duckdb/src/optimizer/expression_heuristics.cpp

@@ -42,6 +42,7 @@ void ExpressionHeuristics::ReorderExpressions(vector<unique_ptr<Expression>> &ex
 	};
 
 	vector<ExpressionCosts> expression_costs;
+	expression_costs.reserve(expressions.size());
 	// iterate expressions, get cost for each one
 	for (idx_t i = 0; i < expressions.size(); i++) {
 		idx_t cost = Cost(*expressions[i]);

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -635,7 +635,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
 		// get the LHS and RHS nodes
 		auto &left_node = GetNode(*comparison.left);
 		auto &right_node = GetNode(*comparison.right);
-		if (left_node.Equals(&right_node)) {
+		if (left_node.Equals(right_node)) {
 			return FilterResult::UNSUPPORTED;
 		}
 		// get the equivalence sets of the LHS and RHS
@@ -806,7 +806,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 		}
 	}
 
-	if (left_node.Equals(&right_node.get())) {
+	if (left_node.Equals(right_node)) {
 		return FilterResult::UNSUPPORTED;
 	}
 	// get the equivalence sets of the LHS and RHS
@@ -903,7 +903,7 @@ unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression &expr) {
 	for (idx_t i = 0; i < remaining_filters.size(); i++) {
 		if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
 			auto &comparison = remaining_filters[i]->Cast<BoundComparisonExpression>();
-			if (expr.Equals(comparison.right.get()) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
+			if (expr.Equals(*comparison.right) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
 				auto filter = std::move(remaining_filters[i]);
 				remaining_filters.erase(remaining_filters.begin() + i);
 				return filter;

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -479,15 +479,15 @@ optional_ptr<TableFilterSet> CardinalityEstimator::GetTableFilters(LogicalOperat
 	return get ? &get->table_filters : nullptr;
 }
 
-idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *filter,
+idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter &filter,
                                                   unique_ptr<BaseStatistics> base_stats) {
 	auto has_equality_filter = false;
 	auto cardinality_after_filters = cardinality;
-	for (auto &child_filter : filter->child_filters) {
+	for (auto &child_filter : filter.child_filters) {
 		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
 			continue;
 		}
-		auto comparison_filter = (ConstantFilter &)*child_filter;
+		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
 		if (comparison_filter.comparison_type != ExpressionType::COMPARE_EQUAL) {
 			continue;
 		}
@@ -510,15 +510,15 @@ idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t colum
 	return cardinality_after_filters;
 }
 
-idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *filter,
+idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &filter,
                                                  unique_ptr<BaseStatistics> base_stats) {
 	auto has_equality_filter = false;
 	auto cardinality_after_filters = cardinality;
-	for (auto &child_filter : filter->child_filters) {
+	for (auto &child_filter : filter.child_filters) {
 		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
 			continue;
 		}
-		auto comparison_filter = (ConstantFilter &)*child_filter;
+		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
 		if (comparison_filter.comparison_type == ExpressionType::COMPARE_EQUAL) {
 			auto column_count = cardinality_after_filters;
 			if (base_stats) {
@@ -549,14 +549,14 @@ idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperat
 			column_statistics = get->function.statistics(context, &table_scan_bind_data, it.first);
 		}
 		if (it.second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &filter = (ConjunctionAndFilter &)*it.second;
+			auto &filter = it.second->Cast<ConjunctionAndFilter>();
 			idx_t cardinality_with_and_filter =
-			    InspectConjunctionAND(cardinality, it.first, &filter, std::move(column_statistics));
+			    InspectConjunctionAND(cardinality, it.first, filter, std::move(column_statistics));
 			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_and_filter);
 		} else if (it.second->filter_type == TableFilterType::CONJUNCTION_OR) {
-			auto &filter = (ConjunctionOrFilter &)*it.second;
+			auto &filter = it.second->Cast<ConjunctionOrFilter>();
 			idx_t cardinality_with_or_filter =
-			    InspectConjunctionOR(cardinality, it.first, &filter, std::move(column_statistics));
+			    InspectConjunctionOR(cardinality, it.first, filter, std::move(column_statistics));
 			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_or_filter);
 		}
 	}

package/src/duckdb/src/optimizer/matcher/expression_matcher.cpp

@@ -19,7 +19,7 @@ bool ExpressionMatcher::Match(Expression &expr, vector<reference<Expression>> &b
 }
 
 bool ExpressionEqualityMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
-	if (!expr.Equals(&expression)) {
+	if (!expr.Equals(expression)) {
 		return false;
 	}
 	bindings.push_back(expr);

package/src/duckdb/src/optimizer/pullup/pullup_projection.cpp

@@ -24,8 +24,8 @@ static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expres
 		BoundColumnRefExpression &colref = expr.Cast<BoundColumnRefExpression>();
 		// find the corresponding column index in the projection expressions
 		for (idx_t proj_idx = 0; proj_idx < proj_expressions.size(); proj_idx++) {
-			auto proj_expr = proj_expressions[proj_idx].get();
-			if (proj_expr->type == ExpressionType::BOUND_COLUMN_REF) {
+			auto &proj_expr = *proj_expressions[proj_idx];
+			if (proj_expr.type == ExpressionType::BOUND_COLUMN_REF) {
 				if (colref.Equals(proj_expr)) {
 					colref.binding.table_index = proj_table_idx;
 					colref.binding.column_index = proj_idx;

package/src/duckdb/src/optimizer/regex_range_filter.cpp

@@ -39,12 +39,10 @@ unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator
 			}
 			auto filter_left = make_uniq<BoundComparisonExpression>(
 			    ExpressionType::COMPARE_GREATERTHANOREQUALTO, func.children[0]->Copy(),
-			    make_uniq<BoundConstantExpression>(
-			        Value::BLOB((const_data_ptr_t)info.range_min.c_str(), info.range_min.size())));
+			    make_uniq<BoundConstantExpression>(Value::BLOB_RAW(info.range_min)));
 			auto filter_right = make_uniq<BoundComparisonExpression>(
 			    ExpressionType::COMPARE_LESSTHANOREQUALTO, func.children[0]->Copy(),
-			    make_uniq<BoundConstantExpression>(
-			        Value::BLOB((const_data_ptr_t)info.range_max.c_str(), info.range_max.size())));
+			    make_uniq<BoundConstantExpression>(Value::BLOB_RAW(info.range_max)));
 			auto filter_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
 			                                                         std::move(filter_left), std::move(filter_right));
 

package/src/duckdb/src/optimizer/rule/distributivity.cpp

@@ -33,7 +33,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 		// AND, remove expression from the list
 		auto &and_expr = child->Cast<BoundConjunctionExpression>();
 		for (idx_t i = 0; i < and_expr.children.size(); i++) {
-			if (Expression::Equals(and_expr.children[i].get(), &expr)) {
+			if (and_expr.children[i]->Equals(expr)) {
 				result = std::move(and_expr.children[i]);
 				and_expr.children.erase(and_expr.children.begin() + i);
 				break;
@@ -45,7 +45,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 	} else {
 		// not an AND node! remove the entire expression
 		// this happens in the case of e.g. (X AND B) OR X
-		D_ASSERT(Expression::Equals(child.get(), &expr));
+		D_ASSERT(child->Equals(expr));
 		result = std::move(child);
 		conj.children[idx] = nullptr;
 	}

package/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp

@@ -161,15 +161,15 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &
 		SetStatisticsNotNull((right.Cast<BoundColumnRefExpression>()).binding);
 	}
 	// check if this is a comparison between a constant and a column ref
-	BoundConstantExpression *constant = nullptr;
-	BoundColumnRefExpression *columnref = nullptr;
+	optional_ptr<BoundConstantExpression> constant;
+	optional_ptr<BoundColumnRefExpression> columnref;
 	if (left.type == ExpressionType::VALUE_CONSTANT && right.type == ExpressionType::BOUND_COLUMN_REF) {
-		constant = (BoundConstantExpression *)&left;
-		columnref = (BoundColumnRefExpression *)&right;
+		constant = &left.Cast<BoundConstantExpression>();
+		columnref = &right.Cast<BoundColumnRefExpression>();
 		comparison_type = FlipComparisonExpression(comparison_type);
 	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::VALUE_CONSTANT) {
-		columnref = (BoundColumnRefExpression *)&left;
-		constant = (BoundConstantExpression *)&right;
+		columnref = &left.Cast<BoundColumnRefExpression>();
+		constant = &right.Cast<BoundConstantExpression>();
 	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::BOUND_COLUMN_REF) {
 		// comparison between two column refs
 		auto &left_column_ref = left.Cast<BoundColumnRefExpression>();

package/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp

@@ -14,14 +14,14 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFi
 	// FIXME: update stats...
 	switch (filter.filter_type) {
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (ConjunctionAndFilter &)filter;
+		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction_and.child_filters) {
 			UpdateFilterStatistics(input, *child_filter);
 		}
 		break;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		UpdateFilterStatistics(input, constant_filter.comparison_type, constant_filter.constant);
 		break;
 	}

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -26,11 +26,7 @@ void UnnestRewriterPlanUpdater::VisitExpression(unique_ptr<Expression> *expressi
 		for (idx_t i = 0; i < replace_bindings.size(); i++) {
 			if (bound_column_ref.binding == replace_bindings[i].old_binding) {
 				bound_column_ref.binding = replace_bindings[i].new_binding;
-			}
-			// previously pointing to the LOGICAL_DELIM_GET
-			if (bound_column_ref.binding.table_index == replace_bindings[i].old_binding.table_index &&
-			    replace_bindings[i].old_binding.column_index == DConstants::INVALID_INDEX) {
-				bound_column_ref.binding = replace_bindings[i].new_binding;
+				break;
 			}
 		}
 	}
@@ -49,6 +45,7 @@ unique_ptr<LogicalOperator> UnnestRewriter::Optimize(unique_ptr<LogicalOperator>
 
 		// rearrange the logical operators
 		if (RewriteCandidate(candidate)) {
+			updater.overwritten_tbl_idx = overwritten_tbl_idx;
 			// update the bindings of the BOUND_UNNEST expression
 			UpdateBoundUnnestBindings(updater, candidate);
 			// update the sequence of LOGICAL_PROJECTION(s)
@@ -106,7 +103,6 @@ void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
 	if (curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST) {
 		candidates.push_back(op_ptr);
 	}
-	return;
 }
 
 bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
@@ -147,6 +143,11 @@ bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
 	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
 	D_ASSERT(unnest.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET);
 	overwritten_tbl_idx = unnest.children[0]->Cast<LogicalDelimGet>().table_index;
+
+	D_ASSERT(!unnest.children.empty());
+	auto &delim_get = unnest.children[0]->Cast<LogicalDelimGet>();
+	D_ASSERT(delim_get.chunk_types.size() > 1);
+	distinct_unnest_count = delim_get.chunk_types.size();
 	unnest.children[0] = std::move(lhs_op);
 
 	// replace the LOGICAL_DELIM_JOIN with its RHS child operator
@@ -168,10 +169,11 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 		D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
 		auto &proj = curr_op->get()->Cast<LogicalProjection>();
 
-		// pop the two last expressions from all projections (delim_idx and UNNEST column)
-		D_ASSERT(proj.expressions.size() > 2);
-		proj.expressions.pop_back();
-		proj.expressions.pop_back();
+		// pop the unnest columns and the delim index
+		D_ASSERT(proj.expressions.size() > distinct_unnest_count);
+		for (idx_t i = 0; i < distinct_unnest_count; i++) {
+			proj.expressions.pop_back();
+		}
 
 		// store all shifted current bindings
 		idx_t tbl_idx = proj.table_index;
@@ -263,14 +265,23 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
 
 	D_ASSERT(unnest.children.size() == 1);
-	auto unnest_child_cols = unnest.children[0]->GetColumnBindings();
-	for (idx_t delim_col_idx = 0; delim_col_idx < delim_columns.size(); delim_col_idx++) {
-		for (idx_t child_col_idx = 0; child_col_idx < unnest_child_cols.size(); child_col_idx++) {
-			if (delim_columns[delim_col_idx].table_index == unnest_child_cols[child_col_idx].table_index) {
-				ColumnBinding old_binding(overwritten_tbl_idx, DConstants::INVALID_INDEX);
-				updater.replace_bindings.emplace_back(old_binding, delim_columns[delim_col_idx]);
+	auto unnest_cols = unnest.children[0]->GetColumnBindings();
+
+	for (idx_t i = 0; i < delim_columns.size(); i++) {
+		auto delim_binding = delim_columns[i];
+
+		auto unnest_it = unnest_cols.begin();
+		while (unnest_it != unnest_cols.end()) {
+			auto unnest_binding = *unnest_it;
+
+			if (delim_binding.table_index == unnest_binding.table_index) {
+				unnest_binding.table_index = overwritten_tbl_idx;
+				unnest_binding.column_index++;
+				updater.replace_bindings.emplace_back(unnest_binding, delim_binding);
+				unnest_cols.erase(unnest_it);
 				break;
 			}
+			unnest_it++;
 		}
 	}
 

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

@@ -562,7 +562,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/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;
 		}
 	}