duckdb 0.3.2-dev524.0 → 0.3.2-dev528.0

package/package.json

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

package/src/duckdb.cpp

@@ -27298,11 +27298,9 @@ struct RowOperations {
 	//! Swizzles the base pointer of each row to offset within heap block
 	static void SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
 	                               const idx_t count);
-	//! Swizzles the base offset of each row back to a pointer
-	static void UnswizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-	                                 const idx_t count);
-	//! Unswizzles offsets back to pointers to blobs
-	static void UnswizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count);
+	//! Unswizzles all offsets back to pointers
+	static void UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
+	                              const data_ptr_t base_heap_ptr, const idx_t count);
 };
 
 } // namespace duckdb
@@ -27538,46 +27536,44 @@ namespace duckdb {
 
 void RowOperations::SwizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count) {
 	const idx_t row_width = layout.GetRowWidth();
-	const idx_t heap_pointer_offset = layout.GetHeapPointerOffset();
-	// Swizzle the blob columns one by one
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		auto physical_type = layout.GetTypes()[col_idx].InternalType();
-		if (TypeIsConstantSize(physical_type)) {
-			continue;
+	data_ptr_t heap_row_ptrs[STANDARD_VECTOR_SIZE];
+	idx_t done = 0;
+	while (done != count) {
+		const idx_t next = MinValue<idx_t>(count - done, STANDARD_VECTOR_SIZE);
+		const data_ptr_t row_ptr = base_row_ptr + done * row_width;
+		// Load heap row pointers
+		data_ptr_t heap_ptr_ptr = row_ptr + layout.GetHeapPointerOffset();
+		for (idx_t i = 0; i < next; i++) {
+			heap_row_ptrs[i] = Load<data_ptr_t>(heap_ptr_ptr);
+			heap_ptr_ptr += row_width;
 		}
-		data_ptr_t row_ptr = base_row_ptr;
-		const idx_t &col_offset = layout.GetOffsets()[col_idx];
-		if (physical_type == PhysicalType::VARCHAR) {
-			// Replace the pointer with the computed offset (if non-inlined)
-			const idx_t string_pointer_offset = sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-			for (idx_t i = 0; i < count; i++) {
-				const string_t str = Load<string_t>(row_ptr + col_offset);
-				if (!str.IsInlined()) {
-					// Load the pointer to the start of the row in the heap
-					data_ptr_t heap_row_ptr = Load<data_ptr_t>(row_ptr + heap_pointer_offset);
-					// This is where the pointer that points to the heap is stored in the RowLayout
-					data_ptr_t col_ptr = row_ptr + col_offset + string_pointer_offset;
-					// Load the pointer to the data of this column in the same heap row
-					data_ptr_t heap_col_ptr = Load<data_ptr_t>(col_ptr);
-					// Overwrite the column data pointer with the within-row offset (pointer arithmetic)
-					Store<idx_t>(heap_col_ptr - heap_row_ptr, col_ptr);
-				}
-				row_ptr += row_width;
+		// Loop through the blob columns
+		for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
+			auto physical_type = layout.GetTypes()[col_idx].InternalType();
+			if (TypeIsConstantSize(physical_type)) {
+				continue;
 			}
-		} else {
-			// Replace the pointer with the computed offset
-			for (idx_t i = 0; i < count; i++) {
-				// Load the pointer to the start of the row in the heap
-				data_ptr_t heap_row_ptr = Load<data_ptr_t>(row_ptr + heap_pointer_offset);
-				// This is where the pointer that points to the heap is stored in the RowLayout
-				data_ptr_t col_ptr = row_ptr + col_offset;
-				// Load the pointer to the data of this column in the same heap row
-				data_ptr_t heap_col_ptr = Load<data_ptr_t>(col_ptr);
-				// Overwrite the column data pointer with the within-row offset (pointer arithmetic)
-				Store<idx_t>(heap_col_ptr - heap_row_ptr, col_ptr);
-				row_ptr += row_width;
+			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
+			if (physical_type == PhysicalType::VARCHAR) {
+				data_ptr_t string_ptr = col_ptr + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+				for (idx_t i = 0; i < next; i++) {
+					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
+						// Overwrite the string pointer with the within-row offset (if not inlined)
+						Store<idx_t>(Load<data_ptr_t>(string_ptr) - heap_row_ptrs[i], string_ptr);
+					}
+					col_ptr += row_width;
+					string_ptr += row_width;
+				}
+			} else {
+				// Non-varchar blob columns
+				for (idx_t i = 0; i < next; i++) {
+					// Overwrite the column data pointer with the within-row offset
+					Store<idx_t>(Load<data_ptr_t>(col_ptr) - heap_row_ptrs[i], col_ptr);
+					col_ptr += row_width;
+				}
 			}
 		}
+		done += next;
 	}
 }
 
@@ -27593,59 +27589,48 @@ void RowOperations::SwizzleHeapPointer(const RowLayout &layout, data_ptr_t row_p
 	}
 }
 
-void RowOperations::UnswizzleHeapPointer(const RowLayout &layout, data_ptr_t row_ptr, const data_ptr_t heap_base_ptr,
-                                         const idx_t count) {
-	const idx_t row_width = layout.GetRowWidth();
-	row_ptr += layout.GetHeapPointerOffset();
-	for (idx_t i = 0; i < count; i++) {
-		idx_t heap_row_offset = Load<idx_t>(row_ptr);
-		Store<data_ptr_t>(heap_base_ptr + heap_row_offset, row_ptr);
-		row_ptr += row_width;
-	}
-}
-
-void RowOperations::UnswizzleColumns(const RowLayout &layout, const data_ptr_t base_row_ptr, const idx_t count) {
+void RowOperations::UnswizzlePointers(const RowLayout &layout, const data_ptr_t base_row_ptr,
+                                      const data_ptr_t base_heap_ptr, const idx_t count) {
 	const idx_t row_width = layout.GetRowWidth();
-	const idx_t heap_pointer_offset = layout.GetHeapPointerOffset();
-	// Unswizzle the columns one by one
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		auto physical_type = layout.GetTypes()[col_idx].InternalType();
-		if (TypeIsConstantSize(physical_type)) {
-			continue;
-		}
-		const idx_t col_offset = layout.GetOffsets()[col_idx];
-		data_ptr_t row_ptr = base_row_ptr;
-		if (physical_type == PhysicalType::VARCHAR) {
-			// Replace offset with the pointer (if non-inlined)
-			const idx_t string_pointer_offset = sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-			for (idx_t i = 0; i < count; i++) {
-				const string_t str = Load<string_t>(row_ptr + col_offset);
-				if (!str.IsInlined()) {
-					// Load the pointer to the start of the row in the heap
-					data_ptr_t heap_row_ptr = Load<data_ptr_t>(row_ptr + heap_pointer_offset);
-					// This is where the pointer that points to the heap is stored in the RowLayout
-					data_ptr_t col_ptr = row_ptr + col_offset + string_pointer_offset;
-					// Load the offset to the data of this column in the same heap row
-					idx_t heap_col_offset = Load<idx_t>(col_ptr);
+	data_ptr_t heap_row_ptrs[STANDARD_VECTOR_SIZE];
+	idx_t done = 0;
+	while (done != count) {
+		const idx_t next = MinValue<idx_t>(count - done, STANDARD_VECTOR_SIZE);
+		const data_ptr_t row_ptr = base_row_ptr + done * row_width;
+		// Restore heap row pointers
+		data_ptr_t heap_ptr_ptr = row_ptr + layout.GetHeapPointerOffset();
+		for (idx_t i = 0; i < next; i++) {
+			heap_row_ptrs[i] = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
+			Store<data_ptr_t>(heap_row_ptrs[i], heap_ptr_ptr);
+			heap_ptr_ptr += row_width;
+		}
+		// Loop through the blob columns
+		for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
+			auto physical_type = layout.GetTypes()[col_idx].InternalType();
+			if (TypeIsConstantSize(physical_type)) {
+				continue;
+			}
+			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
+			if (physical_type == PhysicalType::VARCHAR) {
+				data_ptr_t string_ptr = col_ptr + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+				for (idx_t i = 0; i < next; i++) {
+					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
+						// Overwrite the string offset with the pointer (if not inlined)
+						Store<data_ptr_t>(heap_row_ptrs[i] + Load<idx_t>(string_ptr), string_ptr);
+					}
+					col_ptr += row_width;
+					string_ptr += row_width;
+				}
+			} else {
+				// Non-varchar blob columns
+				for (idx_t i = 0; i < next; i++) {
 					// Overwrite the column data offset with the pointer
-					Store<data_ptr_t>(heap_row_ptr + heap_col_offset, col_ptr);
+					Store<data_ptr_t>(heap_row_ptrs[i] + Load<idx_t>(col_ptr), col_ptr);
+					col_ptr += row_width;
 				}
-				row_ptr += row_width;
-			}
-		} else {
-			// Replace the offset with the pointer
-			for (idx_t i = 0; i < count; i++) {
-				// Load the pointer to the start of the row in the heap
-				data_ptr_t heap_row_ptr = Load<data_ptr_t>(row_ptr + heap_pointer_offset);
-				// This is where the pointer that points to the heap is stored in the RowLayout
-				data_ptr_t col_ptr = row_ptr + col_offset;
-				// Load the offset to the data of this column in the same heap row
-				idx_t heap_col_offset = Load<idx_t>(col_ptr);
-				// Overwrite the column data offset with the pointer
-				Store<data_ptr_t>(heap_row_ptr + heap_col_offset, col_ptr);
-				row_ptr += row_width;
 			}
 		}
+		done += next;
 	}
 }
 
@@ -32716,8 +32701,7 @@ void SortedData::Unswizzle() {
 		auto &heap_block = heap_blocks[i];
 		auto data_handle_p = buffer_manager.Pin(data_block.block);
 		auto heap_handle_p = buffer_manager.Pin(heap_block.block);
-		RowOperations::UnswizzleHeapPointer(layout, data_handle_p->Ptr(), heap_handle_p->Ptr(), data_block.count);
-		RowOperations::UnswizzleColumns(layout, data_handle_p->Ptr(), data_block.count);
+		RowOperations::UnswizzlePointers(layout, data_handle_p->Ptr(), heap_handle_p->Ptr(), data_block.count);
 		state.heap_blocks.push_back(move(heap_block));
 		state.pinned_blocks.push_back(move(heap_handle_p));
 	}
@@ -32963,9 +32947,7 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 		}
 		// Unswizzle the offsets back to pointers (if needed)
 		if (!sorted_data.layout.AllConstant() && global_sort_state.external) {
-			RowOperations::UnswizzleHeapPointer(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(),
-			                                    next);
-			RowOperations::UnswizzleColumns(sorted_data.layout, data_ptr, next);
+			RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(), next);
 		}
 		// Update state indices
 		read_state.entry_idx += next;

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "469e6a48f"
-#define DUCKDB_VERSION "0.3.2-dev524"
+#define DUCKDB_SOURCE_ID "0546552f6"
+#define DUCKDB_VERSION "0.3.2-dev528"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //