duckdb 0.7.2-dev1901.0 → 0.7.2-dev2233.0

package/src/duckdb/src/include/duckdb/common/types/{row_layout.hpp → row/row_layout.hpp}

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/types/row_layout.hpp
+// duckdb/common/types/row/row_layout.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -17,6 +17,8 @@ namespace duckdb {
 
 class RowLayout {
 public:
+	friend class TupleDataLayout;
+
 	using Aggregates = vector<AggregateObject>;
 	using ValidityBytes = TemplatedValidityMask<uint8_t>;
 

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_allocator.hpp

@@ -0,0 +1,116 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row/tuple_data_allocator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types/row/tuple_data_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_states.hpp"
+
+namespace duckdb {
+
+struct TupleDataSegment;
+struct TupleDataChunk;
+struct TupleDataChunkPart;
+
+struct TupleDataBlock {
+public:
+	TupleDataBlock(BufferManager &buffer_manager, idx_t capacity_p);
+
+	//! Disable copy constructors
+	TupleDataBlock(const TupleDataBlock &other) = delete;
+	TupleDataBlock &operator=(const TupleDataBlock &) = delete;
+
+	//! Enable move constructors
+	TupleDataBlock(TupleDataBlock &&other) noexcept;
+	TupleDataBlock &operator=(TupleDataBlock &&) noexcept;
+
+public:
+	//! Remaining capacity (in bytes)
+	idx_t RemainingCapacity() const {
+		D_ASSERT(size <= capacity);
+		return capacity - size;
+	}
+
+	//! Remaining capacity (in rows)
+	idx_t RemainingCapacity(idx_t row_width) const {
+		return RemainingCapacity() / row_width;
+	}
+
+public:
+	//! The underlying row block
+	shared_ptr<BlockHandle> handle;
+	//! Capacity (in bytes)
+	idx_t capacity;
+	//! Occupied size (in bytes)
+	idx_t size;
+};
+
+class TupleDataAllocator {
+public:
+	TupleDataAllocator(BufferManager &buffer_manager, const TupleDataLayout &layout);
+	TupleDataAllocator(TupleDataAllocator &allocator);
+
+	//! Get the buffer allocator
+	Allocator &GetAllocator();
+	//! Get the layout
+	const TupleDataLayout &GetLayout() const;
+	//! Number of row blocks
+	idx_t RowBlockCount() const;
+	//! Number of heap blocks
+	idx_t HeapBlockCount() const;
+
+public:
+	//! Builds out the chunks for next append, given the metadata in the append state
+	void Build(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
+	           const idx_t append_offset, const idx_t append_count);
+	//! Initializes a chunk, making its pointers valid
+	void InitializeChunkState(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
+	                          idx_t chunk_idx, bool init_heap);
+	static void RecomputeHeapPointers(Vector &old_heap_ptrs, const SelectionVector &old_heap_sel,
+	                                  const data_ptr_t row_locations[], Vector &new_heap_ptrs, const idx_t offset,
+	                                  const idx_t count, const TupleDataLayout &layout, const idx_t base_col_offset);
+	//! Releases or stores any handles in the management state that are no longer required
+	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment, TupleDataChunk &chunk,
+	                           bool release_heap);
+	//! Releases or stores ALL handles in the management state
+	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment);
+
+private:
+	//! Builds out a single part (grabs the lock)
+	TupleDataChunkPart BuildChunkPart(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
+	                                  const idx_t append_offset, const idx_t append_count);
+	//! Internal function for InitializeChunkState
+	void InitializeChunkStateInternal(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, idx_t offset,
+	                                  bool recompute, bool init_heap_pointers, bool init_heap_sizes,
+	                                  vector<TupleDataChunkPart *> &parts);
+	//! Internal function for ReleaseOrStoreHandles
+	static void ReleaseOrStoreHandlesInternal(TupleDataSegment &segment, vector<BufferHandle> &pinned_row_handles,
+	                                          unordered_map<uint32_t, BufferHandle> &handles,
+	                                          const unordered_set<uint32_t> &block_ids, vector<TupleDataBlock> &blocks,
+	                                          TupleDataPinProperties properties);
+	//! Pins the given row block
+	BufferHandle &PinRowBlock(TupleDataPinState &state, const TupleDataChunkPart &part);
+	//! Pins the given heap block
+	BufferHandle &PinHeapBlock(TupleDataPinState &state, const TupleDataChunkPart &part);
+	//! Gets the pointer to the rows for the given chunk part
+	data_ptr_t GetRowPointer(TupleDataPinState &state, const TupleDataChunkPart &part);
+	//! Gets the base pointer to the heap for the given chunk part
+	data_ptr_t GetBaseHeapPointer(TupleDataPinState &state, const TupleDataChunkPart &part);
+
+private:
+	//! The buffer manager
+	BufferManager &buffer_manager;
+	//! The layout of the data
+	const TupleDataLayout layout;
+	//! Blocks storing the fixed-size rows
+	vector<TupleDataBlock> row_blocks;
+	//! Blocks storing the variable-size data of the fixed-size rows (e.g., string, list)
+	vector<TupleDataBlock> heap_blocks;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp

@@ -0,0 +1,239 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row/tuple_data_collection.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types/row/tuple_data_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_segment.hpp"
+#include "duckdb/common/types/row/tuple_data_states.hpp"
+
+namespace duckdb {
+
+class TupleDataAllocator;
+struct TupleDataScatterFunction;
+struct TupleDataGatherFunction;
+
+typedef void (*tuple_data_scatter_function_t)(const Vector &source, const TupleDataVectorFormat &source_format,
+                                              const SelectionVector &append_sel, const idx_t append_count,
+                                              const TupleDataLayout &layout, Vector &row_locations,
+                                              Vector &heap_locations, const idx_t col_idx,
+                                              const UnifiedVectorFormat &list_format,
+                                              const vector<TupleDataScatterFunction> &child_functions);
+
+struct TupleDataScatterFunction {
+	tuple_data_scatter_function_t function;
+	vector<TupleDataScatterFunction> child_functions;
+};
+
+typedef void (*tuple_data_gather_function_t)(const TupleDataLayout &layout, Vector &row_locations, const idx_t col_idx,
+                                             const SelectionVector &scan_sel, const idx_t scan_count, Vector &target,
+                                             const SelectionVector &target_sel, Vector &list_vector,
+                                             const vector<TupleDataGatherFunction> &child_functions);
+
+struct TupleDataGatherFunction {
+	tuple_data_gather_function_t function;
+	vector<TupleDataGatherFunction> child_functions;
+};
+
+//! TupleDataCollection represents a set of buffer-managed data stored in row format
+//! FIXME: rename to RowDataCollection after we phase it out
+class TupleDataCollection {
+	friend class TupleDataChunkIterator;
+
+public:
+	//! Constructs a TupleDataCollection with the specified layout
+	TupleDataCollection(BufferManager &buffer_manager, const TupleDataLayout &layout);
+	//! Constructs a TupleDataCollection with the same (shared) allocator
+	explicit TupleDataCollection(shared_ptr<TupleDataAllocator> allocator);
+
+	~TupleDataCollection();
+
+public:
+	//! The layout of the stored rows
+	const TupleDataLayout &GetLayout() const;
+	//! The number of rows stored in the tuple data collection
+	const idx_t &Count() const;
+	//! The number of chunks stored in the tuple data collection
+	idx_t ChunkCount() const;
+	//! The size (in bytes) of the blocks held by this tuple data collection
+	idx_t SizeInBytes() const;
+	//! Get pointers to the pinned blocks
+	void GetBlockPointers(vector<data_ptr_t> &block_pointers) const;
+	//! Unpins all held pins
+	void Unpin();
+
+	//! Gets the scatter function for the given type
+	static TupleDataScatterFunction GetScatterFunction(const LogicalType &type, bool within_list = false);
+	//! Gets the gather function for the given type
+	static TupleDataGatherFunction GetGatherFunction(const LogicalType &type, bool within_list = false);
+
+	//! Initializes an Append state - useful for optimizing many appends made to the same tuple data collection
+	void InitializeAppend(TupleDataAppendState &append_state,
+	                      TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE);
+	//! Initializes an Append state - useful for optimizing many appends made to the same tuple data collection
+	void InitializeAppend(TupleDataAppendState &append_state, vector<column_t> column_ids,
+	                      TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE);
+	//! Initializes the Pin state of an Append state
+	//! - Useful for optimizing many appends made to the same tuple data collection
+	void InitializeAppend(TupleDataPinState &pin_state,
+	                      TupleDataPinProperties = TupleDataPinProperties::UNPIN_AFTER_DONE);
+	//! Initializes the Chunk state of an Append state
+	//! - Useful for optimizing many appends made to the same tuple data collection
+	void InitializeAppend(TupleDataChunkState &chunk_state, vector<column_t> column_ids = {});
+	//! Append a DataChunk directly to this TupleDataCollection - calls InitializeAppend and Append internally
+	void Append(DataChunk &new_chunk, const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	            idx_t append_count = DConstants::INVALID_INDEX);
+	//! Append a DataChunk directly to this TupleDataCollection - calls InitializeAppend and Append internally
+	void Append(DataChunk &new_chunk, vector<column_t> column_ids,
+	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	            const idx_t append_count = DConstants::INVALID_INDEX);
+	//! Append a DataChunk to this TupleDataCollection using the specified Append state
+	void Append(TupleDataAppendState &append_state, DataChunk &new_chunk,
+	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	            const idx_t append_count = DConstants::INVALID_INDEX);
+	//! Append a DataChunk to this TupleDataCollection using the specified pin and Chunk states
+	void Append(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, DataChunk &new_chunk,
+	            const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	            const idx_t append_count = DConstants::INVALID_INDEX);
+	//! Append a DataChunk to this TupleDataCollection using the specified pin and Chunk states
+	//! - ToUnifiedFormat has already been called
+	void AppendUnified(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, DataChunk &new_chunk,
+	                   const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
+	                   const idx_t append_count = DConstants::INVALID_INDEX);
+
+	//! Creates a UnifiedVectorFormat in the given Chunk state for the given DataChunk
+	static void ToUnifiedFormat(TupleDataChunkState &chunk_state, DataChunk &new_chunk);
+	//! Gets the UnifiedVectorFormat from the Chunk state as an array
+	static void GetVectorData(const TupleDataChunkState &chunk_state, UnifiedVectorFormat result[]);
+	//! Computes the heap sizes for the new DataChunk that will be appended
+	static void ComputeHeapSizes(TupleDataChunkState &chunk_state, const DataChunk &new_chunk,
+	                             const SelectionVector &append_sel, const idx_t append_count);
+
+	//! Builds out the buffer space for the specified Chunk state
+	void Build(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, const idx_t append_offset,
+	           const idx_t append_count);
+	//! Scatters the given DataChunk to the rows in the specified Chunk state
+	void Scatter(TupleDataChunkState &chunk_state, const DataChunk &new_chunk, const SelectionVector &append_sel,
+	             const idx_t append_count) const;
+	//! Scatters the given Vector to the given column id to the rows in the specified Chunk state
+	void Scatter(TupleDataChunkState &chunk_state, const Vector &source, const column_t column_id,
+	             const SelectionVector &append_sel, const idx_t append_count) const;
+	//! Copy rows from input to the built Chunk state
+	void CopyRows(TupleDataChunkState &chunk_state, TupleDataChunkState &input, const SelectionVector &append_sel,
+	              const idx_t append_count) const;
+
+	//! Finalizes the Pin state, releasing or storing blocks
+	void FinalizePinState(TupleDataPinState &pin_state, TupleDataSegment &segment);
+	//! Finalizes the Pin state, releasing or storing blocks
+	void FinalizePinState(TupleDataPinState &pin_state);
+
+	//! Appends the other TupleDataCollection to this, destroying the other data collection
+	void Combine(TupleDataCollection &other);
+	//! Appends the other TupleDataCollection to this, destroying the other data collection
+	void Combine(unique_ptr<TupleDataCollection> other);
+	//! Resets the TupleDataCollection, clearing all data
+	void Reset();
+
+	//! Initializes a chunk with the correct types that can be used to call Append/Scan
+	void InitializeChunk(DataChunk &chunk) const;
+	//! Initializes a chunk with the correct types for a given scan state
+	void InitializeScanChunk(TupleDataScanState &state, DataChunk &chunk) const;
+	//! Initializes a Scan state for scanning all columns
+	void InitializeScan(TupleDataScanState &state,
+	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
+	//! Initializes a Scan state for scanning a subset of the columns
+	void InitializeScan(TupleDataScanState &state, vector<column_t> column_ids,
+	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
+	//! Initialize a parallel scan over the tuple data collection over all columns
+	void InitializeScan(TupleDataParallelScanState &state,
+	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
+	//! Initialize a parallel scan over the tuple data collection over a subset of the columns
+	void InitializeScan(TupleDataParallelScanState &gstate, vector<column_t> column_ids,
+	                    TupleDataPinProperties properties = TupleDataPinProperties::UNPIN_AFTER_DONE) const;
+	//! Scans a DataChunk from the TupleDataCollection
+	bool Scan(TupleDataScanState &state, DataChunk &result);
+	//! Scans a DataChunk from the TupleDataCollection
+	bool Scan(TupleDataParallelScanState &gstate, TupleDataLocalScanState &lstate, DataChunk &result);
+
+	//! Gathers a DataChunk from the TupleDataCollection, given the specific row locations (requires full pin)
+	void Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count, DataChunk &result,
+	            const SelectionVector &target_sel) const;
+	//! Gathers a DataChunk (only the columns given by column_ids) from the TupleDataCollection,
+	//! given the specific row locations (requires full pin)
+	void Gather(Vector &row_locations, const SelectionVector &scan_sel, const idx_t scan_count,
+	            const vector<column_t> &column_ids, DataChunk &result, const SelectionVector &target_sel) const;
+	//! Gathers a Vector (from the given column id) from the TupleDataCollection
+	//! given the specific row locations (requires full pin)
+	void Gather(Vector &row_locations, const SelectionVector &sel, const idx_t scan_count, const column_t column_id,
+	            Vector &result, const SelectionVector &target_sel) const;
+
+	//! Converts this TupleDataCollection to a string representation
+	string ToString();
+	//! Prints the string representation of this TupleDataCollection
+	void Print();
+
+	//! Verify that all blocks are pinned
+	void VerifyEverythingPinned() const;
+
+private:
+	//! Initializes the TupleDataCollection (called by the constructor)
+	void Initialize();
+	//! Gets all column ids
+	void GetAllColumnIDs(vector<column_t> &column_ids);
+
+	//! Computes the heap sizes for the specific Vector that will be appended
+	static void ComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v, TupleDataVectorFormat &source,
+	                             const SelectionVector &append_sel, const idx_t append_count);
+	//! Computes the heap sizes for the specific Vector that will be appended (within a list)
+	static void WithinListHeapComputeSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                       TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
+	                                       const idx_t append_count, const UnifiedVectorFormat &list_data);
+	//! Computes the heap sizes for the fixed-size type Vector that will be appended (within a list)
+	static void ComputeFixedWithinListHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                            TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
+	                                            const idx_t append_count, const UnifiedVectorFormat &list_data);
+	//! Computes the heap sizes for the string Vector that will be appended (within a list)
+	static void StringWithinListComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                             TupleDataVectorFormat &source_format,
+	                                             const SelectionVector &append_sel, const idx_t append_count,
+	                                             const UnifiedVectorFormat &list_data);
+	//! Computes the heap sizes for the struct Vector that will be appended (within a list)
+	static void StructWithinListComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                             TupleDataVectorFormat &source_format,
+	                                             const SelectionVector &append_sel, const idx_t append_count,
+	                                             const UnifiedVectorFormat &list_data);
+	//! Computes the heap sizes for the list Vector that will be appended (within a list)
+	static void ListWithinListComputeHeapSizes(Vector &heap_sizes_v, const Vector &source_v,
+	                                           TupleDataVectorFormat &source_format, const SelectionVector &append_sel,
+	                                           const idx_t append_count, const UnifiedVectorFormat &list_data);
+
+	//! Get the next segment/chunk index for the scan
+	bool NextScanIndex(TupleDataScanState &scan_state, idx_t &segment_index, idx_t &chunk_index);
+	//! Scans the chunk at the given segment/chunk indices
+	void ScanAtIndex(TupleDataPinState &pin_state, TupleDataChunkState &chunk_state, const vector<column_t> &column_ids,
+	                 idx_t segment_index, idx_t chunk_index, DataChunk &result);
+
+	//! Verify counts of the segments in this collection
+	void Verify() const;
+
+private:
+	//! The layout of the TupleDataCollection
+	const TupleDataLayout layout;
+	//! The TupleDataAllocator
+	shared_ptr<TupleDataAllocator> allocator;
+	//! The number of entries stored in the TupleDataCollection
+	idx_t count;
+	//! The data segments of the TupleDataCollection
+	vector<TupleDataSegment> segments;
+	//! The set of scatter functions
+	vector<TupleDataScatterFunction> scatter_functions;
+	//! The set of gather functions
+	vector<TupleDataGatherFunction> gather_functions;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_iterator.hpp

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row/tuple_data_iterator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
+
+namespace duckdb {
+
+class TupleDataChunkIterator {
+public:
+	//! Creates a TupleDataChunkIterator that iterates over all DataChunks in the TupleDataCollection
+	TupleDataChunkIterator(TupleDataCollection &collection, TupleDataPinProperties properties, bool init_heap);
+	//! Creates a TupleDataChunkIterator that iterates over the specified DataChunk range in the TupleDataCollection
+	TupleDataChunkIterator(TupleDataCollection &collection, TupleDataPinProperties properties, idx_t chunk_idx_from,
+	                       idx_t chunk_idx_to, bool init_heap);
+
+public:
+	//! Whether the iterator is done
+	bool Done() const;
+	//! Fetches the next STANDARD_VECTOR_SIZE row locations (and heap locations/sizes if init_heap is true)
+	bool Next();
+	//! Resets the scan indices to the start
+	void Reset();
+	//! Get the count of the current "DataChunk"
+	idx_t GetCurrentChunkCount() const;
+	//! Get the Chunk state of the scan state of this iterator
+	TupleDataChunkState &GetChunkState();
+	//! Get the array holding the row locations
+	data_ptr_t *GetRowLocations();
+	//! Get the array holding the heap locations
+	data_ptr_t *GetHeapLocations();
+	//! Get the array holding the heap sizes
+	idx_t *GetHeapSizes();
+
+private:
+	//! Initializes the row locations (and heap locations/sizes if init_heap is true) at the current scan indices
+	void InitializeCurrentChunk();
+
+private:
+	//! The collection being iterated over
+	TupleDataCollection &collection;
+	//! Whether or not to fetch the heap locations/sizes while iterating
+	bool init_heap;
+
+	//! Start indices
+	idx_t start_segment_idx;
+	idx_t start_chunk_idx;
+	//! End indices
+	idx_t end_segment_idx;
+	idx_t end_chunk_idx;
+
+	//! Current scan state and scan indices
+	TupleDataScanState state;
+	idx_t current_segment_idx;
+	idx_t current_chunk_idx;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_layout.hpp

@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row/tuple_data_layout.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/types/row/row_layout.hpp"
+#include "duckdb/common/types/validity_mask.hpp"
+#include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
+#include "duckdb/planner/expression.hpp"
+
+namespace duckdb {
+
+class TupleDataLayout {
+public:
+	using Aggregates = vector<AggregateObject>;
+	using ValidityBytes = TemplatedValidityMask<uint8_t>;
+
+	//! Creates an empty TupleDataLayout
+	TupleDataLayout();
+	//! Create a copy of this TupleDataLayout
+	TupleDataLayout Copy() const;
+
+public:
+	//! Initializes the TupleDataLayout with the specified types and aggregates to an empty TupleDataLayout
+	void Initialize(vector<LogicalType> types_p, Aggregates aggregates_p, bool align = true, bool heap_offset = true);
+	//! Initializes the TupleDataLayout with the specified types to an empty TupleDataLayout
+	void Initialize(vector<LogicalType> types, bool align = true, bool heap_offset = true);
+	//! Initializes the TupleDataLayout with the specified aggregates to an empty TupleDataLayout
+	void Initialize(Aggregates aggregates_p, bool align = true, bool heap_offset = true);
+
+	//! Returns the number of data columns
+	inline idx_t ColumnCount() const {
+		return types.size();
+	}
+	//! Returns a list of the column types for this data chunk
+	inline const vector<LogicalType> &GetTypes() const {
+		return types;
+	}
+	//! Returns the number of aggregates
+	inline idx_t AggregateCount() const {
+		return aggregates.size();
+	}
+	//! Returns a list of the aggregates for this data chunk
+	inline Aggregates &GetAggregates() {
+		return aggregates;
+	}
+	//! Returns a map from column id to the struct TupleDataLayout
+	const inline TupleDataLayout &GetStructLayout(idx_t col_idx) const {
+		D_ASSERT(struct_layouts->find(col_idx) != struct_layouts->end());
+		return struct_layouts->find(col_idx)->second;
+	}
+	//! Returns the total width required for each row, including padding
+	inline idx_t GetRowWidth() const {
+		return row_width;
+	}
+	//! Returns the offset to the start of the data
+	inline idx_t GetDataOffset() const {
+		return flag_width;
+	}
+	//! Returns the total width required for the data, including padding
+	inline idx_t GetDataWidth() const {
+		return data_width;
+	}
+	//! Returns the offset to the start of the aggregates
+	inline idx_t GetAggrOffset() const {
+		return flag_width + data_width;
+	}
+	//! Returns the total width required for the aggregates, including padding
+	inline idx_t GetAggrWidth() const {
+		return aggr_width;
+	}
+	//! Returns the column offsets into each row
+	inline const vector<idx_t> &GetOffsets() const {
+		return offsets;
+	}
+	//! Returns whether all columns in this layout are constant size
+	inline bool AllConstant() const {
+		return all_constant;
+	}
+	inline idx_t GetHeapSizeOffset() const {
+		return heap_size_offset;
+	}
+
+private:
+	//! The types of the data columns
+	vector<LogicalType> types;
+	//! The aggregate functions
+	Aggregates aggregates;
+	//! Structs are a recursive TupleDataLayout
+	unique_ptr<unordered_map<idx_t, TupleDataLayout>> struct_layouts;
+	//! The width of the validity header
+	idx_t flag_width;
+	//! The width of the data portion
+	idx_t data_width;
+	//! The width of the aggregate state portion
+	idx_t aggr_width;
+	//! The width of the entire row
+	idx_t row_width;
+	//! The offsets to the columns and aggregate data in each row
+	vector<idx_t> offsets;
+	//! Whether all columns in this layout are constant size
+	bool all_constant;
+	//! Offset to the heap size of every row
+	idx_t heap_size_offset;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_segment.hpp

@@ -0,0 +1,124 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row/tuple_data_segment.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+class TupleDataAllocator;
+class TupleDataLayout;
+
+struct TupleDataChunkPart {
+public:
+	TupleDataChunkPart();
+
+	//! Disable copy constructors
+	TupleDataChunkPart(const TupleDataChunkPart &other) = delete;
+	TupleDataChunkPart &operator=(const TupleDataChunkPart &) = delete;
+
+	//! Enable move constructors
+	TupleDataChunkPart(TupleDataChunkPart &&other) noexcept;
+	TupleDataChunkPart &operator=(TupleDataChunkPart &&) noexcept;
+
+	static constexpr const uint32_t INVALID_INDEX = (uint32_t)-1;
+
+public:
+	//! Index/offset of the row block
+	uint32_t row_block_index;
+	uint32_t row_block_offset;
+	//! Pointer/index/offset of the heap block
+	uint32_t heap_block_index;
+	uint32_t heap_block_offset;
+	data_ptr_t base_heap_ptr;
+	//! Total heap size for this chunk part
+	uint32_t total_heap_size;
+	//! Tuple count for this chunk part
+	uint32_t count;
+	//! Lock for recomputing heap pointers
+	mutex lock;
+};
+
+struct TupleDataChunk {
+public:
+	TupleDataChunk();
+
+	//! Disable copy constructors
+	TupleDataChunk(const TupleDataChunk &other) = delete;
+	TupleDataChunk &operator=(const TupleDataChunk &) = delete;
+
+	//! Enable move constructors
+	TupleDataChunk(TupleDataChunk &&other) noexcept;
+	TupleDataChunk &operator=(TupleDataChunk &&) noexcept;
+
+	//! Add a part to this chunk
+	void AddPart(TupleDataChunkPart &&part, const TupleDataLayout &layout);
+	//! Tries to merge the last chunk part into the second-to-last one
+	void MergeLastChunkPart(const TupleDataLayout &layout);
+	//! Verify counts of the parts in this chunk
+	void Verify() const;
+
+public:
+	//! The parts of this chunk
+	vector<TupleDataChunkPart> parts;
+	//! The row block ids referenced by the chunk
+	unordered_set<uint32_t> row_block_ids;
+	//! The heap block ids referenced by the chunk
+	unordered_set<uint32_t> heap_block_ids;
+	//! Tuple count for this chunk
+	idx_t count;
+};
+
+struct TupleDataSegment {
+public:
+	explicit TupleDataSegment(shared_ptr<TupleDataAllocator> allocator);
+
+	~TupleDataSegment();
+
+	//! Disable copy constructors
+	TupleDataSegment(const TupleDataSegment &other) = delete;
+	TupleDataSegment &operator=(const TupleDataSegment &) = delete;
+
+	//! Enable move constructors
+	TupleDataSegment(TupleDataSegment &&other) noexcept;
+	TupleDataSegment &operator=(TupleDataSegment &&) noexcept;
+
+	//! The number of chunks in this segment
+	idx_t ChunkCount() const;
+	//! The size (in bytes) of this segment
+	idx_t SizeInBytes() const;
+	//! Unpins all held pins
+	void Unpin();
+
+	//! Verify counts of the chunks in this segment
+	void Verify() const;
+	//! Verify that all blocks in this segment are pinned
+	void VerifyEverythingPinned() const;
+
+public:
+	//! The allocator for this segment
+	shared_ptr<TupleDataAllocator> allocator;
+	//! The chunks of this segment
+	vector<TupleDataChunk> chunks;
+	//! The tuple count of this segment
+	idx_t count;
+
+	//! Lock for modifying pinned_handles
+	mutex pinned_handles_lock;
+	//! Where handles to row blocks will be stored with TupleDataPinProperties::KEEP_EVERYTHING_PINNED
+	vector<BufferHandle> pinned_row_handles;
+	//! Where handles to heap blocks will be stored with TupleDataPinProperties::KEEP_EVERYTHING_PINNED
+	vector<BufferHandle> pinned_heap_handles;
+};
+
+} // namespace duckdb