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

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

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/row/tuple_data_states.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/types.hpp"
+
+namespace duckdb {
+
+enum class TupleDataPinProperties : uint8_t {
+	INVALID,
+	//! Keeps all passed blocks pinned while scanning/iterating over the chunks (for both reading/writing)
+	KEEP_EVERYTHING_PINNED,
+	//! Unpins blocks after they are done (for both reading/writing)
+	UNPIN_AFTER_DONE,
+	//! Destroys blocks after they are done (for reading only)
+	DESTROY_AFTER_DONE,
+	//! Assumes all blocks are already pinned (for reading only)
+	ALREADY_PINNED
+};
+
+struct TupleDataPinState {
+	unordered_map<uint32_t, BufferHandle> row_handles;
+	unordered_map<uint32_t, BufferHandle> heap_handles;
+	TupleDataPinProperties properties = TupleDataPinProperties::INVALID;
+};
+
+struct CombinedListData {
+	UnifiedVectorFormat combined_data;
+	list_entry_t combined_list_entries[STANDARD_VECTOR_SIZE];
+	buffer_ptr<SelectionData> selection_data;
+};
+
+struct TupleDataVectorFormat {
+	UnifiedVectorFormat data;
+	vector<TupleDataVectorFormat> child_formats;
+	unique_ptr<CombinedListData> combined_list_data;
+};
+
+struct TupleDataChunkState {
+	vector<TupleDataVectorFormat> vector_data;
+	vector<column_t> column_ids;
+
+	Vector row_locations = Vector(LogicalType::POINTER);
+	Vector heap_locations = Vector(LogicalType::POINTER);
+	Vector heap_sizes = Vector(LogicalType::UBIGINT);
+};
+
+struct TupleDataAppendState {
+	TupleDataPinState pin_state;
+	TupleDataChunkState chunk_state;
+};
+
+struct TupleDataScanState {
+	TupleDataPinState pin_state;
+	TupleDataChunkState chunk_state;
+	idx_t segment_index = DConstants::INVALID_INDEX;
+	idx_t chunk_index = DConstants::INVALID_INDEX;
+};
+
+struct TupleDataParallelScanState {
+	TupleDataScanState scan_state;
+	mutex lock;
+};
+
+using TupleDataLocalScanState = TupleDataScanState;
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp

@@ -170,6 +170,9 @@ public:
 		}
 		return ValidityBuffer::MAX_ENTRY >> (BITS_PER_VALUE - n);
 	}
+	static inline idx_t SizeInBytes(idx_t n) {
+		return (n + BITS_PER_VALUE - 1) / BITS_PER_VALUE;
+	}
 
 	//! RowIsValidUnsafe should only be used if AllValid() is false: it achieves the same as RowIsValid but skips a
 	//! not-null check

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -175,24 +175,16 @@ public:
 	DUCKDB_API static Value BIT(const string &data);
 
 	template <class T>
-	T GetValue() const {
-		throw InternalException("Unimplemented template type for Value::GetValue");
-	}
+	T GetValue() const;
 	template <class T>
-	static Value CreateValue(T value) {
-		throw InternalException("Unimplemented template type for Value::CreateValue");
-	}
+	static Value CreateValue(T value);
 	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the
 	// type of the value. Only use this if you know what you are doing.
 	template <class T>
-	T GetValueUnsafe() const {
-		throw InternalException("Unimplemented template type for Value::GetValueUnsafe");
-	}
+	T GetValueUnsafe() const;
 	//! Returns a reference to the internal value. This can only be used for primitive types.
 	template <class T>
