duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -33,16 +33,18 @@ struct ARTFlags {
 
 class ART : public Index {
 public:
+	// Index type name for the ART
+	static constexpr const char *TYPE_NAME = "ART";
 	//! FixedSizeAllocator count of the ART
 	static constexpr uint8_t ALLOCATOR_COUNT = 6;
 
 public:
 	//! Constructs an ART
-	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
-	    const vector<unique_ptr<Expression>> &unbound_expressions, const IndexConstraintType constraint_type,
+	ART(const string &name, const IndexConstraintType index_constraint_type, const vector<column_t> &column_ids,
+	    TableIOManager &table_io_manager, const vector<unique_ptr<Expression>> &unbound_expressions,
 	    AttachedDatabase &db,
 	    const shared_ptr<array<unique_ptr<FixedSizeAllocator>, ALLOCATOR_COUNT>> &allocators_ptr = nullptr,
-	    const BlockPointer &block = BlockPointer());
+	    const IndexStorageInfo &info = IndexStorageInfo());
 
 	//! Root of the tree
 	Node tree = Node();
@@ -51,22 +53,25 @@ public:
 	//! True, if the ART owns its data
 	bool owns_data;
 
-public:
-	//! Initialize a single predicate scan on the index with the given expression and column IDs
-	unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
-	                                                         const ExpressionType expression_type) override;
-	//! Initialize a two predicate scan on the index with the given expression and column IDs
-	unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction &transaction, const Value &low_value,
-	                                                       const ExpressionType low_expression_type,
-	                                                       const Value &high_value,
-	                                                       const ExpressionType high_expression_type) override;
+	//! Try to initialize a scan on the index with the given expression and filter
+	unique_ptr<IndexScanState> TryInitializeScan(const Transaction &transaction, const Expression &index_expr,
+	                                             const Expression &filter_expr);
+
 	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
 	//! and false otherwise
-	bool Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state, const idx_t max_count,
-	          vector<row_t> &result_ids) override;
+	bool Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state, idx_t max_count,
+	          vector<row_t> &result_ids);
+
+public:
+	//! Create a index instance of this type
+	static unique_ptr<Index> Create(CreateIndexInput &input) {
+		auto art = make_uniq<ART>(input.name, input.constraint_type, input.column_ids, input.table_io_manager,
+		                          input.unbound_expressions, input.db, nullptr, input.storage_info);
+		return std::move(art);
+	}
 
 	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
-	PreservedError Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
+	ErrorData Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Verify that data can be appended to the index without a constraint violation
 	void VerifyAppend(DataChunk &chunk) override;
 	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
@@ -76,7 +81,7 @@ public:
 	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
 	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
 	//! Insert a chunk of entries into the index
-	PreservedError Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
+	ErrorData Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
 
 	//! Construct an ART from a vector of sorted keys
 	bool ConstructFromSorted(idx_t count, vector<ARTKey> &keys, Vector &row_identifiers);
@@ -86,8 +91,8 @@ public:
 	//! Search equal values used for joins that do not need to fetch data
 	void SearchEqualJoinNoFetch(ARTKey &key, idx_t &result_size);
 
-	//! Serializes the index and returns the pair of block_id offset positions
-	BlockPointer Serialize(MetadataWriter &writer) override;
+	//! Returns all ART storage information for serialization
+	IndexStorageInfo GetStorageInfo(const bool get_buffers) override;
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
@@ -96,6 +101,9 @@ public:
 	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
 	void Vacuum(IndexLock &state) override;
 
+	//! Returns the in-memory usage of the index. The lock obtained from InitializeLock must be held
+	idx_t GetInMemorySize(IndexLock &index_lock) override;
+
 	//! Generate ART keys for an input chunk
 	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<ARTKey> &keys);
 
@@ -144,8 +152,15 @@ private:
 	//! or only traverses and verifies the index
 	string VerifyAndToStringInternal(const bool only_verify);
 
-	//! Deserialize the allocators of the ART
+	//! Initialize the allocators of the ART
+	void InitAllocators(const IndexStorageInfo &info);
+	//! STABLE STORAGE NOTE: This is for old storage files, to deserialize the allocators of the ART
 	void Deserialize(const BlockPointer &pointer);
