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

package/src/duckdb/src/common/row_operations/row_match.cpp

@@ -4,10 +4,10 @@
 //===--------------------------------------------------------------------===//
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/constant_operators.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/operator/constant_operators.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
 
 namespace duckdb {
 
@@ -118,12 +118,104 @@ static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, Selection
 	count = match_count;
 }
 
+//! Forward declaration for recursion
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
+                             idx_t &no_match_count, const idx_t original_count);
+
 template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count, const RowLayout &layout,
-                                 const idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
+static void TemplatedMatchStruct(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                                 SelectionVector &sel, idx_t &count, const idx_t col_no, SelectionVector *no_match,
+                                 idx_t &no_match_count, const idx_t original_count) {
+	// Precompute row_mask indexes
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
+
+	// Work our way through the validity of the whole struct
+	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
+	idx_t match_count = 0;
+	if (!col.validity.AllValid()) {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			auto col_idx = col.sel->get_index(idx);
+			if (!col.validity.RowIsValid(col_idx)) {
+				if (isnull) {
+					// match: move to next value to compare
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			} else {
+				if (!isnull) {
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			}
+		}
+	} else {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			if (!isnull) {
+				sel.set_index(match_count++, idx);
+			} else {
+				if (NO_MATCH_SEL) {
+					no_match->set_index(no_match_count++, idx);
+				}
+			}
+		}
+	}
+	count = match_count;
+
+	// Now we construct row pointers to the structs
+	Vector struct_rows(LogicalTypeId::POINTER);
+	auto struct_ptrs = FlatVector::GetData<data_ptr_t>(struct_rows);
+
+	const auto col_offset = layout.GetOffsets()[col_no];
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = sel.get_index(i);
+		auto row = ptrs[idx];
+		struct_ptrs[idx] = row + col_offset;
+	}
+
+	// Get the struct layout, child columns, then recurse
+	const auto &struct_layout = layout.GetStructLayout(col_no);
+	auto &struct_entries = StructVector::GetEntries(vec);
+	D_ASSERT(struct_layout.ColumnCount() == struct_entries.size());
+	for (idx_t struct_col_no = 0; struct_col_no < struct_layout.ColumnCount(); struct_col_no++) {
+		auto &struct_vec = *struct_entries[struct_col_no];
+		UnifiedVectorFormat struct_col;
+		struct_vec.ToUnifiedFormat(original_count, struct_col);
+		TemplatedMatchOp<OP, NO_MATCH_SEL>(struct_vec, struct_col, struct_layout, struct_rows, sel, count,
+		                                   struct_col_no, no_match, no_match_count, original_count);
+	}
+}
+
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchList(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count,
+                               const TupleDataLayout &layout, const idx_t col_no, SelectionVector *no_match,
+                               idx_t &no_match_count) {
 	// Gather a dense Vector containing the column values being matched
 	Vector key(col.GetType());
-	RowOperations::Gather(rows, sel, key, *FlatVector::IncrementalSelectionVector(), count, layout, col_no);
+	const auto gather_function = TupleDataCollection::GetGatherFunction(col.GetType());
+	gather_function.function(layout, rows, col_no, sel, count, key, *FlatVector::IncrementalSelectionVector(), key,
+	                         gather_function.child_functions);
 
 	// Densify the input column
 	Vector sliced(col, sel, count);
@@ -139,9 +231,9 @@ static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel
 }
 
 template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLayout &layout, Vector &rows,
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
                              SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
-                             idx_t &no_match_count) {
+                             idx_t &no_match_count, const idx_t original_count) {
 	if (count == 0) {
 		return;
 	}
@@ -200,9 +292,12 @@ static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLay
 		TemplatedMatchType<string_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
 		                                               no_match_count);
 		break;
-	case PhysicalType::LIST:
 	case PhysicalType::STRUCT:
-		TemplatedMatchNested<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
+		TemplatedMatchStruct<OP, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
+		                                       original_count);
+		break;
+	case PhysicalType::LIST:
+		TemplatedMatchList<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
 		break;
 	default:
 		throw InternalException("Unsupported column type for RowOperations::Match");
@@ -210,9 +305,9 @@ static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLay
 }
 
 template <bool NO_MATCH_SEL>
-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) {
+static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &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) {
 		auto &vec = columns.data[col_no];
 		auto &col = col_data[col_no];
@@ -220,28 +315,28 @@ static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], c
 		case ExpressionType::COMPARE_EQUAL:
 		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
 		case ExpressionType::COMPARE_DISTINCT_FROM:
