duckdb 0.7.2-dev1803.0 → 0.7.2-dev1867.0

package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp

@@ -19,10 +19,10 @@ PhysicalBatchInsert::PhysicalBatchInsert(vector<LogicalType> types, TableCatalog
       bound_defaults(std::move(bound_defaults)) {
 }
 
-PhysicalBatchInsert::PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry *schema,
+PhysicalBatchInsert::PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry &schema,
                                          unique_ptr<BoundCreateTableInfo> info_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::BATCH_CREATE_TABLE_AS, op.types, estimated_cardinality),
-      insert_table(nullptr), schema(schema), info(std::move(info_p)) {
+      insert_table(nullptr), schema(&schema), info(std::move(info_p)) {
 	PhysicalInsert::GetInsertInfo(*info, insert_types, bound_defaults);
 }
 
@@ -100,7 +100,7 @@ public:
 	}
 
 	mutex lock;
-	DuckTableEntry *table;
+	optional_ptr<DuckTableEntry> table;
 	idx_t insert_count;
 	map<idx_t, unique_ptr<RowGroupCollection>> collections;
 
@@ -156,7 +156,8 @@ public:
 	}
 
 	void AddCollection(ClientContext &context, idx_t batch_index, unique_ptr<RowGroupCollection> current_collection,
-	                   OptimisticDataWriter *writer = nullptr, bool *written_to_disk = nullptr) {
+	                   optional_ptr<OptimisticDataWriter> writer = nullptr,
+	                   optional_ptr<bool> written_to_disk = nullptr) {
 		vector<unique_ptr<RowGroupCollection>> merge_collections;
 		idx_t merge_count;
 		{
@@ -240,7 +241,7 @@ public:
 	idx_t current_index;
 	TableAppendState current_append_state;
 	unique_ptr<RowGroupCollection> current_collection;
-	OptimisticDataWriter *writer;
+	optional_ptr<OptimisticDataWriter> writer;
 	bool written_to_disk;
 
 	void FlushToDisk() {
@@ -253,9 +254,9 @@ public:
 		writer->FlushToDisk(*current_collection, true);
 	}
 
-	void CreateNewCollection(DuckTableEntry *table, const vector<LogicalType> &insert_types) {
-		auto &table_info = table->GetStorage().info;
-		auto &block_manager = TableIOManager::Get(table->GetStorage()).GetBlockManagerForRowData();
+	void CreateNewCollection(DuckTableEntry &table, const vector<LogicalType> &insert_types) {
+		auto &table_info = table.GetStorage().info;
+		auto &block_manager = TableIOManager::Get(table.GetStorage()).GetBlockManagerForRowData();
 		current_collection = make_uniq<RowGroupCollection>(table_info, block_manager, insert_types, MAX_ROW_ID);
 		current_collection->InitializeEmpty();
 		current_collection->InitializeAppend(current_append_state);
@@ -269,8 +270,8 @@ unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContex
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = *schema->catalog;
-		result->table =
-		    (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
+		result->table = (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context),
+		                                                      *schema.get_mutable(), info.get());
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
@@ -289,12 +290,12 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkSt
 	auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
 
 	auto table = gstate.table;
-	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
+	PhysicalInsert::ResolveDefaults(*table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
 
 	if (!lstate.current_collection) {
 		lock_guard<mutex> l(gstate.lock);
 		// no collection yet: create a new one
-		lstate.CreateNewCollection(table, insert_types);
+		lstate.CreateNewCollection(*table, insert_types);
 		lstate.writer = gstate.table->GetStorage().CreateOptimisticWriter(context.client);
 	} else if (lstate.current_index != lstate.batch_index) {
 		// batch index has changed: move the old collection to the global state and create a new collection
@@ -303,7 +304,7 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkSt
 		lstate.FlushToDisk();
 		gstate.AddCollection(context.client, lstate.current_index, std::move(lstate.current_collection), lstate.writer,
 		                     &lstate.written_to_disk);
-		lstate.CreateNewCollection(table, insert_types);
+		lstate.CreateNewCollection(*table, insert_types);
 	}
 	lstate.current_index = lstate.batch_index;
 

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -53,10 +53,10 @@ PhysicalInsert::PhysicalInsert(vector<LogicalType> types_p, TableCatalogEntry *t
 	}
 }
 
-PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info_p,
+PhysicalInsert::PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info_p,
                                idx_t estimated_cardinality, bool parallel)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE_AS, op.types, estimated_cardinality), insert_table(nullptr),
-      return_chunk(false), schema(schema), info(std::move(info_p)), parallel(parallel),
+      return_chunk(false), schema(&schema), info(std::move(info_p)), parallel(parallel),
       action_type(OnConflictAction::THROW) {
 	GetInsertInfo(*info, insert_types, bound_defaults);
 }
@@ -80,7 +80,7 @@ public:
 	}
 
 	mutex lock;
-	DuckTableEntry *table;
+	optional_ptr<DuckTableEntry> table;
 	idx_t insert_count;
 	bool initialized;
 	LocalAppendState append_state;
@@ -99,7 +99,7 @@ public:
 	ExpressionExecutor default_executor;
 	TableAppendState local_append_state;
 	unique_ptr<RowGroupCollection> local_collection;
-	OptimisticDataWriter *writer;
+	optional_ptr<OptimisticDataWriter> writer;
 	// Rows that have been updated by a DO UPDATE conflict
 	unordered_set<row_t> updated_rows;
 };
