duckdb 1.1.2-dev2.0 → 1.1.2-dev6.0

package/src/duckdb/src/core_functions/scalar/date/date_diff.cpp

@@ -28,6 +28,14 @@ struct DateDiff {
 		    });
 	}
 
+	//	We need to truncate down, not towards 0
+	static inline int64_t Truncate(int64_t value, int64_t units) {
+		return (value + (value < 0)) / units - (value < 0);
+	}
+	static inline int64_t Diff(int64_t start, int64_t end, int64_t units) {
+		return Truncate(end, units) - Truncate(start, units);
+	}
+
 	struct YearOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA startdate, TB enddate) {
@@ -204,30 +212,28 @@ template <>
 int64_t DateDiff::MillisecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
 	D_ASSERT(Timestamp::IsFinite(startdate));
 	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Timestamp::GetEpochMs(enddate) - Timestamp::GetEpochMs(startdate);
+	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_MSEC);
 }
 
 template <>
 int64_t DateDiff::SecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
 	D_ASSERT(Timestamp::IsFinite(startdate));
 	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Timestamp::GetEpochSeconds(enddate) - Timestamp::GetEpochSeconds(startdate);
+	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_SEC);
 }
 
 template <>
 int64_t DateDiff::MinutesOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
 	D_ASSERT(Timestamp::IsFinite(startdate));
 	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_MINUTE -
-	       Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_MINUTE;
+	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_MINUTE);
 }
 
 template <>
 int64_t DateDiff::HoursOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
 	D_ASSERT(Timestamp::IsFinite(startdate));
 	D_ASSERT(Timestamp::IsFinite(enddate));
-	return Timestamp::GetEpochSeconds(enddate) / Interval::SECS_PER_HOUR -
-	       Timestamp::GetEpochSeconds(startdate) / Interval::SECS_PER_HOUR;
+	return Diff(startdate.value, enddate.value, Interval::MICROS_PER_HOUR);
 }
 
 // TIME specialisations

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -412,7 +412,7 @@ struct DatePart {
 			D_ASSERT(input.ColumnCount() == 1);
 
 			UnaryExecutor::Execute<int64_t, timestamp_t>(input.data[0], result, input.size(), [&](int64_t input) {
-				// milisecond amounts provided to epoch_ms should never be considered infinite
+				// millisecond amounts provided to epoch_ms should never be considered infinite
 				// instead such values will just throw when converted to microseconds
 				return Timestamp::FromEpochMsPossiblyInfinite(input);
 			});

package/src/duckdb/src/execution/expression_executor/execute_between.cpp

@@ -89,9 +89,10 @@ static idx_t BetweenLoopTypeSwitch(Vector &input, Vector &lower, Vector &upper,
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundBetweenExpression &expr,
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ExpressionState>(expr, root);
-	result->AddChild(expr.input.get());
-	result->AddChild(expr.lower.get());
-	result->AddChild(expr.upper.get());
+	result->AddChild(*expr.input);
+	result->AddChild(*expr.lower);
+	result->AddChild(*expr.upper);
+
 	result->Finalize();
 	return result;
 }

package/src/duckdb/src/execution/expression_executor/execute_case.cpp

@@ -18,10 +18,11 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCaseE
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<CaseExpressionState>(expr, root);
 	for (auto &case_check : expr.case_checks) {
-		result->AddChild(case_check.when_expr.get());
-		result->AddChild(case_check.then_expr.get());
+		result->AddChild(*case_check.when_expr);
+		result->AddChild(*case_check.then_expr);
 	}
-	result->AddChild(expr.else_expr.get());
+	result->AddChild(*expr.else_expr);
+
 	result->Finalize();
 	return std::move(result);
 }

package/src/duckdb/src/execution/expression_executor/execute_cast.cpp

