duckdb 0.4.1-dev2193.0 → 0.4.1-dev2195.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.4.1-dev2193.0",
+  "version": "0.4.1-dev2195.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -28552,8 +28552,11 @@ struct RowOperations {
 	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.
+	//! If heap_ptr is not null, then the data is assumed to contain swizzled pointers,
+	//! which will be unswizzled in memory.
 	static void Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-	                   const idx_t count, const idx_t col_offset, const idx_t col_no, const idx_t build_size = 0);
+	                   const idx_t count, const RowLayout &layout, const idx_t col_no, const idx_t build_size = 0,
+	                   data_ptr_t heap_ptr = nullptr);
 	//! Full Scan an entire columns
 	static void FullScanColumn(const RowLayout &layout, Vector &rows, Vector &col, idx_t count, idx_t col_idx);
 
@@ -33373,9 +33376,11 @@ using ValidityBytes = RowLayout::ValidityBytes;
 
 template <class T>
 static void TemplatedGatherLoop(Vector &rows, const SelectionVector &row_sel, Vector &col,
-                                const SelectionVector &col_sel, idx_t count, idx_t col_offset, idx_t col_no,
+                                const SelectionVector &col_sel, idx_t count, const RowLayout &layout, idx_t col_no,
                                 idx_t build_size) {
 	// Precompute mask indexes
+	const auto &offsets = layout.GetOffsets();
+	const auto col_offset = offsets[col_no];
 	idx_t entry_idx;
 	idx_t idx_in_entry;
 	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
@@ -33400,8 +33405,53 @@ static void TemplatedGatherLoop(Vector &rows, const SelectionVector &row_sel, Ve
 	}
 }
 
+static void GatherVarchar(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
+                          idx_t count, const RowLayout &layout, idx_t col_no, idx_t build_size,
+                          data_ptr_t base_heap_ptr) {
+	// Precompute mask indexes
+	const auto &offsets = layout.GetOffsets();
+	const auto col_offset = offsets[col_no];
+	const auto heap_offset = layout.GetHeapOffset();
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
+
+	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
+	auto data = FlatVector::GetData<string_t>(col);
+	auto &col_mask = FlatVector::Validity(col);
+
+	for (idx_t i = 0; i < count; i++) {
+		auto row_idx = row_sel.get_index(i);
+		auto row = ptrs[row_idx];
+		auto col_idx = col_sel.get_index(i);
+		auto col_ptr = row + col_offset;
+		data[col_idx] = Load<string_t>(col_ptr);
+		ValidityBytes row_mask(row);
+		if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
+			if (build_size > STANDARD_VECTOR_SIZE && col_mask.AllValid()) {
+				//! We need to initialize the mask with the vector size.
+				col_mask.Initialize(build_size);
+			}
+			col_mask.SetInvalid(col_idx);
+		} else if (base_heap_ptr && Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
+			//	Not inline, so unswizzle the copied pointer the pointer
+			auto heap_ptr_ptr = row + heap_offset;
+			auto heap_row_ptr = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
+			auto string_ptr = data_ptr_t(data + col_idx) + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+			Store<data_ptr_t>(heap_row_ptr + Load<idx_t>(string_ptr), string_ptr);
+#ifdef DEBUG
+			data[col_idx].Verify();
+#endif
+		}
+	}
+}
+
 static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vector &col,