-	T &GetReferenceUnsafe() {
-		throw InternalException("Unimplemented template type for Value::GetReferenceUnsafe");
-	}
+	T &GetReferenceUnsafe();
 
 	//! Return a copy of this value
 	Value Copy() const {

package/src/duckdb/src/include/duckdb/execution/aggregate_hashtable.hpp

@@ -8,14 +8,14 @@
 
 #pragma once
 
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
 #include "duckdb/execution/base_aggregate_hashtable.hpp"
-#include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/arena_allocator.hpp"
+#include "duckdb/storage/buffer/buffer_handle.hpp"
 
 namespace duckdb {
 class BlockHandle;
 class BufferHandle;
-class RowDataCollection;
 
 struct FlushMoveState;
 
@@ -60,7 +60,7 @@ enum HtEntryType { HT_WIDTH_32, HT_WIDTH_64 };
 
 struct AggregateHTScanState {
 	mutex lock;
-	idx_t scan_position = 0;
+	TupleDataScanState scan_state;
 };
 
 struct AggregateHTAppendState {
@@ -75,6 +75,9 @@ struct AggregateHTAppendState {
 	Vector addresses;
 	unique_ptr<UnifiedVectorFormat[]> group_data;
 	DataChunk group_chunk;
+
+	TupleDataChunkState chunk_state;
+	bool chunk_state_initialized;
 };
 
 class GroupedAggregateHashTable : public BaseAggregateHashTable {
@@ -95,9 +98,6 @@ public:
 	GroupedAggregateHashTable(ClientContext &context, Allocator &allocator, vector<LogicalType> group_types);
 	~GroupedAggregateHashTable() override;
 
-	//! The stringheap of the AggregateHashTable
-	unique_ptr<RowDataCollection> string_heap;
-
 public:
 	//! Add the given data to the HT, computing the aggregates grouped by the
 	//! data in the group chunk. When resize = true, aggregates will not be
@@ -110,7 +110,7 @@ public:
 	//! Scan the HT starting from the scan_position until the result and group
 	//! chunks are filled. scan_position will be updated by this function.
 	//! Returns the amount of elements found.
-	idx_t Scan(AggregateHTScanState &scan_state, DataChunk &result);
+	idx_t Scan(TupleDataParallelScanState &gstate, TupleDataLocalScanState &lstate, DataChunk &result);
 
 	//! Fetch the aggregates for specific groups from the HT and place them in the result
 	void FetchAggregates(DataChunk &groups, DataChunk &result);
@@ -127,10 +127,15 @@ public:
 	//! Executes the filter(if any) and update the aggregates
 	void Combine(GroupedAggregateHashTable &other);
 
-	static idx_t InitialCapacity();
-	idx_t Size() {
-		return entries;
+	TupleDataCollection &GetDataCollection() {
+		return *data_collection;
 	}
+
+	idx_t Count() const {
+		return data_collection->Count();
+	}
+
+	static idx_t InitialCapacity();
 	idx_t Capacity() {
 		return capacity;
 	}
@@ -139,24 +144,23 @@ public:
 	idx_t MaxCapacity();
 	static idx_t GetMaxCapacity(HtEntryType entry_type, idx_t tuple_size);
 
-	void Partition(vector<GroupedAggregateHashTable *> &partition_hts, hash_t mask, idx_t shift);
+	void Partition(vector<GroupedAggregateHashTable *> &partition_hts, idx_t radix_bits);
+	void InitializeFirstPart();
 
 	void Finalize();
 
 private:
 	HtEntryType entry_type;
 
-	//! The total tuple size
+	//! The capacity of the HT. This can be increased using GroupedAggregateHashTable::Resize
+	idx_t capacity;
+	//! Tuple width
 	idx_t tuple_size;
-	//! The amount of tuples that fit in a single block
+	//! Tuples per block
 	idx_t tuples_per_block;
-	//! The capacity of the HT. This can be increased using
-	//! GroupedAggregateHashTable::Resize
-	idx_t capacity;
-	//! The amount of entries stored in the HT currently
-	idx_t entries;
 	//! The data of the HT
-	vector<BufferHandle> payload_hds;
+	unique_ptr<TupleDataCollection> data_collection;
+	TupleDataPinState td_pin_state;
 	vector<data_ptr_t> payload_hds_ptrs;
 
 	//! The hashes of the HT
@@ -165,7 +169,6 @@ private:
 	idx_t hash_offset; // Offset into the layout of the hash column
 
 	hash_t hash_prefix_shift;
-	idx_t payload_page_offset;
 
 	//! Bitmask for getting relevant bits from the hashes to determine the position
 	hash_t bitmask;
@@ -175,30 +178,30 @@ private:
 	vector<ExpressionType> predicates;
 
 	//! The arena allocator used by the aggregates for their internal state
-	ArenaAllocator aggregate_allocator;
+	shared_ptr<ArenaAllocator> aggregate_allocator;
 
 private:
 	GroupedAggregateHashTable(const GroupedAggregateHashTable &) = delete;
 
-	//! Resize the HT to the specified size. Must be larger than the current
-	//! size.
 	void Destroy();
-
 	void Verify();
-
-	void FlushMove(FlushMoveState &state, Vector &source_addresses, Vector &source_hashes, idx_t count);
-	void NewBlock();
-
 	template <class ENTRY>
 	void VerifyInternal();
+	//! Resize the HT to the specified size. Must be larger than the current size.
 	template <class ENTRY>
 	void Resize(idx_t size);
+	//! Initializes the first part of the HT
+	template <class ENTRY>
+	void InitializeHashes();
+	//! Does the actual group matching / creation
+	template <class ENTRY>
+	idx_t FindOrCreateGroupsInternal(DataChunk &groups, Vector &group_hashes_v, Vector &addresses_v,
+	                                 SelectionVector &new_groups);
+	//! Updates payload_hds_ptrs with the new pointers (after appending to data_collection)
+	void UpdateBlockPointers();
 	template <class ENTRY>
 	idx_t FindOrCreateGroupsInternal(AggregateHTAppendState &state, DataChunk &groups, Vector &group_hashes,
 	                                 Vector &addresses, SelectionVector &new_groups);
-
-	template <class FUNC = std::function<void(idx_t, idx_t, data_ptr_t)>>
-	void PayloadApply(FUNC fun);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/base_aggregate_hashtable.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_layout.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
 
@@ -27,7 +27,7 @@ protected:
 	Allocator &allocator;
 	BufferManager &buffer_manager;
 	//! A helper for managing offsets into the data buffers
-	RowLayout layout;
+	TupleDataLayout layout;
 	//! The types of the payload columns stored in the hashtable
 	vector<LogicalType> payload_types;
 	//! Intermediate structures and data for aggregate filters

package/src/duckdb/src/include/duckdb/execution/execution_context.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class ClientContext;
@@ -17,7 +18,7 @@ class Pipeline;
 
 class ExecutionContext {
 public:
-	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p, Pipeline *pipeline_p)
+	ExecutionContext(ClientContext &client_p, ThreadContext &thread_p, optional_ptr<Pipeline> pipeline_p)
 	    : client(client_p), thread(thread_p), pipeline(pipeline_p) {
 	}
 
@@ -26,7 +27,7 @@ public:
 	//! The thread-local context for this execution
 	ThreadContext &thread;
 	//! Reference to the pipeline for this execution, can be used for example by operators determine caching strategy
-	Pipeline *pipeline;
+	optional_ptr<Pipeline> pipeline;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/expression_executor.hpp

@@ -151,7 +151,7 @@ protected:
 
 private:
 	//! Client context
-	ClientContext *context;
+	optional_ptr<ClientContext> context;
 	//! The states of the expression executor; this holds any intermediates and temporary states of expressions
 	vector<unique_ptr<ExpressionExecutorState>> states;
 

package/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp

@@ -10,11 +10,11 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/radix_partitioning.hpp"
-#include "duckdb/common/types/column_data_consumer.hpp"
+#include "duckdb/common/types/column/column_data_consumer.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/row_data_collection.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_iterator.hpp"
+#include "duckdb/common/types/row/tuple_data_layout.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/execution/aggregate_hashtable.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
@@ -30,25 +30,13 @@ struct ClientConfig;
 
 struct JoinHTScanState {
 public:
-	JoinHTScanState() : position(0), block_position(0), total(0), scan_index(0), scanned(0) {
+	JoinHTScanState(TupleDataCollection &collection, idx_t chunk_idx_from, idx_t chunk_idx_to,
+	                TupleDataPinProperties properties = TupleDataPinProperties::ALREADY_PINNED)
+	    : iterator(collection, properties, chunk_idx_from, chunk_idx_to, false), offset_in_chunk(0) {
 	}
 
-	idx_t position;
-	idx_t block_position;
-
-	//! Used for synchronization of parallel external join
-	idx_t total;
-	idx_t scan_index;
-	idx_t scanned;
-
-public:
-	void Reset() {
-		position = 0;
-		block_position = 0;
-		total = 0;
-		scan_index = 0;
-		scanned = 0;
-	}
+	TupleDataChunkIterator iterator;
+	idx_t offset_in_chunk;
 
 private:
 	//! Implicit copying is not allowed
@@ -130,33 +118,38 @@ public:
 	~JoinHashTable();
 
 	//! Add the given data to the HT
-	void Build(DataChunk &keys, DataChunk &input);
+	void Build(PartitionedTupleDataAppendState &append_state, DataChunk &keys, DataChunk &input);
 	//! Merge another HT into this one
 	void Merge(JoinHashTable &other);
+	//! Combines the partitions in sink_collection into data_collection, as if it were not partitioned
+	void Unpartition();
 	//! Initialize the pointer table for the probe
 	void InitializePointerTable();
 	//! Finalize the build of the HT, constructing the actual hash table and making the HT ready for probing.
 	//! Finalize must be called before any call to Probe, and after Finalize is called Build should no longer be
 	//! ever called.
-	void Finalize(idx_t block_idx_start, idx_t block_idx_end, bool parallel);
+	void Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel);
 	//! Probe the HT with the given input chunk, resulting in the given result
 	unique_ptr<ScanStructure> Probe(DataChunk &keys, Vector *precomputed_hashes = nullptr);
-	//! Scan the HT to find the rows for the full outer join and return the number of found entries
-	idx_t ScanFullOuter(JoinHTScanState &state, Vector &addresses);
-	//! Construct the full outer join result given the addresses and number of found entries
-	void GatherFullOuter(DataChunk &result, Vector &addresses, idx_t found_entries);
+	//! Scan the HT to construct the full outer join result
+	void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result);
 
 	//! Fill the pointer with all the addresses from the hashtable for full scan
-	idx_t FillWithHTOffsets(data_ptr_t *key_locations, JoinHTScanState &state);
-	//! Pins all fixed-size blocks
-	void PinAllBlocks();
+	idx_t FillWithHTOffsets(JoinHTScanState &state, Vector &addresses);
 
 	idx_t Count() const {
-		return block_collection->count;
+		return data_collection->Count();
+	}
+	idx_t SizeInBytes() const {
+		return data_collection->SizeInBytes();
+	}
+
+	PartitionedTupleData &GetSinkCollection() {
+		return *sink_collection;
 	}
 
-	const RowDataCollection &GetBlockCollection() const {
-		return *block_collection;
+	TupleDataCollection &GetDataCollection() {
+		return *data_collection;
 	}
 
 	//! BufferManager
@@ -172,7 +165,7 @@ public:
 	//! The comparison predicates
 	vector<ExpressionType> predicates;
 	//! Data column layout
-	RowLayout layout;
+	TupleDataLayout layout;
 	//! The size of an entry as stored in the HashTable
 	idx_t entry_size;
 	//! The total tuple size
@@ -222,13 +215,12 @@ private:
 	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
-	unique_ptr<RowDataCollection> block_collection;
-	//! The stringheap of the JoinHashTable
-	unique_ptr<RowDataCollection> string_heap;
-	//! Pinned handles, these are pinned during finalization only
-	mutex pinned_handles_lock;
-	vector<BufferHandle> pinned_handles;
+	//! Lock for combining data_collection when merging HTs
+	mutex data_lock;
+	//! Partitioned data collection that the data is sunk into when building
+	unique_ptr<PartitionedTupleData> sink_collection;
+	//! The DataCollection holding the main data of the hash table
+	unique_ptr<TupleDataCollection> data_collection;
 	//! The hash map of the HT, created after finalization
 	AllocatedData hash_map;
 	//! Whether or not NULL values are considered equal in each of the comparisons
@@ -297,34 +289,25 @@ public:
 	bool external;
 	//! The current number of radix bits used to partition
 	idx_t radix_bits;
+	//! The max size of the HT
+	idx_t max_ht_size;
 	//! Total count
 	idx_t total_count;
-	//! Number of tuples for the build-side HT per partitioned round
-	idx_t tuples_per_round;
 
-	//! The number of tuples that are swizzled
-	idx_t SwizzledCount() const {
-		return swizzled_block_collection->count;
-	}
-	//! Size of the in-memory data
-	idx_t SizeInBytes() const {
-		return block_collection->SizeInBytes() + string_heap->SizeInBytes();
-	}
-	//! Size of the swizzled data
-	idx_t SwizzledSize() const {
-		return swizzled_block_collection->SizeInBytes() + swizzled_string_heap->SizeInBytes();
-	}
 	//! Capacity of the pointer table given the ht count
 	//! (minimum of 1024 to prevent collision chance for small HT's)
 	static idx_t PointerTableCapacity(idx_t count) {
 		return MaxValue<idx_t>(NextPowerOfTwo(count * 2), 1 << 10);
 	}
+	//! Size of the pointer table (in bytes)
+	static idx_t PointerTableSize(idx_t count) {
+		return PointerTableCapacity(count) * sizeof(data_ptr_t);
+	}
 
-	//! Swizzle the blocks in this HT (moves from block_collection and string_heap to swizzled_...)
-	void SwizzleBlocks();
-
+	//! Whether we need to do an external join
+	bool RequiresExternalJoin(ClientConfig &config, vector<unique_ptr<JoinHashTable>> &local_hts);
 	//! Computes partition sizes and number of radix bits (called before scheduling partition tasks)
-	void ComputePartitionSizes(ClientConfig &config, vector<unique_ptr<JoinHashTable>> &local_hts, idx_t max_ht_size);
+	bool RequiresPartitioning(ClientConfig &config, vector<unique_ptr<JoinHashTable>> &local_hts);
 	//! Partition this HT
 	void Partition(JoinHashTable &global_ht);
 
@@ -340,15 +323,6 @@ private:
 	//! First and last partition of the current probe round
 	idx_t partition_start;
 	idx_t partition_end;
-
-	//! Swizzled row data
-	unique_ptr<RowDataCollection> swizzled_block_collection;
-	unique_ptr<RowDataCollection> swizzled_string_heap;
-
-	//! Partitioned data
-	mutex partitioned_data_lock;
-	vector<unique_ptr<RowDataCollection>> partition_block_collections;
-	vector<unique_ptr<RowDataCollection>> partition_string_heaps;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/nested_loop_join.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_execute.hpp

@@ -18,9 +18,9 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXECUTE;
 
 public:
-	explicit PhysicalExecute(PhysicalOperator *plan);
+	explicit PhysicalExecute(PhysicalOperator &plan);
 
-	PhysicalOperator *plan;
+	PhysicalOperator &plan;
 	unique_ptr<PhysicalOperator> owned_plan;
 	shared_ptr<PreparedStatementData> prepared;
 

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_result_collector.hpp

@@ -21,7 +21,7 @@ public:
 
 	StatementType statement_type;
 	StatementProperties properties;
-	PhysicalOperator *plan;
+	PhysicalOperator &plan;
 	vector<string> names;
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/join/outer_join_marker.hpp

@@ -9,9 +9,9 @@
 #pragma once
 
 #include "duckdb/common/mutex.hpp"
-#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/operator/join/physical_comparison_join.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/execution/physical_operator.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp

@@ -58,7 +58,7 @@ private:
 	template <typename T>
 	bool TemplatedFillSelectionVectorBuild(Vector &source, SelectionVector &sel_vec, SelectionVector &seq_sel_vec,
 	                                       idx_t count);
-	bool FullScanHashTable(JoinHTScanState &state, LogicalType &key_type);
+	bool FullScanHashTable(LogicalType &key_type);
 
 private:
 	const PhysicalHashJoin &join;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_cross_product.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp

@@ -44,8 +44,6 @@ public:
 	vector<LogicalType> delim_types;
 	//! Used in perfect hash join
 	PerfectHashJoinStats perfect_join_statistics;
-	//! Whether we can go external (can't yet if recursive CTE)
-	bool can_go_external;
 
 public:
 	// Operator Interface

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_index_join.hpp

@@ -24,7 +24,7 @@ public:
 public:
 	PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	                  vector<JoinCondition> cond, JoinType join_type, const vector<idx_t> &left_projection_map,
-	                  vector<idx_t> right_projection_map, vector<column_t> column_ids, Index *index, bool lhs_first,
+	                  vector<idx_t> right_projection_map, vector<column_t> column_ids, Index &index, bool lhs_first,
 	                  idx_t estimated_cardinality);
 
 	//! Columns from RHS used in the query
@@ -44,7 +44,7 @@ public:
 	//! The types of all conditions
 	vector<LogicalType> build_types;
 	//! Index used for join
-	Index *index;
+	Index &index;
 
 	vector<JoinCondition> conditions;
 

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_positional_join.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/execution/operator/persistent/buffered_csv_reader.hpp

@@ -87,7 +87,7 @@ private:
 	//! Resets the steam
 	void ResetStream();
 	//! Reads a new buffer from the CSV file if the current one has been exhausted
-	bool ReadBuffer(idx_t &start);
+	bool ReadBuffer(idx_t &start, idx_t &line_start);
 	//! Jumps back to the beginning of input stream and resets necessary internal states
 	bool JumpToNextSample();
 	//! Initializes the TextSearchShiftArrays for complex parser
@@ -124,6 +124,9 @@ private:
 	                                        const vector<LogicalType> &requested_types,
 	                                        vector<vector<LogicalType>> &best_sql_types_candidates,
 	                                        map<LogicalTypeId, vector<string>> &best_format_candidates);
+
+	//! Skip Empty lines for tables with over one column
+	void SkipEmptyLines();
 };
 
 } // namespace duckdb