@@ -110,8 +110,8 @@ unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &co
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
 		auto &catalog = *schema->catalog;
-		result->table =
-		    (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), schema, info.get());
+		result->table = (DuckTableEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context),
+		                                                      *schema.get_mutable(), info.get());
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
@@ -124,7 +124,7 @@ unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &c
 	return make_uniq<InsertLocalState>(context.client, insert_types, bound_defaults);
 }
 
-void PhysicalInsert::ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
+void PhysicalInsert::ResolveDefaults(const TableCatalogEntry &table, DataChunk &chunk,
                                      const physical_index_vector_t<idx_t> &column_index_map,
                                      ExpressionExecutor &default_executor, DataChunk &result) {
 	chunk.Flatten();
@@ -135,7 +135,7 @@ void PhysicalInsert::ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
 
 	if (!column_index_map.empty()) {
 		// columns specified by the user, use column_index_map
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto storage_idx = col.StorageOid();
 			auto mapped_index = column_index_map[col.Physical()];
 			if (mapped_index == DConstants::INVALID_INDEX) {
@@ -216,7 +216,7 @@ void PhysicalInsert::CombineExistingAndInsertTuples(DataChunk &result, DataChunk
 	result.SetCardinality(input_chunk.size());
 }
 
-void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry *table,
+void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table,
                                              Vector &row_ids) const {
 	if (action_type == OnConflictAction::NOTHING) {
 		return;
@@ -255,9 +255,9 @@ void PhysicalInsert::PerformOnConflictAction(ExecutionContext &context, DataChun
 	executor.Execute(chunk, update_chunk);
 	update_chunk.SetCardinality(chunk);
 
-	auto &data_table = table->GetStorage();
+	auto &data_table = table.GetStorage();
 	// Perform the update, using the results of the SET expressions
-	data_table.Update(*table, context.client, row_ids, set_columns, update_chunk);
+	data_table.Update(table, context.client, row_ids, set_columns, update_chunk);
 }
 
 // TODO: should we use a hash table to keep track of this instead?
@@ -274,11 +274,11 @@ void PhysicalInsert::RegisterUpdatedRows(InsertLocalState &lstate, const Vector
 	}
 }
 
-void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionContext &context,
+void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context,
                                         InsertLocalState &lstate) const {
-	auto &data_table = table->GetStorage();
+	auto &data_table = table.GetStorage();
 	if (action_type == OnConflictAction::THROW) {
-		data_table.VerifyAppendConstraints(*table, context.client, lstate.insert_chunk, nullptr);
+		data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, nullptr);
 		return;
 	}
 	// Check whether any conflicts arise, and if they all meet the conflict_target + condition
@@ -287,7 +287,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 	// We either want to do nothing, or perform an update when conflicts arise
 	ConflictInfo conflict_info(conflict_target);
 	ConflictManager conflict_manager(VerifyExistenceType::APPEND, lstate.insert_chunk.size(), &conflict_info);
-	data_table.VerifyAppendConstraints(*table, context.client, lstate.insert_chunk, &conflict_manager);
+	data_table.VerifyAppendConstraints(table, context.client, lstate.insert_chunk, &conflict_manager);
 	conflict_manager.Finalize();
 	if (conflict_manager.ConflictCount() == 0) {
 		// No conflicts found
@@ -312,7 +312,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 		// then we scan the existing table for the conflicting tuples, using the rowids
 		scan_chunk.Initialize(context.client, types_to_fetch);
 		auto fetch_state = make_uniq<ColumnFetchState>();
-		auto &transaction = DuckTransaction::Get(context.client, *table->catalog);
+		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
 		data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
 	}
 
@@ -335,7 +335,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry *table, ExecutionConte
 			}
 			combined_chunk.Slice(sel.Selection(), sel.Count());
 			row_ids.Slice(sel.Selection(), sel.Count());
-			data_table.VerifyAppendConstraints(*table, context.client, combined_chunk, nullptr);
+			data_table.VerifyAppendConstraints(table, context.client, combined_chunk, nullptr);
 			throw InternalException("The previous operation was expected to throw but didn't");
 		}
 	}