-                               const SelectionVector &col_sel, idx_t count, idx_t col_offset, idx_t col_no) {
+                               const SelectionVector &col_sel, idx_t count, const RowLayout &layout, idx_t col_no,
+                               data_ptr_t base_heap_ptr) {
+	const auto &offsets = layout.GetOffsets();
+	const auto col_offset = offsets[col_no];
+	const auto heap_offset = layout.GetHeapOffset();
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Build the gather locations
@@ -33409,8 +33459,16 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	auto mask_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
 	for (idx_t i = 0; i < count; i++) {
 		auto row_idx = row_sel.get_index(i);
-		mask_locations[i] = ptrs[row_idx];
-		data_locations[i] = Load<data_ptr_t>(ptrs[row_idx] + col_offset);
+		auto row = ptrs[row_idx];
+		mask_locations[i] = row;
+		auto col_ptr = ptrs[row_idx] + col_offset;
+		if (base_heap_ptr) {
+			auto heap_ptr_ptr = row + heap_offset;
+			auto heap_row_ptr = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
+			data_locations[i] = heap_row_ptr + Load<idx_t>(col_ptr);
+		} else {
+			data_locations[i] = Load<data_ptr_t>(col_ptr);
+		}
 	}
 
 	// Deserialise into the selected locations
@@ -33418,56 +33476,57 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 }
 
 void RowOperations::Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
-                           const idx_t count, const idx_t col_offset, const idx_t col_no, const idx_t build_size) {
+                           const idx_t count, const RowLayout &layout, const idx_t col_no, const idx_t build_size,
+                           data_ptr_t heap_ptr) {
 	D_ASSERT(rows.GetVectorType() == VectorType::FLAT_VECTOR);
 	D_ASSERT(rows.GetType().id() == LogicalTypeId::POINTER); // "Cannot gather from non-pointer type!"
 
 	col.SetVectorType(VectorType::FLAT_VECTOR);
 	switch (col.GetType().InternalType()) {
 	case PhysicalType::UINT8:
-		TemplatedGatherLoop<uint8_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<uint8_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedGatherLoop<uint16_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<uint16_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedGatherLoop<uint32_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<uint32_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedGatherLoop<uint64_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<uint64_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedGatherLoop<int8_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<int8_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::INT16:
-		TemplatedGatherLoop<int16_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<int16_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::INT32:
-		TemplatedGatherLoop<int32_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<int32_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::INT64:
-		TemplatedGatherLoop<int64_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<int64_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::INT128:
-		TemplatedGatherLoop<hugeint_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<hugeint_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedGatherLoop<float>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<float>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedGatherLoop<double>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<double>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedGatherLoop<interval_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		TemplatedGatherLoop<interval_t>(rows, row_sel, col, col_sel, count, layout, col_no, build_size);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedGatherLoop<string_t>(rows, row_sel, col, col_sel, count, col_offset, col_no, build_size);
+		GatherVarchar(rows, row_sel, col, col_sel, count, layout, col_no, build_size, heap_ptr);
 		break;
 	case PhysicalType::LIST:
 	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
-		GatherNestedVector(rows, row_sel, col, col_sel, count, col_offset, col_no);
+		GatherNestedVector(rows, row_sel, col, col_sel, count, layout, col_no, heap_ptr);
 		break;
 	default:
 		throw InternalException("Unimplemented type for RowOperations::Gather");
@@ -34266,11 +34325,11 @@ static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, Selection
 }
 
 template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count, const idx_t col_offset,
+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) {
 	// Gather a dense Vector containing the column values being matched
 	Vector key(col.GetType());
-	RowOperations::Gather(rows, sel, key, *FlatVector::IncrementalSelectionVector(), count, col_offset, col_no);
+	RowOperations::Gather(rows, sel, key, *FlatVector::IncrementalSelectionVector(), count, layout, col_no);
 
 	// Densify the input column
 	Vector sliced(col, sel, count);
@@ -34350,7 +34409,7 @@ static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLay
 	case PhysicalType::LIST:
 	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
-		TemplatedMatchNested<OP, NO_MATCH_SEL>(vec, rows, sel, count, col_offset, col_no, no_match, no_match_count);
+		TemplatedMatchNested<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");
@@ -37854,10 +37913,9 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 	}
 	D_ASSERT(scanned == count);
 	// Deserialize the payload data
-	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
-		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
-		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_idx],
-		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, col_idx);
+	for (idx_t col_no = 0; col_no < sorted_data.layout.ColumnCount(); col_no++) {
+		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_no],
+		                      *FlatVector::IncrementalSelectionVector(), count, sorted_data.layout, col_no);
 	}
 	chunk.SetCardinality(count);
 	chunk.Verify();
