duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -33,7 +33,7 @@ static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &le
 		if (left_side == JoinSide::RIGHT) {
 			// left = right, right = left, flip the comparison symbol and reverse sides
 			swap(left, right);
-			condition.comparison = FlipComparisionExpression(expr.type);
+			condition.comparison = FlipComparisonExpression(expr.type);
 		}
 		condition.left = std::move(left);
 		condition.right = std::move(right);

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

@@ -28,4 +28,8 @@ void BoundExpression::Serialize(FieldWriter &writer) const {
 	throw SerializationException("Cannot copy or serialize bound expression");
 }
 
+void BoundExpression::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("Cannot copy or serialize bound expression");
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/checkpoint/table_data_reader.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/storage/checkpoint/table_data_reader.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
-
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/types/null_value.hpp"
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
@@ -9,9 +7,6 @@
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 
 #include "duckdb/main/database.hpp"
-#include "duckdb/main/client_context.hpp"
-
-#include "duckdb/storage/table/row_group.hpp"
 
 namespace duckdb {
 
@@ -27,12 +22,9 @@ void TableDataReader::ReadTableData() {
 	info.data->table_stats.Deserialize(reader, columns);
 
 	// deserialize each of the individual row groups
-	auto row_group_count = reader.Read<uint64_t>();
-	info.data->row_groups.reserve(row_group_count);
-	for (idx_t i = 0; i < row_group_count; i++) {
-		auto row_group_pointer = RowGroup::Deserialize(reader, columns);
-		info.data->row_groups.push_back(std::move(row_group_pointer));
-	}
+	info.data->row_group_count = reader.Read<uint64_t>();
+	info.data->block_id = reader.block->BlockId();
+	info.data->offset = reader.offset;
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -50,13 +50,19 @@ void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, Da
 
 	// now start writing the row group pointers to disk
 	table_data_writer.Write<uint64_t>(row_group_pointers.size());
+	idx_t total_rows = 0;
 	for (auto &row_group_pointer : row_group_pointers) {
+		auto row_group_count = row_group_pointer.row_start + row_group_pointer.tuple_count;
+		if (row_group_count > total_rows) {
+			total_rows = row_group_count;
+		}
 		RowGroup::Serialize(row_group_pointer, table_data_writer);
 	}
 
 	// Pointer to the table itself goes to the metadata stream.
 	meta_data_writer.Write<block_id_t>(pointer.block_id);
 	meta_data_writer.Write<uint64_t>(pointer.offset);
+	meta_data_writer.Write<idx_t>(total_rows);
 
 	// Now we serialize indexes in the table_metadata_writer
 	std::vector<BlockPointer> index_pointers = info->indexes.SerializeIndexes(table_data_writer);

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -467,6 +467,7 @@ void CheckpointReader::ReadTableData(ClientContext &context, MetaBlockReader &re
 	TableDataReader data_reader(table_data_reader, bound_info);
 
 	data_reader.ReadTableData();
+	bound_info.data->total_rows = reader.Read<idx_t>();
 
 	// Get any indexes block info
 	idx_t num_indexes = reader.Read<idx_t>();

package/src/duckdb/src/storage/compression/numeric_constant.cpp

@@ -33,7 +33,7 @@ void ConstantFillFunction(ColumnSegment &segment, Vector &result, idx_t start_id
 	auto &nstats = segment.stats.statistics;
 
 	auto data = FlatVector::GetData<T>(result);
-	auto constant_value = NumericStats::GetMinUnsafe<T>(nstats);
+	auto constant_value = NumericStats::GetMin<T>(nstats);
 	for (idx_t i = 0; i < count; i++) {
 		data[start_idx + i] = constant_value;
 	}
@@ -71,7 +71,7 @@ void ConstantScanFunction(ColumnSegment &segment, ColumnScanState &state, idx_t
 	auto &nstats = segment.stats.statistics;
 
 	auto data = FlatVector::GetData<T>(result);
-	data[0] = NumericStats::GetMinUnsafe<T>(nstats);
+	data[0] = NumericStats::GetMin<T>(nstats);
 	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 }
 

package/src/duckdb/src/storage/data_table.cpp

@@ -45,7 +45,7 @@ DataTable::DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_m
 	auto types = GetTypes();
 	this->row_groups =
 	    make_shared<RowGroupCollection>(info, TableIOManager::Get(*this).GetBlockManagerForRowData(), types, 0);
-	if (data && !data->row_groups.empty()) {
+	if (data && data->row_group_count > 0) {
 		this->row_groups->Initialize(*data);
 	} else {
 		this->row_groups->InitializeEmpty();

package/src/duckdb/src/storage/statistics/numeric_stats.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/vector.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
 
 namespace duckdb {
 
@@ -13,6 +14,9 @@ template <>
 void NumericStats::Update<list_entry_t>(BaseStatistics &stats, list_entry_t new_value) {
 }
 
+//===--------------------------------------------------------------------===//
+// NumericStats
+//===--------------------------------------------------------------------===//
 BaseStatistics NumericStats::CreateUnknown(LogicalType type) {
 	BaseStatistics result(std::move(type));
 	result.InitializeUnknown();
@@ -62,73 +66,149 @@ void NumericStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 	}
 }
 
-FilterPropagateResult NumericStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-                                                 const Value &constant) {
-	if (constant.IsNull()) {
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (!NumericStats::HasMinMax(stats)) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	auto min_value = NumericStats::Min(stats);
-	auto max_value = NumericStats::Max(stats);
+struct GetNumericValueUnion {
+	template <class T>
+	static T Operation(const NumericValueUnion &v);
+};
+
+template <>
+int8_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.tinyint;
+}
+
+template <>
+int16_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.smallint;
+}
+
+template <>
+int32_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.integer;
+}
+
+template <>
+int64_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.bigint;
+}
+
+template <>
+hugeint_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.hugeint;
+}
+
+template <>
+uint8_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.utinyint;
+}
+
+template <>
+uint16_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.usmallint;
+}
+
+template <>
+uint32_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.uinteger;
+}
+
+template <>
+uint64_t GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.ubigint;
+}
+
+template <>
+float GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.float_;
+}
+
+template <>
+double GetNumericValueUnion::Operation(const NumericValueUnion &v) {
+	return v.value_.double_;
+}
+
+template <class T>
+T NumericStats::GetMinUnsafe(const BaseStatistics &stats) {
+	return GetNumericValueUnion::Operation<T>(NumericStats::GetDataUnsafe(stats).min);
+}
+
+template <class T>
+T NumericStats::GetMaxUnsafe(const BaseStatistics &stats) {
+	return GetNumericValueUnion::Operation<T>(NumericStats::GetDataUnsafe(stats).max);
+}
+
+template <class T>
+bool ConstantExactRange(T min, T max, T constant) {
+	return Equals::Operation(constant, min) && Equals::Operation(constant, max);
+}
+
+template <class T>
+bool ConstantValueInRange(T min, T max, T constant) {
+	return !(LessThan::Operation(constant, min) || GreaterThan::Operation(constant, max));
+}
+
+template <class T>
+FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, ExpressionType comparison_type,
+                                            const Value &constant_value) {
+	T min_value = NumericStats::GetMinUnsafe<T>(stats);
+	T max_value = NumericStats::GetMaxUnsafe<T>(stats);
+	T constant = constant_value.GetValueUnsafe<T>();
 	switch (comparison_type) {
 	case ExpressionType::COMPARE_EQUAL:
-		if (constant == min_value && constant == max_value) {
+		if (ConstantExactRange(min_value, max_value, constant)) {
 			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (constant >= min_value && constant <= max_value) {
+		}
+		if (ConstantValueInRange(min_value, max_value, constant)) {
 			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
+		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 	case ExpressionType::COMPARE_NOTEQUAL:
-		if (constant < min_value || constant > max_value) {
+		if (!ConstantValueInRange(min_value, max_value, constant)) {
 			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min_value == max_value && min_value == constant) {
+		} else if (ConstantExactRange(min_value, max_value, constant)) {
 			// corner case of a cluster with one numeric equal to the target constant
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// X >= C
+		// GreaterThanEquals::Operation(X, C)
 		// this can be true only if max(X) >= C
 		// if min(X) >= C, then this is always true
-		if (min_value >= constant) {
+		if (GreaterThanEquals::Operation(min_value, constant)) {
 			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (max_value >= constant) {
+		} else if (GreaterThanEquals::Operation(max_value, constant)) {
 			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
 	case ExpressionType::COMPARE_GREATERTHAN:
-		// X > C
+		// GreaterThan::Operation(X, C)
 		// this can be true only if max(X) > C
 		// if min(X) > C, then this is always true
-		if (min_value > constant) {
+		if (GreaterThan::Operation(min_value, constant)) {
 			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (max_value > constant) {
+		} else if (GreaterThan::Operation(max_value, constant)) {
 			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
 	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// X <= C
+		// LessThanEquals::Operation(X, C)
 		// this can be true only if min(X) <= C
 		// if max(X) <= C, then this is always true
-		if (max_value <= constant) {
+		if (LessThanEquals::Operation(max_value, constant)) {
 			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min_value <= constant) {
+		} else if (LessThanEquals::Operation(min_value, constant)) {
 			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
 	case ExpressionType::COMPARE_LESSTHAN:
-		// X < C
+		// LessThan::Operation(X, C)
 		// this can be true only if min(X) < C
 		// if max(X) < C, then this is always true
-		if (max_value < constant) {
+		if (LessThan::Operation(max_value, constant)) {
 			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min_value < constant) {
+		} else if (LessThan::Operation(min_value, constant)) {
 			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
@@ -138,6 +218,43 @@ FilterPropagateResult NumericStats::CheckZonemap(const BaseStatistics &stats, Ex
 	}
 }
 
+FilterPropagateResult NumericStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+                                                 const Value &constant) {
+	D_ASSERT(constant.type() == stats.GetType());
+	if (constant.IsNull()) {
+		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
+	}
+	if (!NumericStats::HasMinMax(stats)) {
+		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
+	}
+	switch (stats.GetType().InternalType()) {
+	case PhysicalType::INT8:
+		return CheckZonemapTemplated<int8_t>(stats, comparison_type, constant);
+	case PhysicalType::INT16:
+		return CheckZonemapTemplated<int16_t>(stats, comparison_type, constant);
+	case PhysicalType::INT32:
+		return CheckZonemapTemplated<int32_t>(stats, comparison_type, constant);
+	case PhysicalType::INT64:
+		return CheckZonemapTemplated<int64_t>(stats, comparison_type, constant);
+	case PhysicalType::UINT8:
+		return CheckZonemapTemplated<uint8_t>(stats, comparison_type, constant);
+	case PhysicalType::UINT16:
+		return CheckZonemapTemplated<uint16_t>(stats, comparison_type, constant);
+	case PhysicalType::UINT32:
+		return CheckZonemapTemplated<uint32_t>(stats, comparison_type, constant);
+	case PhysicalType::UINT64:
+		return CheckZonemapTemplated<uint64_t>(stats, comparison_type, constant);
+	case PhysicalType::INT128:
+		return CheckZonemapTemplated<hugeint_t>(stats, comparison_type, constant);
+	case PhysicalType::FLOAT:
+		return CheckZonemapTemplated<float>(stats, comparison_type, constant);
+	case PhysicalType::DOUBLE:
+		return CheckZonemapTemplated<double>(stats, comparison_type, constant);
+	default:
+		throw InternalException("Unsupported type for NumericStats::CheckZonemap");
+	}
+}
+
 bool NumericStats::IsConstant(const BaseStatistics &stats) {
 	return NumericStats::Max(stats) <= NumericStats::Min(stats);
 }
@@ -471,59 +588,4 @@ void NumericStats::Verify(const BaseStatistics &stats, Vector &vector, const Sel
 	}
 }
 
-template <>
-int8_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.tinyint;
-}
-
-template <>
-int16_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.smallint;
-}
-
-template <>
-int32_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.integer;
-}
-
-template <>
-int64_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.bigint;
-}
-
-template <>
-hugeint_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.hugeint;
-}
-
-template <>
-uint8_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.utinyint;
-}
-
-template <>
-uint16_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.usmallint;
-}
-
-template <>
-uint32_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.uinteger;
-}
-
-template <>
-uint64_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.ubigint;
-}
-
-template <>
-float &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.float_;
-}
-
-template <>
-double &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.double_;
-}
-
 } // namespace duckdb

package/src/duckdb/src/storage/statistics/numeric_stats_union.cpp

@@ -0,0 +1,65 @@
+#include "duckdb/storage/statistics/numeric_stats_union.hpp"
+
+namespace duckdb {
+
+template <>
+bool &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.boolean;
+}
+
+template <>
+int8_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.tinyint;
+}
+
+template <>
+int16_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.smallint;
+}
+
+template <>
+int32_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.integer;
+}
+
+template <>
+int64_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.bigint;
+}
+
+template <>
+hugeint_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.hugeint;
+}
+
+template <>
+uint8_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.utinyint;
+}
+
+template <>
+uint16_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.usmallint;
+}
+
+template <>
+uint32_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.uinteger;
+}
+
+template <>
+uint64_t &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.ubigint;
+}
+
+template <>
+float &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.float_;
+}
+
+template <>
+double &NumericValueUnion::GetReferenceUnsafe() {
+	return value_.double_;
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 47;
+const uint64_t VERSION_NUMBER = 48;
 
 struct StorageVersionInfo {
 	const char *version_name;

package/src/duckdb/src/storage/table/column_checkpoint_state.cpp

@@ -1,12 +1,7 @@
-
 #include "duckdb/storage/table/column_data.hpp"
-
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
 #include "duckdb/storage/checkpoint/write_overflow_strings_to_disk.hpp"
-#include "duckdb/storage/table/validity_column_data.hpp"
-#include "duckdb/storage/table/standard_column_data.hpp"
-#include "duckdb/storage/table/list_column_data.hpp"
-#include "duckdb/transaction/transaction.hpp"
 #include "duckdb/storage/table/row_group.hpp"
 #include "duckdb/storage/checkpoint/table_data_writer.hpp"
 

package/src/duckdb/src/storage/table/column_data.cpp

@@ -32,10 +32,9 @@ ColumnData::ColumnData(ColumnData &other, idx_t start, ColumnData *parent)
 		updates = make_unique<UpdateSegment>(*other.updates, *this);
 	}
 	idx_t offset = 0;
-	for (auto segment = other.data.GetRootSegment(); segment; segment = segment->Next()) {
-		auto &other = (ColumnSegment &)*segment;
-		this->data.AppendSegment(ColumnSegment::CreateSegment(other, start + offset));
-		offset += segment->count;
+	for (auto &segment : other.data.Segments()) {
+		this->data.AppendSegment(ColumnSegment::CreateSegment(segment, start + offset));
+		offset += segment.count;
 	}
 }
 
@@ -75,7 +74,8 @@ idx_t ColumnData::GetMaxEntry() {
 }
 
 void ColumnData::InitializeScan(ColumnScanState &state) {
-	state.current = (ColumnSegment *)data.GetRootSegment();
+	state.current = data.GetRootSegment();
+	state.segment_tree = &data;
 	state.row_index = state.current ? state.current->start : 0;
 	state.internal_index = state.row_index;
 	state.initialized = false;
@@ -84,7 +84,8 @@ void ColumnData::InitializeScan(ColumnScanState &state) {
 }
 
 void ColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	state.current = (ColumnSegment *)data.GetSegment(row_idx);
+	state.current = data.GetSegment(row_idx);
+	state.segment_tree = &data;
 	state.row_index = row_idx;
 	state.internal_index = state.current->start;
 	state.initialized = false;
@@ -125,11 +126,12 @@ idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remai
 		}
 
 		if (remaining > 0) {
-			if (!state.current->next) {
+			auto next = data.GetNextSegment(state.current);
+			if (!next) {
 				break;
 			}
 			state.previous_states.emplace_back(std::move(state.scan_state));
-			state.current = (ColumnSegment *)state.current->Next();
+			state.current = next;
 			state.current->InitializeScan(state);
 			state.segment_checked = false;
 			D_ASSERT(state.row_index >= state.current->start &&
@@ -234,14 +236,14 @@ void ColumnData::InitializeAppend(ColumnAppendState &state) {
 		// no segments yet, append an empty segment
 		AppendTransientSegment(l, start);
 	}
-	auto segment = (ColumnSegment *)data.GetLastSegment(l);
+	auto segment = data.GetLastSegment(l);
 	if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
 		// no transient segments yet
 		auto total_rows = segment->start + segment->count;
 		AppendTransientSegment(l, total_rows);
-		state.current = (ColumnSegment *)data.GetLastSegment(l);
+		state.current = data.GetLastSegment(l);
 	} else {
-		state.current = (ColumnSegment *)segment;
+		state.current = segment;
 	}
 
 	D_ASSERT(state.current->segment_type == ColumnSegmentType::TRANSIENT);
@@ -264,7 +266,7 @@ void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, Uni
 		{
 			auto l = data.Lock();
 			AppendTransientSegment(l, state.current->start + state.current->count);
-			state.current = (ColumnSegment *)data.GetLastSegment(l);
+			state.current = data.GetLastSegment(l);
 			state.current->InitializeAppend(state);
 		}
 		offset += copied_elements;
@@ -284,7 +286,7 @@ void ColumnData::RevertAppend(row_t start_row) {
 	// find the segment index that the current row belongs to
 	idx_t segment_index = data.GetSegmentIndex(l, start_row);
 	auto segment = data.GetSegmentByIndex(l, segment_index);
-	auto &transient = (ColumnSegment &)*segment;
+	auto &transient = *segment;
 	D_ASSERT(transient.segment_type == ColumnSegmentType::TRANSIENT);
 
 	// remove any segments AFTER this segment: they should be deleted entirely
@@ -299,14 +301,14 @@ idx_t ColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
 	D_ASSERT(idx_t(row_id) >= start);
 	// perform the fetch within the segment
 	state.row_index = start + ((row_id - start) / STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE);
-	state.current = (ColumnSegment *)data.GetSegment(state.row_index);
+	state.current = data.GetSegment(state.row_index);
 	state.internal_index = state.current->start;
 	return ScanVector(state, result, STANDARD_VECTOR_SIZE);
 }
 
 void ColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
                           idx_t result_idx) {
-	auto segment = (ColumnSegment *)data.GetSegment(row_id);
+	auto segment = data.GetSegment(row_id);
 
 	// now perform the fetch within the segment
 	segment->FetchRow(state, row_id, result, result_idx);
@@ -357,15 +359,14 @@ void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) {
 }
 
 void ColumnData::CommitDropColumn() {
-	auto segment = (ColumnSegment *)data.GetRootSegment();
-	while (segment) {
-		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			auto block_id = segment->GetBlockId();
+	for (auto &segment_p : data.Segments()) {
+		auto &segment = segment_p;
+		if (segment.segment_type == ColumnSegmentType::PERSISTENT) {
+			auto block_id = segment.GetBlockId();
 			if (block_id != INVALID_BLOCK) {
 				block_manager.MarkBlockAsModified(block_id);
 			}
 		}
-		segment = (ColumnSegment *)segment->Next();
 	}
 }
 
@@ -464,7 +465,6 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 	while (segment) {
 		ColumnSegmentInfo column_info;
 		column_info.row_group_index = row_group_index;
-		;
 		column_info.column_id = col_path[0];
 		column_info.column_path = col_path_str;
 		column_info.segment_idx = segment_idx;
@@ -487,7 +487,7 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		result.column_segments.push_back(std::move(column_info));
 
 		segment_idx++;
-		segment = (ColumnSegment *)segment->Next();
+		segment = (ColumnSegment *)data.GetNextSegment(segment);
 	}
 }
 
@@ -495,19 +495,13 @@ void ColumnData::Verify(RowGroup &parent) {
 #ifdef DEBUG
 	D_ASSERT(this->start == parent.start);
 	data.Verify();
-	auto root = data.GetRootSegment();
-	if (root) {
-		D_ASSERT(root != nullptr);
-		D_ASSERT(root->start == this->start);
-		idx_t prev_end = root->start;
-		while (root) {
-			D_ASSERT(prev_end == root->start);
-			prev_end = root->start + root->count;
-			if (!root->next) {
-				D_ASSERT(prev_end == parent.start + parent.count);
-			}
-			root = root->Next();
-		}
+	idx_t current_index = 0;
+	idx_t current_start = this->start;
+	for (auto &segment : data.Segments()) {
+		D_ASSERT(segment.index == current_index);
+		D_ASSERT(segment.start == current_start);
+		current_start += segment.count;
+		current_index++;
 	}
 #endif
 }