duckdb 0.4.1-dev696.0 → 0.4.1-dev723.0

package/src/duckdb.cpp

@@ -29957,7 +29957,7 @@ class RowDataCollection;
 struct SelectionVector;
 class StringHeap;
 class Vector;
-struct VectorData;
+struct UnifiedVectorFormat;
 
 // RowOperations contains a set of operations that operate on data using a RowLayout
 struct RowOperations {
@@ -29982,7 +29982,7 @@ struct RowOperations {
 	// Read/Write Operators
 	//===--------------------------------------------------------------------===//
 	//! Scatter group data to the rows. Initialises the ValidityMask.
-	static void Scatter(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
+	static void Scatter(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
 	                    RowDataCollection &string_heap, const SelectionVector &sel, idx_t count);
 	//! Gather a single column.
 	static void Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
@@ -29998,7 +29998,7 @@ struct RowOperations {
 	//! Returns the number of matches remaining in the selection.
 	using Predicates = vector<ExpressionType>;
 
-	static idx_t Match(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
+	static idx_t Match(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
 	                   const Predicates &predicates, SelectionVector &sel, idx_t count, SelectionVector *no_match,
 	                   idx_t &no_match_count);
 
@@ -30009,15 +30009,15 @@ struct RowOperations {
 	static void ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
 	                              const SelectionVector &sel, idx_t offset = 0);
 	//! Compute the entry sizes of vector data with variable size type (used before building heap buffer space).
-	static void ComputeEntrySizes(Vector &v, VectorData &vdata, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-	                              const SelectionVector &sel, idx_t offset = 0);
+	static void ComputeEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t vcount,
+	                              idx_t ser_count, const SelectionVector &sel, idx_t offset = 0);
 	//! Scatter vector with variable size type to the heap.
 	static void HeapScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
 	                        data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset = 0);
 	//! Scatter vector data with variable size type to the heap.
-	static void HeapScatterVData(VectorData &vdata, PhysicalType type, const SelectionVector &sel, idx_t ser_count,
-	                             idx_t col_idx, data_ptr_t *key_locations, data_ptr_t *validitymask_locations,
-	                             idx_t offset = 0);
+	static void HeapScatterVData(UnifiedVectorFormat &vdata, PhysicalType type, const SelectionVector &sel,
+	                             idx_t ser_count, idx_t col_idx, data_ptr_t *key_locations,
+	                             data_ptr_t *validitymask_locations, idx_t offset = 0);
 	//! Gather a single column with variable size type from the heap.
 	static void HeapGather(Vector &v, const idx_t &vcount, const SelectionVector &sel, const idx_t &col_idx,
 	                       data_ptr_t key_locations[], data_ptr_t validitymask_locations[]);
@@ -30256,7 +30256,7 @@ void RowOperations::UpdateFilteredStates(AggregateFilterData &filter_data, Aggre
 	idx_t count = filter_data.ApplyFilter(payload);
 
 	Vector filtered_addresses(addresses, filter_data.true_sel, count);
-	filtered_addresses.Normalify(count);
+	filtered_addresses.Flatten(count);
 
 	UpdateStates(aggr, filtered_addresses, filter_data.filtered_payload, arg_idx, count);
 }
@@ -30950,7 +30950,7 @@ namespace duckdb {
 
 using ValidityBytes = TemplatedValidityMask<uint8_t>;
 
-static void ComputeStringEntrySizes(VectorData &vdata, idx_t entry_sizes[], const idx_t ser_count,
+static void ComputeStringEntrySizes(UnifiedVectorFormat &vdata, idx_t entry_sizes[], const idx_t ser_count,
                                     const SelectionVector &sel, const idx_t offset) {
 	auto strings = (string_t *)vdata.data;
 	for (idx_t i = 0; i < ser_count; i++) {
@@ -30979,7 +30979,7 @@ static void ComputeStructEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount
 	}
 }
 
-static void ComputeListEntrySizes(Vector &v, VectorData &vdata, idx_t entry_sizes[], idx_t ser_count,
+static void ComputeListEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t ser_count,
                                   const SelectionVector &sel, idx_t offset) {
 	auto list_data = ListVector::GetData(v);
 	auto &child_vector = ListVector::GetEntry(v);
@@ -31022,8 +31022,8 @@ static void ComputeListEntrySizes(Vector &v, VectorData &vdata, idx_t entry_size
 	}
 }
 
-void RowOperations::ComputeEntrySizes(Vector &v, VectorData &vdata, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
-                                      const SelectionVector &sel, idx_t offset) {
+void RowOperations::ComputeEntrySizes(Vector &v, UnifiedVectorFormat &vdata, idx_t entry_sizes[], idx_t vcount,
+                                      idx_t ser_count, const SelectionVector &sel, idx_t offset) {
 	const auto physical_type = v.GetType().InternalType();
 	if (TypeIsConstantSize(physical_type)) {
 		const auto type_size = GetTypeIdSize(physical_type);
@@ -31052,13 +31052,13 @@ void RowOperations::ComputeEntrySizes(Vector &v, VectorData &vdata, idx_t entry_
 
 void RowOperations::ComputeEntrySizes(Vector &v, idx_t entry_sizes[], idx_t vcount, idx_t ser_count,
                                       const SelectionVector &sel, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
+	UnifiedVectorFormat vdata;
+	v.ToUnifiedFormat(vcount, vdata);
 	ComputeEntrySizes(v, vdata, entry_sizes, vcount, ser_count, sel, offset);
 }
 
 template <class T>
-static void TemplatedHeapScatter(VectorData &vdata, const SelectionVector &sel, idx_t count, idx_t col_idx,
+static void TemplatedHeapScatter(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t count, idx_t col_idx,
                                  data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
 	auto source = (T *)vdata.data;
 	if (!validitymask_locations) {
@@ -31093,8 +31093,8 @@ static void TemplatedHeapScatter(VectorData &vdata, const SelectionVector &sel,
 
 static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
                                     data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
+	UnifiedVectorFormat vdata;
+	v.ToUnifiedFormat(vcount, vdata);
 
 	auto strings = (string_t *)vdata.data;
 	if (!validitymask_locations) {
@@ -31137,8 +31137,8 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 
 static void HeapScatterStructVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
                                     data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
+	UnifiedVectorFormat vdata;
+	v.ToUnifiedFormat(vcount, vdata);
 
 	auto &children = StructVector::GetEntries(v);
 	idx_t num_children = children.size();
@@ -31176,8 +31176,8 @@ static void HeapScatterStructVector(Vector &v, idx_t vcount, const SelectionVect
 
 static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_no,
                                   data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
+	UnifiedVectorFormat vdata;
+	v.ToUnifiedFormat(vcount, vdata);
 
 	idx_t entry_idx;
 	idx_t idx_in_entry;
@@ -31187,8 +31187,8 @@ static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector
 
 	auto &child_vector = ListVector::GetEntry(v);
 
-	VectorData list_vdata;
-	child_vector.Orrify(ListVector::GetListSize(v), list_vdata);
+	UnifiedVectorFormat list_vdata;
+	child_vector.ToUnifiedFormat(ListVector::GetListSize(v), list_vdata);
 	auto child_type = ListType::GetChildType(v.GetType()).InternalType();
 
 	idx_t list_entry_sizes[STANDARD_VECTOR_SIZE];
@@ -31278,8 +31278,8 @@ static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector
 void RowOperations::HeapScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count, idx_t col_idx,
                                 data_ptr_t *key_locations, data_ptr_t *validitymask_locations, idx_t offset) {
 	if (TypeIsConstantSize(v.GetType().InternalType())) {
-		VectorData vdata;
-		v.Orrify(vcount, vdata);
+		UnifiedVectorFormat vdata;
+		v.ToUnifiedFormat(vcount, vdata);
 		RowOperations::HeapScatterVData(vdata, v.GetType().InternalType(), sel, ser_count, col_idx, key_locations,
 		                                validitymask_locations, offset);
 	} else {
@@ -31302,9 +31302,9 @@ void RowOperations::HeapScatter(Vector &v, idx_t vcount, const SelectionVector &
 	}
 }
 
-void RowOperations::HeapScatterVData(VectorData &vdata, PhysicalType type, const SelectionVector &sel, idx_t ser_count,
-                                     idx_t col_idx, data_ptr_t *key_locations, data_ptr_t *validitymask_locations,
-                                     idx_t offset) {
+void RowOperations::HeapScatterVData(UnifiedVectorFormat &vdata, PhysicalType type, const SelectionVector &sel,
+                                     idx_t ser_count, idx_t col_idx, data_ptr_t *key_locations,
+                                     data_ptr_t *validitymask_locations, idx_t offset) {
 	switch (type) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -31408,8 +31408,8 @@ idx_t SelectComparison<LessThanEquals>(Vector &left, Vector &right, const Select
 }
 
 template <class T, class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchType(VectorData &col, Vector &rows, SelectionVector &sel, idx_t &count, idx_t col_offset,
-                               idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
+static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, SelectionVector &sel, idx_t &count,
+                               idx_t col_offset, idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
 	// Precompute row_mask indexes
 	idx_t entry_idx;
 	idx_t idx_in_entry;
@@ -31490,8 +31490,9 @@ static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel
 }
 
 template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchOp(Vector &vec, VectorData &col, const RowLayout &layout, Vector &rows, SelectionVector &sel,
-                             idx_t &count, idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLayout &layout, Vector &rows,
+                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
+                             idx_t &no_match_count) {
 	if (count == 0) {
 		return;
 	}
@@ -31561,7 +31562,7 @@ static void TemplatedMatchOp(Vector &vec, VectorData &col, const RowLayout &layo
 }
 
 template <bool NO_MATCH_SEL>
-static void TemplatedMatch(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
+static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
                            const Predicates &predicates, SelectionVector &sel, idx_t &count, SelectionVector *no_match,
                            idx_t &no_match_count) {
 	for (idx_t col_no = 0; col_no < predicates.size(); ++col_no) {
@@ -31600,7 +31601,7 @@ static void TemplatedMatch(DataChunk &columns, VectorData col_data[], const RowL
 	}
 }
 
-idx_t RowOperations::Match(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
+idx_t RowOperations::Match(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
                            const Predicates &predicates, SelectionVector &sel, idx_t count, SelectionVector *no_match,
                            idx_t &no_match_count) {
 	if (no_match) {
@@ -31621,8 +31622,9 @@ idx_t RowOperations::Match(DataChunk &columns, VectorData col_data[], const RowL
 namespace duckdb {
 
 template <class T>
-void TemplatedRadixScatter(VectorData &vdata, const SelectionVector &sel, idx_t add_count, data_ptr_t *key_locations,
-                           const bool desc, const bool has_null, const bool nulls_first, const idx_t offset) {
+void TemplatedRadixScatter(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
+                           data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
+                           const idx_t offset) {
 	auto source = (T *)vdata.data;
 	if (has_null) {
 		auto &validity = vdata.validity;
@@ -31665,9 +31667,9 @@ void TemplatedRadixScatter(VectorData &vdata, const SelectionVector &sel, idx_t
 	}
 }
 
-void RadixScatterStringVector(VectorData &vdata, const SelectionVector &sel, idx_t add_count, data_ptr_t *key_locations,
-                              const bool desc, const bool has_null, const bool nulls_first, const idx_t prefix_len,
-                              idx_t offset) {
+void RadixScatterStringVector(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
+                              data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
+                              const idx_t prefix_len, idx_t offset) {
 	auto source = (string_t *)vdata.data;
 	if (has_null) {
 		auto &validity = vdata.validity;
@@ -31710,7 +31712,7 @@ void RadixScatterStringVector(VectorData &vdata, const SelectionVector &sel, idx
 	}
 }
 
-void RadixScatterListVector(Vector &v, VectorData &vdata, const SelectionVector &sel, idx_t add_count,
+void RadixScatterListVector(Vector &v, UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t add_count,
                             data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
                             const idx_t prefix_len, const idx_t width, const idx_t offset) {
 	auto list_data = ListVector::GetData(v);
@@ -31786,9 +31788,9 @@ void RadixScatterListVector(Vector &v, VectorData &vdata, const SelectionVector
 	}
 }
 
-void RadixScatterStructVector(Vector &v, VectorData &vdata, idx_t vcount, const SelectionVector &sel, idx_t add_count,
-                              data_ptr_t *key_locations, const bool desc, const bool has_null, const bool nulls_first,
-                              const idx_t prefix_len, idx_t width, const idx_t offset) {
+void RadixScatterStructVector(Vector &v, UnifiedVectorFormat &vdata, idx_t vcount, const SelectionVector &sel,
+                              idx_t add_count, data_ptr_t *key_locations, const bool desc, const bool has_null,
+                              const bool nulls_first, const idx_t prefix_len, idx_t width, const idx_t offset) {
 	// serialize null values
 	if (has_null) {
 		auto &validity = vdata.validity;
@@ -31825,8 +31827,8 @@ void RadixScatterStructVector(Vector &v, VectorData &vdata, idx_t vcount, const
 void RowOperations::RadixScatter(Vector &v, idx_t vcount, const SelectionVector &sel, idx_t ser_count,
                                  data_ptr_t *key_locations, bool desc, bool has_null, bool nulls_first,
                                  idx_t prefix_len, idx_t width, idx_t offset) {
-	VectorData vdata;
-	v.Orrify(vcount, vdata);
+	UnifiedVectorFormat vdata;
+	v.ToUnifiedFormat(vcount, vdata);
 	switch (v.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -31902,7 +31904,7 @@ namespace duckdb {
 using ValidityBytes = RowLayout::ValidityBytes;
 
 template <class T>
-static void TemplatedScatter(VectorData &col, Vector &rows, const SelectionVector &sel, const idx_t count,
+static void TemplatedScatter(UnifiedVectorFormat &col, Vector &rows, const SelectionVector &sel, const idx_t count,
                              const idx_t col_offset, const idx_t col_no) {
 	auto data = (T *)col.data;
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
@@ -31932,7 +31934,7 @@ static void TemplatedScatter(VectorData &col, Vector &rows, const SelectionVecto
 	}
 }
 
-static void ComputeStringEntrySizes(const VectorData &col, idx_t entry_sizes[], const SelectionVector &sel,
+static void ComputeStringEntrySizes(const UnifiedVectorFormat &col, idx_t entry_sizes[], const SelectionVector &sel,
                                     const idx_t count, const idx_t offset = 0) {
 	auto data = (const string_t *)col.data;
 	for (idx_t i = 0; i < count; i++) {
@@ -31945,8 +31947,9 @@ static void ComputeStringEntrySizes(const VectorData &col, idx_t entry_sizes[],
 	}
 }
 
-static void ScatterStringVector(VectorData &col, Vector &rows, data_ptr_t str_locations[], const SelectionVector &sel,
-                                const idx_t count, const idx_t col_offset, const idx_t col_no) {
+static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr_t str_locations[],
+                                const SelectionVector &sel, const idx_t count, const idx_t col_offset,
+                                const idx_t col_no) {
 	auto string_data = (string_t *)col.data;
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
@@ -31971,7 +31974,7 @@ static void ScatterStringVector(VectorData &col, Vector &rows, data_ptr_t str_lo
 	}
 }
 
-static void ScatterNestedVector(Vector &vec, VectorData &col, Vector &rows, data_ptr_t data_locations[],
+static void ScatterNestedVector(Vector &vec, UnifiedVectorFormat &col, Vector &rows, data_ptr_t data_locations[],
                                 const SelectionVector &sel, const idx_t count, const idx_t col_offset,
                                 const idx_t col_no, const idx_t vcount) {
 	// Store pointers to the data in the row
@@ -31990,7 +31993,7 @@ static void ScatterNestedVector(Vector &vec, VectorData &col, Vector &rows, data
 	RowOperations::HeapScatter(vec, vcount, sel, count, col_no, data_locations, validitymask_locations);
 }
 
-void RowOperations::Scatter(DataChunk &columns, VectorData col_data[], const RowLayout &layout, Vector &rows,
+void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
                             RowDataCollection &string_heap, const SelectionVector &sel, idx_t count) {
 	if (count == 0) {
 		return;
@@ -35027,14 +35030,14 @@ void LocalSortState::SinkChunk(DataChunk &sort, DataChunk &payload) {
 			}
 		}
 		handles = blob_sorting_data->Build(blob_chunk.size(), data_pointers, nullptr);
-		auto blob_data = blob_chunk.Orrify();
+		auto blob_data = blob_chunk.ToUnifiedFormat();
 		RowOperations::Scatter(blob_chunk, blob_data.get(), sort_layout->blob_layout, addresses, *blob_sorting_heap,
 		                       sel_ptr, blob_chunk.size());
 	}
 
 	// Finally, serialize payload data
 	handles = payload_data->Build(payload.size(), data_pointers, nullptr);
-	auto input_data = payload.Orrify();
+	auto input_data = payload.ToUnifiedFormat();
 	RowOperations::Scatter(payload, input_data.get(), *payload_layout, addresses, *payload_heap, sel_ptr,
 	                       payload.size());
 }
@@ -38109,7 +38112,7 @@ void ChunkCollection::Append(DataChunk &new_chunk) {
 		idx_t added_data = MinValue<idx_t>(remaining_data, STANDARD_VECTOR_SIZE - last_chunk.size());
 		if (added_data > 0) {
 			// copy <added_data> elements to the last chunk
-			new_chunk.Normalify();
+			new_chunk.Flatten();
 			// have to be careful here: setting the cardinality without calling normalify can cause incorrect partial
 			// decompression
 			idx_t old_count = new_chunk.size();
@@ -38739,9 +38742,9 @@ void DataChunk::Append(const DataChunk &other, bool resize, SelectionVector *sel
 	SetCardinality(new_size);
 }
 
-void DataChunk::Normalify() {
+void DataChunk::Flatten() {
 	for (idx_t i = 0; i < ColumnCount(); i++) {
-		data[i].Normalify(size());
+		data[i].Flatten(size());
 	}
 }
 
@@ -38815,10 +38818,10 @@ void DataChunk::Slice(DataChunk &other, const SelectionVector &sel, idx_t count_
 	}
 }
 
-unique_ptr<VectorData[]> DataChunk::Orrify() {
-	auto orrified_data = unique_ptr<VectorData[]>(new VectorData[ColumnCount()]);
+unique_ptr<UnifiedVectorFormat[]> DataChunk::ToUnifiedFormat() {
+	auto orrified_data = unique_ptr<UnifiedVectorFormat[]>(new UnifiedVectorFormat[ColumnCount()]);
 	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		data[col_idx].Orrify(size(), orrified_data[col_idx]);
+		data[col_idx].ToUnifiedFormat(size(), orrified_data[col_idx]);
 	}
 	return orrified_data;
 }
@@ -38977,8 +38980,8 @@ void SetStructMap(DuckDBArrowArrayChildHolder &child_holder, const LogicalType &
 	for (idx_t child_idx = 0; child_idx < child_holder.children.size(); child_idx++) {
 		auto &list_vector_child = ListVector::GetEntry(*children[child_idx]);
 		if (child_idx == 0) {
-			VectorData list_data;
-			children[child_idx]->Orrify(size, list_data);
+			UnifiedVectorFormat list_data;
+			children[child_idx]->ToUnifiedFormat(size, list_data);
 			auto list_child_validity = FlatVector::Validity(list_vector_child);
 			if (!list_child_validity.AllValid()) {
 				//! Get the offsets to check from the selection vector
@@ -39259,7 +39262,7 @@ void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType
 }
 
 void DataChunk::ToArrowArray(ArrowArray *out_array) {
-	Normalify();
+	Flatten();
 	D_ASSERT(out_array);
 
 	// Allocate as unique_ptr first to cleanup properly on error
@@ -40847,10 +40850,10 @@ uint64_t MurmurHash64A(const void *key, int len, unsigned int seed);
 
 namespace duckdb {
 
-void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
+void AddToLogsInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
                        const SelectionVector *log_sel);
 
-void AddToSingleLogInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log);
+void AddToSingleLogInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log);
 
 } // namespace duckdb
 
@@ -40895,13 +40898,13 @@ public:
 public:
 	//! Compute HLL hashes over vdata, and store them in 'hashes'
 	//! Then, compute register indices and prefix lengths, and also store them in 'hashes' as a pair of uint32_t
-	static void ProcessEntries(VectorData &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
+	static void ProcessEntries(UnifiedVectorFormat &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
 	                           idx_t count);
 	//! Add the indices and counts to the logs
-	static void AddToLogs(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], HyperLogLog **logs[],
-	                      const SelectionVector *log_sel);
+	static void AddToLogs(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[],
+	                      HyperLogLog **logs[], const SelectionVector *log_sel);
 	//! Add the indices and counts to THIS log
-	void AddToLog(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
+	void AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
 
 private:
 	explicit HyperLogLog(void *hll);
@@ -41105,7 +41108,7 @@ inline uint64_t TemplatedHash(const string_t &elem) {
 }
 
 template <class T>
-void TemplatedComputeHashes(VectorData &vdata, const idx_t &count, uint64_t hashes[]) {
+void TemplatedComputeHashes(UnifiedVectorFormat &vdata, const idx_t &count, uint64_t hashes[]) {
 	T *data = (T *)vdata.data;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
@@ -41117,7 +41120,7 @@ void TemplatedComputeHashes(VectorData &vdata, const idx_t &count, uint64_t hash
 	}
 }
 
-static void ComputeHashes(VectorData &vdata, const LogicalType &type, uint64_t hashes[], idx_t count) {
+static void ComputeHashes(UnifiedVectorFormat &vdata, const LogicalType &type, uint64_t hashes[], idx_t count) {
 	switch (type.InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -41164,20 +41167,20 @@ static inline void ComputeIndexAndCount(uint64_t &hash, uint8_t &prefix) {
 	hash = index;
 }
 
-void HyperLogLog::ProcessEntries(VectorData &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
-                                 idx_t count) {
+void HyperLogLog::ProcessEntries(UnifiedVectorFormat &vdata, const LogicalType &type, uint64_t hashes[],
+                                 uint8_t counts[], idx_t count) {
 	ComputeHashes(vdata, type, hashes, count);
 	for (idx_t i = 0; i < count; i++) {
 		ComputeIndexAndCount(hashes[i], counts[i]);
 	}
 }
 
-void HyperLogLog::AddToLogs(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], HyperLogLog **logs[],
-                            const SelectionVector *log_sel) {
+void HyperLogLog::AddToLogs(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[],
+                            HyperLogLog **logs[], const SelectionVector *log_sel) {
 	AddToLogsInternal(vdata, count, indices, counts, (void ****)logs, log_sel);
 }
 
-void HyperLogLog::AddToLog(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[]) {
+void HyperLogLog::AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]) {
 	lock_guard<mutex> guard(lock);
 	AddToSingleLogInternal(vdata, count, indices, counts, hll);
 }
@@ -46024,7 +46027,7 @@ static void TemplatedFlattenConstantVector(data_ptr_t data, data_ptr_t old_data,
 	}
 }
 
-void Vector::Normalify(idx_t count) {
+void Vector::Flatten(idx_t count) {
 	switch (GetVectorType()) {
 	case VectorType::FLAT_VECTOR:
 		// already a flat vector
@@ -46109,13 +46112,13 @@ void Vector::Normalify(idx_t count) {
 			for (auto &child : child_entries) {
 				D_ASSERT(child->GetVectorType() == VectorType::CONSTANT_VECTOR);
 				auto vector = make_unique<Vector>(*child);
-				vector->Normalify(count);
+				vector->Flatten(count);
 				new_children.push_back(move(vector));
 			}
 			auxiliary = move(normalified_buffer);
 		} break;
 		default:
-			throw InternalException("Unimplemented type for VectorOperations::Normalify");
+			throw InternalException("Unimplemented type for VectorOperations::Flatten");
 		}
 		break;
 	}
@@ -46133,7 +46136,7 @@ void Vector::Normalify(idx_t count) {
 	}
 }
 
-void Vector::Normalify(const SelectionVector &sel, idx_t count) {
+void Vector::Flatten(const SelectionVector &sel, idx_t count) {
 	switch (GetVectorType()) {
 	case VectorType::FLAT_VECTOR:
 		// already a flat vector
@@ -46152,7 +46155,7 @@ void Vector::Normalify(const SelectionVector &sel, idx_t count) {
 	}
 }
 
-void Vector::Orrify(idx_t count, VectorData &data) {
+void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &data) {
 	switch (GetVectorType()) {
 	case VectorType::DICTIONARY_VECTOR: {
 		auto &sel = DictionaryVector::SelVector(*this);
@@ -46164,7 +46167,7 @@ void Vector::Orrify(idx_t count, VectorData &data) {
 		} else {
 			// dictionary with non-flat child: create a new reference to the child and normalify it
 			Vector child_vector(child);
-			child_vector.Normalify(sel, count);
+			child_vector.Flatten(sel, count);
 			auto new_aux = make_buffer<VectorChildBuffer>(move(child_vector));
 
 			data.sel = &sel;
@@ -46180,7 +46183,7 @@ void Vector::Orrify(idx_t count, VectorData &data) {
 		data.validity = ConstantVector::Validity(*this);
 		break;
 	default:
-		Normalify(count);
+		Flatten(count);
 		data.sel = FlatVector::IncrementalSelectionVector();
 		data.data = FlatVector::GetData(*this);
 		data.validity = FlatVector::Validity(*this);
@@ -46201,8 +46204,8 @@ void Vector::Sequence(int64_t start, int64_t increment) {
 void Vector::Serialize(idx_t count, Serializer &serializer) {
 	auto &type = GetType();
 
-	VectorData vdata;
-	Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	ToUnifiedFormat(count, vdata);
 
 	const auto write_validity = (count > 0) && !vdata.validity.AllValid();
 	serializer.Write<bool>(write_validity);
@@ -46232,7 +46235,7 @@ void Vector::Serialize(idx_t count, Serializer &serializer) {
 			break;
 		}
 		case PhysicalType::STRUCT: {
-			Normalify(count);
+			Flatten(count);
 			auto &entries = StructVector::GetEntries(*this);
 			for (auto &entry : entries) {
 				entry->Serialize(count, serializer);
@@ -46576,8 +46579,8 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i
 	switch (source_type.InternalType()) {
 	case PhysicalType::LIST: {
 		// retrieve the list entry from the source vector
-		VectorData vdata;
-		source.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		source.ToUnifiedFormat(count, vdata);
 
 		auto list_index = vdata.sel->get_index(position);
 		if (!vdata.validity.RowIsValid(list_index)) {
@@ -46604,8 +46607,8 @@ void ConstantVector::Reference(Vector &vector, Vector &source, idx_t position, i
 		break;
 	}
 	case PhysicalType::STRUCT: {
-		VectorData vdata;
-		source.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		source.ToUnifiedFormat(count, vdata);
 
 		auto struct_index = vdata.sel->get_index(position);
 		if (!vdata.validity.RowIsValid(struct_index)) {
@@ -46772,8 +46775,8 @@ void ListVector::Reserve(Vector &vector, idx_t required_capacity) {
 template <class T>
 void TemplatedSearchInMap(Vector &list, T key, vector<idx_t> &offsets, bool is_key_null, idx_t offset, idx_t length) {
 	auto &list_vector = ListVector::GetEntry(list);
-	VectorData vector_data;
-	list_vector.Orrify(ListVector::GetListSize(list), vector_data);
+	UnifiedVectorFormat vector_data;
+	list_vector.ToUnifiedFormat(ListVector::GetListSize(list), vector_data);
 	auto data = (T *)vector_data.data;
 	auto validity_mask = vector_data.validity;
 
@@ -46804,8 +46807,8 @@ void TemplatedSearchInMap(Vector &list, const Value &key, vector<idx_t> &offsets
 void SearchStringInMap(Vector &list, const string &key, vector<idx_t> &offsets, bool is_key_null, idx_t offset,
                        idx_t length) {
 	auto &list_vector = ListVector::GetEntry(list);
-	VectorData vector_data;
-	list_vector.Orrify(ListVector::GetListSize(list), vector_data);
+	UnifiedVectorFormat vector_data;
+	list_vector.ToUnifiedFormat(ListVector::GetListSize(list), vector_data);
 	auto data = (string_t *)vector_data.data;
 	auto validity_mask = vector_data.validity;
 	if (is_key_null) {
@@ -48917,9 +48920,9 @@ static void TemplatedBooleanNullmask(Vector &left, Vector &right, Vector &result
 		ConstantVector::SetNull(result, is_null);
 	} else {
 		// perform generic loop
-		VectorData ldata, rdata;
-		left.Orrify(count, ldata);
-		right.Orrify(count, rdata);
+		UnifiedVectorFormat ldata, rdata;
+		left.ToUnifiedFormat(count, ldata);
+		right.ToUnifiedFormat(count, rdata);
 
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 		auto left_data = (uint8_t *)ldata.data; // we use uint8 to avoid load of gunk bools
@@ -49219,7 +49222,8 @@ inline idx_t ComparisonSelector::Select<duckdb::LessThanEquals>(Vector &left, Ve
 	return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, false_sel);
 }
 
-static void ComparesNotNull(VectorData &ldata, VectorData &rdata, ValidityMask &vresult, idx_t count) {
+static void ComparesNotNull(UnifiedVectorFormat &ldata, UnifiedVectorFormat &rdata, ValidityMask &vresult,
+                            idx_t count) {
 	for (idx_t i = 0; i < count; ++i) {
 		auto lidx = ldata.sel->get_index(i);
 		auto ridx = rdata.sel->get_index(i);
@@ -49255,9 +49259,9 @@ static void NestedComparisonExecutor(Vector &left, Vector &right, Vector &result
 	auto result_data = FlatVector::GetData<bool>(result);
 	auto &result_validity = FlatVector::Validity(result);
 
-	VectorData leftv, rightv;
-	left.Orrify(count, leftv);
-	right.Orrify(count, rightv);
+	UnifiedVectorFormat leftv, rightv;
+	left.ToUnifiedFormat(count, leftv);
+	right.ToUnifiedFormat(count, rightv);
 	if (!leftv.validity.AllValid() || !rightv.validity.AllValid()) {
 		ComparesNotNull(leftv, rightv, result_validity, count);
 	}
@@ -49511,10 +49515,10 @@ static void DistinctExecuteGeneric(Vector &left, Vector &right, Vector &result,
 	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		DistinctExecuteConstant<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP>(left, right, result);
 	} else {
-		VectorData ldata, rdata;
+		UnifiedVectorFormat ldata, rdata;
 
-		left.Orrify(count, ldata);
-		right.Orrify(count, rdata);
+		left.ToUnifiedFormat(count, ldata);
+		right.ToUnifiedFormat(count, rdata);
 
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 		auto result_data = FlatVector::GetData<RESULT_TYPE>(result);
@@ -49610,10 +49614,10 @@ DistinctSelectGenericLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restr
 template <class LEFT_TYPE, class RIGHT_TYPE, class OP>
 static idx_t DistinctSelectGeneric(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                    SelectionVector *true_sel, SelectionVector *false_sel) {
-	VectorData ldata, rdata;
+	UnifiedVectorFormat ldata, rdata;
 
-	left.Orrify(count, ldata);
-	right.Orrify(count, rdata);
+	left.ToUnifiedFormat(count, ldata);
+	right.ToUnifiedFormat(count, rdata);
 
 	return DistinctSelectGenericLoopSwitch<LEFT_TYPE, RIGHT_TYPE, OP>((LEFT_TYPE *)ldata.data, (RIGHT_TYPE *)rdata.data,
 	                                                                  ldata.sel, rdata.sel, sel, count, ldata.validity,
@@ -49749,9 +49753,9 @@ template <class OP>
 static idx_t DistinctSelectNotNull(Vector &left, Vector &right, const idx_t count, idx_t &true_count,
                                    const SelectionVector &sel, SelectionVector &maybe_vec, OptionalSelection &true_opt,
                                    OptionalSelection &false_opt) {
-	VectorData lvdata, rvdata;
-	left.Orrify(count, lvdata);
-	right.Orrify(count, rvdata);
+	UnifiedVectorFormat lvdata, rvdata;
+	left.ToUnifiedFormat(count, lvdata);
+	right.ToUnifiedFormat(count, rvdata);
 
 	auto &lmask = lvdata.validity;
 	auto &rmask = rvdata.validity;
@@ -49959,11 +49963,11 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, cons
 	for (idx_t col_no = 0; col_no < lchildren.size(); ++col_no) {
 		// Slice the children to maintain density
 		Vector lchild(*lchildren[col_no]);
-		lchild.Normalify(vcount);
+		lchild.Flatten(vcount);
 		lchild.Slice(slice_sel, count);
 
 		Vector rchild(*rchildren[col_no]);
-		rchild.Normalify(vcount);
+		rchild.Flatten(vcount);
 		rchild.Slice(slice_sel, count);
 
 		// Find everything that definitely matches
@@ -50011,7 +50015,7 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, cons
 	return match_count;
 }
 
-static void PositionListCursor(SelectionVector &cursor, VectorData &vdata, const idx_t pos,
+static void PositionListCursor(SelectionVector &cursor, UnifiedVectorFormat &vdata, const idx_t pos,
                                const SelectionVector &slice_sel, const idx_t count) {
 	const auto data = (const list_entry_t *)vdata.data;
 	for (idx_t i = 0; i < count; ++i) {
@@ -50034,8 +50038,8 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const
 	SelectionVector lcursor(count);
 	SelectionVector rcursor(count);
 
-	ListVector::GetEntry(left).Normalify(count);
-	ListVector::GetEntry(right).Normalify(count);
+	ListVector::GetEntry(left).Flatten(count);
+	ListVector::GetEntry(right).Flatten(count);
 	Vector lchild(ListVector::GetEntry(left), lcursor, count);
 	Vector rchild(ListVector::GetEntry(right), rcursor, count);
 
@@ -50054,12 +50058,12 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const
 	// }
 
 	// Get pointers to the list entries
-	VectorData lvdata;
-	left.Orrify(count, lvdata);
+	UnifiedVectorFormat lvdata;
+	left.ToUnifiedFormat(count, lvdata);
 	const auto ldata = (const list_entry_t *)lvdata.data;
 
-	VectorData rvdata;
-	right.Orrify(count, rvdata);
+	UnifiedVectorFormat rvdata;
+	right.ToUnifiedFormat(count, rvdata);
 	const auto rdata = (const list_entry_t *)rvdata.data;
 
 	// In order to reuse the comparators, we have to track what passed and failed internally.
@@ -50415,8 +50419,8 @@ void IsNullLoop(Vector &input, Vector &result, idx_t count) {
 		auto result_data = ConstantVector::GetData<bool>(result);
 		*result_data = INVERSE ? !ConstantVector::IsNull(input) : ConstantVector::IsNull(input);
 	} else {
-		VectorData data;
-		input.Orrify(count, data);
+		UnifiedVectorFormat data;
+		input.ToUnifiedFormat(count, data);
 
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 		auto result_data = FlatVector::GetData<bool>(result);
@@ -50442,8 +50446,8 @@ bool VectorOperations::HasNotNull(Vector &input, idx_t count) {
 	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		return !ConstantVector::IsNull(input);
 	} else {
-		VectorData data;
-		input.Orrify(count, data);
+		UnifiedVectorFormat data;
+		input.ToUnifiedFormat(count, data);
 
 		if (data.validity.AllValid()) {
 			return true;
@@ -50465,8 +50469,8 @@ bool VectorOperations::HasNull(Vector &input, idx_t count) {
 	if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		return ConstantVector::IsNull(input);
 	} else {
-		VectorData data;
-		input.Orrify(count, data);
+		UnifiedVectorFormat data;
+		input.ToUnifiedFormat(count, data);
 
 		if (data.validity.AllValid()) {
 			return false;
@@ -50484,8 +50488,8 @@ bool VectorOperations::HasNull(Vector &input, idx_t count) {
 idx_t VectorOperations::CountNotNull(Vector &input, const idx_t count) {
 	idx_t valid = 0;
 
-	VectorData vdata;
-	input.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	input.ToUnifiedFormat(count, vdata);
 	if (vdata.validity.AllValid()) {
 		return count;
 	}
@@ -51155,8 +51159,8 @@ bool TransformEnum(Vector &source, Vector &result, idx_t count, string *error_me
 		                error_message, nullptr);
 	}
 	default: {
-		VectorData vdata;
-		source.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		source.ToUnifiedFormat(count, vdata);
 
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 
@@ -51526,7 +51530,7 @@ static bool ListCastSwitch(Vector &source, Vector &result, idx_t count, string *
 			auto tdata = ConstantVector::GetData<list_entry_t>(result);
 			*tdata = *ldata;
 		} else {
-			source.Normalify(count);
+			source.Flatten(count);
 			result.SetVectorType(VectorType::FLAT_VECTOR);
 			FlatVector::SetValidity(result, FlatVector::Validity(source));
 
@@ -51562,8 +51566,8 @@ bool FillEnum(Vector &source, Vector &result, idx_t count, string *error_message
 
 	auto res_enum_type = result.GetType();
 
-	VectorData vdata;
-	source.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	source.ToUnifiedFormat(count, vdata);
 
 	auto source_data = (SRC_TYPE *)vdata.data;
 	auto source_sel = vdata.sel;
@@ -51720,7 +51724,7 @@ static bool StructCastSwitch(Vector &source, Vector &result, idx_t count, string
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
 			ConstantVector::SetNull(result, ConstantVector::IsNull(source));
 		} else {
-			source.Normalify(count);
+			source.Flatten(count);
 			FlatVector::Validity(result) = FlatVector::Validity(source);
 		}
 		return true;
@@ -52129,8 +52133,8 @@ static inline void TemplatedLoopHash(Vector &input, Vector &result, const Select
 	} else {
 		result.SetVectorType(VectorType::FLAT_VECTOR);
 
-		VectorData idata;
-		input.Orrify(count, idata);
+		UnifiedVectorFormat idata;
+		input.ToUnifiedFormat(count, idata);
 
 		TightLoopHash<HAS_RSEL, T>((T *)idata.data, FlatVector::GetData<hash_t>(result), rsel, count, idata.sel,
 		                           idata.validity);
@@ -52168,8 +52172,8 @@ template <bool HAS_RSEL, bool FIRST_HASH>
 static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVector *rsel, idx_t count) {
 	auto hdata = FlatVector::GetData<hash_t>(hashes);
 
-	VectorData idata;
-	input.Orrify(count, idata);
+	UnifiedVectorFormat idata;
+	input.ToUnifiedFormat(count, idata);
 	const auto ldata = (const list_entry_t *)idata.data;
 
 	// Hash the children into a temporary
@@ -52364,8 +52368,8 @@ void TemplatedLoopCombineHash(Vector &input, Vector &hashes, const SelectionVect
 		auto other_hash = HashOp::Operation(*ldata, ConstantVector::IsNull(input));
 		*hash_data = CombineHashScalar(*hash_data, other_hash);
 	} else {
-		VectorData idata;
-		input.Orrify(count, idata);
+		UnifiedVectorFormat idata;
+		input.ToUnifiedFormat(count, idata);
 		if (hashes.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			// mix constant with non-constant, first get the constant value
 			auto constant_hash = *ConstantVector::GetData<hash_t>(hashes);
@@ -52454,7 +52458,7 @@ void VectorOperations::CombineHash(Vector &hashes, Vector &input, const Selectio
 namespace duckdb {
 
 template <class T>
-static void CopyToStorageLoop(VectorData &vdata, idx_t count, data_ptr_t target) {
+static void CopyToStorageLoop(UnifiedVectorFormat &vdata, idx_t count, data_ptr_t target) {
 	auto ldata = (T *)vdata.data;
 	auto result_data = (T *)target;
 	for (idx_t i = 0; i < count; i++) {
@@ -52471,8 +52475,8 @@ void VectorOperations::WriteToStorage(Vector &source, idx_t count, data_ptr_t ta
 	if (count == 0) {
 		return;
 	}
-	VectorData vdata;
-	source.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	source.ToUnifiedFormat(count, vdata);
 
 	switch (source.GetType().InternalType()) {
 	case PhysicalType::BOOL:
@@ -53200,7 +53204,7 @@ idx_t GroupedAggregateHashTable::AddChunk(DataChunk &groups, Vector &group_hashe
 				distinct_addresses.Verify(new_group_count);
 
 				if (aggr.filter) {
-					distinct_addresses.Normalify(new_group_count);
+					distinct_addresses.Flatten(new_group_count);
 					RowOperations::UpdateFilteredStates(filter_set.GetFilterData(aggr_idx), aggr, distinct_addresses,
 					                                    distinct_payload, payload_idx);
 				} else {
@@ -53262,14 +53266,14 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 	D_ASSERT(capacity - entries >= groups.size());
 	D_ASSERT(group_hashes.GetType() == LogicalType::HASH);
 
-	group_hashes.Normalify(groups.size());
+	group_hashes.Flatten(groups.size());
 	auto group_hashes_ptr = FlatVector::GetData<hash_t>(group_hashes);
 
 	D_ASSERT(ht_offsets.GetVectorType() == VectorType::FLAT_VECTOR);
 	D_ASSERT(ht_offsets.GetType() == LogicalType::BIGINT);
 
 	D_ASSERT(addresses.GetType() == LogicalType::POINTER);
-	addresses.Normalify(groups.size());
+	addresses.Flatten(groups.size());
 	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(addresses);
 
 	// now compute the entry in the table based on the hash using a modulo
@@ -53299,8 +53303,8 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 	group_chunk.data[groups.ColumnCount()].Reference(group_hashes);
 	group_chunk.SetCardinality(groups);
 
-	// orrify all the groups
-	auto group_data = group_chunk.Orrify();
+	// convert all vectors to unified format
+	auto group_data = group_chunk.ToUnifiedFormat();
 
 	idx_t new_group_count = 0;
 	while (remaining_entries > 0) {
@@ -54220,8 +54224,8 @@ void TemplatedFillLoop(Vector &vector, Vector &result, const SelectionVector &se
 			}
 		}
 	} else {
-		VectorData vdata;
-		vector.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		vector.ToUnifiedFormat(count, vdata);
 		auto data = (T *)vdata.data;
 		for (idx_t i = 0; i < count; i++) {
 			auto source_idx = vdata.sel->get_index(i);
@@ -54243,8 +54247,8 @@ void ValidityFillLoop(Vector &vector, Vector &result, const SelectionVector &sel
 			}
 		}
 	} else {
-		VectorData vdata;
-		vector.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		vector.ToUnifiedFormat(count, vdata);
 		if (vdata.validity.AllValid()) {
 			return;
 		}
@@ -54525,9 +54529,9 @@ idx_t NestedSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &ri
 static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count, const SelectionVector &sel,
                                   SelectionVector &maybe_vec, OptionalSelection &false_opt) {
 
-	VectorData lvdata, rvdata;
-	left.Orrify(count, lvdata);
-	right.Orrify(count, rvdata);
+	UnifiedVectorFormat lvdata, rvdata;
+	left.ToUnifiedFormat(count, lvdata);
+	right.ToUnifiedFormat(count, rvdata);
 
 	auto &lmask = lvdata.validity;
 	auto &rmask = rvdata.validity;
@@ -54880,8 +54884,8 @@ static void VerifyNullHandling(const BoundFunctionExpression &expr, DataChunk &a
 	idx_t count = args.size();
 	ValidityMask combined_mask(count);
 	for (auto &arg : args.data) {
-		VectorData arg_data;
-		arg.Orrify(count, arg_data);
+		UnifiedVectorFormat arg_data;
+		arg.ToUnifiedFormat(count, arg_data);
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = arg_data.sel->get_index(i);
@@ -54892,8 +54896,8 @@ static void VerifyNullHandling(const BoundFunctionExpression &expr, DataChunk &a
 	}
 
 	// Default is that if any of the arguments are NULL, the result is also NULL
-	VectorData result_data;
-	result.Orrify(count, result_data);
+	UnifiedVectorFormat result_data;
+	result.ToUnifiedFormat(count, result_data);
 	for (idx_t i = 0; i < count; i++) {
 		if (!combined_mask.RowIsValid(i)) {
 			auto idx = result_data.sel->get_index(i);
@@ -55005,8 +55009,8 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
 			Execute(*expr.children[child], state->child_states[child].get(), current_sel, remaining_count,
 			        vector_to_check);
 
-			VectorData vdata;
-			vector_to_check.Orrify(remaining_count, vdata);
+			UnifiedVectorFormat vdata;
+			vector_to_check.ToUnifiedFormat(remaining_count, vdata);
 
 			idx_t result_count = 0;
 			next_count = 0;
@@ -55348,7 +55352,7 @@ static inline idx_t DefaultSelectLoop(const SelectionVector *bsel, uint8_t *__re
 }
 
 template <bool NO_NULL>
-static inline idx_t DefaultSelectSwitch(VectorData &idata, const SelectionVector *sel, idx_t count,
+static inline idx_t DefaultSelectSwitch(UnifiedVectorFormat &idata, const SelectionVector *sel, idx_t count,
                                         SelectionVector *true_sel, SelectionVector *false_sel) {
 	if (true_sel && false_sel) {
 		return DefaultSelectLoop<NO_NULL, true, true>(idata.sel, (uint8_t *)idata.data, idata.validity, sel, count,
@@ -55372,8 +55376,8 @@ idx_t ExpressionExecutor::DefaultSelect(const Expression &expr, ExpressionState
 	Vector intermediate(LogicalType::BOOLEAN, (data_ptr_t)intermediate_bools);
 	Execute(expr, state, sel, count, intermediate);
 
-	VectorData idata;
-	intermediate.Orrify(count, idata);
+	UnifiedVectorFormat idata;
+	intermediate.ToUnifiedFormat(count, idata);
 
 	if (!sel) {
 		sel = FlatVector::IncrementalSelectionVector();
@@ -55498,8 +55502,8 @@ unique_ptr<IndexScanState> ART::InitializeScanTwoPredicates(Transaction &transac
 //===--------------------------------------------------------------------===//
 template <class T>
 static void TemplatedGenerateKeys(Vector &input, idx_t count, vector<unique_ptr<Key>> &keys) {
-	VectorData idata;
-	input.Orrify(count, idata);
+	UnifiedVectorFormat idata;
+	input.ToUnifiedFormat(count, idata);
 
 	auto input_data = (T *)idata.data;
 	for (idx_t i = 0; i < count; i++) {
@@ -55514,8 +55518,8 @@ static void TemplatedGenerateKeys(Vector &input, idx_t count, vector<unique_ptr<
 
 template <class T>
 static void ConcatenateKeys(Vector &input, idx_t count, vector<unique_ptr<Key>> &keys) {
-	VectorData idata;
-	input.Orrify(count, idata);
+	UnifiedVectorFormat idata;
+	input.ToUnifiedFormat(count, idata);
 
 	auto input_data = (T *)idata.data;
 	for (idx_t i = 0; i < count; i++) {
@@ -55640,7 +55644,7 @@ bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 	GenerateKeys(input, keys);
 
 	// now insert the elements into the index
-	row_ids.Normalify(input.size());
+	row_ids.Flatten(input.size());
 	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
 	idx_t failed_index = DConstants::INVALID_INDEX;
 	for (idx_t i = 0; i < input.size(); i++) {
@@ -55796,7 +55800,7 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 	GenerateKeys(expression, keys);
 
 	// now erase the elements from the database
-	row_ids.Normalify(input.size());
+	row_ids.Flatten(input.size());
 	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
 
 	for (idx_t i = 0; i < input.size(); i++) {
@@ -57327,7 +57331,7 @@ public:
 	//! returned by the JoinHashTable::Scan function and can be used to resume a
 	//! probe.
 	struct ScanStructure {
-		unique_ptr<VectorData[]> key_data;
+		unique_ptr<UnifiedVectorFormat[]> key_data;
 		Vector pointers;
 		idx_t count;
 		SelectionVector sel_vector;
@@ -57457,7 +57461,7 @@ private:
 	//! hashes. Caller should hold lock in parallel HT.
 	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[]);
 
-	idx_t PrepareKeys(DataChunk &keys, unique_ptr<VectorData[]> &key_data, const SelectionVector *&current_sel,
+	idx_t PrepareKeys(DataChunk &keys, unique_ptr<UnifiedVectorFormat[]> &key_data, const SelectionVector *&current_sel,
 	                  SelectionVector &sel, bool build_side);
 
 	//! The RowDataCollection holding the main data of the hash table
@@ -57546,7 +57550,7 @@ void JoinHashTable::ApplyBitmask(Vector &hashes, idx_t count) {
 		auto indices = ConstantVector::GetData<hash_t>(hashes);
 		*indices = *indices & bitmask;
 	} else {
-		hashes.Normalify(count);
+		hashes.Flatten(count);
 		auto indices = FlatVector::GetData<hash_t>(hashes);
 		for (idx_t i = 0; i < count; i++) {
 			indices[i] &= bitmask;
@@ -57555,8 +57559,8 @@ void JoinHashTable::ApplyBitmask(Vector &hashes, idx_t count) {
 }
 
 void JoinHashTable::ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx_t count, Vector &pointers) {
-	VectorData hdata;
-	hashes.Orrify(count, hdata);
+	UnifiedVectorFormat hdata;
+	hashes.ToUnifiedFormat(count, hdata);
 
 	auto hash_data = (hash_t *)hdata.data;
 	auto result_data = FlatVector::GetData<data_ptr_t *>(pointers);
@@ -57585,7 +57589,8 @@ void JoinHashTable::Hash(DataChunk &keys, const SelectionVector &sel, idx_t coun
 	}
 }
 
-static idx_t FilterNullValues(VectorData &vdata, const SelectionVector &sel, idx_t count, SelectionVector &result) {
+static idx_t FilterNullValues(UnifiedVectorFormat &vdata, const SelectionVector &sel, idx_t count,
+                              SelectionVector &result) {
 	idx_t result_count = 0;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
@@ -57597,9 +57602,9 @@ static idx_t FilterNullValues(VectorData &vdata, const SelectionVector &sel, idx
 	return result_count;
 }
 
-idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unique_ptr<VectorData[]> &key_data,
+idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unique_ptr<UnifiedVectorFormat[]> &key_data,
                                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side) {
-	key_data = keys.Orrify();
+	key_data = keys.ToUnifiedFormat();
 
 	// figure out which keys are NULL, and create a selection vector out of them
 	current_sel = FlatVector::IncrementalSelectionVector();
@@ -57650,7 +57655,7 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 	}
 
 	// prepare the keys for processing
-	unique_ptr<VectorData[]> key_data;
+	unique_ptr<UnifiedVectorFormat[]> key_data;
 	const SelectionVector *current_sel;
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
 	idx_t added_count = PrepareKeys(keys, key_data, current_sel, sel, true);
@@ -57675,7 +57680,7 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 	DataChunk source_chunk;
 	source_chunk.InitializeEmpty(layout.GetTypes());
 
-	vector<VectorData> source_data;
+	vector<UnifiedVectorFormat> source_data;
 	source_data.reserve(layout.ColumnCount());
 
 	// serialize the keys to the key locations
@@ -57687,22 +57692,22 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 	D_ASSERT(build_types.size() == payload.ColumnCount());
 	for (idx_t i = 0; i < payload.ColumnCount(); i++) {
 		source_chunk.data[source_data.size()].Reference(payload.data[i]);
-		VectorData pdata;
-		payload.data[i].Orrify(payload.size(), pdata);
+		UnifiedVectorFormat pdata;
+		payload.data[i].ToUnifiedFormat(payload.size(), pdata);
 		source_data.emplace_back(move(pdata));
 	}
 	if (IsRightOuterJoin(join_type)) {
 		// for FULL/RIGHT OUTER joins initialize the "found" boolean to false
 		source_chunk.data[source_data.size()].Reference(vfound);
-		VectorData fdata;
-		vfound.Orrify(keys.size(), fdata);
+		UnifiedVectorFormat fdata;
+		vfound.ToUnifiedFormat(keys.size(), fdata);
 		source_data.emplace_back(move(fdata));
 	}
 
 	// serialise the hashes at the end
 	source_chunk.data[source_data.size()].Reference(hash_values);
-	VectorData hdata;
-	hash_values.Orrify(keys.size(), hdata);
+	UnifiedVectorFormat hdata;
+	hash_values.ToUnifiedFormat(keys.size(), hdata);
 	source_data.emplace_back(move(hdata));
 
 	source_chunk.SetCardinality(keys);
@@ -57717,7 +57722,7 @@ void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_loc
 	// use bitmask to get position in array
 	ApplyBitmask(hashes, count);
 
-	hashes.Normalify(count);
+	hashes.Flatten(count);
 
 	D_ASSERT(hashes.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto pointers = (data_ptr_t *)hash_map.Ptr();
@@ -58027,8 +58032,8 @@ void ScanStructure::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &chi
 		if (ht.null_values_are_equal[col_idx]) {
 			continue;
 		}
-		VectorData jdata;
-		join_keys.data[col_idx].Orrify(join_keys.size(), jdata);
+		UnifiedVectorFormat jdata;
+		join_keys.data[col_idx].ToUnifiedFormat(join_keys.size(), jdata);
 		if (!jdata.validity.AllValid()) {
 			for (idx_t i = 0; i < join_keys.size(); i++) {
 				auto jidx = jdata.sel->get_index(i);
@@ -58096,8 +58101,8 @@ void ScanStructure::NextMarkJoin(DataChunk &keys, DataChunk &input, DataChunk &r
 			mask.Copy(FlatVector::Validity(last_key), input.size());
 			break;
 		default: {
-			VectorData kdata;
-			last_key.Orrify(keys.size(), kdata);
+			UnifiedVectorFormat kdata;
+			last_key.ToUnifiedFormat(keys.size(), kdata);
 			for (idx_t i = 0; i < input.size(); i++) {
 				auto kidx = kdata.sel->get_index(i);
 				mask.Set(i, kdata.validity.RowIsValid(kidx));
@@ -58322,9 +58327,9 @@ struct InitialNestedLoopJoin {
 	                       SelectionVector &lvector, SelectionVector &rvector, idx_t current_match_count) {
 		// initialize phase of nested loop join
 		// fill lvector and rvector with matches from the base vectors
-		VectorData left_data, right_data;
-		left.Orrify(left_size, left_data);
-		right.Orrify(right_size, right_data);
+		UnifiedVectorFormat left_data, right_data;
+		left.ToUnifiedFormat(left_size, left_data);
+		right.ToUnifiedFormat(right_size, right_data);
 
 		auto ldata = (T *)left_data.data;
 		auto rdata = (T *)right_data.data;
@@ -58356,9 +58361,9 @@ struct RefineNestedLoopJoin {
 	template <class T, class OP>
 	static idx_t Operation(Vector &left, Vector &right, idx_t left_size, idx_t right_size, idx_t &lpos, idx_t &rpos,
 	                       SelectionVector &lvector, SelectionVector &rvector, idx_t current_match_count) {
-		VectorData left_data, right_data;
-		left.Orrify(left_size, left_data);
-		right.Orrify(right_size, right_data);
+		UnifiedVectorFormat left_data, right_data;
+		left.ToUnifiedFormat(left_size, left_data);
+		right.ToUnifiedFormat(right_size, right_data);
 
 		// refine phase of the nested loop join
 		// refine lvector and rvector based on matches of subsequent conditions (in case there are multiple conditions
@@ -58504,9 +58509,9 @@ namespace duckdb {
 
 template <class T, class OP>
 static void TemplatedMarkJoin(Vector &left, Vector &right, idx_t lcount, idx_t rcount, bool found_match[]) {
-	VectorData left_data, right_data;
-	left.Orrify(lcount, left_data);
-	right.Orrify(rcount, right_data);
+	UnifiedVectorFormat left_data, right_data;
+	left.ToUnifiedFormat(lcount, left_data);
+	right.ToUnifiedFormat(rcount, right_data);
 
 	auto ldata = (T *)left_data.data;
 	auto rdata = (T *)right_data.data;
@@ -59895,8 +59900,8 @@ void VerifyNullHandling(DataChunk &chunk, AggregateState &state, const vector<un
 		auto &aggr = (BoundAggregateExpression &)*aggregates[aggr_idx];
 		if (state.counts[aggr_idx] == 0 && aggr.function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
 			// Default is when 0 values go in, NULL comes out
-			VectorData vdata;
-			chunk.data[aggr_idx].Orrify(1, vdata);
+			UnifiedVectorFormat vdata;
+			chunk.data[aggr_idx].ToUnifiedFormat(1, vdata);
 			D_ASSERT(!vdata.validity.RowIsValid(vdata.sel->get_index(0)));
 		}
 	}
@@ -60533,11 +60538,11 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 		Vector addresses(LogicalType::POINTER);
 		auto key_locations = FlatVector::GetData<data_ptr_t>(addresses);
 		auto handles = rows->Build(row_count, key_locations, nullptr, row_sel);
-		vector<VectorData> payload_data;
+		vector<UnifiedVectorFormat> payload_data;
 		payload_data.reserve(payload_chunk.ColumnCount());
 		for (idx_t i = 0; i < payload_chunk.ColumnCount(); i++) {
-			VectorData pdata;
-			payload_chunk.data[i].Orrify(row_count, pdata);
+			UnifiedVectorFormat pdata;
+			payload_chunk.data[i].ToUnifiedFormat(row_count, pdata);
 			payload_data.emplace_back(move(pdata));
 		}
 		RowOperations::Scatter(payload_chunk, payload_data.data(), payload_layout, addresses, *strings, *row_sel,
@@ -61410,8 +61415,8 @@ static void ComputeWindowExpression(BoundWindowExpression *wexpr, ChunkCollectio
 			idx_t pos = 0;
 			for (auto &chunk : payload_collection.Chunks()) {
 				const auto count = chunk->size();
-				VectorData vdata;
-				chunk->data[0].Orrify(count, vdata);
+				UnifiedVectorFormat vdata;
+				chunk->data[0].ToUnifiedFormat(count, vdata);
 				if (!vdata.validity.AllValid()) {
 					//	Lazily materialise the contents when we find the first NULL
 					if (ignore_nulls.AllValid()) {
@@ -64042,7 +64047,7 @@ public:
 	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
 
 	void Update(Vector &update, idx_t count, bool sample = true);
-	void Update(VectorData &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
+	void Update(UnifiedVectorFormat &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
 
 	string ToString() const override;
 	idx_t GetCount() const;
@@ -64481,8 +64486,8 @@ bool PerfectHashJoinExecutor::TemplatedFillSelectionVectorBuild(Vector &source,
 	}
 	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
 	auto max_value = perfect_join_statistics.build_max.GetValueUnsafe<T>();
-	VectorData vector_data;
-	source.Orrify(count, vector_data);
+	UnifiedVectorFormat vector_data;
+	source.ToUnifiedFormat(count, vector_data);
 	auto data = reinterpret_cast<T *>(vector_data.data);
 	// generate the selection vector
 	for (idx_t i = 0, sel_idx = 0; i < count; ++i) {
@@ -64604,8 +64609,8 @@ void PerfectHashJoinExecutor::TemplatedFillSelectionVectorProbe(Vector &source,
 	auto min_value = perfect_join_statistics.build_min.GetValueUnsafe<T>();
 	auto max_value = perfect_join_statistics.build_max.GetValueUnsafe<T>();
 
-	VectorData vector_data;
-	source.Orrify(count, vector_data);
+	UnifiedVectorFormat vector_data;
+	source.ToUnifiedFormat(count, vector_data);
 	auto data = reinterpret_cast<T *>(vector_data.data);
 	auto validity_mask = &vector_data.validity;
 	// build selection vector for non-dense build
@@ -67741,8 +67746,8 @@ PhysicalNestedLoopJoin::PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<P
 
 static bool HasNullValues(DataChunk &chunk) {
 	for (idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
-		VectorData vdata;
-		chunk.data[col_idx].Orrify(chunk.size(), vdata);
+		UnifiedVectorFormat vdata;
+		chunk.data[col_idx].ToUnifiedFormat(chunk.size(), vdata);
 
 		if (vdata.validity.AllValid()) {
 			continue;
@@ -67801,8 +67806,8 @@ void PhysicalJoin::ConstructMarkJoinResult(DataChunk &join_keys, DataChunk &left
 	auto bool_result = FlatVector::GetData<bool>(mark_vector);
 	auto &mask = FlatVector::Validity(mark_vector);
 	for (idx_t col_idx = 0; col_idx < join_keys.ColumnCount(); col_idx++) {
-		VectorData jdata;
-		join_keys.data[col_idx].Orrify(join_keys.size(), jdata);
+		UnifiedVectorFormat jdata;
+		join_keys.data[col_idx].ToUnifiedFormat(join_keys.size(), jdata);
 		if (!jdata.validity.AllValid()) {
 			for (idx_t i = 0; i < join_keys.size(); i++) {
 				auto jidx = jdata.sel->get_index(i);
@@ -68654,7 +68659,7 @@ void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, Da
 		// The only part of the join keys that is actually used is the validity mask.
 		// Since the payload is sorted, we can just set the tail end of the validity masks to invalid.
 		for (auto &key : lhs_table.keys.data) {
-			key.Normalify(lhs_table.keys.size());
+			key.Flatten(lhs_table.keys.size());
 			auto &mask = FlatVector::Validity(key);
 			if (mask.AllValid()) {
 				continue;
@@ -69201,8 +69206,8 @@ idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(const vector<JoinCondition
 		}
 		return 0;
 	} else if (keys.ColumnCount() > 1) {
-		//	Normalify the primary, as it will need to merge arbitrary validity masks
-		primary.Normalify(count);
+		//	Flatten the primary, as it will need to merge arbitrary validity masks
+		primary.Flatten(count);
 		auto &pvalidity = FlatVector::Validity(primary);
 		D_ASSERT(keys.ColumnCount() == conditions.size());
 		for (size_t c = 1; c < keys.data.size(); ++c) {
@@ -69210,10 +69215,10 @@ idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(const vector<JoinCondition
 			if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
 				continue;
 			}
-			//	Orrify the rest, as the sort code will do this anyway.
+			//	ToUnifiedFormat the rest, as the sort code will do this anyway.
 			auto &v = keys.data[c];
-			VectorData vdata;
-			v.Orrify(count, vdata);
+			UnifiedVectorFormat vdata;
+			v.ToUnifiedFormat(count, vdata);
 			auto &vvalidity = vdata.validity;
 			if (vvalidity.AllValid()) {
 				continue;
@@ -72517,7 +72522,7 @@ SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &
 
 	lock_guard<mutex> delete_guard(gstate.delete_lock);
 	if (return_chunk) {
-		row_identifiers.Normalify(input.size());
+		row_identifiers.Flatten(input.size());
 		table.Fetch(transaction, ustate.delete_chunk, column_ids, row_identifiers, input.size(), cfs);
 		gstate.return_chunk_collection.Append(ustate.delete_chunk);
 	}
@@ -72947,7 +72952,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 	auto &gstate = (InsertGlobalState &)state;
 	auto &istate = (InsertLocalState &)lstate;
 
-	chunk.Normalify();
+	chunk.Flatten();
 	istate.default_executor.SetChunk(chunk);
 
 	istate.insert_chunk.Reset();
@@ -73163,7 +73168,7 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 	DataChunk &update_chunk = ustate.update_chunk;
 	DataChunk &mock_chunk = ustate.mock_chunk;
 
-	chunk.Normalify();
+	chunk.Flatten();
 	ustate.default_executor.SetChunk(chunk);
 
 	// update data in the base table
@@ -73541,8 +73546,8 @@ public:
 
 	ExpressionExecutor executor;
 	DataChunk list_data;
-	vector<VectorData> list_vector_data;
-	vector<VectorData> list_child_data;
+	vector<UnifiedVectorFormat> list_vector_data;
+	vector<UnifiedVectorFormat> list_child_data;
 };
 
 // this implements a sorted window functions variant
@@ -73572,7 +73577,7 @@ static void UnnestNull(idx_t start, idx_t end, Vector &result) {
 }
 
 template <class T>
-static void TemplatedUnnest(VectorData &vdata, idx_t start, idx_t end, Vector &result) {
+static void TemplatedUnnest(UnifiedVectorFormat &vdata, idx_t start, idx_t end, Vector &result) {
 	auto source_data = (T *)vdata.data;
 	auto &source_mask = vdata.validity;
 	auto result_data = FlatVector::GetData<T>(result);
@@ -73590,7 +73595,7 @@ static void TemplatedUnnest(VectorData &vdata, idx_t start, idx_t end, Vector &r
 	}
 }
 
-static void UnnestValidity(VectorData &vdata, idx_t start, idx_t end, Vector &result) {
+static void UnnestValidity(UnifiedVectorFormat &vdata, idx_t start, idx_t end, Vector &result) {
 	auto &source_mask = vdata.validity;
 	auto &result_mask = FlatVector::Validity(result);
 
@@ -73601,7 +73606,8 @@ static void UnnestValidity(VectorData &vdata, idx_t start, idx_t end, Vector &re
 	}
 }
 
-static void UnnestVector(VectorData &vdata, Vector &source, idx_t list_size, idx_t start, idx_t end, Vector &result) {
+static void UnnestVector(UnifiedVectorFormat &vdata, Vector &source, idx_t list_size, idx_t start, idx_t end,
+                         Vector &result) {
 	switch (result.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -73655,8 +73661,8 @@ static void UnnestVector(VectorData &vdata, Vector &source, idx_t list_size, idx
 		auto &target_entries = StructVector::GetEntries(result);
 		UnnestValidity(vdata, start, end, result);
 		for (idx_t i = 0; i < source_entries.size(); i++) {
-			VectorData sdata;
-			source_entries[i]->Orrify(list_size, sdata);
+			UnifiedVectorFormat sdata;
+			source_entries[i]->ToUnifiedFormat(list_size, sdata);
 			UnnestVector(sdata, *source_entries[i], list_size, start, end, *target_entries[i]);
 		}
 		break;
@@ -73693,19 +73699,19 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
 			D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
 			D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
 
-			// initialize VectorData object so the nullmask can accessed
+			// initialize UnifiedVectorFormat object so the nullmask can accessed
 			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
 				auto &list_vector = state.list_data.data[col_idx];
-				list_vector.Orrify(state.list_data.size(), state.list_vector_data[col_idx]);
+				list_vector.ToUnifiedFormat(state.list_data.size(), state.list_vector_data[col_idx]);
 
 				if (list_vector.GetType() == LogicalType::SQLNULL) {
 					// UNNEST(NULL)
 					auto &child_vector = list_vector;
-					child_vector.Orrify(0, state.list_child_data[col_idx]);
+					child_vector.ToUnifiedFormat(0, state.list_child_data[col_idx]);
 				} else {
 					auto list_size = ListVector::GetListSize(list_vector);
 					auto &child_vector = ListVector::GetEntry(list_vector);
-					child_vector.Orrify(list_size, state.list_child_data[col_idx]);
+					child_vector.ToUnifiedFormat(list_size, state.list_child_data[col_idx]);
 				}
 			}
 			state.first_fetch = false;
@@ -75363,7 +75369,7 @@ idx_t PartitionableHashTable::AddChunk(DataChunk &groups, DataChunk &payload, bo
 		sel_vector_sizes[r] = 0;
 	}
 
-	hashes.Normalify(groups.size());
+	hashes.Flatten(groups.size());
 	auto hashes_ptr = FlatVector::GetData<hash_t>(hashes);
 
 	for (idx_t i = 0; i < groups.size(); i++) {
@@ -75480,7 +75486,7 @@ PerfectAggregateHashTable::~PerfectAggregateHashTable() {
 }
 
 template <class T>
-static void ComputeGroupLocationTemplated(VectorData &group_data, Value &min, uintptr_t *address_data,
+static void ComputeGroupLocationTemplated(UnifiedVectorFormat &group_data, Value &min, uintptr_t *address_data,
                                           idx_t current_shift, idx_t count) {
 	auto data = (T *)group_data.data;
 	auto min_val = min.GetValueUnsafe<T>();
@@ -75508,8 +75514,8 @@ static void ComputeGroupLocationTemplated(VectorData &group_data, Value &min, ui
 }
 
 static void ComputeGroupLocation(Vector &group, Value &min, uintptr_t *address_data, idx_t current_shift, idx_t count) {
-	VectorData vdata;
-	group.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	group.ToUnifiedFormat(count, vdata);
 
 	switch (group.GetType().InternalType()) {
 	case PhysicalType::INT8:
@@ -80187,7 +80193,7 @@ void ReservoirSample::ReplaceElement(DataChunk &input, idx_t index_in_chunk) {
 
 idx_t ReservoirSample::FillReservoir(DataChunk &input) {
 	idx_t chunk_count = input.size();
-	input.Normalify();
+	input.Flatten();
 
 	// we have not: append to the reservoir
 	idx_t required_count;
@@ -80237,7 +80243,7 @@ void ReservoirSamplePercentage::AddToReservoir(DataChunk &input) {
 		idx_t append_to_next_sample = input.size() - append_to_current_sample_count;
 		if (append_to_current_sample_count > 0) {
 			// we have elements remaining, first add them to the current sample
-			input.Normalify();
+			input.Flatten();
 
 			input.SetCardinality(append_to_current_sample_count);
 			current_sample->AddToReservoir(input);
@@ -80374,7 +80380,7 @@ WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData
 #if STANDARD_VECTOR_SIZE < 512
 	throw NotImplementedException("Window functions are not supported for vector sizes < 512");
 #endif
-	statep.Normalify(STANDARD_VECTOR_SIZE);
+	statep.Flatten(STANDARD_VECTOR_SIZE);
 	statev.SetVectorType(VectorType::FLAT_VECTOR); // Prevent conversion of results to constants
 
 	if (input_ref && input_ref->ColumnCount() > 0) {
@@ -81570,8 +81576,8 @@ static void ApproxCountDistinctSimpleUpdateFunction(Vector inputs[], AggregateIn
 		agg_state->log = new HyperLogLog();
 	}
 
-	VectorData vdata;
-	inputs[0].Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	inputs[0].ToUnifiedFormat(count, vdata);
 
 	uint64_t indices[STANDARD_VECTOR_SIZE];
 	uint8_t counts[STANDARD_VECTOR_SIZE];
@@ -81584,8 +81590,8 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
                                               Vector &state_vector, idx_t count) {
 	D_ASSERT(input_count == 1);
 
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
+	UnifiedVectorFormat sdata;
+	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = (ApproxDistinctCountState **)sdata.data;
 
 	for (idx_t i = 0; i < count; i++) {
@@ -81595,8 +81601,8 @@ static void ApproxCountDistinctUpdateFunction(Vector inputs[], AggregateInputDat
 		}
 	}
 
-	VectorData vdata;
-	inputs[0].Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	inputs[0].ToUnifiedFormat(count, vdata);
 
 	uint64_t indices[STANDARD_VECTOR_SIZE];
 	uint8_t counts[STANDARD_VECTOR_SIZE];
@@ -82620,8 +82626,8 @@ struct FirstVectorFunction {
 
 	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
 		auto &input = inputs[0];
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
+		UnifiedVectorFormat sdata;
+		state_vector.ToUnifiedFormat(count, sdata);
 
 		auto states = (FirstStateVector **)sdata.data;
 		for (idx_t i = 0; i < count; i++) {
@@ -83095,9 +83101,9 @@ struct MaxOperationString : public StringMinMaxBase {
 
 template <typename T, class OP>
 static bool TemplatedOptimumType(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
-	VectorData lvdata, rvdata;
-	left.Orrify(lcount, lvdata);
-	right.Orrify(rcount, rvdata);
+	UnifiedVectorFormat lvdata, rvdata;
+	left.ToUnifiedFormat(lcount, lvdata);
+	right.ToUnifiedFormat(rcount, rvdata);
 
 	lidx = lvdata.sel->get_index(lidx);
 	ridx = rvdata.sel->get_index(ridx);
@@ -83166,9 +83172,9 @@ static bool TemplatedOptimumStruct(Vector &left, idx_t lidx_p, idx_t lcount, Vec
                                    idx_t rcount) {
 	// STRUCT dictionaries apply to all the children
 	// so map the indexes first
-	VectorData lvdata, rvdata;
-	left.Orrify(lcount, lvdata);
-	right.Orrify(rcount, rvdata);
+	UnifiedVectorFormat lvdata, rvdata;
+	left.ToUnifiedFormat(lcount, lvdata);
+	right.ToUnifiedFormat(rcount, rvdata);
 
 	idx_t lidx = lvdata.sel->get_index(lidx_p);
 	idx_t ridx = rvdata.sel->get_index(ridx_p);
@@ -83208,9 +83214,9 @@ static bool TemplatedOptimumStruct(Vector &left, idx_t lidx_p, idx_t lcount, Vec
 
 template <class OP>
 static bool TemplatedOptimumList(Vector &left, idx_t lidx, idx_t lcount, Vector &right, idx_t ridx, idx_t rcount) {
-	VectorData lvdata, rvdata;
-	left.Orrify(lcount, lvdata);
-	right.Orrify(rcount, rvdata);
+	UnifiedVectorFormat lvdata, rvdata;
+	left.ToUnifiedFormat(lcount, lvdata);
+	right.ToUnifiedFormat(rcount, rvdata);
 
 	// Update the indexes and vector sizes for recursion.
 	lidx = lvdata.sel->get_index(lidx);
@@ -83298,11 +83304,11 @@ struct VectorMinMaxBase {
 	template <class STATE, class OP>
 	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
 		auto &input = inputs[0];
-		VectorData idata;
-		input.Orrify(count, idata);
+		UnifiedVectorFormat idata;
+		input.ToUnifiedFormat(count, idata);
 
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
+		UnifiedVectorFormat sdata;
+		state_vector.ToUnifiedFormat(count, sdata);
 
 		auto states = (STATE **)sdata.data;
 		for (idx_t i = 0; i < count; i++) {
@@ -87255,7 +87261,7 @@ namespace duckdb {
 
 struct HistogramFunctor {
 	template <class T, class MAP_TYPE = map<T, idx_t>>
-	static void HistogramUpdate(VectorData &sdata, VectorData &input_data, idx_t count) {
+	static void HistogramUpdate(UnifiedVectorFormat &sdata, UnifiedVectorFormat &input_data, idx_t count) {
 
 		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 		for (idx_t i = 0; i < count; i++) {
@@ -87278,7 +87284,7 @@ struct HistogramFunctor {
 
 struct HistogramStringFunctor {
 	template <class T, class MAP_TYPE = map<T, idx_t>>
-	static void HistogramUpdate(VectorData &sdata, VectorData &input_data, idx_t count) {
+	static void HistogramUpdate(UnifiedVectorFormat &sdata, UnifiedVectorFormat &input_data, idx_t count) {
 
 		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 		for (idx_t i = 0; i < count; i++) {
@@ -87325,10 +87331,10 @@ static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &, idx_t
 	D_ASSERT(input_count == 1);
 
 	auto &input = inputs[0];
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
-	VectorData input_data;
-	input.Orrify(count, input_data);
+	UnifiedVectorFormat sdata;
+	state_vector.ToUnifiedFormat(count, sdata);
+	UnifiedVectorFormat input_data;
+	input.ToUnifiedFormat(count, input_data);
 
 	OP::template HistogramUpdate<T, MAP_TYPE>(sdata, input_data, count);
 }
@@ -87336,8 +87342,8 @@ static void HistogramUpdateFunction(Vector inputs[], AggregateInputData &, idx_t
 template <class T, class MAP_TYPE>
 static void HistogramCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
 
-	VectorData sdata;
-	state.Orrify(count, sdata);
+	UnifiedVectorFormat sdata;
+	state.ToUnifiedFormat(count, sdata);
 	auto states_ptr = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 
 	auto combined_ptr = FlatVector::GetData<HistogramAggState<T, MAP_TYPE> *>(combined);
@@ -87362,8 +87368,8 @@ template <class OP, class T, class MAP_TYPE>
 static void HistogramFinalizeFunction(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count,
                                       idx_t offset) {
 
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
+	UnifiedVectorFormat sdata;
+	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 
 	auto &mask = FlatVector::Validity(result);
@@ -87553,14 +87559,14 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &, idx_t inpu
 	D_ASSERT(input_count == 1);
 
 	auto &input = inputs[0];
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
+	UnifiedVectorFormat sdata;
+	state_vector.ToUnifiedFormat(count, sdata);
 
 	auto list_vector_type = LogicalType::LIST(input.GetType());
 
 	auto states = (ListAggState **)sdata.data;
 	if (input.GetVectorType() == VectorType::SEQUENCE_VECTOR) {
-		input.Normalify(count);
+		input.Flatten(count);
 	}
 	for (idx_t i = 0; i < count; i++) {
 		auto state = states[sdata.sel->get_index(i)];
@@ -87574,8 +87580,8 @@ static void ListUpdateFunction(Vector inputs[], AggregateInputData &, idx_t inpu
 }
 
 static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputData &, idx_t count) {
-	VectorData sdata;
-	state.Orrify(count, sdata);
+	UnifiedVectorFormat sdata;
+	state.ToUnifiedFormat(count, sdata);
 	auto states_ptr = (ListAggState **)sdata.data;
 
 	auto combined_ptr = FlatVector::GetData<ListAggState *>(combined);
@@ -87597,8 +87603,8 @@ static void ListCombineFunction(Vector &state, Vector &combined, AggregateInputD
 }
 
 static void ListFinalize(Vector &state_vector, AggregateInputData &, Vector &result, idx_t count, idx_t offset) {
-	VectorData sdata;
-	state_vector.Orrify(count, sdata);
+	UnifiedVectorFormat sdata;
+	state_vector.ToUnifiedFormat(count, sdata);
 	auto states = (ListAggState **)sdata.data;
 
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
@@ -88371,8 +88377,8 @@ struct SortedAggregateFunction {
 
 		// We have to scatter the chunks one at a time
 		// so build a selection vector for each one.
-		VectorData svdata;
-		states.Orrify(count, svdata);
+		UnifiedVectorFormat svdata;
+		states.ToUnifiedFormat(count, svdata);
 
 		// Build the selection vector for each state.
 		auto sdata = (SortedAggregateState **)svdata.data;
@@ -91975,8 +91981,8 @@ struct StructDatePart {
 				}
 			}
 		} else {
-			VectorData rdata;
-			input.Orrify(count, rdata);
+			UnifiedVectorFormat rdata;
+			input.ToUnifiedFormat(count, rdata);
 
 			const auto &arg_valid = rdata.validity;
 			auto tdata = (const INPUT_TYPE *)rdata.data;
@@ -93427,9 +93433,9 @@ struct SenaryExecutor {
 			auto &result_validity = FlatVector::Validity(result);
 
 			bool all_valid = true;
-			vector<VectorData> vdata(NCOLS);
+			vector<UnifiedVectorFormat> vdata(NCOLS);
 			for (size_t c = 0; c < NCOLS; ++c) {
-				input.data[c].Orrify(count, vdata[c]);
+				input.data[c].ToUnifiedFormat(count, vdata[c]);
 				all_valid = all_valid && vdata[c].validity.AllValid();
 			}
 
@@ -95340,7 +95346,7 @@ static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vect
 			auto &input_mask = FlatVector::Validity(args.data[idx]);
 			if (!input_mask.AllValid()) {
 				// there are null values: need to merge them into the result
-				result.Normalify(args.size());
+				result.Flatten(args.size());
 				auto &result_mask = FlatVector::Validity(result);
 				result_mask.Combine(input_mask, args.size());
 			}
@@ -95356,10 +95362,10 @@ static void ConstantOrNullFunction(DataChunk &args, ExpressionState &state, Vect
 			break;
 		}
 		default: {
-			VectorData vdata;
-			args.data[idx].Orrify(args.size(), vdata);
+			UnifiedVectorFormat vdata;
+			args.data[idx].ToUnifiedFormat(args.size(), vdata);
 			if (!vdata.validity.AllValid()) {
-				result.Normalify(args.size());
+				result.Flatten(args.size());
 				auto &result_mask = FlatVector::Validity(result);
 				for (idx_t i = 0; i < args.size(); i++) {
 					if (!vdata.validity.RowIsValid(vdata.sel->get_index(i))) {
@@ -95513,8 +95519,8 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 	// copy over the first column
 	bool result_has_value[STANDARD_VECTOR_SIZE];
 	{
-		VectorData vdata;
-		args.data[0].Orrify(args.size(), vdata);
+		UnifiedVectorFormat vdata;
+		args.data[0].ToUnifiedFormat(args.size(), vdata);
 		auto input_data = (T *)vdata.data;
 		for (idx_t i = 0; i < args.size(); i++) {
 			auto vindex = vdata.sel->get_index(i);
@@ -95534,8 +95540,8 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 			continue;
 		}
 
-		VectorData vdata;
-		args.data[col_idx].Orrify(args.size(), vdata);
+		UnifiedVectorFormat vdata;
+		args.data[col_idx].ToUnifiedFormat(args.size(), vdata);
 
 		auto input_data = (T *)vdata.data;
 		if (!vdata.validity.AllValid()) {
@@ -95806,11 +95812,11 @@ static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const
 			rdata[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
 		}
 	} else {
-		VectorData sdata, bdata, edata;
+		UnifiedVectorFormat sdata, bdata, edata;
 
-		s.Orrify(count, sdata);
-		b.Orrify(count, bdata);
-		e.Orrify(count, edata);
+		s.ToUnifiedFormat(count, sdata);
+		b.ToUnifiedFormat(count, bdata);
+		e.ToUnifiedFormat(count, edata);
 
 		auto rdata = FlatVector::GetData<INPUT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
@@ -95851,7 +95857,7 @@ static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &
 	Vector &b = args.data[1];
 	Vector &e = args.data[2];
 
-	s.Normalify(count);
+	s.Flatten(count);
 	switch (result.GetType().id()) {
 	case LogicalTypeId::LIST:
 		// Share the value dictionary as we are just going to slice it
@@ -95965,15 +95971,15 @@ static void TemplatedContainsOrPosition(DataChunk &args, ExpressionState &state,
 	auto list_size = ListVector::GetListSize(list);
 	auto &child_vector = ListVector::GetEntry(list);
 
-	VectorData child_data;
-	child_vector.Orrify(list_size, child_data);
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(list_size, child_data);
 
-	VectorData list_data;
-	list.Orrify(count, list_data);
+	UnifiedVectorFormat list_data;
+	list.ToUnifiedFormat(count, list_data);
 	auto list_entries = (list_entry_t *)list_data.data;
 
-	VectorData value_data;
-	value_vector.Orrify(count, value_data);
+	UnifiedVectorFormat value_data;
+	value_vector.ToUnifiedFormat(count, value_data);
 
 	// not required for a comparison of nested types
 	auto child_value = FlatVector::GetData<CHILD_TYPE>(child_vector);
@@ -96192,8 +96198,8 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 
 	idx_t count = args.size();
 
-	VectorData list_data;
-	input.Orrify(count, list_data);
+	UnifiedVectorFormat list_data;
+	input.ToUnifiedFormat(count, list_data);
 	auto list_entries = (list_entry_t *)list_data.data;
 
 	auto &child_vector = ListVector::GetEntry(input);
@@ -96217,8 +96223,8 @@ void ListFlattenFunction(DataChunk &args, ExpressionState &state, Vector &result
 	}
 
 	auto child_size = ListVector::GetListSize(input);
-	VectorData child_data;
-	child_vector.Orrify(child_size, child_data);
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(child_size, child_data);
 	auto child_entries = (list_entry_t *)child_data.data;
 	auto &data_vector = ListVector::GetEntry(child_vector);
 
@@ -96395,8 +96401,8 @@ struct DistinctFunctor {
 	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
 	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
 
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
+		UnifiedVectorFormat sdata;
+		state_vector.ToUnifiedFormat(count, sdata);
 		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 
 		auto result_data = FlatVector::GetData<list_entry_t>(result);
@@ -96428,8 +96434,8 @@ struct UniqueFunctor {
 	template <class OP, class T, class MAP_TYPE = unordered_map<T, idx_t>>
 	static void ListExecuteFunction(Vector &result, Vector &state_vector, idx_t count) {
 
-		VectorData sdata;
-		state_vector.Orrify(count, sdata);
+		UnifiedVectorFormat sdata;
+		state_vector.ToUnifiedFormat(count, sdata);
 		auto states = (HistogramAggState<T, MAP_TYPE> **)sdata.data;
 
 		auto result_data = FlatVector::GetData<uint64_t>(result);
@@ -96475,11 +96481,11 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	auto lists_size = ListVector::GetListSize(lists);
 	auto &child_vector = ListVector::GetEntry(lists);
 
-	VectorData child_data;
-	child_vector.Orrify(lists_size, child_data);
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(lists_size, child_data);
 
-	VectorData lists_data;
-	lists.Orrify(count, lists_data);
+	UnifiedVectorFormat lists_data;
+	lists.ToUnifiedFormat(count, lists_data);
 	auto list_entries = (list_entry_t *)lists_data.data;
 
 	// state_buffer holds the state for each list of this chunk
@@ -96818,10 +96824,10 @@ static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &
 		return;
 	}
 
-	VectorData lhs_data;
-	VectorData rhs_data;
-	lhs.Orrify(count, lhs_data);
-	rhs.Orrify(count, rhs_data);
+	UnifiedVectorFormat lhs_data;
+	UnifiedVectorFormat rhs_data;
+	lhs.ToUnifiedFormat(count, lhs_data);
+	rhs.ToUnifiedFormat(count, rhs_data);
 	auto lhs_entries = (list_entry_t *)lhs_data.data;
 	auto rhs_entries = (list_entry_t *)rhs_data.data;
 
@@ -96829,10 +96835,10 @@ static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &
 	auto rhs_list_size = ListVector::GetListSize(rhs);
 	auto &lhs_child = ListVector::GetEntry(lhs);
 	auto &rhs_child = ListVector::GetEntry(rhs);
-	VectorData lhs_child_data;
-	VectorData rhs_child_data;
-	lhs_child.Orrify(lhs_list_size, lhs_child_data);
-	rhs_child.Orrify(rhs_list_size, rhs_child_data);
+	UnifiedVectorFormat lhs_child_data;
+	UnifiedVectorFormat rhs_child_data;
+	lhs_child.ToUnifiedFormat(lhs_list_size, lhs_child_data);
+	rhs_child.ToUnifiedFormat(rhs_list_size, rhs_child_data);
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_entries = FlatVector::GetData<list_entry_t>(result);
@@ -96945,10 +96951,10 @@ void ListConcatFun::RegisterFunction(BuiltinFunctions &set) {
 namespace duckdb {
 
 template <class T, bool HEAP_REF = false, bool VALIDITY_ONLY = false>
-void ListExtractTemplate(idx_t count, VectorData &list_data, VectorData &offsets_data, Vector &child_vector,
-                         idx_t list_size, Vector &result) {
-	VectorData child_data;
-	child_vector.Orrify(list_size, child_data);
+void ListExtractTemplate(idx_t count, UnifiedVectorFormat &list_data, UnifiedVectorFormat &offsets_data,
+                         Vector &child_vector, idx_t list_size, Vector &result) {
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(list_size, child_data);
 
 	T *result_data;
 
@@ -97008,8 +97014,8 @@ void ListExtractTemplate(idx_t count, VectorData &list_data, VectorData &offsets
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
 }
-static void ExecuteListExtractInternal(const idx_t count, VectorData &list, VectorData &offsets, Vector &child_vector,
-                                       idx_t list_size, Vector &result) {
+static void ExecuteListExtractInternal(const idx_t count, UnifiedVectorFormat &list, UnifiedVectorFormat &offsets,
+                                       Vector &child_vector, idx_t list_size, Vector &result) {
 	D_ASSERT(child_vector.GetType() == result.GetType());
 	switch (result.GetType().InternalType()) {
 	case PhysicalType::BOOL:
@@ -97080,11 +97086,11 @@ static void ExecuteListExtractInternal(const idx_t count, VectorData &list, Vect
 
 static void ExecuteListExtract(Vector &result, Vector &list, Vector &offsets, const idx_t count) {
 	D_ASSERT(list.GetType().id() == LogicalTypeId::LIST);
-	VectorData list_data;
-	VectorData offsets_data;
+	UnifiedVectorFormat list_data;
+	UnifiedVectorFormat offsets_data;
 
-	list.Orrify(count, list_data);
-	offsets.Orrify(count, offsets_data);
+	list.ToUnifiedFormat(count, list_data);
+	offsets.ToUnifiedFormat(count, offsets_data);
 	ExecuteListExtractInternal(count, list_data, offsets_data, ListVector::GetEntry(list),
 	                           ListVector::GetListSize(list), result);
 	result.Verify(count);
@@ -97217,8 +97223,8 @@ ListLambdaBindData::~ListLambdaBindData() {
 static void AppendTransformedToResult(Vector &lambda_vector, idx_t &elem_cnt, Vector &result) {
 
 	// append the lambda_vector to the result list
-	VectorData lambda_child_data;
-	lambda_vector.Orrify(elem_cnt, lambda_child_data);
+	UnifiedVectorFormat lambda_child_data;
+	lambda_vector.ToUnifiedFormat(elem_cnt, lambda_child_data);
 	ListVector::Append(result, lambda_vector, *lambda_child_data.sel, elem_cnt, 0);
 }
 
@@ -97267,9 +97273,9 @@ static void AppendFilteredToResult(Vector &lambda_vector, list_entry_t *result_e
 
 	// slice to get the new lists and append them to the result
 	Vector new_lists(input_chunk.data[0], true_sel, true_count);
-	new_lists.Normalify(true_count);
-	VectorData new_lists_child_data;
-	new_lists.Orrify(true_count, new_lists_child_data);
+	new_lists.Flatten(true_count);
+	UnifiedVectorFormat new_lists_child_data;
+	new_lists.ToUnifiedFormat(true_count, new_lists_child_data);
 	ListVector::Append(result, new_lists, *new_lists_child_data.sel, true_count, 0);
 }
 
@@ -97283,14 +97289,14 @@ static void ExecuteExpression(vector<LogicalType> &types, vector<LogicalType> &r
 
 	// set the list child vector
 	Vector slice(child_vector, sel, elem_cnt);
-	slice.Normalify(elem_cnt);
+	slice.Flatten(elem_cnt);
 	input_chunk.data[0].Reference(slice);
 
 	// set the other vectors
 	vector<Vector> slices;
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount() - 1; col_idx++) {
 		slices.emplace_back(Vector(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt));
-		slices[col_idx].Normalify(elem_cnt);
+		slices[col_idx].Flatten(elem_cnt);
 		input_chunk.data[col_idx + 1].Reference(slices[col_idx]);
 	}
 
@@ -97317,8 +97323,8 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 	}
 
 	// get the lists data
-	VectorData lists_data;
-	lists.Orrify(count, lists_data);
+	UnifiedVectorFormat lists_data;
+	lists.ToUnifiedFormat(count, lists_data);
 	auto list_entries = (list_entry_t *)lists_data.data;
 
 	// get the lambda expression
@@ -97329,8 +97335,8 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 	// get the child vector and child data
 	auto lists_size = ListVector::GetListSize(lists);
 	auto &child_vector = ListVector::GetEntry(lists);
-	VectorData child_data;
-	child_vector.Orrify(lists_size, child_data);
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(lists_size, child_data);
 
 	// to slice the child vector
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
@@ -97340,7 +97346,7 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 	result_types.push_back(lambda_expr->return_type);
 
 	// non-lambda parameter columns
-	vector<VectorData> columns;
+	vector<UnifiedVectorFormat> columns;
 	vector<idx_t> indexes;
 	vector<SelectionVector> sel_vectors;
 
@@ -97349,8 +97355,8 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	// skip the list column
 	for (idx_t i = 1; i < args.ColumnCount(); i++) {
-		columns.emplace_back(VectorData());
-		args.data[i].Orrify(count, columns[i - 1]);
+		columns.emplace_back(UnifiedVectorFormat());
+		args.data[i].ToUnifiedFormat(count, columns[i - 1]);
 		indexes.push_back(0);
 		sel_vectors.emplace_back(SelectionVector(STANDARD_VECTOR_SIZE));
 		types.push_back(args.data[i].GetType());
@@ -97674,12 +97680,12 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 	// get the child vector
 	auto lists_size = ListVector::GetListSize(lists);
 	auto &child_vector = ListVector::GetEntry(lists);
-	VectorData child_data;
-	child_vector.Orrify(lists_size, child_data);
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(lists_size, child_data);
 
 	// get the lists data
-	VectorData lists_data;
-	lists.Orrify(count, lists_data);
+	UnifiedVectorFormat lists_data;
+	lists.ToUnifiedFormat(count, lists_data);
 	auto list_entries = (list_entry_t *)lists_data.data;
 
 	// create the lists_indices vector, this contains an element for each list's entry,
@@ -97775,7 +97781,7 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 
 		D_ASSERT(sel_sorted_idx == incr_payload_count);
 		child_vector.Slice(sel_sorted, sel_sorted_idx);
-		child_vector.Normalify(sel_sorted_idx);
+		child_vector.Flatten(sel_sorted_idx);
 	}
 
 	result.Reference(lists);
@@ -98108,16 +98114,16 @@ public:
 	explicit RangeInfoStruct(DataChunk &args_p) : args(args_p) {
 		switch (args.ColumnCount()) {
 		case 1:
-			args.data[0].Orrify(args.size(), vdata[0]);
+			args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
 			break;
 		case 2:
-			args.data[0].Orrify(args.size(), vdata[0]);
-			args.data[1].Orrify(args.size(), vdata[1]);
+			args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
+			args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
 			break;
 		case 3:
-			args.data[0].Orrify(args.size(), vdata[0]);
-			args.data[1].Orrify(args.size(), vdata[1]);
-			args.data[2].Orrify(args.size(), vdata[2]);
+			args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
+			args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
+			args.data[2].ToUnifiedFormat(args.size(), vdata[2]);
 			break;
 		default:
 			throw InternalException("Unsupported number of parameters for range");
@@ -98178,7 +98184,7 @@ public:
 
 private:
 	DataChunk &args;
-	VectorData vdata[3];
+	UnifiedVectorFormat vdata[3];
 };
 
 template <class OP, bool INCLUSIVE_BOUND>
@@ -98275,12 +98281,12 @@ namespace duckdb {
 
 static void CardinalityFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &map = args.data[0];
-	VectorData list_data;
+	UnifiedVectorFormat list_data;
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<uint64_t>(result);
 
 	auto &children = StructVector::GetEntries(map);
-	children[0]->Orrify(args.size(), list_data);
+	children[0]->ToUnifiedFormat(args.size(), list_data);
 	for (idx_t row = 0; row < args.size(); row++) {
 		auto list_entry = ((list_entry_t *)list_data.data)[list_data.sel->get_index(row)];
 		result_data[row] = list_entry.length;
@@ -98358,19 +98364,19 @@ namespace duckdb {
 // TODO: this doesn't recursively verify maps if maps are nested
 MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) {
 	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
-	VectorData map_vdata;
-	map.Orrify(count, map_vdata);
+	UnifiedVectorFormat map_vdata;
+	map.ToUnifiedFormat(count, map_vdata);
 	auto &map_validity = map_vdata.validity;
 
 	auto &key_vector = *(StructVector::GetEntries(map)[0]);
-	VectorData key_vdata;
-	key_vector.Orrify(count, key_vdata);
+	UnifiedVectorFormat key_vdata;
+	key_vector.ToUnifiedFormat(count, key_vdata);
 	auto key_data = (list_entry_t *)key_vdata.data;
 	auto &key_validity = key_vdata.validity;
 
 	auto &key_entries = ListVector::GetEntry(key_vector);
-	VectorData key_entry_vdata;
-	key_entries.Orrify(count, key_entry_vdata);
+	UnifiedVectorFormat key_entry_vdata;
+	key_entries.ToUnifiedFormat(count, key_entry_vdata);
 	auto &entry_validity = key_entry_vdata.validity;
 
 	for (idx_t row = 0; row < count; row++) {
@@ -98534,10 +98540,10 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 	auto &key = args.data[1];
 
 	auto key_value = key.GetValue(0);
-	VectorData offset_data;
+	UnifiedVectorFormat offset_data;
 
 	auto &children = StructVector::GetEntries(map);
-	children[0]->Orrify(args.size(), offset_data);
+	children[0]->ToUnifiedFormat(args.size(), offset_data);
 	auto &key_type = ListType::GetChildType(children[0]->GetType());
 	if (key_type != LogicalTypeId::SQLNULL) {
 		key_value = key_value.CastAs(key_type);
@@ -100003,7 +100009,7 @@ static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &res
 	auto &func_expr = (BoundFunctionExpression &)state.expr;
 	auto &info = (SetseedBindData &)*func_expr.bind_info;
 	auto &input = args.data[0];
-	input.Normalify(args.size());
+	input.Flatten(args.size());
 
 	auto input_seeds = FlatVector::GetData<double>(input);
 	uint32_t half_max = NumericLimits<uint32_t>::Maximum() / 2;
@@ -102451,8 +102457,8 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			// non-constant vector: set the result type to a flat vector
 			result.SetVectorType(VectorType::FLAT_VECTOR);
 			// now get the lengths of each of the input elements
-			VectorData vdata;
-			input.Orrify(args.size(), vdata);
+			UnifiedVectorFormat vdata;
+			input.ToUnifiedFormat(args.size(), vdata);
 
 			auto input_data = (string_t *)vdata.data;
 			// now add the length of each vector to the result length
@@ -102497,8 +102503,8 @@ static void ConcatFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			}
 		} else {
 			// standard vector
-			VectorData idata;
-			input.Orrify(args.size(), idata);
+			UnifiedVectorFormat idata;
+			input.ToUnifiedFormat(args.size(), idata);
 
 			auto input_data = (string_t *)idata.data;
 			for (idx_t i = 0; i < args.size(); i++) {
@@ -102541,9 +102547,9 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
                               const SelectionVector &rsel, idx_t count, Vector &result) {
 	vector<idx_t> result_lengths(args.size(), 0);
 	vector<bool> has_results(args.size(), false);
-	auto orrified_data = unique_ptr<VectorData[]>(new VectorData[args.ColumnCount() - 1]);
+	auto orrified_data = unique_ptr<UnifiedVectorFormat[]>(new UnifiedVectorFormat[args.ColumnCount() - 1]);
 	for (idx_t col_idx = 1; col_idx < args.ColumnCount(); col_idx++) {
-		args.data[col_idx].Orrify(args.size(), orrified_data[col_idx - 1]);
+		args.data[col_idx].ToUnifiedFormat(args.size(), orrified_data[col_idx - 1]);
 	}
 
 	// first figure out the lengths
@@ -102609,8 +102615,8 @@ static void TemplatedConcatWS(DataChunk &args, string_t *sep_data, const Selecti
 
 static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &separator = args.data[0];
-	VectorData vdata;
-	separator.Orrify(args.size(), vdata);
+	UnifiedVectorFormat vdata;
+	separator.ToUnifiedFormat(args.size(), vdata);
 
 	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
@@ -104276,7 +104282,7 @@ static void PrintfFunction(DataChunk &args, ExpressionState &state, Vector &resu
 			break;
 		default:
 			// FLAT VECTOR, we can directly OR the nullmask
-			args.data[i].Normalify(args.size());
+			args.data[i].Flatten(args.size());
 			result.SetVectorType(VectorType::FLAT_VECTOR);
 			result_validity.Combine(FlatVector::Validity(args.data[i]), args.size());
 			break;
@@ -105168,12 +105174,12 @@ unique_ptr<Vector> BaseStringSplitFunction(string_t input, string_t delim, const
 }
 
 static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, const bool regex) {
-	VectorData input_data;
-	args.data[0].Orrify(args.size(), input_data);
+	UnifiedVectorFormat input_data;
+	args.data[0].ToUnifiedFormat(args.size(), input_data);
 	auto inputs = (string_t *)input_data.data;
 
-	VectorData delim_data;
-	args.data[1].Orrify(args.size(), delim_data);
+	UnifiedVectorFormat delim_data;
+	args.data[1].ToUnifiedFormat(args.size(), delim_data);
 	auto delims = (string_t *)delim_data.data;
 
 	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
@@ -106158,8 +106164,8 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 
 	auto state_vec_ptr = FlatVector::GetData<data_ptr_t>(local_state.addresses);
 
-	VectorData state_data;
-	input.data[0].Orrify(input.size(), state_data);
+	UnifiedVectorFormat state_data;
+	input.data[0].ToUnifiedFormat(input.size(), state_data);
 	for (idx_t i = 0; i < input.size(); i++) {
 		auto state_idx = state_data.sel->get_index(i);
 		auto state_entry = &((string_t *)state_data.data)[state_idx];
@@ -106202,9 +106208,9 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		                  input.data[0].GetType().ToString(), input.data[1].GetType().ToString());
 	}
 
-	VectorData state0_data, state1_data;
-	input.data[0].Orrify(input.size(), state0_data);
-	input.data[1].Orrify(input.size(), state1_data);
+	UnifiedVectorFormat state0_data, state1_data;
+	input.data[0].ToUnifiedFormat(input.size(), state0_data);
+	input.data[1].ToUnifiedFormat(input.size(), state1_data);
 
 	auto result_ptr = FlatVector::GetData<string_t>(result);
 
@@ -108410,7 +108416,7 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 		}
 	}
 
-	cast_chunk.Normalify();
+	cast_chunk.Flatten();
 	auto &writer = local_data.serializer;
 	// now loop over the vectors and output the values
 	for (idx_t row_idx = 0; row_idx < cast_chunk.size(); row_idx++) {
@@ -112898,7 +112904,7 @@ unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context,
 	}
 	if (bind_data.all_flat) {
 		for (auto &entry : result->entries) {
-			entry->Normalify();
+			entry->Flatten();
 			entry->Verify();
 		}
 	}
@@ -129828,7 +129834,7 @@ unique_ptr<DataChunk> QueryResult::Fetch() {
 	if (!chunk) {
 		return nullptr;
 	}
-	chunk->Normalify();
+	chunk->Flatten();
 	return chunk;
 }
 
@@ -181584,7 +181590,7 @@ public:
 	virtual void InitializeAppend(ColumnAppendState &state);
 	//! Append a vector of type [type] to the end of the column
 	virtual void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count);
-	virtual void AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count);
+	virtual void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count);
 	//! Revert a set of appends to the ColumnData
 	virtual void RevertAppend(row_t start_row);
 
@@ -181753,8 +181759,8 @@ unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalTyp
 template <class T>
 bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	auto &analyze_state = (BitpackingAnalyzeState<T> &)state;
-	VectorData vdata;
-	input.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	input.ToUnifiedFormat(count, vdata);
 
 	auto data = (T *)vdata.data;
 	for (idx_t i = 0; i < count; i++) {
@@ -181842,7 +181848,7 @@ public:
 		width_ptr = handle.Ptr() + current_segment->GetBlockOffset() + Storage::BLOCK_SIZE - sizeof(bitpacking_width_t);
 	}
 
-	void Append(VectorData &vdata, idx_t count) {
+	void Append(UnifiedVectorFormat &vdata, idx_t count) {
 		// TODO Optimization: avoid use of compression buffer if we can compress straight to result vector
 		auto data = (T *)vdata.data;
 
@@ -181896,8 +181902,8 @@ unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointer &c
 template <class T>
 void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
 	auto &state = (BitpackingCompressState<T> &)state_p;
-	VectorData vdata;
-	scan_vector.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	scan_vector.ToUnifiedFormat(count, vdata);
 	state.Append(vdata, count);
 }
 
@@ -182252,14 +182258,15 @@ public:
 	                           idx_t result_idx);
 	static unique_ptr<CompressedSegmentState> StringInitSegment(ColumnSegment &segment, block_id_t block_id);
 
-	static idx_t StringAppend(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset,
+	static idx_t StringAppend(ColumnSegment &segment, SegmentStatistics &stats, UnifiedVectorFormat &data, idx_t offset,
 	                          idx_t count) {
 		return StringAppendBase(segment, stats, data, offset, count);
 	}
 
 	template <bool DUPLICATE_ELIMINATE = false>
-	static idx_t StringAppendBase(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset,
-	                              idx_t count, std::unordered_map<string, int32_t> *seen_strings = nullptr) {
+	static idx_t StringAppendBase(ColumnSegment &segment, SegmentStatistics &stats, UnifiedVectorFormat &data,
+	                              idx_t offset, idx_t count,
+	                              std::unordered_map<string, int32_t> *seen_strings = nullptr) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 		auto handle = buffer_manager.Pin(segment.block);
 
@@ -182419,8 +182426,8 @@ using string_set_t = unordered_set<string_t, StringHash, StringEquality>;
 class DictionaryCompressionState : public CompressionState {
 public:
 	bool UpdateState(Vector &scan_vector, idx_t count) {
-		VectorData vdata;
-		scan_vector.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		scan_vector.ToUnifiedFormat(count, vdata);
 		auto data = (string_t *)vdata.data;
 		Verify();
 
@@ -183125,8 +183132,8 @@ unique_ptr<CompressionState> UncompressedFunctions::InitCompression(ColumnDataCh
 
 void UncompressedFunctions::Compress(CompressionState &state_p, Vector &data, idx_t count) {
 	auto &state = (UncompressedCompressState &)state_p;
-	VectorData vdata;
-	data.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	data.ToUnifiedFormat(count, vdata);
 
 	ColumnAppendState append_state;
 	idx_t offset = 0;
@@ -183220,7 +183227,7 @@ void FixedSizeFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t ro
 // Append
 //===--------------------------------------------------------------------===//
 template <class T>
-static void AppendLoop(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, VectorData &adata,
+static void AppendLoop(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, UnifiedVectorFormat &adata,
                        idx_t offset, idx_t count) {
 	auto sdata = (T *)adata.data;
 	auto tdata = (T *)target;
@@ -183249,8 +183256,8 @@ static void AppendLoop(SegmentStatistics &stats, data_ptr_t target, idx_t target
 }
 
 template <>
-void AppendLoop<list_entry_t>(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset, VectorData &adata,
-                              idx_t offset, idx_t count) {
+void AppendLoop<list_entry_t>(SegmentStatistics &stats, data_ptr_t target, idx_t target_offset,
+                              UnifiedVectorFormat &adata, idx_t offset, idx_t count) {
 	auto sdata = (list_entry_t *)adata.data;
 	auto tdata = (list_entry_t *)target;
 	for (idx_t i = 0; i < count; i++) {
@@ -183261,7 +183268,8 @@ void AppendLoop<list_entry_t>(SegmentStatistics &stats, data_ptr_t target, idx_t
 }
 
 template <class T>
-idx_t FixedSizeAppend(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset, idx_t count) {
+idx_t FixedSizeAppend(ColumnSegment &segment, SegmentStatistics &stats, UnifiedVectorFormat &data, idx_t offset,
+                      idx_t count) {
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	auto handle = buffer_manager.Pin(segment.block);
 	D_ASSERT(segment.GetBlockOffset() == 0);
@@ -183581,8 +183589,8 @@ unique_ptr<AnalyzeState> RLEInitAnalyze(ColumnData &col_data, PhysicalType type)
 template <class T>
 bool RLEAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	auto &rle_state = (RLEAnalyzeState<T> &)state;
-	VectorData vdata;
-	input.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	input.ToUnifiedFormat(count, vdata);
 
 	auto data = (T *)vdata.data;
 	for (idx_t i = 0; i < count; i++) {
@@ -183643,7 +183651,7 @@ struct RLECompressState : public CompressionState {
 		handle = buffer_manager.Pin(current_segment->block);
 	}
 
-	void Append(VectorData &vdata, idx_t count) {
+	void Append(UnifiedVectorFormat &vdata, idx_t count) {
 		auto data = (T *)vdata.data;
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);
@@ -183717,8 +183725,8 @@ unique_ptr<CompressionState> RLEInitCompression(ColumnDataCheckpointer &checkpoi
 template <class T>
 void RLECompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
 	auto &state = (RLECompressState<T> &)state_p;
-	VectorData vdata;
-	scan_vector.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	scan_vector.ToUnifiedFormat(count, vdata);
 
 	state.Append(vdata, count);
 }
@@ -183921,8 +183929,8 @@ unique_ptr<AnalyzeState> UncompressedStringStorage::StringInitAnalyze(ColumnData
 
 bool UncompressedStringStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
 	auto &state = (StringAnalyzeState &)state_p;
-	VectorData vdata;
-	input.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	input.ToUnifiedFormat(count, vdata);
 
 	state.count += count;
 	auto data = (string_t *)vdata.data;
@@ -184670,7 +184678,7 @@ void ValidityScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t s
 }
 
 void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	result.Normalify(scan_count);
+	result.Flatten(scan_count);
 
 	auto start = segment.GetRelativeIndex(state.row_index);
 	if (start % ValidityMask::BITS_PER_VALUE == 0) {
@@ -184729,7 +184737,8 @@ unique_ptr<CompressedSegmentState> ValidityInitSegment(ColumnSegment &segment, b
 	return nullptr;
 }
 
-idx_t ValidityAppend(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset, idx_t vcount) {
+idx_t ValidityAppend(ColumnSegment &segment, SegmentStatistics &stats, UnifiedVectorFormat &data, idx_t offset,
+                     idx_t vcount) {
 	D_ASSERT(segment.GetBlockOffset() == 0);
 	auto &validity_stats = (ValidityStatistics &)*stats.statistics;
 
@@ -184874,7 +184883,7 @@ public:
 	idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count) override;
 
 	void InitializeAppend(ColumnAppendState &state) override;
-	void AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count) override;
+	void AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) override;
 	void RevertAppend(row_t start_row) override;
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
@@ -185351,8 +185360,8 @@ static void VerifyCheckConstraint(TableCatalogEntry &table, Expression &expr, Da
 	} catch (...) { // LCOV_EXCL_START
 		throw ConstraintException("CHECK constraint failed: %s (Unknown Error)", table.name);
 	} // LCOV_EXCL_STOP
-	VectorData vdata;
-	result.Orrify(chunk.size(), vdata);
+	UnifiedVectorFormat vdata;
+	result.ToUnifiedFormat(chunk.size(), vdata);
 
 	auto dataptr = (int32_t *)vdata.data;
 	for (idx_t i = 0; i < chunk.size(); i++) {
@@ -185894,7 +185903,7 @@ idx_t DataTable::Delete(TableCatalogEntry &table, ClientContext &context, Vector
 
 	auto &transaction = Transaction::GetTransaction(context);
 
-	row_identifiers.Normalify(count);
+	row_identifiers.Flatten(count);
 	auto ids = FlatVector::GetData<row_t>(row_identifiers);
 	auto first_id = ids[0];
 
@@ -186046,8 +186055,8 @@ void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector
 	// now perform the actual update
 	auto &transaction = Transaction::GetTransaction(context);
 
-	updates.Normalify();
-	row_ids.Normalify(count);
+	updates.Flatten();
+	row_ids.Flatten(count);
 	auto ids = FlatVector::GetData<row_t>(row_ids);
 	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
 	if (first_id >= MAX_ROW_ID) {
@@ -186104,8 +186113,8 @@ void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, V
 	// now perform the actual update
 	auto &transaction = Transaction::GetTransaction(context);
 
-	updates.Normalify();
-	row_ids.Normalify(updates.size());
+	updates.Flatten();
+	row_ids.Flatten(updates.size());
 	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
 	if (first_id >= MAX_ROW_ID) {
 		throw NotImplementedException("Cannot update a column-path on transaction local data");
@@ -186606,8 +186615,8 @@ idx_t LocalStorage::Delete(DataTable *table, Vector &row_ids, idx_t count) {
 		// Slice out the rows that are being deleted from the storage Chunk
 		auto &chunk = storage->collection.GetChunk(chunk_idx);
 
-		VectorData row_ids_data;
-		row_ids.Orrify(count, row_ids_data);
+		UnifiedVectorFormat row_ids_data;
+		row_ids.ToUnifiedFormat(count, row_ids_data);
 		auto row_identifiers = (const row_t *)row_ids_data.data;
 		SelectionVector sel(count);
 		for (idx_t i = 0; i < count; ++i) {
@@ -186655,8 +186664,8 @@ idx_t LocalStorage::Delete(DataTable *table, Vector &row_ids, idx_t count) {
 template <class T>
 static void TemplatedUpdateLoop(Vector &data_vector, Vector &update_vector, Vector &row_ids, idx_t count,
                                 idx_t base_index) {
-	VectorData udata;
-	update_vector.Orrify(count, udata);
+	UnifiedVectorFormat udata;
+	update_vector.ToUnifiedFormat(count, udata);
 
 	auto target = FlatVector::GetData<T>(data_vector);
 	auto &mask = FlatVector::Validity(data_vector);
@@ -186840,7 +186849,7 @@ void LocalStorage::AddColumn(DataTable *old_dt, DataTable *new_dt, ColumnDefinit
 		} else {
 			FlatVector::Validity(result).SetAllInvalid(chunk.size());
 		}
-		result.Normalify(chunk.size());
+		result.Flatten(chunk.size());
 		chunk.data.push_back(move(result));
 	}
 
@@ -186863,8 +186872,8 @@ void LocalStorage::FetchChunk(DataTable *table, Vector &row_ids, idx_t count, Da
 	idx_t chunk_idx = GetChunk(row_ids);
 	auto &chunk = storage->collection.GetChunk(chunk_idx);
 
-	VectorData row_ids_data;
-	row_ids.Orrify(count, row_ids_data);
+	UnifiedVectorFormat row_ids_data;
+	row_ids.ToUnifiedFormat(count, row_ids_data);
 	auto row_identifiers = (const row_t *)row_ids_data.data;
 	SelectionVector sel(count);
 	for (idx_t i = 0; i < count; ++i) {
@@ -187775,12 +187784,12 @@ unique_ptr<DistinctStatistics> DistinctStatistics::Deserialize(FieldReader &read
 }
 
 void DistinctStatistics::Update(Vector &v, idx_t count, bool sample) {
-	VectorData vdata;
-	v.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	v.ToUnifiedFormat(count, vdata);
 	Update(vdata, v.GetType(), count, sample);
 }
 
-void DistinctStatistics::Update(VectorData &vdata, const LogicalType &type, idx_t count, bool sample) {
+void DistinctStatistics::Update(UnifiedVectorFormat &vdata, const LogicalType &type, idx_t count, bool sample) {
 	if (count == 0) {
 		return;
 	}
@@ -187881,8 +187890,8 @@ void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t co
 
 	if (child_stats) {
 		auto &child_entry = ListVector::GetEntry(vector);
-		VectorData vdata;
-		vector.Orrify(count, vdata);
+		UnifiedVectorFormat vdata;
+		vector.ToUnifiedFormat(count, vdata);
 
 		auto list_data = (list_entry_t *)vdata.data;
 		idx_t total_list_count = 0;
@@ -188057,8 +188066,8 @@ string NumericStatistics::ToString() const {
 
 template <class T>
 void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	VectorData vdata;
-	vector.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	vector.ToUnifiedFormat(count, vdata);
 
 	auto data = (T *)vdata.data;
 	for (idx_t i = 0; i < count; i++) {
@@ -188322,8 +188331,8 @@ void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t
 	string_t min_string((const char *)min, MAX_STRING_MINMAX_SIZE);
 	string_t max_string((const char *)max, MAX_STRING_MINMAX_SIZE);
 
-	VectorData vdata;
-	vector.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	vector.ToUnifiedFormat(count, vdata);
 	auto data = (string_t *)vdata.data;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
@@ -188535,8 +188544,8 @@ void ValidityStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_
 		// nothing to verify
 		return;
 	}
-	VectorData vdata;
-	vector.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	vector.ToUnifiedFormat(count, vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
 		auto index = vdata.sel->get_index(idx);
@@ -189551,7 +189560,7 @@ idx_t ColumnData::ScanVector(Transaction *transaction, idx_t vector_index, Colum
 		if (!ALLOW_UPDATES && updates->HasUncommittedUpdates(vector_index)) {
 			throw TransactionException("Cannot create index with outstanding updates");
 		}
-		result.Normalify(scan_count);
+		result.Flatten(scan_count);
 		if (SCAN_COMMITTED) {
 			updates->FetchCommitted(vector_index, result);
 		} else {
@@ -189588,7 +189597,7 @@ void ColumnData::ScanCommittedRange(idx_t row_group_start, idx_t offset_in_row_g
 	InitializeScanWithOffset(child_state, row_group_start + offset_in_row_group);
 	auto scan_count = ScanVector(child_state, result, count);
 	if (updates) {
-		result.Normalify(scan_count);
+		result.Flatten(scan_count);
 		updates->FetchCommittedRange(offset_in_row_group, count, result);
 	}
 }
@@ -189605,7 +189614,7 @@ idx_t ColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count)
 void ColumnData::Select(Transaction &transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
                         SelectionVector &sel, idx_t &count, const TableFilter &filter) {
 	idx_t scan_count = Scan(transaction, vector_index, state, result);
-	result.Normalify(scan_count);
+	result.Flatten(scan_count);
 	ColumnSegment::FilterSelection(sel, result, filter, count, FlatVector::Validity(result));
 }
 
@@ -189654,8 +189663,8 @@ void ColumnScanState::NextVector() {
 }
 
 void ColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	VectorData vdata;
-	vector.Orrify(count, vdata);
+	UnifiedVectorFormat vdata;
+	vector.ToUnifiedFormat(count, vdata);
 	AppendData(stats, state, vdata, count);
 }
 
@@ -189679,7 +189688,7 @@ void ColumnData::InitializeAppend(ColumnAppendState &state) {
 	state.current->InitializeAppend(state);
 }
 
-void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count) {
+void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) {
 	idx_t offset = 0;
 	while (true) {
 		// append the data from the vector
@@ -189757,7 +189766,7 @@ void ColumnData::Update(Transaction &transaction, idx_t column_index, Vector &up
 	ColumnScanState state;
 	auto fetch_count = Fetch(state, row_ids[0], base_vector);
 
-	base_vector.Normalify(fetch_count);
+	base_vector.Flatten(fetch_count);
 	updates->Update(transaction, column_index, update_vector, row_ids, update_count, base_vector);
 }
 
@@ -189800,7 +189809,7 @@ void ColumnData::CheckpointScan(ColumnSegment *segment, ColumnScanState &state,
                                 Vector &scan_vector) {
 	segment->Scan(state, count, scan_vector, 0, true);
 	if (updates) {
-		scan_vector.Normalify(count);
+		scan_vector.Flatten(count);
 		updates->FetchCommittedRange(state.row_index - row_group_start, count, scan_vector);
 	}
 }
@@ -190313,7 +190322,7 @@ void ColumnSegment::InitializeAppend(ColumnAppendState &state) {
 //===--------------------------------------------------------------------===//
 // Append
 //===--------------------------------------------------------------------===//
-idx_t ColumnSegment::Append(ColumnAppendState &state, VectorData &append_data, idx_t offset, idx_t count) {
+idx_t ColumnSegment::Append(ColumnAppendState &state, UnifiedVectorFormat &append_data, idx_t offset, idx_t count) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
 	if (!function->append) {
 		throw InternalException("Attempting to append to a segment without append method");
@@ -190808,7 +190817,7 @@ void ListColumnData::Append(BaseStatistics &stats_p, ColumnAppendState &state, V
 	D_ASSERT(count > 0);
 	auto &stats = (ListStatistics &)stats_p;
 
-	vector.Normalify(count);
+	vector.Flatten(count);
 	auto &list_validity = FlatVector::Validity(vector);
 
 	// construct the list_entry_t entries to append to the column data
@@ -190840,7 +190849,7 @@ void ListColumnData::Append(BaseStatistics &stats_p, ColumnAppendState &state, V
 	         child_count);
 #endif
 
-	VectorData vdata;
+	UnifiedVectorFormat vdata;
 	vdata.validity = list_validity;
 	vdata.sel = FlatVector::IncrementalSelectionVector();
 	vdata.data = (data_ptr_t)append_offsets.get();
@@ -191617,7 +191626,7 @@ void RowGroup::Update(Transaction &transaction, DataChunk &update_chunk, row_t *
 		D_ASSERT(columns[column]->type.id() == update_chunk.data[i].GetType().id());
 		if (offset > 0) {
 			Vector sliced_vector(update_chunk.data[i], offset);
-			sliced_vector.Normalify(count);
+			sliced_vector.Flatten(count);
 			columns[column]->Update(transaction, column, sliced_vector, ids + offset, count);
 		} else {
 			columns[column]->Update(transaction, column, update_chunk.data[i], ids, count);
@@ -192043,7 +192052,8 @@ void StandardColumnData::InitializeAppend(ColumnAppendState &state) {
 	state.child_appends.push_back(move(child_append));
 }
 
-void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, VectorData &vdata, idx_t count) {
+void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
+                                    idx_t count) {
 	ColumnData::AppendData(stats, state, vdata, count);
 
 	validity.AppendData(*stats.validity_stats, state.child_appends[0], vdata, count);
@@ -192280,7 +192290,7 @@ void StructColumnData::InitializeAppend(ColumnAppendState &state) {
 }
 
 void StructColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	vector.Normalify(count);
+	vector.Flatten(count);
 
 	// append the null values
 	validity.Append(*stats.validity_stats, state.child_appends[0], vector, count);
@@ -192293,7 +192303,7 @@ void StructColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, V
 		if (!struct_validity.AllValid()) {
 			// we set the child entries of the struct to NULL
 			// for any values in which the struct itself is NULL
-			child_entries[i]->Normalify(count);
+			child_entries[i]->Flatten(count);
 
 			auto &child_validity = FlatVector::Validity(*child_entries[i]);
 			child_validity.Combine(struct_validity, count);
@@ -193575,7 +193585,7 @@ void UpdateSegment::Update(Transaction &transaction, idx_t column_index, Vector
 	// obtain an exclusive lock
 	auto write_lock = lock.GetExclusiveLock();
 
-	update.Normalify(count);
+	update.Flatten(count);
 
 	// update statistics
 	SelectionVector sel;
@@ -229460,7 +229470,7 @@ static inline int AddToLog(void *log, const uint64_t &index, const uint8_t &coun
 	return duckdb_hll::hllDenseSet(hdr->registers + 1, index, count);
 }
 
-void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
+void AddToLogsInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
                        const SelectionVector *log_sel) {
 	// 'logs' is an array of pointers to AggregateStates
 	// AggregateStates have a pointer to a HyperLogLog object
@@ -229473,7 +229483,7 @@ void AddToLogsInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8
 	}
 }
 
-void AddToSingleLogInternal(VectorData &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log) {
+void AddToSingleLogInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log) {
 	const auto o = (duckdb_hll::robj *)log;
 	duckdb_hll::hllhdr *hdr = (duckdb_hll::hllhdr *)o->ptr;
 	D_ASSERT(hdr->encoding == HLL_DENSE);