@@ -45757,10 +45815,9 @@ void RowDataCollectionScanner::Scan(DataChunk &chunk) {
 	}
 	D_ASSERT(scanned == count);
 	// Deserialize the payload data
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		const auto col_offset = layout.GetOffsets()[col_idx];
-		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_idx],
-		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, col_idx);
+	for (idx_t col_no = 0; col_no < layout.ColumnCount(); col_no++) {
+		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_no],
+		                      *FlatVector::IncrementalSelectionVector(), count, layout, col_no);
 	}
 	chunk.SetCardinality(count);
 	chunk.Verify();
@@ -56961,11 +57018,10 @@ void GroupedAggregateHashTable::FlushMove(FlushMoveState &state, Vector &source_
 
 	state.groups.Reset();
 	state.groups.SetCardinality(count);
-	for (idx_t i = 0; i < state.groups.ColumnCount(); i++) {
-		auto &column = state.groups.data[i];
-		const auto col_offset = layout.GetOffsets()[i];
+	for (idx_t col_no = 0; col_no < state.groups.ColumnCount(); col_no++) {
+		auto &column = state.groups.data[col_no];
 		RowOperations::Gather(source_addresses, *FlatVector::IncrementalSelectionVector(), column,
-		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, i);
+		                      *FlatVector::IncrementalSelectionVector(), count, layout, col_no);
 	}
 
 	FindOrCreateGroups(state.groups, source_hashes, state.group_addresses, state.new_groups_sel);
@@ -57086,11 +57142,10 @@ idx_t GroupedAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) {
 	result.SetCardinality(this_n);
 	// fetch the group columns (ignoring the final hash column
 	const auto group_cols = layout.ColumnCount() - 1;
-	for (idx_t i = 0; i < group_cols; i++) {
-		auto &column = result.data[i];
-		const auto col_offset = layout.GetOffsets()[i];
+	for (idx_t col_no = 0; col_no < group_cols; col_no++) {
+		auto &column = result.data[col_no];
 		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), column,
-		                      *FlatVector::IncrementalSelectionVector(), result.size(), col_offset, i);
+		                      *FlatVector::IncrementalSelectionVector(), result.size(), layout, col_no);
 	}
 
 	RowOperations::FinalizeStates(layout, addresses, result, group_cols);
@@ -61748,8 +61803,7 @@ void ScanStructure::AdvancePointers() {
 
 void ScanStructure::GatherResult(Vector &result, const SelectionVector &result_vector,
                                  const SelectionVector &sel_vector, const idx_t count, const idx_t col_no) {
-	const auto col_offset = ht.layout.GetOffsets()[col_no];
-	RowOperations::Gather(pointers, sel_vector, result, result_vector, count, col_offset, col_no);
+	RowOperations::Gather(pointers, sel_vector, result, result_vector, count, ht.layout, col_no);
 }
 
 void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count,
@@ -62092,8 +62146,7 @@ void JoinHashTable::GatherFullOuter(DataChunk &result, Vector &addresses, idx_t
 		auto &vector = result.data[left_column_count + i];
 		D_ASSERT(vector.GetType() == build_types[i]);
 		const auto col_no = condition_types.size() + i;
-		const auto col_offset = layout.GetOffsets()[col_no];
-		RowOperations::Gather(addresses, sel_vector, vector, sel_vector, found_entries, col_offset, col_no);
+		RowOperations::Gather(addresses, sel_vector, vector, sel_vector, found_entries, layout, col_no);
 	}
 }
 