+	//! Initializes the serialization of the index by combining the allocator data onto partial blocks
+	void WritePartialBlocks();
+
+	string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
+	                                     DataChunk &input) override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/fixed_size_allocator.hpp

@@ -8,16 +8,15 @@
 
 #pragma once
 
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/map.hpp"
 #include "duckdb/common/types/validity_mask.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/metadata/metadata_manager.hpp"
-#include "duckdb/storage/metadata/metadata_writer.hpp"
 #include "duckdb/execution/index/fixed_size_buffer.hpp"
 #include "duckdb/execution/index/index_pointer.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/constants.hpp"
-#include "duckdb/common/map.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/partial_block_manager.hpp"
 
 namespace duckdb {
 
@@ -30,14 +29,13 @@ public:
 	static constexpr uint8_t VACUUM_THRESHOLD = 10;
 
 public:
+	//! Construct a new fixed-size allocator
 	FixedSizeAllocator(const idx_t segment_size, BlockManager &block_manager);
 
 	//! Block manager of the database instance
 	BlockManager &block_manager;
 	//! Buffer manager of the database instance
 	BufferManager &buffer_manager;
-	//! Metadata manager for (de)serialization
-	MetadataManager &metadata_manager;
 
 public:
 	//! Get a new IndexPointer to a segment, might cause a new buffer allocation
@@ -53,8 +51,8 @@ public:
 	//! Resets the allocator, e.g., during 'DELETE FROM table'
 	void Reset();
 
-	//! Returns the in-memory usage in bytes
-	inline idx_t GetMemoryUsage() const;
+	//! Returns the in-memory size in bytes
+	idx_t GetInMemorySize() const;
 
 	//! Returns the upper bound of the available buffer IDs, i.e., upper_bound > max_buffer_id
 	idx_t GetUpperBoundBufferId() const;
@@ -75,10 +73,16 @@ public:
 	//! Vacuums an IndexPointer
 	IndexPointer VacuumPointer(const IndexPointer ptr);
 
-	//! Serializes all in-memory buffers and the metadata
-	BlockPointer Serialize(PartialBlockManager &partial_block_manager, MetadataWriter &writer);
-	//! Deserializes all metadata
-	void Deserialize(const BlockPointer &block_pointer);
+	//! Returns all FixedSizeAllocator information for serialization
+	FixedSizeAllocatorInfo GetInfo() const;
+	//! Serializes all in-memory buffers
+	void SerializeBuffers(PartialBlockManager &partial_block_manager);
+	//! Sets the allocation sizes and returns data to serialize each buffer
+	vector<IndexBufferInfo> InitSerializationToWAL();
+	//! Initialize a fixed-size allocator from allocator storage information
+	void Init(const FixedSizeAllocatorInfo &info);
+	//! Deserializes all metadata of older storage files
+	void Deserialize(MetadataManager &metadata_manager, const BlockPointer &block_pointer);
 
 private:
 	//! Allocation size of one segment in a buffer

package/src/duckdb/src/include/duckdb/execution/index/fixed_size_buffer.hpp

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/storage/partial_block_manager.hpp"
-#include "duckdb/common/typedefs.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
 #include "duckdb/storage/block_manager.hpp"
@@ -91,6 +90,8 @@ public:
 	void Pin();
 	//! Returns the first free offset in a bitmask
 	uint32_t GetOffset(const idx_t bitmask_count);
+	//! Sets the allocation size, if dirty
+	void SetAllocationSize(const idx_t available_segments, const idx_t segment_size, const idx_t bitmask_offset);
 
 private:
 	//! The buffer handle of the in-memory buffer

package/src/duckdb/src/include/duckdb/execution/index/index_type.hpp

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/index_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+
+namespace duckdb {
+
+class Index;
+enum class IndexConstraintType : uint8_t;
+class Expression;
+class TableIOManager;
+class AttachedDatabase;
+struct IndexStorageInfo;
+
+struct CreateIndexInput {
+	TableIOManager &table_io_manager;
+	AttachedDatabase &db;
+	IndexConstraintType constraint_type;
+	const string &name;
+	const vector<column_t> &column_ids;
+	const vector<unique_ptr<Expression>> &unbound_expressions;
+	const IndexStorageInfo &storage_info;
+	const case_insensitive_map_t<Value> &options;
+
+	CreateIndexInput(TableIOManager &table_io_manager, AttachedDatabase &db, IndexConstraintType constraint_type,
+	                 const string &name, const vector<column_t> &column_ids,
+	                 const vector<unique_ptr<Expression>> &unbound_expressions, const IndexStorageInfo &storage_info,
+	                 const case_insensitive_map_t<Value> &options)
+	    : table_io_manager(table_io_manager), db(db), constraint_type(constraint_type), name(name),
+	      column_ids(column_ids), unbound_expressions(unbound_expressions), storage_info(storage_info),
+	      options(options) {};
+};
+
+typedef unique_ptr<Index> (*index_create_function_t)(CreateIndexInput &input);
+//! A index "type"
+class IndexType {
+public:
+	// The name of the index type
+	string name;
+
+	// Callbacks
+	index_create_function_t create_instance;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/index_type_set.hpp

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/index_type_set.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/index/index_type.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+
+namespace duckdb {
+
+class IndexTypeSet {
+	mutex lock;
+	case_insensitive_map_t<IndexType> functions;
+
+public:
+	IndexTypeSet();
+	DUCKDB_API optional_ptr<IndexType> FindByName(const string &name);
+	DUCKDB_API void RegisterIndexType(const IndexType &index_type);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/unknown_index.hpp

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/unknown_index.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/index.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+
+namespace duckdb {
+
+// An unknown index is an index that has been created by an extension, which has not been loaded yet.
+// It is used as a placeholder for the index until the extension is loaded, at which point the extension will replace
+// all recognized unknown indexes with the correct index type.
+// Calling any function on an unknown index will throw a NotImplementedException
+class UnknownIndex final : public Index {
+private:
+	CreateIndexInfo create_info;
+	IndexStorageInfo storage_info;
+	string GenerateErrorMessage() const;
+
+public:
+	UnknownIndex(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
+	             const vector<column_t> &column_ids, TableIOManager &table_io_manager,
+	             const vector<unique_ptr<Expression>> &unbound_expressions, AttachedDatabase &db,
+	             const CreateIndexInfo &create_info, IndexStorageInfo storage_info);
+
+	const CreateIndexInfo &GetCreateInfo() const {
+		return create_info;
+	}
+	const IndexStorageInfo &GetStorageInfo() const {
+		return storage_info;
+	}
+	const string &GetIndexType() {
+		return create_info.index_type;
+	}
+
+public:
+	bool IsUnknown() override {
+		return true;
+	}
+
+	// Index interface (unused)
+
+	ErrorData Append(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
+	void VerifyAppend(DataChunk &chunk) override;
+	void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) override;
+	void CommitDrop(IndexLock &index_lock) override;
+	void Delete(IndexLock &lock, DataChunk &entries, Vector &row_identifiers) override;
+	ErrorData Insert(IndexLock &lock, DataChunk &data, Vector &row_ids) override;
+	IndexStorageInfo GetStorageInfo(bool get_buffers) override;
+	bool MergeIndexes(IndexLock &state, Index &other_index) override;
+	void Vacuum(IndexLock &state) override;
+	idx_t GetInMemorySize(IndexLock &index_lock) override;
+	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
+	string VerifyAndToString(IndexLock &state, bool only_verify) override;
+	string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
+	                                     DataChunk &input) override;
+};
+
+} // namespace duckdb

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

@@ -77,6 +77,8 @@ public:
 		explicit ScanStructure(JoinHashTable &ht, TupleDataChunkState &key_state);
 		//! Get the next batch of data from the scan structure
 		void Next(DataChunk &keys, DataChunk &left, DataChunk &result);
+		//! Are pointer chains all pointing to NULL?
+		bool PointersExhausted();
 
 	private:
 		//! Next operator for the inner join
@@ -114,7 +116,7 @@ public:
 
 public:
 	JoinHashTable(BufferManager &buffer_manager, const vector<JoinCondition> &conditions,
-	              vector<LogicalType> build_types, JoinType type);
+	              vector<LogicalType> build_types, JoinType type, const vector<idx_t> &output_columns);
 	~JoinHashTable();
 
 	//! Add the given data to the HT
@@ -163,6 +165,8 @@ public:
 	vector<LogicalType> condition_types;
 	//! The types of all conditions
 	vector<LogicalType> build_types;
+	//! Positions of the columns that need to output
+	const vector<idx_t> &output_columns;
 	//! The comparison predicates
 	vector<ExpressionType> predicates;
 	//! Data column layout
@@ -238,13 +242,12 @@ public:
 	//===--------------------------------------------------------------------===//
 	// External Join
 	//===--------------------------------------------------------------------===//
+	static constexpr const idx_t INITIAL_RADIX_BITS = 4;
+
 	struct ProbeSpillLocalAppendState {
 		//! Local partition and append state (if partitioned)
 		PartitionedColumnData *local_partition;
 		PartitionedColumnDataAppendState *local_partition_append_state;
-		//! Local spill and append state (if not partitioned)
-		ColumnDataCollection *local_spill_collection;
-		ColumnDataAppendState *local_spill_append_state;
 	};
 	//! ProbeSpill represents materialized probe-side data that could not be probed during PhysicalHashJoin::Execute
 	//! because the HashTable did not fit in memory. The ProbeSpill is not partitioned if the remaining data can be
@@ -272,32 +275,31 @@ public:
 		mutex lock;
 		ClientContext &context;
 
-		//! Whether the probe data is partitioned
-		bool partitioned;
 		//! The types of the probe DataChunks
 		const vector<LogicalType> &probe_types;
 		//! The column ids
 		vector<column_t> column_ids;
 
-		//! The partitioned probe data (if partitioned) and append states
+		//! The partitioned probe data and append states
 		unique_ptr<PartitionedColumnData> global_partitions;
 		vector<unique_ptr<PartitionedColumnData>> local_partitions;
 		vector<unique_ptr<PartitionedColumnDataAppendState>> local_partition_append_states;
 
-		//! The probe data (if not partitioned) and append states
+		//! The active probe data
 		unique_ptr<ColumnDataCollection> global_spill_collection;
-		vector<unique_ptr<ColumnDataCollection>> local_spill_collections;
-		vector<unique_ptr<ColumnDataAppendState>> local_spill_append_states;
 	};
 
-	//! Whether we are doing an external hash join
-	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;
+	idx_t GetRadixBits() const {
+		return radix_bits;
+	}
+
+	idx_t GetPartitionStart() const {
+		return partition_start;
+	}
+
+	idx_t GetPartitionEnd() const {
+		return partition_end;
+	}
 
 	//! Capacity of the pointer table given the ht count
 	//! (minimum of 1024 to prevent collision chance for small HT's)
@@ -309,23 +311,32 @@ public:
 		return PointerTableCapacity(count) * sizeof(data_ptr_t);
 	}
 
-	//! 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)
-	bool RequiresPartitioning(ClientConfig &config, vector<unique_ptr<JoinHashTable>> &local_hts);
+	//! Get total size of HT if all partitions would be built
+	idx_t GetTotalSize(vector<unique_ptr<JoinHashTable>> &local_hts, idx_t &max_partition_size,
+	                   idx_t &max_partition_count) const;
+	idx_t GetTotalSize(const vector<idx_t> &partition_sizes, const vector<idx_t> &partition_counts,
+	                   idx_t &max_partition_size, idx_t &max_partition_count) const;
+	//! Get the remaining size of the unbuilt partitions
+	idx_t GetRemainingSize();
+	//! Sets number of radix bits according to the max ht size
+	void SetRepartitionRadixBits(vector<unique_ptr<JoinHashTable>> &local_hts, const idx_t max_ht_size,
+	                             const idx_t max_partition_size, const idx_t max_partition_count);
 	//! Partition this HT
-	void Partition(JoinHashTable &global_ht);
+	void Repartition(JoinHashTable &global_ht);
 
 	//! Delete blocks that belong to the current partitioned HT
 	void Reset();
 	//! Build HT for the next partitioned probe round
-	bool PrepareExternalFinalize();
+	bool PrepareExternalFinalize(const idx_t max_ht_size);
 	//! Probe whatever we can, sink the rest into a thread-local HT
 	unique_ptr<ScanStructure> ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, DataChunk &payload,
 	                                        ProbeSpill &probe_spill, ProbeSpillLocalAppendState &spill_state,
 	                                        DataChunk &spill_chunk);
 
 private:
+	//! The current number of radix bits used to partition
+	idx_t radix_bits;
+
 	//! First and last partition of the current probe round
 	idx_t partition_start;
 	idx_t partition_end;