@@ -8,8 +8,9 @@ namespace duckdb {
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastExpression &expr,
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ExecuteFunctionState>(expr, root);
-	result->AddChild(expr.child.get());
+	result->AddChild(*expr.child);
 	result->Finalize();
+
 	if (expr.bound_cast.init_local_state) {
 		CastLocalStateParameters parameters(root.executor->GetContext(), expr.bound_cast.cast_data);
 		result->local_state = expr.bound_cast.init_local_state(parameters);

package/src/duckdb/src/execution/expression_executor/execute_comparison.cpp

@@ -12,8 +12,9 @@ namespace duckdb {
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundComparisonExpression &expr,
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ExpressionState>(expr, root);
-	result->AddChild(expr.left.get());
-	result->AddChild(expr.right.get());
+	result->AddChild(*expr.left);
+	result->AddChild(*expr.right);
+
 	result->Finalize();
 	return result;
 }

package/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp

@@ -18,8 +18,9 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConju
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ConjunctionState>(expr, root);
 	for (auto &child : expr.children) {
-		result->AddChild(child.get());
+		result->AddChild(*child);
 	}
+
 	result->Finalize();
 	return std::move(result);
 }

package/src/duckdb/src/execution/expression_executor/execute_function.cpp

@@ -14,8 +14,9 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundFunct
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ExecuteFunctionState>(expr, root);
 	for (auto &child : expr.children) {
-		result->AddChild(child.get());
+		result->AddChild(*child);
 	}
+
 	result->Finalize();
 	if (expr.function.init_local_state) {
 		result->local_state = expr.function.init_local_state(*result, expr, expr.bind_info.get());

package/src/duckdb/src/execution/expression_executor/execute_operator.cpp

@@ -8,8 +8,9 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundOpera
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ExpressionState>(expr, root);
 	for (auto &child : expr.children) {
-		result->AddChild(child.get());
+		result->AddChild(*child);
 	}
+
 	result->Finalize();
 	return result;
 }
@@ -33,7 +34,7 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
 		intermediate.Reference(false_val);
 
 		// in rhs is a list of constants
-		// for every child, OR the result of the comparision with the left
+		// for every child, OR the result of the comparison with the left
 		// to get the overall result.
 		for (idx_t child = 1; child < expr.children.size(); child++) {
 			Vector vector_to_check(expr.children[child]->return_type);

package/src/duckdb/src/execution/expression_executor/execute_reference.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundReferenceExpression &expr,
                                                                 ExpressionExecutorState &root) {
 	auto result = make_uniq<ExpressionState>(expr, root);
-	result->Finalize(true);
+	result->Finalize();
 	return result;
 }
 

package/src/duckdb/src/execution/expression_executor.cpp

@@ -170,10 +170,16 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const Expression
 void ExpressionExecutor::Execute(const Expression &expr, ExpressionState *state, const SelectionVector *sel,
                                  idx_t count, Vector &result) {
 #ifdef DEBUG
-	// the result vector has to be used for the first time or has to be reset
-	// otherwise, the validity mask might contain previous (now incorrect) data
+	// The result vector must be used for the first time, or must be reset.
+	// Otherwise, the validity mask can contain previous (now incorrect) data.
 	if (result.GetVectorType() == VectorType::FLAT_VECTOR) {
-		D_ASSERT(FlatVector::Validity(result).CheckAllValid(count));
+
+		// We do not initialize vector caches for these expressions.
+		if (expr.GetExpressionClass() != ExpressionClass::BOUND_REF &&
+		    expr.GetExpressionClass() != ExpressionClass::BOUND_CONSTANT &&
+		    expr.GetExpressionClass() != ExpressionClass::BOUND_PARAMETER) {
+			D_ASSERT(FlatVector::Validity(result).CheckAllValid(count));
+		}
 	}
 #endif
 

package/src/duckdb/src/execution/expression_executor_state.cpp

@@ -6,20 +6,22 @@
 
 namespace duckdb {
 
-void ExpressionState::AddChild(Expression *expr) {
-	types.push_back(expr->return_type);
-	child_states.push_back(ExpressionExecutor::InitializeState(*expr, root));
+void ExpressionState::AddChild(Expression &child_expr) {
+	types.push_back(child_expr.return_type);
+	auto child_state = ExpressionExecutor::InitializeState(child_expr, root);
+	child_states.push_back(std::move(child_state));
+
+	auto expr_class = child_expr.GetExpressionClass();
+	auto initialize_child = expr_class != ExpressionClass::BOUND_REF && expr_class != ExpressionClass::BOUND_CONSTANT &&
+	                        expr_class != ExpressionClass::BOUND_PARAMETER;
+	initialize.push_back(initialize_child);
 }
 
-void ExpressionState::Finalize(bool empty) {
+void ExpressionState::Finalize() {
 	if (types.empty()) {
 		return;
 	}
-	if (empty) {
-		intermediate_chunk.InitializeEmpty(types);
-	} else {
-		intermediate_chunk.Initialize(GetAllocator(), types);
-	}
+	intermediate_chunk.Initialize(GetAllocator(), types, initialize);
 }
 
 Allocator &ExpressionState::GetAllocator() {

package/src/duckdb/src/execution/index/art/fixed_size_allocator.cpp

@@ -0,0 +1,238 @@
+#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+
+namespace duckdb {
+
+constexpr idx_t FixedSizeAllocator::BASE[];
+constexpr uint8_t FixedSizeAllocator::SHIFT[];
+
+FixedSizeAllocator::FixedSizeAllocator(const idx_t allocation_size, Allocator &allocator)
+    : allocation_size(allocation_size), total_allocations(0), allocator(allocator) {
+
+	// calculate how many allocations fit into one buffer
+
+	idx_t bits_per_value = sizeof(validity_t) * 8;
+	idx_t curr_alloc_size = 0;
+
+	bitmask_count = 0;
+	allocations_per_buffer = 0;
+
+	while (curr_alloc_size < BUFFER_ALLOC_SIZE) {
+		if (!bitmask_count || (bitmask_count * bits_per_value) % allocations_per_buffer == 0) {
+			bitmask_count++;
+			curr_alloc_size += sizeof(validity_t);
+		}
+
+		auto remaining_alloc_size = BUFFER_ALLOC_SIZE - curr_alloc_size;
+		auto remaining_allocations = MinValue(remaining_alloc_size / allocation_size, bits_per_value);
+
+		if (remaining_allocations == 0) {
+			break;
+		}
+
+		allocations_per_buffer += remaining_allocations;
+		curr_alloc_size += remaining_allocations * allocation_size;
+	}
+
+	allocation_offset = bitmask_count * sizeof(validity_t);
+}
+
+FixedSizeAllocator::~FixedSizeAllocator() {
+	for (auto &buffer : buffers) {
+		allocator.FreeData(buffer.ptr, BUFFER_ALLOC_SIZE);
+	}
+}
+
+Node FixedSizeAllocator::New() {
+
+	// no more free pointers
+	if (buffers_with_free_space.empty()) {
+
+		// add a new buffer
+		idx_t buffer_id = buffers.size();
+		D_ASSERT(buffer_id <= (uint32_t)DConstants::INVALID_INDEX);
+		auto buffer = allocator.AllocateData(BUFFER_ALLOC_SIZE);
+		buffers.emplace_back(buffer, 0);
+		buffers_with_free_space.insert(buffer_id);
+
+		// set the bitmask
+		ValidityMask mask(reinterpret_cast<validity_t *>(buffer));
+		mask.SetAllValid(allocations_per_buffer);
+	}
+
+	// return a pointer
+	D_ASSERT(!buffers_with_free_space.empty());
+	auto buffer_id = (uint32_t)*buffers_with_free_space.begin();
+
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[buffer_id].ptr);
+	ValidityMask mask(bitmask_ptr);
+	auto offset = GetOffset(mask, buffers[buffer_id].allocation_count);
+
+	buffers[buffer_id].allocation_count++;
+	total_allocations++;
+	if (buffers[buffer_id].allocation_count == allocations_per_buffer) {
+		buffers_with_free_space.erase(buffer_id);
+	}
+
+	return Node(buffer_id, offset);
+}
+
+void FixedSizeAllocator::Free(const Node ptr) {
+	auto bitmask_ptr = reinterpret_cast<validity_t *>(buffers[ptr.GetBufferId()].ptr);
+	ValidityMask mask(bitmask_ptr);
+	D_ASSERT(!mask.RowIsValid(ptr.GetOffset()));
+	mask.SetValid(ptr.GetOffset());
+	buffers_with_free_space.insert(ptr.GetBufferId());
+
+	D_ASSERT(total_allocations > 0);
+	D_ASSERT(buffers[ptr.GetBufferId()].allocation_count > 0);
+	buffers[ptr.GetBufferId()].allocation_count--;
+	total_allocations--;
+}
+
+void FixedSizeAllocator::Reset() {
+
+	for (auto &buffer : buffers) {
+		allocator.FreeData(buffer.ptr, BUFFER_ALLOC_SIZE);
+	}
+	buffers.clear();
+	buffers_with_free_space.clear();
+	total_allocations = 0;
+}
+
+void FixedSizeAllocator::Merge(FixedSizeAllocator &other) {
+
+	D_ASSERT(allocation_size == other.allocation_size);
+
+	// remember the buffer count and merge the buffers
+	idx_t buffer_count = buffers.size();
+	for (auto &buffer : other.buffers) {
+		buffers.push_back(buffer);
+	}
+	other.buffers.clear();
+
+	// merge the buffers with free spaces
+	for (auto &buffer_id : other.buffers_with_free_space) {
+		buffers_with_free_space.insert(buffer_id + buffer_count);
+	}
+	other.buffers_with_free_space.clear();
+
+	// add the total allocations
+	total_allocations += other.total_allocations;
+}
+
+bool FixedSizeAllocator::InitializeVacuum() {
+
+	if (total_allocations == 0) {
+		Reset();
+		return false;
+	}
+
+	auto total_available_allocations = allocations_per_buffer * buffers.size();
+	D_ASSERT(total_available_allocations >= total_allocations);
+	auto total_free_positions = total_available_allocations - total_allocations;
+
+	// vacuum_count buffers can be freed
+	auto vacuum_count = total_free_positions / allocations_per_buffer;
+
+	// calculate the vacuum threshold adaptively
+	D_ASSERT(vacuum_count < buffers.size());
+	idx_t memory_usage = GetMemoryUsage();
+	idx_t excess_memory_usage = vacuum_count * BUFFER_ALLOC_SIZE;
+	auto excess_percentage = (double)excess_memory_usage / (double)memory_usage;
+	auto threshold = (double)VACUUM_THRESHOLD / 100.0;
+	if (excess_percentage < threshold) {
+		return false;
+	}
+
+	min_vacuum_buffer_id = buffers.size() - vacuum_count;
+
+	// remove all invalid buffers from the available buffer list to ensure that we do not reuse them
+	auto it = buffers_with_free_space.begin();
+	while (it != buffers_with_free_space.end()) {
+		if (*it >= min_vacuum_buffer_id) {
+			it = buffers_with_free_space.erase(it);
+		} else {
+			it++;
+		}
+	}
+
+	return true;
+}
+
+void FixedSizeAllocator::FinalizeVacuum() {
+
+	// free all (now unused) buffers
+	while (min_vacuum_buffer_id < buffers.size()) {
+		allocator.FreeData(buffers.back().ptr, BUFFER_ALLOC_SIZE);
+		buffers.pop_back();
+	}
+}
+
+Node FixedSizeAllocator::VacuumPointer(const Node ptr) {
+
+	// we do not need to adjust the bitmask of the old buffer, because we will free the entire
+	// buffer after the vacuum operation
+
+	auto new_ptr = New();
+
+	// new increases the allocation count
+	total_allocations--;
+
+	memcpy(Get(new_ptr), Get(ptr), allocation_size);
+	return new_ptr;
+}
+
+void FixedSizeAllocator::Verify() const {
+#ifdef DEBUG
+	auto total_available_allocations = allocations_per_buffer * buffers.size();
+	D_ASSERT(total_available_allocations >= total_allocations);
+	D_ASSERT(buffers.size() >= buffers_with_free_space.size());
+#endif
+}
+
+uint32_t FixedSizeAllocator::GetOffset(ValidityMask &mask, const idx_t allocation_count) {
+
+	auto data = mask.GetData();
+
+	// fills up a buffer sequentially before searching for free bits
+	if (mask.RowIsValid(allocation_count)) {
+		mask.SetInvalid(allocation_count);
+		return allocation_count;
+	}
+
+	// get an entry with free bits
+	for (idx_t entry_idx = 0; entry_idx < bitmask_count; entry_idx++) {
+		if (data[entry_idx] != 0) {
+
+			// find the position of the free bit
+			auto entry = data[entry_idx];
+			idx_t first_valid_bit = 0;
+
+			// this loop finds the position of the rightmost set bit in entry and stores it
+			// in first_valid_bit
+			for (idx_t i = 0; i < 6; i++) {
+				// set the left half of the bits of this level to zero and test if the entry is still not zero
+				if (entry & BASE[i]) {
+					// first valid bit is in the rightmost s[i] bits
+					// permanently set the left half of the bits to zero
+					entry &= BASE[i];
+				} else {
+					// first valid bit is in the leftmost s[i] bits
+					// shift by s[i] for the next iteration and add s[i] to the position of the rightmost set bit
+					entry >>= SHIFT[i];
+					first_valid_bit += SHIFT[i];
+				}
+			}
+			D_ASSERT(entry);
+
+			auto prev_bits = entry_idx * sizeof(validity_t) * 8;
+			D_ASSERT(mask.RowIsValid(prev_bits + first_valid_bit));
+			mask.SetInvalid(prev_bits + first_valid_bit);
+			return (prev_bits + first_valid_bit);
+		}
+	}
+
+	throw InternalException("Invalid bitmask of FixedSizeAllocator");
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/index/art/plan_art.cpp

@@ -0,0 +1,94 @@
+
+#include "duckdb/execution/operator/order/physical_order.hpp"
+#include "duckdb/execution/operator/projection/physical_projection.hpp"
+#include "duckdb/execution/operator/filter/physical_filter.hpp"
+#include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
+
+#include "duckdb/planner/expression/bound_operator_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/operator/logical_create_index.hpp"
+
+#include "duckdb/execution/index/art/art.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> ART::CreatePlan(PlanIndexInput &input) {
+	// generate a physical plan for the parallel index creation which consists of the following operators
+	// table scan - projection (for expression execution) - filter (NOT NULL) - order (if applicable) - create index
+
+	auto &op = input.op;
+	auto &table_scan = input.table_scan;
+
+	vector<LogicalType> new_column_types;
+	vector<unique_ptr<Expression>> select_list;
+	for (idx_t i = 0; i < op.expressions.size(); i++) {
+		new_column_types.push_back(op.expressions[i]->return_type);
+		select_list.push_back(std::move(op.expressions[i]));
+	}
+	new_column_types.emplace_back(LogicalType::ROW_TYPE);
+	select_list.push_back(make_uniq<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
+
+	auto projection = make_uniq<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
+	projection->children.push_back(std::move(table_scan));
+
+	// filter operator for IS_NOT_NULL on each key column
+
+	vector<LogicalType> filter_types;
+	vector<unique_ptr<Expression>> filter_select_list;
+
+	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
+		filter_types.push_back(new_column_types[i]);
+		auto is_not_null_expr =
+		    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
+		auto bound_ref = make_uniq<BoundReferenceExpression>(new_column_types[i], i);
+		is_not_null_expr->children.push_back(std::move(bound_ref));
+		filter_select_list.push_back(std::move(is_not_null_expr));
+	}
+
+	auto null_filter =
+	    make_uniq<PhysicalFilter>(std::move(filter_types), std::move(filter_select_list), op.estimated_cardinality);
+	null_filter->types.emplace_back(LogicalType::ROW_TYPE);
+	null_filter->children.push_back(std::move(projection));
+
+	// determine if we sort the data prior to index creation
+	// we don't sort, if either VARCHAR or compound key
+	auto perform_sorting = true;
+	if (op.unbound_expressions.size() > 1) {
+		perform_sorting = false;
+	} else if (op.unbound_expressions[0]->return_type.InternalType() == PhysicalType::VARCHAR) {
+		perform_sorting = false;
+	}
+
+	// actual physical create index operator
+
+	auto physical_create_index =
+	    make_uniq<PhysicalCreateARTIndex>(op, op.table, op.info->column_ids, std::move(op.info),
+	                                      std::move(op.unbound_expressions), op.estimated_cardinality, perform_sorting);
+
+	if (perform_sorting) {
+
+		// optional order operator
+		vector<BoundOrderByNode> orders;
+		vector<idx_t> projections;
+		for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
+			auto col_expr = make_uniq_base<Expression, BoundReferenceExpression>(new_column_types[i], i);
+			orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(col_expr));
+			projections.emplace_back(i);
+		}
+		projections.emplace_back(new_column_types.size() - 1);
+
+		auto physical_order = make_uniq<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections),
+		                                               op.estimated_cardinality);
+		physical_order->children.push_back(std::move(null_filter));
+
+		physical_create_index->children.push_back(std::move(physical_order));
+	} else {
+
+		// no ordering
+		physical_create_index->children.push_back(std::move(null_filter));
+	}
+
+	return std::move(physical_create_index);
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/index/index_type_set.cpp

@@ -5,10 +5,13 @@
 namespace duckdb {
 
 IndexTypeSet::IndexTypeSet() {
-	// Register the ART index type
+
+	// Register the ART index type by default
 	IndexType art_index_type;
 	art_index_type.name = ART::TYPE_NAME;
 	art_index_type.create_instance = ART::Create;
+	art_index_type.create_plan = ART::CreatePlan;
+
 	RegisterIndexType(art_index_type);
 }
 

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -453,23 +453,21 @@ static inline data_ptr_t InsertRowToEntry(atomic<ht_entry_t> &entry, const data_
 		// if we expect the entry to be empty, if the operation fails we need to cancel the whole operation as another
 		// key might have been inserted in the meantime that does not match the current key
 		if (EXPECT_EMPTY) {
-
 			// add nullptr to the end of the list to mark the end
 			StorePointer(nullptr, row_ptr_to_insert + pointer_offset);
 
 			ht_entry_t new_empty_entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt);
 			ht_entry_t expected_empty_entry = ht_entry_t::GetEmptyEntry();
-			std::atomic_compare_exchange_weak(&entry, &expected_empty_entry, new_empty_entry);
+			entry.compare_exchange_strong(expected_empty_entry, new_empty_entry, std::memory_order_acquire,
+			                              std::memory_order_relaxed);
 
 			// if the expected empty entry actually was null, we can just return the pointer, and it will be a nullptr
 			// if the expected entry was filled in the meantime, we need to cancel the operation and will return the
 			// pointer to the next entry
 			return expected_empty_entry.GetPointerOrNull();
-		}
-
-		// if we expect the entry to be full, we know that even if the insert fails the keys still match so we can
-		// just keep trying until we succeed
-		else {
+		} else {
+			// if we expect the entry to be full, we know that even if the insert fails the keys still match so we can
+			// just keep trying until we succeed
 			ht_entry_t expected_current_entry = entry.load(std::memory_order_relaxed);
 			ht_entry_t desired_new_entry = ht_entry_t::GetDesiredEntry(row_ptr_to_insert, salt);
 			D_ASSERT(expected_current_entry.IsOccupied());
@@ -477,7 +475,8 @@ static inline data_ptr_t InsertRowToEntry(atomic<ht_entry_t> &entry, const data_
 			do {
 				data_ptr_t current_row_pointer = expected_current_entry.GetPointer();
 				StorePointer(current_row_pointer, row_ptr_to_insert + pointer_offset);
-			} while (!std::atomic_compare_exchange_weak(&entry, &expected_current_entry, desired_new_entry));
+			} while (!entry.compare_exchange_weak(expected_current_entry, desired_new_entry, std::memory_order_release,
+			                                      std::memory_order_relaxed));
 
 			return nullptr;
 		}

package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp

@@ -319,15 +319,17 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Data
 			for (idx_t group_idx = 0; group_idx < grouped_aggregate_data.groups.size(); group_idx++) {
 				auto &group = grouped_aggregate_data.groups[group_idx];
 				auto &bound_ref = group->Cast<BoundReferenceExpression>();
-				filtered_input.data[bound_ref.index].Reference(chunk.data[bound_ref.index]);
+				auto &col = filtered_input.data[bound_ref.index];
+				col.Reference(chunk.data[bound_ref.index]);
+				col.Slice(sel_vec, count);
 			}
 			for (idx_t child_idx = 0; child_idx < aggregate.children.size(); child_idx++) {
 				auto &child = aggregate.children[child_idx];
 				auto &bound_ref = child->Cast<BoundReferenceExpression>();
-
-				filtered_input.data[bound_ref.index].Reference(chunk.data[bound_ref.index]);
+				auto &col = filtered_input.data[bound_ref.index];
+				col.Reference(chunk.data[bound_ref.index]);
+				col.Slice(sel_vec, count);
 			}
-			filtered_input.Slice(sel_vec, count);
 			filtered_input.SetCardinality(count);
 
 			radix_table.Sink(context, filtered_input, sink_input, empty_chunk, empty_filter);

package/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp

@@ -119,15 +119,15 @@ void CSVBufferManager::ResetBuffer(const idx_t buffer_idx) {
 	}
 }
 
-idx_t CSVBufferManager::GetBufferSize() {
+idx_t CSVBufferManager::GetBufferSize() const {
 	return buffer_size;
 }
 
-idx_t CSVBufferManager::BufferCount() {
+idx_t CSVBufferManager::BufferCount() const {
 	return cached_buffers.size();
 }
 
-bool CSVBufferManager::Done() {
+bool CSVBufferManager::Done() const {
 	return done;
 }
 
@@ -144,7 +144,7 @@ void CSVBufferManager::ResetBufferManager() {
 	}
 }
 
-string CSVBufferManager::GetFilePath() {
+string CSVBufferManager::GetFilePath() const {
 	return file_path;
 }