duckdb 0.7.2-dev1803.0 → 0.7.2-dev1898.0

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

@@ -4,6 +4,7 @@
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/parser/expression_map.hpp"
 #include "duckdb/function/aggregate/distributive_functions.hpp"
 
@@ -12,7 +13,8 @@ namespace duckdb {
 struct SortedAggregateBindData : public FunctionData {
 	SortedAggregateBindData(ClientContext &context, BoundAggregateExpression &expr)
 	    : buffer_manager(BufferManager::GetBufferManager(context)), function(expr.function),
-	      bind_info(std::move(expr.bind_info)) {
+	      bind_info(std::move(expr.bind_info)), threshold(ClientConfig::GetConfig(context).ordered_aggregate_threshold),
+	      external(ClientConfig::GetConfig(context).force_external) {
 		auto &children = expr.children;
 		arg_types.reserve(children.size());
 		for (const auto &child : children) {
@@ -32,7 +34,8 @@ struct SortedAggregateBindData : public FunctionData {
 
 	SortedAggregateBindData(const SortedAggregateBindData &other)
 	    : buffer_manager(other.buffer_manager), function(other.function), arg_types(other.arg_types),
-	      sort_types(other.sort_types), sorted_on_args(other.sorted_on_args) {
+	      sort_types(other.sort_types), sorted_on_args(other.sorted_on_args), threshold(other.threshold),
+	      external(other.external) {
 		if (other.bind_info) {
 			bind_info = other.bind_info->Copy();
 		}
@@ -76,13 +79,17 @@ struct SortedAggregateBindData : public FunctionData {
 	vector<BoundOrderByNode> orders;
 	vector<LogicalType> sort_types;
 	bool sorted_on_args;
+
+	//! The sort flush threshold
+	const idx_t threshold;
+	const bool external;
 };
 
 struct SortedAggregateState {
 	//! Default buffer size, optimised for small group to avoid blowing out memory.
 	static const idx_t BUFFER_CAPACITY = 16;
 
-	SortedAggregateState() : nsel(0), offset(0) {
+	SortedAggregateState() : count(0), nsel(0), offset(0) {
 	}
 
 	static inline void InitializeBuffer(DataChunk &chunk, const vector<LogicalType> &types) {
@@ -98,7 +105,7 @@ struct SortedAggregateState {
 		chunk.Initialize(Allocator::DefaultAllocator(), types);
 	}
 
-	void Flush(SortedAggregateBindData &order_bind) {
+	void Flush(const SortedAggregateBindData &order_bind) {
 		if (ordering) {
 			return;
 		}
@@ -116,7 +123,9 @@ struct SortedAggregateState {
 		}
 	}
 
-	void Update(SortedAggregateBindData &order_bind, DataChunk &sort_chunk, DataChunk &arg_chunk) {
+	void Update(const SortedAggregateBindData &order_bind, DataChunk &sort_chunk, DataChunk &arg_chunk) {
+		count += sort_chunk.size();
+
 		// Lazy instantiation of the buffer chunks
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		if (!order_bind.sorted_on_args) {
@@ -139,7 +148,9 @@ struct SortedAggregateState {
 		}
 	}
 
-	void UpdateSlice(SortedAggregateBindData &order_bind, DataChunk &sort_inputs, DataChunk &arg_inputs) {
+	void UpdateSlice(const SortedAggregateBindData &order_bind, DataChunk &sort_inputs, DataChunk &arg_inputs) {
+		count += nsel;
+
 		// Lazy instantiation of the buffer chunks
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		if (!order_bind.sorted_on_args) {
@@ -178,25 +189,35 @@ struct SortedAggregateState {
 			Flush(order_bind);
 			ordering->Combine(*other.ordering);
 			arguments->Combine(*other.arguments);
+			count += other.count;
 		} else if (other.ordering) {
 			// Force CDC if the other has it
 			Flush(order_bind);
 			ordering->Combine(*other.ordering);
+			count += other.count;
 		} else if (other.sort_buffer.size()) {
 			Update(order_bind, other.sort_buffer, other.arg_buffer);
 		}
 	}
 
-	void Finalize(SortedAggregateBindData &order_bind, LocalSortState &local_sort) {
+	void PrefixSortBuffer(DataChunk &prefixed) {
+		for (column_t col_idx = 0; col_idx < sort_buffer.ColumnCount(); ++col_idx) {
+			prefixed.data[col_idx + 1].Reference(sort_buffer.data[col_idx]);
+		}
+		prefixed.SetCardinality(sort_buffer);
+	}
+
+	void Finalize(const SortedAggregateBindData &order_bind, DataChunk &prefixed, LocalSortState &local_sort) {
 		if (arguments) {
 			ColumnDataScanState sort_state;
 			ordering->InitializeScan(sort_state);
 			ColumnDataScanState arg_state;
 			arguments->InitializeScan(arg_state);
 			for (sort_buffer.Reset(); ordering->Scan(sort_state, sort_buffer); sort_buffer.Reset()) {
+				PrefixSortBuffer(prefixed);
 				arg_buffer.Reset();
 				arguments->Scan(arg_state, arg_buffer);
-				local_sort.SinkChunk(sort_buffer, arg_buffer);
+				local_sort.SinkChunk(prefixed, arg_buffer);
 			}
 			ordering->Reset();
 			arguments->Reset();
@@ -204,16 +225,20 @@ struct SortedAggregateState {
 			ColumnDataScanState sort_state;
 			ordering->InitializeScan(sort_state);
 			for (sort_buffer.Reset(); ordering->Scan(sort_state, sort_buffer); sort_buffer.Reset()) {
-				local_sort.SinkChunk(sort_buffer, sort_buffer);
+				PrefixSortBuffer(prefixed);
+				local_sort.SinkChunk(prefixed, sort_buffer);
 			}
 			ordering->Reset();
 		} else if (order_bind.sorted_on_args) {
-			local_sort.SinkChunk(sort_buffer, sort_buffer);
+			PrefixSortBuffer(prefixed);
+			local_sort.SinkChunk(prefixed, sort_buffer);
 		} else {
-			local_sort.SinkChunk(sort_buffer, arg_buffer);
+			PrefixSortBuffer(prefixed);
+			local_sort.SinkChunk(prefixed, arg_buffer);
 		}
 	}
 
+	idx_t count;
 	unique_ptr<ColumnDataCollection> arguments;
 	unique_ptr<ColumnDataCollection> ordering;
 
@@ -237,19 +262,19 @@ struct SortedAggregateFunction {
 		state->~STATE();
 	}
 
-	static void ProjectInputs(Vector inputs[], SortedAggregateBindData *order_bind, idx_t input_count, idx_t count,
-	                          DataChunk &arg_chunk, DataChunk &sort_chunk) {
+	static void ProjectInputs(Vector inputs[], const SortedAggregateBindData &order_bind, idx_t input_count,
+	                          idx_t count, DataChunk &arg_chunk, DataChunk &sort_chunk) {
 		idx_t col = 0;
 
-		if (!order_bind->sorted_on_args) {
-			arg_chunk.InitializeEmpty(order_bind->arg_types);
+		if (!order_bind.sorted_on_args) {
+			arg_chunk.InitializeEmpty(order_bind.arg_types);
 			for (auto &dst : arg_chunk.data) {
 				dst.Reference(inputs[col++]);
 			}
 			arg_chunk.SetCardinality(count);
 		}
 
-		sort_chunk.InitializeEmpty(order_bind->sort_types);
+		sort_chunk.InitializeEmpty(order_bind.sort_types);
 		for (auto &dst : sort_chunk.data) {
 			dst.Reference(inputs[col++]);
 		}
@@ -258,13 +283,13 @@ struct SortedAggregateFunction {
 
 	static void SimpleUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
 	                         idx_t count) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
+		const auto order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
 		DataChunk arg_chunk;
 		DataChunk sort_chunk;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_chunk, sort_chunk);
 
 		const auto order_state = (SortedAggregateState *)state;
-		order_state->Update(*order_bind, sort_chunk, arg_chunk);
+		order_state->Update(order_bind, sort_chunk, arg_chunk);
 	}
 
 	static void ScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
@@ -274,7 +299,7 @@ struct SortedAggregateFunction {
 		}
 
 		// Append the arguments to the two sub-collections
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
+		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
 		DataChunk arg_inputs;
 		DataChunk sort_inputs;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_inputs, sort_inputs);
@@ -315,7 +340,7 @@ struct SortedAggregateFunction {
 				continue;
 			}
 
-			order_state->UpdateSlice(*order_bind, sort_inputs, arg_inputs);
+			order_state->UpdateSlice(order_bind, sort_inputs, arg_inputs);
 		}
 	}
 
@@ -333,78 +358,162 @@ struct SortedAggregateFunction {
 	}
 
 	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                     idx_t offset) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
-		auto &buffer_manager = order_bind->buffer_manager;
-		auto &orders = order_bind->orders;
+	                     const idx_t offset) {
+		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
+		auto &buffer_manager = order_bind.buffer_manager;
 		RowLayout payload_layout;
-		payload_layout.Initialize(order_bind->arg_types);
+		payload_layout.Initialize(order_bind.arg_types);
 		DataChunk chunk;
-		chunk.Initialize(Allocator::DefaultAllocator(), order_bind->arg_types);
+		chunk.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
+		DataChunk sliced;
+		sliced.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
 
 		//	 Reusable inner state
-		vector<data_t> agg_state(order_bind->function.state_size());
+		vector<data_t> agg_state(order_bind.function.state_size());
 		Vector agg_state_vec(Value::POINTER((idx_t)agg_state.data()));
 
 		// State variables
-		const auto input_count = order_bind->function.arguments.size();
-		auto bind_info = order_bind->bind_info.get();
+		auto bind_info = order_bind.bind_info.get();
 		AggregateInputData aggr_bind_info(bind_info, Allocator::DefaultAllocator());
 
 		// Inner aggregate APIs
-		auto initialize = order_bind->function.initialize;
-		auto destructor = order_bind->function.destructor;
-		auto simple_update = order_bind->function.simple_update;
-		auto update = order_bind->function.update;
-		auto finalize = order_bind->function.finalize;
+		auto initialize = order_bind.function.initialize;
+		auto destructor = order_bind.function.destructor;
+		auto simple_update = order_bind.function.simple_update;
+		auto update = order_bind.function.update;
+		auto finalize = order_bind.function.finalize;
 
 		auto sdata = FlatVector::GetData<SortedAggregateState *>(states);
+
+		vector<idx_t> state_unprocessed(count, 0);
 		for (idx_t i = 0; i < count; ++i) {
-			initialize(agg_state.data());
-			auto state = sdata[i];
-
-			// Apply the sort before delegating the chunks
-			auto global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
-			LocalSortState local_sort;
-			local_sort.Initialize(*global_sort, global_sort->buffer_manager);
-			state->Finalize(*order_bind, local_sort);
-			global_sort->AddLocalState(local_sort);
-
-			if (!global_sort->sorted_blocks.empty()) {
-				global_sort->PrepareMergePhase();
-				while (global_sort->sorted_blocks.size() > 1) {
-					global_sort->InitializeMergeRound();
-					MergeSorter merge_sorter(*global_sort, global_sort->buffer_manager);
-					merge_sorter.PerformInMergeRound();
-					global_sort->CompleteMergeRound(false);
+			state_unprocessed[i] = sdata[i]->count;
+		}
+
+		// Sort the input payloads on (state_idx ASC, orders)
+		vector<BoundOrderByNode> orders;
+		orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST,
+		                                     make_uniq<BoundConstantExpression>(Value::USMALLINT(0))));
+		for (const auto &order : order_bind.orders) {
+			orders.emplace_back(order.Copy());
+		}
+
+		auto global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
+		global_sort->external = order_bind.external;
+		auto local_sort = make_uniq<LocalSortState>();
+		local_sort->Initialize(*global_sort, global_sort->buffer_manager);
+
+		DataChunk prefixed;
+		prefixed.Initialize(Allocator::DefaultAllocator(), global_sort->sort_layout.logical_types);
+
+		//	Go through the states accumulating values to sort until we hit the sort threshold
+		idx_t unsorted_count = 0;
+		idx_t sorted = 0;
+		for (idx_t finalized = 0; finalized < count;) {
+			if (unsorted_count < order_bind.threshold) {
+				auto state = sdata[finalized];
+				prefixed.Reset();
+				prefixed.data[0].Reference(Value::USMALLINT(finalized));
+				state->Finalize(order_bind, prefixed, *local_sort);
+				unsorted_count += state_unprocessed[finalized];
+
+				// Go to the next aggregate unless this is the last one
+				if (++finalized < count) {
+					continue;
 				}
+			}
+
+			//	If they were all empty (filtering) flush them
+			//	(This can only happen on the last range)
+			if (!unsorted_count) {
+				break;
+			}
+
+			//	Sort all the data
+			global_sort->AddLocalState(*local_sort);
+			global_sort->PrepareMergePhase();
+			while (global_sort->sorted_blocks.size() > 1) {
+				global_sort->InitializeMergeRound();
+				MergeSorter merge_sorter(*global_sort, global_sort->buffer_manager);
+				merge_sorter.PerformInMergeRound();
+				global_sort->CompleteMergeRound(false);
+			}
 
-				PayloadScanner scanner(*global_sort);
-				for (;;) {
-					chunk.Reset();
-					scanner.Scan(chunk);
-					if (chunk.size() == 0) {
-						break;
+			auto scanner = make_uniq<PayloadScanner>(*global_sort);
+			initialize(agg_state.data());
+			while (scanner->Remaining()) {
+				chunk.Reset();
+				scanner->Scan(chunk);
+				idx_t consumed = 0;
+
+				// Distribute the scanned chunk to the aggregates
+				while (consumed < chunk.size()) {
+					//	Find the next aggregate that needs data
+					for (; !state_unprocessed[sorted]; ++sorted) {
+						// Finalize a single value at the next offset
+						agg_state_vec.SetVectorType(states.GetVectorType());
+						finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
+						if (destructor) {
+							destructor(agg_state_vec, aggr_bind_info, 1);
+						}
+
+						initialize(agg_state.data());
+					}
+					const auto input_count = MinValue(state_unprocessed[sorted], chunk.size() - consumed);
+					for (column_t col_idx = 0; col_idx < chunk.ColumnCount(); ++col_idx) {
+						sliced.data[col_idx].Slice(chunk.data[col_idx], consumed, consumed + input_count);
 					}
+					sliced.SetCardinality(input_count);
+
 					// These are all simple updates, so use it if available
 					if (simple_update) {
-						simple_update(chunk.data.data(), aggr_bind_info, input_count, agg_state.data(), chunk.size());
+						simple_update(sliced.data.data(), aggr_bind_info, 1, agg_state.data(), sliced.size());
 					} else {
 						// We are only updating a constant state
 						agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-						update(chunk.data.data(), aggr_bind_info, input_count, agg_state_vec, chunk.size());
+						update(sliced.data.data(), aggr_bind_info, 1, agg_state_vec, sliced.size());
 					}
+
+					consumed += input_count;
+					state_unprocessed[sorted] -= input_count;
 				}
 			}
 
+			//	Finalize the last state for this sort
+			agg_state_vec.SetVectorType(states.GetVectorType());
+			finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
+			if (destructor) {
+				destructor(agg_state_vec, aggr_bind_info, 1);
+			}
+			++sorted;
+
+			//	Stop if we are done
+			if (finalized >= count) {
+				break;
+			}
+
+			//	Create a new sort
+			scanner.reset();
+			global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
+			global_sort->external = order_bind.external;
+			local_sort = make_uniq<LocalSortState>();
+			local_sort->Initialize(*global_sort, global_sort->buffer_manager);
+			unsorted_count = 0;
+		}
+
+		for (; sorted < count; ++sorted) {
+			initialize(agg_state.data());
+
 			// Finalize a single value at the next offset
 			agg_state_vec.SetVectorType(states.GetVectorType());
-			finalize(agg_state_vec, aggr_bind_info, result, 1, i + offset);
+			finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
 
 			if (destructor) {
 				destructor(agg_state_vec, aggr_bind_info, 1);
 			}
 		}
+
+		result.Verify(count);
 	}
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
@@ -429,15 +538,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/operators/arithmetic.cpp

@@ -907,23 +907,29 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
 }
 
 void DivideFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("/");
+	ScalarFunctionSet fp_divide("/");
+	fp_divide.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::FLOAT)));
+	fp_divide.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::DOUBLE)));
+	fp_divide.AddFunction(
+	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
+	set.AddFunction(fp_divide);
+
+	ScalarFunctionSet full_divide("//");
 	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			continue;
 		} else {
-			functions.AddFunction(
+			full_divide.AddFunction(
 			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type)));
 		}
 	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
+	set.AddFunction(full_divide);
 
-	set.AddFunction(functions);
-
-	functions.name = "divide";
-	set.AddFunction(functions);
+	full_divide.name = "divide";
+	set.AddFunction(full_divide);
 }
 
 //===--------------------------------------------------------------------===//

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);
 	}
 }