@@ -359,7 +359,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 
 	auto table = gstate.table;
 	auto &storage = table->GetStorage();
-	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
+	PhysicalInsert::ResolveDefaults(*table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
 
 	if (!parallel) {
 		if (!gstate.initialized) {
@@ -367,7 +367,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			gstate.initialized = true;
 		}
 
-		OnConflictHandling(table, context, lstate);
+		OnConflictHandling(*table, context, lstate);
 		storage.LocalAppend(gstate.append_state, *table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
@@ -387,7 +387,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
 			lstate.writer = gstate.table->GetStorage().CreateOptimisticWriter(context.client);
 		}
-		OnConflictHandling(table, context, lstate);
+		OnConflictHandling(*table, context, lstate);
 		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
 		if (new_row_group) {
 			lstate.writer->CheckFlushToDisk(*lstate.local_collection);

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -7,7 +7,7 @@
 
 namespace duckdb {
 
-PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema,
+PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry &schema,
                                          unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE, op.types, estimated_cardinality), schema(schema),
       info(std::move(info)) {
@@ -34,7 +34,7 @@ void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, G
 	if (state.finished) {
 		return;
 	}
-	auto &catalog = *schema->catalog;
+	auto &catalog = *schema.catalog;
 	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, info.get());
 	state.finished = true;
 }

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -43,7 +43,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	    make_uniq<PhysicalTableScan>(op.info->scan_types, op.function, std::move(op.bind_data), op.info->column_ids,
 	                                 op.info->names, std::move(table_filters), op.estimated_cardinality);
 
-	dependencies.AddDependency(&op.table);
+	dependencies.AddDependency(op.table);
 	op.info->column_ids.pop_back();
 
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -21,10 +21,10 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
 	unique_ptr<PhysicalOperator> create;
 	if (!parallel_streaming_insert && use_batch_index) {
-		create = make_uniq<PhysicalBatchInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality);
+		create = make_uniq<PhysicalBatchInsert>(op, *op.schema, std::move(op.info), op.estimated_cardinality);
 
 	} else {
-		create = make_uniq<PhysicalInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality,
+		create = make_uniq<PhysicalInsert>(op, *op.schema, std::move(op.info), op.estimated_cardinality,
 		                                   parallel_streaming_insert && num_threads > 1);
 	}
 
@@ -42,7 +42,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTabl
 		auto plan = CreatePlan(*op.children[0]);
 		return op.schema->catalog->PlanCreateTableAs(context, op, std::move(plan));
 	} else {
-		return make_uniq<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
+		return make_uniq<PhysicalCreateTable>(op, *op.schema, std::move(op.info), op.estimated_cardinality);
 	}
 }
 

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -25,7 +25,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.AddDependency(op.table);
+	dependencies.AddDependency(*op.table);
 	return op.table->catalog->PlanDelete(context, op, std::move(plan));
 }
 