@@ -69348,8 +69401,7 @@ bool PerfectHashJoinExecutor::FullScanHashTable(JoinHTScanState &state, LogicalT
 		auto &vector = perfect_hash_table[i];
 		D_ASSERT(vector.GetType() == ht.build_types[i]);
 		const auto col_no = ht.condition_types.size() + i;
-		const auto col_offset = ht.layout.GetOffsets()[col_no];
-		RowOperations::Gather(tuples_addresses, sel_tuples, vector, sel_build, keys_count, col_offset, col_no,
+		RowOperations::Gather(tuples_addresses, sel_tuples, vector, sel_build, keys_count, ht.layout, col_no,
 		                      build_size);
 	}
 	return true;
@@ -71518,8 +71570,10 @@ public:
 
 public:
 	// Gather the result values and slice the payload columns to those values.
-	static void SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-	                               const SelectionVector &result, const idx_t result_count, const idx_t left_cols = 0);
+	// Returns a buffer handle to the pinned heap block (if any)
+	static BufferHandle SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
+	                                       const SelectionVector &result, const idx_t result_count,
+	                                       const idx_t left_cols = 0);
 	// Apply a tail condition to the current selection
 	static idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
 	                            const SelectionVector *sel, idx_t count, SelectionVector *true_sel);
@@ -73946,6 +74000,7 @@ public:
 	DataChunk rhs_keys;
 	DataChunk rhs_input;
 	ExpressionExecutor rhs_executor;
+	BufferHandle payload_heap_handle;
 
 public:
 	void ResolveJoinKeys(DataChunk &input) {
@@ -74295,8 +74350,8 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 			for (idx_t c = 0; c < state.lhs_payload.ColumnCount(); ++c) {
 				chunk.data[c].Slice(state.lhs_payload.data[c], left_info.result, result_count);
 			}
-			SliceSortedPayload(chunk, right_info.state, right_info.block_idx, right_info.result, result_count,
-			                   left_cols);
+			state.payload_heap_handle = SliceSortedPayload(chunk, right_info.state, right_info.block_idx,
+			                                               right_info.result, result_count, left_cols);
 			chunk.SetCardinality(result_count);
 
 			auto sel = FlatVector::IncrementalSelectionVector();
@@ -74736,9 +74791,9 @@ idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(const vector<JoinCondition
 	}
 }
 
-void PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-                                           const SelectionVector &result, const idx_t result_count,
-                                           const idx_t left_cols) {
+BufferHandle PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
+                                                   const SelectionVector &result, const idx_t result_count,
+                                                   const idx_t left_cols) {
 	// There should only be one sorted block if they have been sorted
 	D_ASSERT(state.sorted_blocks.size() == 1);
 	SBScanState read_state(state.buffer_manager, state);
@@ -74748,6 +74803,7 @@ void PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &
 	read_state.SetIndices(block_idx, 0);
 	read_state.PinData(sorted_data);
 	const auto data_ptr = read_state.DataPtr(sorted_data);
+	data_ptr_t heap_ptr = nullptr;
 
 	// Set up a batch of pointers to scan data from
 	Vector addresses(LogicalType::POINTER, result_count);
@@ -74773,19 +74829,18 @@ void PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &
 
 	// Unswizzle the offsets back to pointers (if needed)
 	if (!sorted_data.layout.AllConstant() && state.external) {
-		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle.Ptr(),
-		                                 addr_count);
-		sorted_data.data_blocks[read_state.block_idx]->block->SetSwizzling("PhysicalRangeJoin::SliceSortedPayload");
+		heap_ptr = read_state.payload_heap_handle.Ptr();
 	}
 
 	// Deserialize the payload data
 	auto sel = FlatVector::IncrementalSelectionVector();
-	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
-		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
-		auto &col = payload.data[left_cols + col_idx];
-		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, col_offset, col_idx);
+	for (idx_t col_no = 0; col_no < sorted_data.layout.ColumnCount(); col_no++) {
+		auto &col = payload.data[left_cols + col_no];
+		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, sorted_data.layout, col_no, 0, heap_ptr);
 		col.Slice(gsel, result_count);
 	}
+
+	return move(read_state.payload_heap_handle);
 }
 
 idx_t PhysicalRangeJoin::SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "28c9eb44a"
-#define DUCKDB_VERSION "v0.4.1-dev2193"
+#define DUCKDB_SOURCE_ID "0e8ff9fff"
+#define DUCKDB_VERSION "v0.4.1-dev2195"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //