duckdb 0.7.2-dev2233.0 → 0.7.2-dev2320.0

package/src/duckdb/src/storage/table/column_segment.cpp

@@ -20,7 +20,7 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
                                                                  CompressionType compression_type,
                                                                  BaseStatistics statistics) {
 	auto &config = DBConfig::GetConfig(db);
-	CompressionFunction *function;
+	optional_ptr<CompressionFunction> function;
 	shared_ptr<BlockHandle> block;
 	if (block_id == INVALID_BLOCK) {
 		// constant segment, no need to allocate an actual block
@@ -30,7 +30,7 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
 		block = block_manager.RegisterBlock(block_id);
 	}
 	auto segment_size = Storage::BLOCK_SIZE;
-	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::PERSISTENT, start, count, function,
+	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::PERSISTENT, start, count, *function,
 	                                std::move(statistics), block_id, offset, segment_size);
 }
 
@@ -46,7 +46,7 @@ unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance
 	} else {
 		buffer_manager.Allocate(segment_size, false, &block);
 	}
-	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0, function,
+	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0, *function,
 	                                BaseStatistics::CreateEmpty(type), INVALID_BLOCK, 0, segment_size);
 }
 
@@ -55,15 +55,14 @@ unique_ptr<ColumnSegment> ColumnSegment::CreateSegment(ColumnSegment &other, idx
 }
 
 ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, LogicalType type_p,
-                             ColumnSegmentType segment_type, idx_t start, idx_t count, CompressionFunction *function_p,
+                             ColumnSegmentType segment_type, idx_t start, idx_t count, CompressionFunction &function_p,
                              BaseStatistics statistics, block_id_t block_id_p, idx_t offset_p, idx_t segment_size_p)
     : SegmentBase<ColumnSegment>(start, count), db(db), type(std::move(type_p)),
       type_size(GetTypeIdSize(type.InternalType())), segment_type(segment_type), function(function_p),
       stats(std::move(statistics)), block(std::move(block)), block_id(block_id_p), offset(offset_p),
       segment_size(segment_size_p) {
-	D_ASSERT(function);
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
+	if (function.get().init_segment) {
+		segment_state = function.get().init_segment(*this, block_id);
 	}
 }
 
@@ -81,7 +80,7 @@ ColumnSegment::~ColumnSegment() {
 // Scan
 //===--------------------------------------------------------------------===//
 void ColumnSegment::InitializeScan(ColumnScanState &state) {
-	state.scan_state = function->init_scan(*this);
+	state.scan_state = function.get().init_scan(*this);
 }
 
 void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset,
@@ -97,23 +96,23 @@ void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &resul
 }
 
 void ColumnSegment::Skip(ColumnScanState &state) {
-	function->skip(*this, state, state.row_index - state.internal_index);
+	function.get().skip(*this, state, state.row_index - state.internal_index);
 	state.internal_index = state.row_index;
 }
 
 void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result) {
-	function->scan_vector(*this, state, scan_count, result);
+	function.get().scan_vector(*this, state, scan_count, result);
 }
 
 void ColumnSegment::ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset) {
-	function->scan_partial(*this, state, scan_count, result, result_offset);
+	function.get().scan_partial(*this, state, scan_count, result, result_offset);
 }
 
 //===--------------------------------------------------------------------===//
 // Fetch
 //===--------------------------------------------------------------------===//
 void ColumnSegment::FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	function->fetch_row(*this, state, row_id - this->start, result, result_idx);
+	function.get().fetch_row(*this, state, row_id - this->start, result, result_idx);
 }
 
 //===--------------------------------------------------------------------===//
@@ -138,34 +137,34 @@ void ColumnSegment::Resize(idx_t new_size) {
 
 void ColumnSegment::InitializeAppend(ColumnAppendState &state) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->init_append) {
+	if (!function.get().init_append) {
 		throw InternalException("Attempting to init append to a segment without init_append method");
 	}
-	state.append_state = function->init_append(*this);
+	state.append_state = function.get().init_append(*this);
 }
 
 idx_t ColumnSegment::Append(ColumnAppendState &state, UnifiedVectorFormat &append_data, idx_t offset, idx_t count) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->append) {
+	if (!function.get().append) {
 		throw InternalException("Attempting to append to a segment without append method");
 	}
-	return function->append(*state.append_state, *this, stats, append_data, offset, count);
+	return function.get().append(*state.append_state, *this, stats, append_data, offset, count);
 }
 
 idx_t ColumnSegment::FinalizeAppend(ColumnAppendState &state) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->finalize_append) {
+	if (!function.get().finalize_append) {
 		throw InternalException("Attempting to call FinalizeAppend on a segment without a finalize_append method");
 	}
-	auto result_count = function->finalize_append(*this, stats);
+	auto result_count = function.get().finalize_append(*this, stats);
 	state.append_state.reset();
 	return result_count;
 }
 
 void ColumnSegment::RevertAppend(idx_t start_row) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (function->revert_append) {
-		function->revert_append(*this, start_row);
+	if (function.get().revert_append) {
+		function.get().revert_append(*this, start_row);
 	}
 	this->count = start_row - this->start;
 }
@@ -193,8 +192,8 @@ void ColumnSegment::ConvertToPersistent(BlockManager *block_manager, block_id_t
 	}
 
 	segment_state.reset();
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
+	if (function.get().init_segment) {
+		segment_state = function.get().init_segment(*this, block_id);
 	}
 }
 
@@ -207,8 +206,8 @@ void ColumnSegment::MarkAsPersistent(shared_ptr<BlockHandle> block_p, uint32_t o
 	block = std::move(block_p);
 
 	segment_state.reset();
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
+	if (function.get().init_segment) {
+		segment_state = function.get().init_segment(*this, block_id);
 	}
 }
 

package/src/duckdb/src/storage/table/row_group.cpp

@@ -927,14 +927,14 @@ void RowGroup::GetStorageInfo(idx_t row_group_index, TableStorageInfo &result) {
 //===--------------------------------------------------------------------===//
 class VersionDeleteState {
 public:
-	VersionDeleteState(RowGroup &info, TransactionData transaction, DataTable *table, idx_t base_row)
+	VersionDeleteState(RowGroup &info, TransactionData transaction, DataTable &table, idx_t base_row)
 	    : info(info), transaction(transaction), table(table), current_info(nullptr),
 	      current_chunk(DConstants::INVALID_INDEX), count(0), base_row(base_row), delete_count(0) {
 	}
 
 	RowGroup &info;
 	TransactionData transaction;
-	DataTable *table;
+	DataTable &table;
 	ChunkVectorInfo *current_info;
 	idx_t current_chunk;
 	row_t rows[STANDARD_VECTOR_SIZE];
@@ -948,7 +948,7 @@ public:
 	void Flush();
 };
 
-idx_t RowGroup::Delete(TransactionData transaction, DataTable *table, row_t *ids, idx_t count) {
+idx_t RowGroup::Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count) {
 	lock_guard<mutex> lock(row_group_lock);
 	VersionDeleteState del_state(*this, transaction, table, this->start);
 

package/src/duckdb/src/storage/table/row_group_collection.cpp

@@ -456,7 +456,7 @@ void RowGroupCollection::MergeStorage(RowGroupCollection &data) {
 //===--------------------------------------------------------------------===//
 // Delete
 //===--------------------------------------------------------------------===//
-idx_t RowGroupCollection::Delete(TransactionData transaction, DataTable *table, row_t *ids, idx_t count) {
+idx_t RowGroupCollection::Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count) {
 	idx_t delete_count = 0;
 	// delete is in the row groups
 	// we need to figure out for each id to which row group it belongs

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -461,15 +461,15 @@ void UpdateSegment::FetchRow(TransactionData transaction, idx_t row_id, Vector &
 // Rollback update
 //===--------------------------------------------------------------------===//
 template <class T>
-static void RollbackUpdate(UpdateInfo *base_info, UpdateInfo *rollback_info) {
-	auto base_data = (T *)base_info->tuple_data;
-	auto rollback_data = (T *)rollback_info->tuple_data;
+static void RollbackUpdate(UpdateInfo &base_info, UpdateInfo &rollback_info) {
+	auto base_data = (T *)base_info.tuple_data;
+	auto rollback_data = (T *)rollback_info.tuple_data;
 	idx_t base_offset = 0;
-	for (idx_t i = 0; i < rollback_info->N; i++) {
-		auto id = rollback_info->tuples[i];
-		while (base_info->tuples[base_offset] < id) {
+	for (idx_t i = 0; i < rollback_info.N; i++) {
+		auto id = rollback_info.tuples[i];
+		while (base_info.tuples[base_offset] < id) {
 			base_offset++;
-			D_ASSERT(base_offset < base_info->N);
+			D_ASSERT(base_offset < base_info.N);
 		}
 		base_data[base_offset] = rollback_data[i];
 	}
@@ -511,13 +511,13 @@ static UpdateSegment::rollback_update_function_t GetRollbackUpdateFunction(Physi
 	}
 }
 
-void UpdateSegment::RollbackUpdate(UpdateInfo *info) {
+void UpdateSegment::RollbackUpdate(UpdateInfo &info) {
 	// obtain an exclusive lock
 	auto lock_handle = lock.GetExclusiveLock();
 
 	// move the data from the UpdateInfo back into the base info
-	D_ASSERT(root->info[info->vector_index]);
-	rollback_update_function(root->info[info->vector_index]->info.get(), info);
+	D_ASSERT(root->info[info.vector_index]);
+	rollback_update_function(*root->info[info.vector_index]->info, info);
 
 	// clean up the update chain
 	CleanupUpdateInternal(*lock_handle, info);
@@ -526,16 +526,16 @@ void UpdateSegment::RollbackUpdate(UpdateInfo *info) {
 //===--------------------------------------------------------------------===//
 // Cleanup Update
 //===--------------------------------------------------------------------===//
-void UpdateSegment::CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo *info) {
-	D_ASSERT(info->prev);
-	auto prev = info->prev;
-	prev->next = info->next;
+void UpdateSegment::CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo &info) {
+	D_ASSERT(info.prev);
+	auto prev = info.prev;
+	prev->next = info.next;
 	if (prev->next) {
 		prev->next->prev = prev;
 	}
 }
 
-void UpdateSegment::CleanupUpdate(UpdateInfo *info) {
+void UpdateSegment::CleanupUpdate(UpdateInfo &info) {
 	// obtain an exclusive lock
 	auto lock_handle = lock.GetExclusiveLock();
 	CleanupUpdateInternal(*lock_handle, info);

package/src/duckdb/src/storage/wal_replay.cpp

@@ -411,7 +411,7 @@ void ReplayState::ReplayCreateIndex() {
 		}
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto expressions = binder->BindCreateIndexExpressions(table, info.get());
+	auto expressions = binder->BindCreateIndexExpressions(*table, *info);
 
 	// create the empty index
 	unique_ptr<Index> index;

package/src/duckdb/src/transaction/cleanup_state.cpp

@@ -29,12 +29,12 @@ void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::DELETE_TUPLE: {
 		auto info = (DeleteInfo *)data;
-		CleanupDelete(info);
+		CleanupDelete(*info);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {
 		auto info = (UpdateInfo *)data;
-		CleanupUpdate(info);
+		CleanupUpdate(*info);
 		break;
 	}
 	default:
@@ -42,16 +42,16 @@ void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
 	}
 }
 
-void CleanupState::CleanupUpdate(UpdateInfo *info) {
+void CleanupState::CleanupUpdate(UpdateInfo &info) {
 	// remove the update info from the update chain
 	// first obtain an exclusive lock on the segment
-	info->segment->CleanupUpdate(info);
+	info.segment->CleanupUpdate(info);
 }
 
-void CleanupState::CleanupDelete(DeleteInfo *info) {
-	auto version_table = info->table;
-	D_ASSERT(version_table->info->cardinality >= info->count);
-	version_table->info->cardinality -= info->count;
+void CleanupState::CleanupDelete(DeleteInfo &info) {
+	auto version_table = info.table;
+	D_ASSERT(version_table->info->cardinality >= info.count);
+	version_table->info->cardinality -= info.count;
 	if (version_table->info->indexes.Empty()) {
 		// this table has no indexes: no cleanup to be done
 		return;
@@ -62,8 +62,8 @@ void CleanupState::CleanupDelete(DeleteInfo *info) {
 		current_table = version_table;
 	}
 	count = 0;
-	for (idx_t i = 0; i < info->count; i++) {
-		row_numbers[count++] = info->vinfo->start + info->rows[i];
+	for (idx_t i = 0; i < info.count; i++) {
+		row_numbers[count++] = info.vinfo->start + info.rows[i];
 	}
 	Flush();
 }

package/src/duckdb/src/transaction/commit_state.cpp

@@ -19,7 +19,7 @@
 
 namespace duckdb {
 
-CommitState::CommitState(ClientContext &context, transaction_t commit_id, WriteAheadLog *log)
+CommitState::CommitState(ClientContext &context, transaction_t commit_id, optional_ptr<WriteAheadLog> log)
     : log(log), commit_id(commit_id), current_table_info(nullptr), context(context) {
 }
 
@@ -149,10 +149,10 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 	}
 }
 
-void CommitState::WriteDelete(DeleteInfo *info) {
+void CommitState::WriteDelete(DeleteInfo &info) {
 	D_ASSERT(log);
 	// switch to the current table, if necessary
-	SwitchTable(info->table->info.get(), UndoFlags::DELETE_TUPLE);
+	SwitchTable(info.table->info.get(), UndoFlags::DELETE_TUPLE);
 
 	if (!delete_chunk) {
 		delete_chunk = make_uniq<DataChunk>();
@@ -160,17 +160,17 @@ void CommitState::WriteDelete(DeleteInfo *info) {
 		delete_chunk->Initialize(Allocator::DefaultAllocator(), delete_types);
 	}
 	auto rows = FlatVector::GetData<row_t>(delete_chunk->data[0]);
-	for (idx_t i = 0; i < info->count; i++) {
-		rows[i] = info->base_row + info->rows[i];
+	for (idx_t i = 0; i < info.count; i++) {
+		rows[i] = info.base_row + info.rows[i];
 	}
-	delete_chunk->SetCardinality(info->count);
+	delete_chunk->SetCardinality(info.count);
 	log->WriteDelete(*delete_chunk);
 }
 
-void CommitState::WriteUpdate(UpdateInfo *info) {
+void CommitState::WriteUpdate(UpdateInfo &info) {
 	D_ASSERT(log);
 	// switch to the current table, if necessary
-	auto &column_data = info->segment->column_data;
+	auto &column_data = info.segment->column_data;
 	auto &table_info = column_data.GetTableInfo();
 
 	SwitchTable(&table_info, UndoFlags::UPDATE_TUPLE);
@@ -188,25 +188,25 @@ void CommitState::WriteUpdate(UpdateInfo *info) {
 	update_chunk->Initialize(Allocator::DefaultAllocator(), update_types);
 
 	// fetch the updated values from the base segment
-	info->segment->FetchCommitted(info->vector_index, update_chunk->data[0]);
+	info.segment->FetchCommitted(info.vector_index, update_chunk->data[0]);
 
 	// write the row ids into the chunk
 	auto row_ids = FlatVector::GetData<row_t>(update_chunk->data[1]);
-	idx_t start = column_data.start + info->vector_index * STANDARD_VECTOR_SIZE;
-	for (idx_t i = 0; i < info->N; i++) {
-		row_ids[info->tuples[i]] = start + info->tuples[i];
+	idx_t start = column_data.start + info.vector_index * STANDARD_VECTOR_SIZE;
+	for (idx_t i = 0; i < info.N; i++) {
+		row_ids[info.tuples[i]] = start + info.tuples[i];
 	}
 	if (column_data.type.id() == LogicalTypeId::VALIDITY) {
 		// zero-initialize the booleans
 		// FIXME: this is only required because of NullValue<T> in Vector::Serialize...
 		auto booleans = FlatVector::GetData<bool>(update_chunk->data[0]);
-		for (idx_t i = 0; i < info->N; i++) {
-			auto idx = info->tuples[i];
+		for (idx_t i = 0; i < info.N; i++) {
+			auto idx = info.tuples[i];
 			booleans[idx] = false;
 		}
 	}
-	SelectionVector sel(info->tuples);
-	update_chunk->Slice(sel, info->N);
+	SelectionVector sel(info.tuples);
+	update_chunk->Slice(sel, info.N);
 
 	// construct the column index path
 	vector<column_t> column_indexes;
@@ -215,7 +215,7 @@ void CommitState::WriteUpdate(UpdateInfo *info) {
 		column_indexes.push_back(column_data_ptr->column_index);
 		column_data_ptr = column_data_ptr->parent;
 	}
-	column_indexes.push_back(info->column_index);
+	column_indexes.push_back(info.column_index);
 	std::reverse(column_indexes.begin(), column_indexes.end());
 
 	log->WriteUpdate(*update_chunk, column_indexes);
@@ -260,7 +260,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		// deletion:
 		auto info = (DeleteInfo *)data;
 		if (HAS_LOG && !info->table->info->IsTemporary()) {
-			WriteDelete(info);
+			WriteDelete(*info);
 		}
 		// mark the tuples as committed
 		info->vinfo->CommitDelete(commit_id, info->rows, info->count);
@@ -270,7 +270,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		// update:
 		auto info = (UpdateInfo *)data;
 		if (HAS_LOG && !info->segment->column_data.GetTableInfo().IsTemporary()) {
-			WriteUpdate(info);
+			WriteUpdate(*info);
 		}
 		info->version_number = commit_id;
 		break;

package/src/duckdb/src/transaction/duck_transaction.cpp

@@ -51,14 +51,14 @@ LocalStorage &DuckTransaction::GetLocalStorage() {
 	return *storage;
 }
 
-void DuckTransaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data, idx_t extra_data_size) {
+void DuckTransaction::PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data, idx_t extra_data_size) {
 	idx_t alloc_size = sizeof(CatalogEntry *);
 	if (extra_data_size > 0) {
 		alloc_size += extra_data_size + sizeof(idx_t);
 	}
 	auto baseptr = undo_buffer.CreateEntry(UndoFlags::CATALOG_ENTRY, alloc_size);
 	// store the pointer to the catalog entry
-	Store<CatalogEntry *>(entry, baseptr);
+	Store<CatalogEntry *>(&entry, baseptr);
 	if (extra_data_size > 0) {
 		// copy the extra data behind the catalog entry pointer (if any)
 		baseptr += sizeof(CatalogEntry *);
@@ -70,19 +70,19 @@ void DuckTransaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_dat
 	}
 }
 
-void DuckTransaction::PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
+void DuckTransaction::PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
 	auto delete_info =
 	    (DeleteInfo *)undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count);
 	delete_info->vinfo = vinfo;
-	delete_info->table = table;
+	delete_info->table = &table;
 	delete_info->count = count;
 	delete_info->base_row = base_row;
 	memcpy(delete_info->rows, rows, sizeof(row_t) * count);
 }
 
-void DuckTransaction::PushAppend(DataTable *table, idx_t start_row, idx_t row_count) {
+void DuckTransaction::PushAppend(DataTable &table, idx_t start_row, idx_t row_count) {
 	auto append_info = (AppendInfo *)undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo));
-	append_info->table = table;
+	append_info->table = &table;
 	append_info->start_row = start_row;
 	append_info->count = row_count;
 }
@@ -116,7 +116,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 	UndoBuffer::IteratorState iterator_state;
 	LocalStorage::CommitState commit_state;
 	unique_ptr<StorageCommitState> storage_commit_state;
-	WriteAheadLog *log;
+	optional_ptr<WriteAheadLog> log;
 	if (!db.IsSystem()) {
 		auto &storage_manager = db.GetStorageManager();
 		log = storage_manager.GetWriteAheadLog();

package/src/duckdb/src/transaction/rollback_state.cpp

@@ -35,7 +35,7 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::UPDATE_TUPLE: {
 		auto info = (UpdateInfo *)data;
-		info->segment->RollbackUpdate(info);
+		info->segment->RollbackUpdate(*info);
 		break;
 	}
 	default: // LCOV_EXCL_START

package/src/duckdb/src/transaction/undo_buffer.cpp

@@ -128,7 +128,8 @@ void UndoBuffer::Cleanup() {
 	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CleanupEntry(type, data); });
 }
 
-void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, WriteAheadLog *log, transaction_t commit_id) {
+void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, optional_ptr<WriteAheadLog> log,
+                        transaction_t commit_id) {
 	CommitState state(context, commit_id, log);
 	if (log) {
 		// commit WITH write ahead log

package/src/duckdb/ub_src_common_adbc.cpp

@@ -0,0 +1,4 @@
+#include "src/common/adbc/adbc.cpp"
+
+#include "src/common/adbc/driver_manager.cpp"
+

package/src/duckdb/src/include/duckdb/common/single_thread_ptr.hpp

@@ -1,185 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/single_thread_ptr.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/unique_ptr.hpp"
-
-class RefCounter {
-public:
-	uint32_t pn;
-	RefCounter() : pn(1) {
-	}
-	void inc() {
-		++pn;
-	}
-	void dec() {
-		--pn;
-	}
-	uint32_t getPn() const {
-		return pn;
-	}
-	virtual ~RefCounter() {
-	}
-};
-
-namespace duckdb {
-template <typename T>
-class single_thread_ptr {
-public:
-	T *ptr;                // contained pointer
-	RefCounter *ref_count; // reference counter
-
-public:
-	// Default constructor, constructs an empty single_thread_ptr.
-	constexpr single_thread_ptr() : ptr(nullptr), ref_count(nullptr) {
-	}
-	// Construct empty single_thread_ptr.
-	constexpr single_thread_ptr(std::nullptr_t) : ptr(nullptr), ref_count(nullptr) {
-	}
-	// Construct a single_thread_ptr that wraps raw pointer.
-
-	single_thread_ptr(RefCounter *r, T *p) {
-		ptr = p;
-		ref_count = r;
-	}
-
-	template <class U>
-	single_thread_ptr(RefCounter *r, U *p) {
-		ptr = p;
-		ref_count = r;
-	}
-
-	// Copy  constructor.
-	single_thread_ptr(const single_thread_ptr &sp) : ptr(nullptr), ref_count(nullptr) {
-		if (sp.ptr) {
-			ptr = sp.ptr;
-			ref_count = sp.ref_count;
-			ref_count->inc();
-		}
-	}
-
-	// Conversion constructor.
-	template <typename U>
-	single_thread_ptr(const single_thread_ptr<U> &sp) : ptr(nullptr), ref_count(nullptr) {
-		if (sp.ptr) {
-			ptr = sp.ptr;
-			ref_count = sp.ref_count;
-			ref_count->inc();
-		}
-	}
-
-	// move  constructor.
-	single_thread_ptr(single_thread_ptr &&sp) noexcept : ptr {sp.ptr}, ref_count {sp.ref_count} {
-		sp.ptr = nullptr;
-		sp.ref_count = nullptr;
-	}
-
-	// move  constructor.
-	template <class U>
-	single_thread_ptr(single_thread_ptr<U> &&sp) noexcept : ptr {sp.ptr}, ref_count {sp.ref_count} {
-		sp.ptr = nullptr;
-		sp.ref_count = nullptr;
-	}
-
-	// No effect if single_thread_ptr is empty or use_count() > 1, otherwise release the resources.
-	~single_thread_ptr() {
-		release();
-	}
-
-	void release() {
-		if (ptr && ref_count) {
-			ref_count->dec();
-			if ((ref_count->getPn()) == 0) {
-				delete ref_count;
-			}
-		}
-		ref_count = nullptr;
-		ptr = nullptr;
-	}
-
-	// Copy assignment.
-	single_thread_ptr &operator=(single_thread_ptr sp) noexcept {
-		std::swap(this->ptr, sp.ptr);
-		std::swap(this->ref_count, sp.ref_count);
-		return *this;
-	}
-
-	// Dereference pointer to managed object.
-	T &operator*() const noexcept {
-		return *ptr;
-	}
-	T *operator->() const noexcept {
-		return ptr;
-	}
-
-	// Return the contained pointer.
-	T *get() const noexcept {
-		return ptr;
-	}
-
-	// Return use count (use count == 0 if single_thread_ptr is empty).
-	long use_count() const noexcept {
-		if (ptr)
-			return ref_count->getPn();
-		else
-			return 0;
-	}
-
-	// Check if there is an associated managed object.
-	explicit operator bool() const noexcept {
-		return (ptr);
-	}
-
-	// Resets single_thread_ptr to empty.
-	void reset() noexcept {
-		release();
-	}
-};
-
-template <class T>
-struct _object_and_block : public RefCounter {
-	T object;
-
-	template <class... Args>
-	explicit _object_and_block(Args &&... args) : object(std::forward<Args>(args)...) {
-	}
-};
-
-// Operator overloading.
-template <typename T, typename U>
-inline bool operator==(const single_thread_ptr<T> &sp1, const single_thread_ptr<U> &sp2) {
-	return sp1.get() == sp2.get();
-}
-
-template <typename T>
-inline bool operator==(const single_thread_ptr<T> &sp, std::nullptr_t) noexcept {
-	return !sp;
-}
-
-template <typename T, typename U>
-inline bool operator!=(const single_thread_ptr<T> &sp1, const single_thread_ptr<U> &sp2) {
-	return sp1.get() != sp2.get();
-}
-
-template <typename T>
-inline bool operator!=(const single_thread_ptr<T> &sp, std::nullptr_t) noexcept {
-	return sp.get();
-}
-
-template <typename T>
-inline bool operator!=(std::nullptr_t, const single_thread_ptr<T> &sp) noexcept {
-	return sp.get();
-}
-
-template <class T, class... Args>
-single_thread_ptr<T> single_thread_make_shared(Args &&... args) {
-	auto tmp_object = new _object_and_block<T>(std::forward<Args>(args)...);
-	return single_thread_ptr<T>(tmp_object, &(tmp_object->object));
-}
-} // namespace duckdb