-			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                       no_match_count);
+			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
+			                                       count);
 			break;
 		case ExpressionType::COMPARE_NOTEQUAL:
 			TemplatedMatchOp<NotEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                          no_match_count);
+			                                          no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
 			TemplatedMatchOp<GreaterThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                            no_match_count);
+			                                            no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 			TemplatedMatchOp<GreaterThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                                  no_match_count);
+			                                                  no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_LESSTHAN:
 			TemplatedMatchOp<LessThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                         no_match_count);
+			                                         no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
 			TemplatedMatchOp<LessThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                               no_match_count);
+			                                               no_match_count, count);
 			break;
 		default:
 			throw InternalException("Unsupported comparison type for RowOperations::Match");
@@ -249,9 +344,9 @@ static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], c
 	}
 }
 
-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) {
+idx_t RowOperations::Match(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
+                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t count,
+                           SelectionVector *no_match, idx_t &no_match_count) {
 	if (no_match) {
 		TemplatedMatch<true>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
 	} else {

package/src/duckdb/src/common/row_operations/row_scatter.cpp

@@ -8,8 +8,8 @@
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/row_operations/row_operations.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/row_data_collection.hpp"
+#include "duckdb/common/types/row/row_layout.hpp"
 #include "duckdb/common/types/selection_vector.hpp"
 #include "duckdb/common/types/vector.hpp"
 

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/common/sort/partition_state.hpp"
 
-#include "duckdb/common/types/column_data_consumer.hpp"
+#include "duckdb/common/types/column/column_data_consumer.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/parallel/event.hpp"

package/src/duckdb/src/common/sort/sort_state.cpp

@@ -303,7 +303,8 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 		ordered_data_ptr += row_width;
 		sorting_ptr += sorting_entry_size;
 	}
-	ordered_data_block->block->SetSwizzling(sd.swizzled ? "LocalSortState::ReOrder.ordered_data" : nullptr);
+	ordered_data_block->block->SetSwizzling(
+	    sd.layout.AllConstant() || !sd.swizzled ? nullptr : "LocalSortState::ReOrder.ordered_data");
 	// Replace the unordered data block with the re-ordered data block
 	sd.data_blocks.clear();
 	sd.data_blocks.push_back(std::move(ordered_data_block));

package/src/duckdb/src/common/sort/sorted_block.cpp

@@ -3,7 +3,7 @@
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/sort/sort.hpp"
-#include "duckdb/common/types/row_data_collection.hpp"
+#include "duckdb/common/types/row/row_data_collection.hpp"
 
 #include <numeric>
 

package/src/duckdb/src/common/types/{column_data_allocator.cpp → column/column_data_allocator.cpp}

@@ -1,6 +1,6 @@
-#include "duckdb/common/types/column_data_allocator.hpp"
+#include "duckdb/common/types/column/column_data_allocator.hpp"
 
-#include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/types/column/column_data_collection_segment.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
 

package/src/duckdb/src/common/types/{column_data_collection.cpp → column/column_data_collection.cpp}

@@ -1,11 +1,11 @@
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/types/column/column_data_collection_segment.hpp"
+#include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/common/types/value_map.hpp"
 
 namespace duckdb {
 
@@ -887,6 +887,7 @@ void ColumnDataCollection::Combine(ColumnDataCollection &other) {
 	for (auto &other_seg : other.segments) {
 		segments.push_back(std::move(other_seg));
 	}
+	other.Reset();
 	Verify();
 }
 
@@ -930,7 +931,24 @@ void ColumnDataCollection::Verify() {
 }
 
 string ColumnDataCollection::ToString() const {
-	return "Column Data Collection";
+	DataChunk chunk;
+	InitializeScanChunk(chunk);
+
+	ColumnDataScanState scan_state;
+	InitializeScan(scan_state);
+
+	string result = StringUtil::Format("ColumnDataCollection - [%llu Chunks, %llu Rows]\n", ChunkCount(), Count());
+	idx_t chunk_idx = 0;
+	idx_t row_count = 0;
+	while (Scan(scan_state, chunk)) {
+		result +=
+		    StringUtil::Format("Chunk %llu - [Rows %llu - %llu]\n", chunk_idx, row_count, row_count + chunk.size()) +
+		    chunk.ToString();
+		chunk_idx++;
+		row_count += chunk.size();
+	}
+
+	return result;
 }
 
 void ColumnDataCollection::Print() const {
@@ -952,7 +970,7 @@ struct ValueResultEquals {
 };
 
 bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const ColumnDataCollection &right,
-                                        string &error_message) {
+                                        string &error_message, bool ordered) {
 	if (left.ColumnCount() != right.ColumnCount()) {
 		error_message = "Column count mismatch";
 		return false;
@@ -967,6 +985,7 @@ bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const
 		for (idx_t c = 0; c < left.ColumnCount(); c++) {
 			auto lvalue = left_rows.GetValue(c, r);
 			auto rvalue = right_rows.GetValue(c, r);
+
 			if (!Value::DefaultValuesAreEqual(lvalue, rvalue)) {
 				error_message =
 				    StringUtil::Format("%s <> %s (row: %lld, col: %lld)\n", lvalue.ToString(), rvalue.ToString(), r, c);
@@ -974,7 +993,11 @@ bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const
 			}
 		}
 		if (!error_message.empty()) {
-			break;
+			if (ordered) {
+				return false;
+			} else {
+				break;
+			}
 		}
 	}
 	if (!error_message.empty()) {

package/src/duckdb/src/common/types/{column_data_collection_segment.cpp → column/column_data_collection_segment.cpp}

@@ -1,4 +1,5 @@
-#include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/types/column/column_data_collection_segment.hpp"
+
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 
 namespace duckdb {

package/src/duckdb/src/common/types/{column_data_consumer.cpp → column/column_data_consumer.cpp}

@@ -1,4 +1,4 @@
-#include "duckdb/common/types/column_data_consumer.hpp"
+#include "duckdb/common/types/column/column_data_consumer.hpp"
 
 #include <algorithm>
 

package/src/duckdb/src/common/types/{partitioned_column_data.cpp → column/partitioned_column_data.cpp}

@@ -1,14 +1,15 @@
-#include "duckdb/common/types/partitioned_column_data.hpp"
+#include "duckdb/common/types/column/partitioned_column_data.hpp"
 
-#include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/common/hive_partitioning.hpp"
+#include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 
 namespace duckdb {
 
 PartitionedColumnData::PartitionedColumnData(PartitionedColumnDataType type_p, ClientContext &context_p,
                                              vector<LogicalType> types_p)
-    : type(type_p), context(context_p), types(std::move(types_p)), allocators(make_shared<PartitionAllocators>()) {
+    : type(type_p), context(context_p), types(std::move(types_p)),
+      allocators(make_shared<PartitionColumnDataAllocators>()) {
 }
 
 PartitionedColumnData::PartitionedColumnData(const PartitionedColumnData &other)
@@ -47,8 +48,9 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 
 	// Compute the counts per partition
 	const auto count = input.size();
-	unordered_map<idx_t, list_entry_t> partition_entries;
 	const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
+	auto &partition_entries = state.partition_entries;
+	partition_entries.clear();
 	switch (state.partition_indices.GetVectorType()) {
 	case VectorType::FLAT_VECTOR:
 		for (idx_t i = 0; i < count; i++) {
@@ -72,8 +74,8 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 	if (partition_entries.size() == 1) {
 		const auto &partition_index = partition_entries.begin()->first;
 		auto &partition = *partitions[partition_index];
-		auto &partition_append_state = state.partition_append_states[partition_index];
-		partition.Append(*partition_append_state, input);
+		auto &partition_append_state = *state.partition_append_states[partition_index];
+		partition.Append(partition_append_state, input);
 		return;
 	}
 
@@ -101,7 +103,7 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 		// Partition, buffer, and append state for this partition index
 		auto &partition = *partitions[partition_index];
 		auto &partition_buffer = *state.partition_buffers[partition_index];
-		auto &partition_append_state = state.partition_append_states[partition_index];
+		auto &partition_append_state = *state.partition_append_states[partition_index];
 
 		// Length and offset into the selection vector for this chunk, for this partition
 		const auto &partition_entry = pc.second;
@@ -117,14 +119,14 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 			state.slice_chunk.Slice(input, partition_sel, partition_length);
 
 			// Append it to the partition directly
-			partition.Append(*partition_append_state, state.slice_chunk);
+			partition.Append(partition_append_state, state.slice_chunk);
 		} else {
 			// Append the input chunk to the partition buffer using the selection vector
 			partition_buffer.Append(input, false, &partition_sel, partition_length);
 
 			if (partition_buffer.size() >= HalfBufferSize()) {
 				// Next batch won't fit in the buffer, flush it to the partition
-				partition.Append(*partition_append_state, partition_buffer);
+				partition.Append(partition_append_state, partition_buffer);
 				partition_buffer.Reset();
 				partition_buffer.SetCapacity(BufferSize());
 			}