package/src/duckdb/src/execution/physical_plan/plan_insert.cpp

@@ -106,7 +106,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op
 		D_ASSERT(op.children.size() == 1);
 		plan = CreatePlan(*op.children[0]);
 	}
-	dependencies.AddDependency(op.table);
+	dependencies.AddDependency(*op.table);
 	return op.table->catalog->PlanInsert(context, op, std::move(plan));
 }
 

package/src/duckdb/src/execution/physical_plan/plan_update.cpp

@@ -22,7 +22,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	dependencies.AddDependency(op.table);
+	dependencies.AddDependency(*op.table);
 	return op.table->catalog->PlanUpdate(context, op, std::move(plan));
 }
 

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -429,15 +429,15 @@ void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateE
 		// similarly, we only need to ORDER BY each aggregate once
 		expression_set_t seen_expressions;
 		for (auto &target : groups) {
-			seen_expressions.insert(target.get());
+			seen_expressions.insert(*target);
 		}
 		vector<BoundOrderByNode> new_order_nodes;
 		for (auto &order_node : expr.order_bys->orders) {
-			if (seen_expressions.find(order_node.expression.get()) != seen_expressions.end()) {
+			if (seen_expressions.find(*order_node.expression) != seen_expressions.end()) {
 				// we do not need to order by this node
 				continue;
 			}
-			seen_expressions.insert(order_node.expression.get());
+			seen_expressions.insert(*order_node.expression);
 			new_order_nodes.push_back(std::move(order_node));
 		}
 		if (new_order_nodes.empty()) {

package/src/duckdb/src/function/cast/cast_function_set.cpp

@@ -6,7 +6,8 @@
 
 namespace duckdb {
 
-BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, optional_ptr<ClientContext> context)
+BindCastInput::BindCastInput(CastFunctionSet &function_set, optional_ptr<BindCastInfo> info,
+                             optional_ptr<ClientContext> context)
     : function_set(function_set), info(info), context(context) {
 }
 

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -15,11 +15,11 @@
 namespace duckdb {
 
 struct NextvalBindData : public FunctionData {
-	explicit NextvalBindData(SequenceCatalogEntry *sequence) : sequence(sequence) {
+	explicit NextvalBindData(optional_ptr<SequenceCatalogEntry> sequence) : sequence(sequence) {
 	}
 
 	//! The sequence to use for the nextval computation; only if the sequence is a constant
-	SequenceCatalogEntry *sequence;
+	optional_ptr<SequenceCatalogEntry> sequence;
 
 	unique_ptr<FunctionData> Copy() const override {
 		return make_uniq<NextvalBindData>(sequence);
@@ -32,45 +32,45 @@ struct NextvalBindData : public FunctionData {
 };
 
 struct CurrentSequenceValueOperator {
-	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry *seq) {
-		lock_guard<mutex> seqlock(seq->lock);
+	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry &seq) {
+		lock_guard<mutex> seqlock(seq.lock);
 		int64_t result;
-		if (seq->usage_count == 0u) {
+		if (seq.usage_count == 0u) {
 			throw SequenceException("currval: sequence is not yet defined in this session");
 		}
-		result = seq->last_value;
+		result = seq.last_value;
 		return result;
 	}
 };
 
 struct NextSequenceValueOperator {
-	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry *seq) {
-		lock_guard<mutex> seqlock(seq->lock);
+	static int64_t Operation(DuckTransaction &transaction, SequenceCatalogEntry &seq) {
+		lock_guard<mutex> seqlock(seq.lock);
 		int64_t result;
-		result = seq->counter;
-		bool overflow = !TryAddOperator::Operation(seq->counter, seq->increment, seq->counter);
-		if (seq->cycle) {
+		result = seq.counter;
+		bool overflow = !TryAddOperator::Operation(seq.counter, seq.increment, seq.counter);
+		if (seq.cycle) {
 			if (overflow) {
-				seq->counter = seq->increment < 0 ? seq->max_value : seq->min_value;
-			} else if (seq->counter < seq->min_value) {
-				seq->counter = seq->max_value;
-			} else if (seq->counter > seq->max_value) {
-				seq->counter = seq->min_value;
+				seq.counter = seq.increment < 0 ? seq.max_value : seq.min_value;
+			} else if (seq.counter < seq.min_value) {
+				seq.counter = seq.max_value;
+			} else if (seq.counter > seq.max_value) {
+				seq.counter = seq.min_value;
 			}
 		} else {
-			if (result < seq->min_value || (overflow && seq->increment < 0)) {
-				throw SequenceException("nextval: reached minimum value of sequence \"%s\" (%lld)", seq->name,
-				                        seq->min_value);
+			if (result < seq.min_value || (overflow && seq.increment < 0)) {
+				throw SequenceException("nextval: reached minimum value of sequence \"%s\" (%lld)", seq.name,
+				                        seq.min_value);
 			}
-			if (result > seq->max_value || overflow) {
-				throw SequenceException("nextval: reached maximum value of sequence \"%s\" (%lld)", seq->name,
-				                        seq->max_value);
+			if (result > seq.max_value || overflow) {
+				throw SequenceException("nextval: reached maximum value of sequence \"%s\" (%lld)", seq.name,
+				                        seq.max_value);
 			}
 		}
-		seq->last_value = result;
-		seq->usage_count++;
-		if (!seq->temporary) {
-			transaction.sequence_usage[seq] = SequenceValue(seq->usage_count, seq->counter);
+		seq.last_value = result;
+		seq.usage_count++;
+		if (!seq.temporary) {
+			transaction.sequence_usage[&seq] = SequenceValue(seq.usage_count, seq.counter);
 		}
 		return result;
 	}
@@ -98,7 +98,7 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 		auto result_data = FlatVector::GetData<int64_t>(result);
 		for (idx_t i = 0; i < args.size(); i++) {
 			// get the next value from the sequence
-			result_data[i] = OP::Operation(transaction, info.sequence);
+			result_data[i] = OP::Operation(transaction, *info.sequence);
 		}
 	} else {
 		// sequence to use comes from the input
@@ -107,7 +107,7 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 			auto sequence = BindSequence(context, value.GetString());
 			// finally get the next value from the sequence
 			auto &transaction = DuckTransaction::Get(context, *sequence->catalog);
-			return OP::Operation(transaction, sequence);
+			return OP::Operation(transaction, *sequence);
 		});
 	}
 }
@@ -129,7 +129,7 @@ static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFuncti
 static void NextValDependency(BoundFunctionExpression &expr, DependencyList &dependencies) {
 	auto &info = expr.bind_info->Cast<NextvalBindData>();
 	if (info.sequence) {
-		dependencies.AddDependency(info.sequence);
+		dependencies.AddDependency(*info.sequence);
 	}
 }
 

package/src/duckdb/src/function/scalar/string/damerau_levenshtein.cpp

@@ -0,0 +1,106 @@
+#include "duckdb/function/scalar/string_functions.hpp"
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+// Using Lowrance-Wagner (LW) algorithm: https://doi.org/10.1145%2F321879.321880
+// Can't calculate as trivial modification to levenshtein algorithm
+// as we need to potentially know about earlier in the string
+static idx_t DamerauLevenshteinDistance(const string_t &source, const string_t &target) {
+	// costs associated with each type of edit, to aid readability
+	constexpr uint8_t COST_SUBSTITUTION = 1;
+	constexpr uint8_t COST_INSERTION = 1;
+	constexpr uint8_t COST_DELETION = 1;
+	constexpr uint8_t COST_TRANSPOSITION = 1;
+	const auto source_len = source.GetSize();
+	const auto target_len = target.GetSize();
+
+	// If one string is empty, the distance equals the length of the other string
+	// either through target_len insertions
+	// or source_len deletions
+	if (source_len == 0) {
+		return target_len * COST_INSERTION;
+	} else if (target_len == 0) {
+		return source_len * COST_DELETION;
+	}
+
+	const auto source_str = source.GetDataUnsafe();
+	const auto target_str = target.GetDataUnsafe();
+
+	// larger than the largest possible value:
+	const auto inf = source_len * COST_DELETION + target_len * COST_INSERTION + 1;
+	// minimum edit distance from prefix of source string to prefix of target string
+	// same object as H in LW paper (with indices offset by 1)
+	vector<vector<idx_t>> distance(source_len + 2, vector<idx_t>(target_len + 2, inf));
+	// keeps track of the largest string indices of source string matching each character
+	// same as DA in LW paper
+	map<char, idx_t> largest_source_chr_matching;
+
+	// initialise row/column corresponding to zero-length strings
+	// partial string -> empty requires a deletion for each character
+	for (idx_t source_idx = 0; source_idx <= source_len; source_idx++) {
+		distance[source_idx + 1][1] = source_idx * COST_DELETION;
+	}
+	// and empty -> partial string means simply inserting characters
+	for (idx_t target_idx = 1; target_idx <= target_len; target_idx++) {
+		distance[1][target_idx + 1] = target_idx * COST_INSERTION;
+	}
+	// loop through string indices - these are offset by 2 from distance indices
+	for (idx_t source_idx = 0; source_idx < source_len; source_idx++) {
+		// keeps track of the largest string indices of target string matching current source character
+		// same as DB in LW paper
+		idx_t largest_target_chr_matching;
+		largest_target_chr_matching = 0;
+		for (idx_t target_idx = 0; target_idx < target_len; target_idx++) {
+			// correspond to i1 and j1 in LW paper respectively
+			idx_t largest_source_chr_matching_target;
+			idx_t largest_target_chr_matching_source;
+			// cost associated to diagnanl shift in distance matrix
+			// corresponds to d in LW paper
+			uint8_t cost_diagonal_shift;
+			largest_source_chr_matching_target = largest_source_chr_matching[target_str[target_idx]];
+			largest_target_chr_matching_source = largest_target_chr_matching;
+			// if characters match, diagonal move costs nothing and we update our largest target index
+			// otherwise move is substitution and costs as such
+			if (source_str[source_idx] == target_str[target_idx]) {
+				cost_diagonal_shift = 0;
+				largest_target_chr_matching = target_idx + 1;
+			} else {
+				cost_diagonal_shift = COST_SUBSTITUTION;
+			}
+			distance[source_idx + 2][target_idx + 2] = MinValue(
+			    distance[source_idx + 1][target_idx + 1] + cost_diagonal_shift,
+			    MinValue(distance[source_idx + 2][target_idx + 1] + COST_INSERTION,
+			             MinValue(distance[source_idx + 1][target_idx + 2] + COST_DELETION,
+			                      distance[largest_source_chr_matching_target][largest_target_chr_matching_source] +
+			                          (source_idx - largest_source_chr_matching_target) * COST_DELETION +
+			                          COST_TRANSPOSITION +
+			                          (target_idx - largest_target_chr_matching_source) * COST_INSERTION)));
+		}
+		largest_source_chr_matching[source_str[source_idx]] = source_idx + 1;
+	}
+	return distance[source_len + 1][target_len + 1];
+}
+
+static int64_t DamerauLevenshteinScalarFunction(Vector &result, const string_t source, const string_t target) {
+	return (int64_t)DamerauLevenshteinDistance(source, target);
+}
+
+static void DamerauLevenshteinFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &source_vec = args.data[0];
+	auto &target_vec = args.data[1];
+
+	BinaryExecutor::Execute<string_t, string_t, int64_t>(
+	    source_vec, target_vec, result, args.size(),
+	    [&](string_t source, string_t target) { return DamerauLevenshteinScalarFunction(result, source, target); });
+}
+
+void DamerauLevenshteinFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet damerau_levenshtein("damerau_levenshtein");
+	damerau_levenshtein.AddFunction(ScalarFunction("damerau_levenshtein", {LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                                               LogicalType::BIGINT, DamerauLevenshteinFunction));
+	set.AddFunction(damerau_levenshtein);
+}
+
+} // namespace duckdb