duckdb 0.10.2-dev0.0 → 0.10.2-dev5.0

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp

@@ -28,7 +28,7 @@ namespace duckdb {
 template <class T>
 struct AlpRDVectorState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	void Reset() {
 		index = 0;
@@ -70,7 +70,7 @@ public:
 template <class T>
 struct AlpRDScanState : public SegmentScanState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	explicit AlpRDScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
@@ -220,7 +220,7 @@ unique_ptr<SegmentScanState> AlpRDInitScan(ColumnSegment &segment) {
 template <class T>
 void AlpRDScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                       idx_t result_offset) {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	auto &scan_state = (AlpRDScanState<T> &)*state.scan_state;
 
 	// Get the pointer to the result values

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/flag_buffer.hpp

@@ -58,7 +58,7 @@ public:
 #endif
 
 	uint64_t BitsWritten() const {
-		return counter * 2;
+		return counter * 2ULL;
 	}
 
 	void Insert(ChimpConstants::Flags value) {

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/leading_zero_buffer.hpp

@@ -77,7 +77,7 @@ public:
 	}
 
 	uint64_t BitsWritten() const {
-		return counter * 3;
+		return counter * 3ULL;
 	}
 
 	// Reset the counter, but don't replace the buffer
@@ -98,7 +98,7 @@ public:
 #endif
 
 	inline uint64_t BlockIndex() const {
-		return ((counter >> 3) * (LEADING_ZERO_BLOCK_BIT_SIZE / 8));
+		return ((counter >> 3ULL) * (LEADING_ZERO_BLOCK_BIT_SIZE / 8ULL));
 	}
 
 	void FlushBuffer() {
@@ -111,7 +111,7 @@ public:
 		// Verify that the bits are copied correctly
 
 		uint32_t temp_value = 0;
-		memcpy((uint8_t *)&temp_value, (void *)(buffer + buffer_idx), 3);
+		memcpy(reinterpret_cast<uint8_t *>(&temp_value), (void *)(buffer + buffer_idx), 3);
 		for (idx_t i = 0; i < flags.size(); i++) {
 			D_ASSERT(flags[i] == ExtractValue(temp_value, i));
 		}

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp.hpp

@@ -25,12 +25,12 @@ struct ChimpType {};
 
 template <>
 struct ChimpType<double> {
-	typedef uint64_t type;
+	using TYPE = uint64_t;
 };
 
 template <>
 struct ChimpType<float> {
-	typedef uint32_t type;
+	using TYPE = uint32_t;
 };
 
 class ChimpPrimitives {
@@ -46,7 +46,7 @@ public:
 template <class T, bool EMPTY>
 struct ChimpState {
 public:
-	using CHIMP_TYPE = typename ChimpType<T>::type;
+	using CHIMP_TYPE = typename ChimpType<T>::TYPE;
 
 	ChimpState() : chimp() {
 	}

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_analyze.hpp

@@ -33,7 +33,6 @@ bool ChimpAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 template <class T>
 idx_t ChimpFinalAnalyze(AnalyzeState &state) {
 	throw InternalException("Chimp has been deprecated, can no longer be used to compress data");
-	return DConstants::INVALID_INDEX;
 }
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_fetch.hpp

@@ -26,7 +26,7 @@ namespace duckdb {
 
 template <class T>
 void ChimpFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using INTERNAL_TYPE = typename ChimpType<T>::type;
+	using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
 
 	ChimpScanState<T> scan_state(segment);
 	scan_state.Skip(segment, row_id);

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp

@@ -135,7 +135,7 @@ private:
 template <class T>
 struct ChimpScanState : public SegmentScanState {
 public:
-	using CHIMP_TYPE = typename ChimpType<T>::type;
+	using CHIMP_TYPE = typename ChimpType<T>::TYPE;
 
 	explicit ChimpScanState(ColumnSegment &segment) : segment(segment), segment_count(segment.count) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
@@ -203,7 +203,7 @@ public:
 		D_ASSERT(leading_zero_block_count <= ChimpPrimitives::CHIMP_SEQUENCE_SIZE / 8);
 
 		// Load the leading zero block count
-		metadata_ptr -= 3 * leading_zero_block_count;
+		metadata_ptr -= 3ULL * leading_zero_block_count;
 		const auto leading_zero_block_ptr = metadata_ptr;
 
 		// Figure out how many flags there are
@@ -240,7 +240,7 @@ public:
 	//! Skip the next 'skip_count' values, we don't store the values
 	// TODO: use the metadata to determine if we can skip a group
 	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		using INTERNAL_TYPE = typename ChimpType<T>::type;
+		using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
 		INTERNAL_TYPE buffer[ChimpPrimitives::CHIMP_SEQUENCE_SIZE];
 
 		while (skip_count) {
@@ -263,7 +263,7 @@ unique_ptr<SegmentScanState> ChimpInitScan(ColumnSegment &segment) {
 template <class T>
 void ChimpScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                       idx_t result_offset) {
-	using INTERNAL_TYPE = typename ChimpType<T>::type;
+	using INTERNAL_TYPE = typename ChimpType<T>::TYPE;
 	auto &scan_state = state.scan_state->Cast<ChimpScanState<T>>();
 
 	T *result_data = FlatVector::GetData<T>(result);

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas.hpp

@@ -25,20 +25,20 @@ struct FloatingToExact {};
 
 template <>
 struct FloatingToExact<double> {
-	typedef uint64_t type;
+	using TYPE = uint64_t;
 };
 
 template <>
 struct FloatingToExact<float> {
-	typedef uint32_t type;
+	using TYPE = uint32_t;
 };
 
 template <class T, bool EMPTY>
 struct PatasState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
-	PatasState(void *state_p = nullptr) : data_ptr(state_p), patas_state() {
+	explicit PatasState(void *state_p = nullptr) : data_ptr(state_p), patas_state() {
 	}
 	//! The Compress/Analyze State
 	void *data_ptr;

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_analyze.hpp

@@ -33,7 +33,6 @@ bool PatasAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 template <class T>
 idx_t PatasFinalAnalyze(AnalyzeState &state) {
 	throw InternalException("Patas has been deprecated, can no longer be used to compress data");
-	return DConstants::INVALID_INDEX;
 }
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_fetch.hpp

@@ -26,7 +26,7 @@ namespace duckdb {
 
 template <class T>
 void PatasFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	PatasScanState<T> scan_state(segment);
 	scan_state.Skip(segment, row_id);

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp

@@ -87,7 +87,7 @@ private:
 template <class T>
 struct PatasScanState : public SegmentScanState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	explicit PatasScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
@@ -174,7 +174,7 @@ public:
 public:
 	//! Skip the next 'skip_count' values, we don't store the values
 	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		using EXACT_TYPE = typename FloatingToExact<T>::type;
+		using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 		if (total_value_count != 0 && !GroupFinished()) {
 			// Finish skipping the current group
@@ -210,7 +210,7 @@ unique_ptr<SegmentScanState> PatasInitScan(ColumnSegment &segment) {
 template <class T>
 void PatasScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                       idx_t result_offset) {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	auto &scan_state = (PatasScanState<T> &)*state.scan_state;
 
 	// Get the pointer to the result values

package/src/duckdb/src/include/duckdb/storage/data_pointer.hpp

@@ -34,7 +34,7 @@ struct ColumnSegmentState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -160,7 +160,7 @@ public:
 
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };

package/src/duckdb/src/include/duckdb/storage/magic_bytes.hpp

@@ -22,7 +22,7 @@ enum class DataFileType : uint8_t {
 
 class MagicBytes {
 public:
-	static DataFileType CheckMagicBytes(FileSystem *fs, const string &path);
+	static DataFileType CheckMagicBytes(FileSystem &fs, const string &path);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/object_cache.hpp

@@ -46,8 +46,8 @@ public:
 		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
 	}
 
-	template <class T, class... Args>
-	shared_ptr<T> GetOrCreate(const string &key, Args &&...args) {
+	template <class T, class... ARGS>
+	shared_ptr<T> GetOrCreate(const string &key, ARGS &&... args) {
 		lock_guard<mutex> glock(lock);
 
 		auto entry = cache.find(key);
@@ -65,7 +65,7 @@ public:
 
 	void Put(string key, shared_ptr<ObjectCacheEntry> value) {
 		lock_guard<mutex> glock(lock);
-		cache[key] = std::move(value);
+		cache.insert(make_pair(std::move(key), std::move(value)));
 	}
 
 	void Delete(const string &key) {

package/src/duckdb/src/include/duckdb/storage/optimistic_data_writer.hpp

@@ -15,7 +15,7 @@ class PartialBlockManager;
 
 class OptimisticDataWriter {
 public:
-	OptimisticDataWriter(DataTable &table);
+	explicit OptimisticDataWriter(DataTable &table);
 	OptimisticDataWriter(DataTable &table, OptimisticDataWriter &parent);
 	~OptimisticDataWriter();
 

package/src/duckdb/src/include/duckdb/storage/partial_block_manager.hpp

@@ -110,7 +110,7 @@ public:
 	PartialBlockAllocation GetBlockAllocation(uint32_t segment_size);
 
 	//! Register a partially filled block that is filled with "segment_size" entries
-	void RegisterPartialBlock(PartialBlockAllocation &&allocation);
+	void RegisterPartialBlock(PartialBlockAllocation allocation);
 
 	//! Clear remaining blocks without writing them to disk
 	void ClearBlocks();

package/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp

@@ -36,7 +36,7 @@ class SingleFileBlockManager : public BlockManager {
 public:
 	SingleFileBlockManager(AttachedDatabase &db, string path, StorageManagerOptions options);
 
-	void GetFileFlags(uint8_t &flags, FileLockType &lock, bool create_new);
+	FileOpenFlags GetFileFlags(bool create_new) const;
 	void CreateNewDatabase();
 	void LoadExistingDatabase();
 
@@ -80,6 +80,7 @@ private:
 
 	//! Return the blocks to which we will write the free list and modified blocks
 	vector<MetadataHandle> GetFreeListBlocks();
+	void TrimFreeBlocks();
 
 private:
 	AttachedDatabase &db;
@@ -93,6 +94,8 @@ private:
 	FileBuffer header_buffer;
 	//! The list of free blocks that can be written to currently
 	set<block_id_t> free_list;
+	//! The list of blocks that were freed since the last checkpoint.
+	set<block_id_t> newly_freed_list;
 	//! The list of multi-use blocks (i.e. blocks that have >1 reference in the file)
 	//! When a multi-use block is marked as modified, the reference count is decreased by 1 instead of directly
 	//! Appending the block to the modified_blocks list

package/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp

@@ -36,7 +36,7 @@ class StandardBufferManager : public BufferManager {
 
 public:
 	StandardBufferManager(DatabaseInstance &db, string temp_directory);
-	virtual ~StandardBufferManager();
+	~StandardBufferManager() override;
 
 public:
 	static unique_ptr<StandardBufferManager> CreateBufferManager(DatabaseInstance &db, string temp_directory);
@@ -46,41 +46,41 @@ public:
 	//! Registers an in-memory buffer that cannot be unloaded until it is destroyed
 	//! This buffer can be small (smaller than BLOCK_SIZE)
 	//! Unpin and pin are nops on this block of memory
-	shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size) final override;
+	shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size) final;
 
-	idx_t GetUsedMemory() const final override;
-	idx_t GetMaxMemory() const final override;
+	idx_t GetUsedMemory() const final;
+	idx_t GetMaxMemory() const final;
 
 	//! Allocate an in-memory buffer with a single pin.
 	//! The allocated memory is released when the buffer handle is destroyed.
 	DUCKDB_API BufferHandle Allocate(MemoryTag tag, idx_t block_size, bool can_destroy = true,
-	                                 shared_ptr<BlockHandle> *block = nullptr) final override;
+	                                 shared_ptr<BlockHandle> *block = nullptr) final;
 
 	//! Reallocate an in-memory buffer that is pinned.
-	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) final override;
+	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) final;
 
-	BufferHandle Pin(shared_ptr<BlockHandle> &handle) final override;
-	void Unpin(shared_ptr<BlockHandle> &handle) final override;
+	BufferHandle Pin(shared_ptr<BlockHandle> &handle) final;
+	void Unpin(shared_ptr<BlockHandle> &handle) final;
 
 	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
 	//! blocks can be evicted
-	void SetLimit(idx_t limit = (idx_t)-1) final override;
+	void SetLimit(idx_t limit = (idx_t)-1) final;
 
 	//! Returns informaton about memory usage
 	vector<MemoryInformation> GetMemoryUsageInfo() const override;
 
 	//! Returns a list of all temporary files
-	vector<TemporaryFileInformation> GetTemporaryFiles() final override;
+	vector<TemporaryFileInformation> GetTemporaryFiles() final;
 
-	const string &GetTemporaryDirectory() final override {
+	const string &GetTemporaryDirectory() const final {
 		return temp_directory;
 	}
 
-	void SetTemporaryDirectory(const string &new_dir) final override;
+	void SetTemporaryDirectory(const string &new_dir) final;
 
-	DUCKDB_API Allocator &GetBufferAllocator() final override;
+	DUCKDB_API Allocator &GetBufferAllocator() final;
 
-	DatabaseInstance &GetDatabase() final override {
+	DatabaseInstance &GetDatabase() {
 		return db;
 	}
 
@@ -88,9 +88,9 @@ public:
 	unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
 	                                              FileBufferType type = FileBufferType::MANAGED_BUFFER) override;
 
-	DUCKDB_API void ReserveMemory(idx_t size) final override;
-	DUCKDB_API void FreeReservedMemory(idx_t size) final override;
-	bool HasTemporaryDirectory() const final override;
+	DUCKDB_API void ReserveMemory(idx_t size) final;
+	DUCKDB_API void FreeReservedMemory(idx_t size) final;
+	bool HasTemporaryDirectory() const final;
 
 protected:
 	//! Helper
@@ -106,24 +106,24 @@ protected:
 	shared_ptr<BlockHandle> RegisterMemory(MemoryTag tag, idx_t block_size, bool can_destroy);
 
 	//! Garbage collect eviction queue
-	void PurgeQueue() final override;
+	void PurgeQueue() final;
 
-	BufferPool &GetBufferPool() const final override;
-	TemporaryMemoryManager &GetTemporaryMemoryManager() final override;
+	BufferPool &GetBufferPool() const final;
+	TemporaryMemoryManager &GetTemporaryMemoryManager() final;
 
 	//! Write a temporary buffer to disk
-	void WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) final override;
+	void WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) final;
 	//! Read a temporary buffer from disk
 	unique_ptr<FileBuffer> ReadTemporaryBuffer(MemoryTag tag, block_id_t id,
-	                                           unique_ptr<FileBuffer> buffer = nullptr) final override;
+	                                           unique_ptr<FileBuffer> buffer = nullptr) final;
 	//! Get the path of the temporary buffer
 	string GetTemporaryPath(block_id_t id);
 
-	void DeleteTemporaryFile(block_id_t id) final override;
+	void DeleteTemporaryFile(block_id_t id) final;
 
 	void RequireTemporaryDirectory();
 
-	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle) final override;
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle) final;
 
 	const char *InMemoryWarning();
 

package/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats_union.hpp

@@ -27,9 +27,9 @@ struct NumericValueUnion {
 		uint64_t ubigint;
 		hugeint_t hugeint;
 		uhugeint_t uhugeint;
-		float float_;
-		double double_;
-	} value_;
+		float float_;   // NOLINT
+		double double_; // NOLINT
+	} value_;           // NOLINT
 
 	template <class T>
 	T &GetReferenceUnsafe();

package/src/duckdb/src/include/duckdb/storage/statistics/segment_statistics.hpp

@@ -16,8 +16,8 @@ namespace duckdb {
 
 class SegmentStatistics {
 public:
-	SegmentStatistics(LogicalType type);
-	SegmentStatistics(BaseStatistics statistics);
+	explicit SegmentStatistics(LogicalType type);
+	explicit SegmentStatistics(BaseStatistics statistics);
 
 	//! Type-specific statistics of the segment
 	BaseStatistics statistics;

package/src/duckdb/src/include/duckdb/storage/storage_info.hpp

@@ -66,10 +66,10 @@ struct MainHeader {
 	static void CheckMagicBytes(FileHandle &handle);
 
 	string LibraryGitDesc() {
-		return string((char *)library_git_desc, 0, MAX_VERSION_SIZE);
+		return string(char_ptr_cast(library_git_desc), 0, MAX_VERSION_SIZE);
 	}
 	string LibraryGitHash() {
-		return string((char *)library_git_hash, 0, MAX_VERSION_SIZE);
+		return string(char_ptr_cast(library_git_hash), 0, MAX_VERSION_SIZE);
 	}
 
 	void Write(WriteStream &ser);

package/src/duckdb/src/include/duckdb/storage/storage_manager.hpp

@@ -46,7 +46,7 @@ public:
 	static StorageManager &Get(Catalog &catalog);
 
 	//! Initialize a database or load an existing database from the given path
-	void Initialize();
+	void Initialize(optional_ptr<ClientContext> context);
 
 	DatabaseInstance &GetDatabase();
 	AttachedDatabase &GetAttached() {
@@ -73,7 +73,7 @@ public:
 	virtual shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) = 0;
 
 protected:
-	virtual void LoadDatabase() = 0;
+	virtual void LoadDatabase(optional_ptr<ClientContext> context = nullptr) = 0;
 
 protected:
 	//! The database this storage manager belongs to
@@ -96,7 +96,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -121,6 +121,6 @@ public:
 	shared_ptr<TableIOManager> GetTableIOManager(BoundCreateTableInfo *info) override;
 
 protected:
-	void LoadDatabase() override;
+	void LoadDatabase(optional_ptr<ClientContext> context = nullptr) override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -61,6 +61,7 @@ public:
 
 	static unique_ptr<CompressionAppendState> StringInitAppend(ColumnSegment &segment) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
+		// This block was initialized in StringInitSegment
 		auto handle = buffer_manager.Pin(segment.block);
 		return make_uniq<CompressionAppendState>(std::move(handle));
 	}
@@ -82,9 +83,9 @@ public:
 		D_ASSERT(segment.GetBlockOffset() == 0);
 		auto handle_ptr = handle.Ptr();
 		auto source_data = UnifiedVectorFormat::GetData<string_t>(data);
-		auto result_data = (int32_t *)(handle_ptr + DICTIONARY_HEADER_SIZE);
-		uint32_t *dictionary_size = (uint32_t *)handle_ptr;
-		uint32_t *dictionary_end = (uint32_t *)(handle_ptr + sizeof(uint32_t));
+		auto result_data = reinterpret_cast<int32_t *>(handle_ptr + DICTIONARY_HEADER_SIZE);
+		auto dictionary_size = reinterpret_cast<uint32_t *>(handle_ptr);
+		auto dictionary_end = reinterpret_cast<uint32_t *>(handle_ptr + sizeof(uint32_t));
 
 		idx_t remaining_space = RemainingSpace(segment, handle);
 		auto base_count = segment.count.load();
@@ -136,18 +137,19 @@ public:
 			if (DUCKDB_UNLIKELY(use_overflow_block)) {
 				// write to overflow blocks
 				block_id_t block;
-				int32_t offset;
+				int32_t current_offset;
 				// write the string into the current string block
-				WriteString(segment, source_data[source_idx], block, offset);
+				WriteString(segment, source_data[source_idx], block, current_offset);
 				*dictionary_size += BIG_STRING_MARKER_SIZE;
 				remaining_space -= BIG_STRING_MARKER_SIZE;
 				auto dict_pos = end - *dictionary_size;
 
 				// write a big string marker into the dictionary
-				WriteStringMarker(dict_pos, block, offset);
+				WriteStringMarker(dict_pos, block, current_offset);
 
 				// place the dictionary offset into the set of vectors
 				// note: for overflow strings we write negative value
+				D_ASSERT(*dictionary_size <= int32_t(Storage::BLOCK_SIZE));
 				result_data[target_idx] = -(*dictionary_size);
 			} else {
 				// string fits in block, append to dictionary and increment dictionary position
@@ -159,6 +161,7 @@ public:
 				memcpy(dict_pos, source_data[source_idx].GetData(), string_length);
 
 				// place the dictionary offset into the set of vectors
+				D_ASSERT(*dictionary_size <= int32_t(Storage::BLOCK_SIZE));
 				result_data[target_idx] = *dictionary_size;
 			}
 			D_ASSERT(RemainingSpace(segment, handle) <= Storage::BLOCK_SIZE);

package/src/duckdb/src/include/duckdb/storage/table/append_state.hpp

@@ -36,7 +36,7 @@ struct ColumnAppendState {
 };
 
 struct RowGroupAppendState {
-	RowGroupAppendState(TableAppendState &parent_p) : parent(parent_p) {
+	explicit RowGroupAppendState(TableAppendState &parent_p) : parent(parent_p) {
 	}
 
 	//! The parent append state

package/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp

@@ -17,7 +17,7 @@ class RowGroup;
 struct SelectionVector;
 class Transaction;
 struct TransactionData;
-
+struct DeleteInfo;
 class Serializer;
 class Deserializer;
 
@@ -132,7 +132,7 @@ public:
 	//! Note that "rows" is written to to reflect the row ids that were actually deleted
 	//! i.e. after calling this function, rows will hold [0..actual_delete_count] row ids of the actually deleted tuples
 	idx_t Delete(transaction_t transaction_id, row_t rows[], idx_t count);
-	void CommitDelete(transaction_t commit_id, row_t rows[], idx_t count);
+	void CommitDelete(transaction_t commit_id, const DeleteInfo &info);
 
 	bool HasDeletes() const override;
 

package/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp

@@ -51,7 +51,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };

package/src/duckdb/src/include/duckdb/storage/table/column_data.hpp

@@ -75,6 +75,8 @@ public:
 	virtual void SetStart(idx_t new_start);
 	//! The root type of the column
 	const LogicalType &RootType() const;
+	//! Whether or not the column has any updates
+	virtual bool HasUpdates() const;
 
 	//! Initialize a scan of the column
 	virtual void InitializeScan(ColumnScanState &state);
@@ -159,11 +161,18 @@ protected:
 	template <bool SCAN_COMMITTED, bool ALLOW_UPDATES>
 	idx_t ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result);
 
+	void ClearUpdates();
+	void FetchUpdates(TransactionData transaction, idx_t vector_index, Vector &result, idx_t scan_count,
+	                  bool allow_updates, bool scan_committed);
+	void FetchUpdateRow(TransactionData transaction, row_t row_id, Vector &result, idx_t result_idx);
+	void UpdateInternal(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
+	                    idx_t update_count, Vector &base_vector);
+
 protected:
 	//! The segments holding the data of this column segment
 	ColumnSegmentTree data;
 	//! The lock for the updates
-	mutex update_lock;
+	mutable mutex update_lock;
 	//! The updates for this column segment
 	unique_ptr<UpdateSegment> updates;
 	//! The stats of the root segment

package/src/duckdb/src/include/duckdb/storage/table/data_table_info.hpp

@@ -19,8 +19,9 @@ class TableIOManager;
 struct DataTableInfo {
 	DataTableInfo(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_manager_p, string schema, string table);
 
-	//! Initialize any unknown indexes whose types might now be present after an extension load
-	void InitializeIndexes(ClientContext &context);
+	//! Initialize any unknown indexes whose types might now be present after an extension load, optionally throwing an
+	//! exception if an index can't be initialized
+	void InitializeIndexes(ClientContext &context, bool throw_on_failure = false);
 
 	//! The database instance of the table
 	AttachedDatabase &db;

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -54,7 +54,7 @@ public:
 
 public:
 	RowGroup(RowGroupCollection &collection, idx_t start, idx_t count);
-	RowGroup(RowGroupCollection &collection, RowGroupPointer &&pointer);
+	RowGroup(RowGroupCollection &collection, RowGroupPointer pointer);
 	~RowGroup();
 
 private:

package/src/duckdb/src/include/duckdb/storage/table/row_group_segment_tree.hpp

@@ -18,7 +18,7 @@ class MetadataReader;
 
 class RowGroupSegmentTree : public SegmentTree<RowGroup, true> {
 public:
-	RowGroupSegmentTree(RowGroupCollection &collection);
+	explicit RowGroupSegmentTree(RowGroupCollection &collection);
 	~RowGroupSegmentTree() override;
 
 	void Initialize(PersistentTableData &data);