duckdb 0.7.2-dev1734.0 → 0.7.2-dev1867.0

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -14,44 +14,47 @@ namespace duckdb {
 DependencyManager::DependencyManager(DuckCatalog &catalog) : catalog(catalog) {
 }
 
-void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry *object, DependencyList &dependencies) {
+void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry &object, DependencyList &dependencies) {
 	// check for each object in the sources if they were not deleted yet
-	for (auto &dependency : dependencies.set) {
+	for (auto &dep : dependencies.set) {
+		auto &dependency = dep.get();
 		CatalogEntry *catalog_entry;
-		if (dependency->catalog != object->catalog) {
+		if (dependency.catalog != object.catalog) {
 			throw DependencyException(
 			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
 			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
-			    object->name, dependency->name, dependency->catalog->GetName(), object->catalog->GetName());
+			    object.name, dependency.name, dependency.catalog->GetName(), object.catalog->GetName());
 		}
-		if (!dependency->set) {
+		if (!dependency.set) {
 			throw InternalException("Dependency has no set");
 		}
-		if (!dependency->set->GetEntryInternal(transaction, dependency->name, nullptr, catalog_entry)) {
+		if (!dependency.set->GetEntryInternal(transaction, dependency.name, nullptr, catalog_entry)) {
 			throw InternalException("Dependency has already been deleted?");
 		}
 	}
 	// indexes do not require CASCADE to be dropped, they are simply always dropped along with the table
-	auto dependency_type = object->type == CatalogType::INDEX_ENTRY ? DependencyType::DEPENDENCY_AUTOMATIC
-	                                                                : DependencyType::DEPENDENCY_REGULAR;
+	auto dependency_type = object.type == CatalogType::INDEX_ENTRY ? DependencyType::DEPENDENCY_AUTOMATIC
+	                                                               : DependencyType::DEPENDENCY_REGULAR;
 	// add the object to the dependents_map of each object that it depends on
 	for (auto &dependency : dependencies.set) {
-		dependents_map[dependency].insert(Dependency(object, dependency_type));
+		auto &set = dependents_map[dependency];
+		set.insert(Dependency(object, dependency_type));
 	}
 	// create the dependents map for this object: it starts out empty
 	dependents_map[object] = dependency_set_t();
 	dependencies_map[object] = dependencies.set;
 }
 
-void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry *object, bool cascade) {
+void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade) {
 	D_ASSERT(dependents_map.find(object) != dependents_map.end());
 
 	// first check the objects that depend on this object
 	auto &dependent_objects = dependents_map[object];
 	for (auto &dep : dependent_objects) {
 		// look up the entry in the catalog set
-		auto &catalog_set = *dep.entry->set;
-		auto mapping_value = catalog_set.GetMapping(transaction, dep.entry->name, true /* get_latest */);
+		auto &entry = dep.entry.get();
+		auto &catalog_set = *entry.set;
+		auto mapping_value = catalog_set.GetMapping(transaction, entry.name, true /* get_latest */);
 		if (mapping_value == nullptr) {
 			continue;
 		}
@@ -70,23 +73,24 @@ void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry
 			// no cascade and there are objects that depend on this object: throw error
 			throw DependencyException("Cannot drop entry \"%s\" because there are entries that "
 			                          "depend on it. Use DROP...CASCADE to drop all dependents.",
-			                          object->name);
+			                          object.name);
 		}
 	}
 }
 
-void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry *old_obj, CatalogEntry *new_obj) {
+void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj) {
 	D_ASSERT(dependents_map.find(old_obj) != dependents_map.end());
 	D_ASSERT(dependencies_map.find(old_obj) != dependencies_map.end());
 
 	// first check the objects that depend on this object
-	vector<CatalogEntry *> owned_objects_to_add;
+	catalog_entry_vector_t owned_objects_to_add;
 	auto &dependent_objects = dependents_map[old_obj];
 	for (auto &dep : dependent_objects) {
 		// look up the entry in the catalog set
-		auto &catalog_set = *dep.entry->set;
+		auto &entry = dep.entry.get();
+		auto &catalog_set = *entry.set;
 		CatalogEntry *dependency_entry;
-		if (!catalog_set.GetEntryInternal(transaction, dep.entry->name, nullptr, dependency_entry)) {
+		if (!catalog_set.GetEntryInternal(transaction, entry.name, nullptr, dependency_entry)) {
 			// the dependent object was already deleted, no conflict
 			continue;
 		}
@@ -99,15 +103,16 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 		// no cascade and there are objects that depend on this object: throw error
 		throw DependencyException("Cannot alter entry \"%s\" because there are entries that "
 		                          "depend on it.",
-		                          old_obj->name);
+		                          old_obj.name);
 	}
 	// add the new object to the dependents_map of each object that it depends on
 	auto &old_dependencies = dependencies_map[old_obj];
-	vector<CatalogEntry *> to_delete;
-	for (auto &dependency : old_dependencies) {
-		if (dependency->type == CatalogType::TYPE_ENTRY) {
-			auto &user_type = dependency->Cast<TypeCatalogEntry>();
-			auto &table = new_obj->Cast<TableCatalogEntry>();
+	catalog_entry_vector_t to_delete;
+	for (auto &dep : old_dependencies) {
+		auto &dependency = dep.get();
+		if (dependency.type == CatalogType::TYPE_ENTRY) {
+			auto &user_type = dependency.Cast<TypeCatalogEntry>();
+			auto &table = new_obj.Cast<TableCatalogEntry>();
 			bool deleted_dependency = true;
 			for (auto &column : table.GetColumns().Logical()) {
 				if (column.Type() == user_type.user_type) {
@@ -122,19 +127,20 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 		}
 		dependents_map[dependency].insert(new_obj);
 	}
-	for (auto &dependency : to_delete) {
+	for (auto &dep : to_delete) {
+		auto &dependency = dep.get();
 		old_dependencies.erase(dependency);
 		dependents_map[dependency].erase(old_obj);
 	}
 
 	// We might have to add a type dependency
-	vector<CatalogEntry *> to_add;
-	if (new_obj->type == CatalogType::TABLE_ENTRY) {
-		auto table = (TableCatalogEntry *)new_obj;
-		for (auto &column : table->GetColumns().Logical()) {
+	catalog_entry_vector_t to_add;
+	if (new_obj.type == CatalogType::TABLE_ENTRY) {
+		auto &table = new_obj.Cast<TableCatalogEntry>();
+		for (auto &column : table.GetColumns().Logical()) {
 			auto user_type_catalog = LogicalType::GetCatalog(column.Type());
 			if (user_type_catalog) {
-				to_add.push_back(user_type_catalog);
+				to_add.push_back(*user_type_catalog);
 			}
 		}
 	}
@@ -154,12 +160,12 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 	}
 }
 
-void DependencyManager::EraseObject(CatalogEntry *object) {
+void DependencyManager::EraseObject(CatalogEntry &object) {
 	// obtain the writing lock
 	EraseObjectInternal(object);
 }
 
-void DependencyManager::EraseObjectInternal(CatalogEntry *object) {
+void DependencyManager::EraseObjectInternal(CatalogEntry &object) {
 	if (dependents_map.find(object) == dependents_map.end()) {
 		// dependencies already removed
 		return;
@@ -179,7 +185,7 @@ void DependencyManager::EraseObjectInternal(CatalogEntry *object) {
 	dependencies_map.erase(object);
 }
 
-void DependencyManager::Scan(const std::function<void(CatalogEntry *, CatalogEntry *, DependencyType)> &callback) {
+void DependencyManager::Scan(const std::function<void(CatalogEntry &, CatalogEntry &, DependencyType)> &callback) {
 	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	for (auto &entry : dependents_map) {
 		for (auto &dependent : entry.second) {
@@ -188,26 +194,26 @@ void DependencyManager::Scan(const std::function<void(CatalogEntry *, CatalogEnt
 	}
 }
 
-void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntry *owner, CatalogEntry *entry) {
+void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntry &owner, CatalogEntry &entry) {
 	// lock the catalog for writing
 	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 
 	// If the owner is already owned by something else, throw an error
 	for (auto &dep : dependents_map[owner]) {
 		if (dep.dependency_type == DependencyType::DEPENDENCY_OWNED_BY) {
-			throw DependencyException(owner->name + " already owned by " + dep.entry->name);
+			throw DependencyException(owner.name + " already owned by " + dep.entry.get().name);
 		}
 	}
 
 	// If the entry is already owned, throw an error
 	for (auto &dep : dependents_map[entry]) {
 		// if the entry is already owned, throw error
-		if (dep.entry != owner) {
-			throw DependencyException(entry->name + " already depends on " + dep.entry->name);
+		if (&dep.entry.get() != &owner) {
+			throw DependencyException(entry.name + " already depends on " + dep.entry.get().name);
 		}
 		// if the entry owns the owner, throw error
-		if (dep.entry == owner && dep.dependency_type == DependencyType::DEPENDENCY_OWNS) {
-			throw DependencyException(entry->name + " already owns " + owner->name +
+		if (&dep.entry.get() == &owner && dep.dependency_type == DependencyType::DEPENDENCY_OWNS) {
+			throw DependencyException(entry.name + " already owns " + owner.name +
 			                          ". Cannot have circular dependencies");
 		}
 	}

package/src/duckdb/src/common/serializer/buffered_file_reader.cpp

@@ -7,11 +7,11 @@
 
 namespace duckdb {
 
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, ClientContext *context, FileLockType lock_type,
-                                       FileOpener *opener)
-    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), context(context),
-      total_read(0) {
-	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener);
+BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, optional_ptr<ClientContext> context,
+                                       FileLockType lock_type, optional_ptr<FileOpener> opener)
+    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0),
+      context(context) {
+	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener.get());
 	file_size = fs.GetFileSize(*handle);
 }
 
@@ -63,8 +63,13 @@ ClientContext &BufferedFileReader::GetContext() {
 	return *context;
 }
 
-Catalog *BufferedFileReader::GetCatalog() {
+optional_ptr<Catalog> BufferedFileReader::GetCatalog() {
 	return catalog;
 }
 
+void BufferedFileReader::SetCatalog(Catalog &catalog_p) {
+	D_ASSERT(!catalog);
+	this->catalog = &catalog_p;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/types/batched_data_collection.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/common/types/batched_data_collection.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 
@@ -9,7 +10,7 @@ BatchedDataCollection::BatchedDataCollection(vector<LogicalType> types_p) : type
 
 void BatchedDataCollection::Append(DataChunk &input, idx_t batch_index) {
 	D_ASSERT(batch_index != DConstants::INVALID_INDEX);
-	ColumnDataCollection *collection;
+	optional_ptr<ColumnDataCollection> collection;
 	if (last_collection.collection && last_collection.batch_index == batch_index) {
 		// we are inserting into the same collection as before: use it directly
 		collection = last_collection.collection;

package/src/duckdb/src/common/types/column_data_allocator.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/types/column_data_collection_segment.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/common/types/vector.cpp

@@ -237,10 +237,10 @@ void Vector::Initialize(bool zero_data, idx_t capacity) {
 struct DataArrays {
 	Vector &vec;
 	data_ptr_t data;
-	VectorBuffer *buffer;
+	optional_ptr<VectorBuffer> buffer;
 	idx_t type_size;
 	bool is_nested;
-	DataArrays(Vector &vec, data_ptr_t data, VectorBuffer *buffer, idx_t type_size, bool is_nested)
+	DataArrays(Vector &vec, data_ptr_t data, optional_ptr<VectorBuffer> buffer, idx_t type_size, bool is_nested)
 	    : vec(vec), data(data), buffer(buffer), type_size(type_size), is_nested(is_nested) {
 	}
 };

package/src/duckdb/src/common/types.cpp

@@ -1187,8 +1187,8 @@ idx_t StructType::GetChildCount(const LogicalType &type) {
 	return StructType::GetChildTypes(type).size();
 }
 
-LogicalType LogicalType::STRUCT(const child_list_t<LogicalType> &children) {
-	auto info = make_shared<StructTypeInfo>(children);
+LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
+	auto info = make_shared<StructTypeInfo>(std::move(children));
 	return LogicalType(LogicalTypeId::STRUCT, std::move(info));
 }
 

package/src/duckdb/src/common/vector_operations/vector_copy.cpp

@@ -23,6 +23,17 @@ static void TemplatedCopy(const Vector &source, const SelectionVector &sel, Vect
 	}
 }
 
+static const ValidityMask &CopyValidityMask(const Vector &v) {
+	switch (v.GetVectorType()) {
+	case VectorType::FLAT_VECTOR:
+		return FlatVector::Validity(v);
+	case VectorType::FSST_VECTOR:
+		return FSSTVector::Validity(v);
+	default:
+		throw InternalException("Unsupported vector type in vector copy");
+	}
+}
+
 void VectorOperations::Copy(const Vector &source_p, Vector &target, const SelectionVector &sel_p, idx_t source_count,
                             idx_t source_offset, idx_t target_offset) {
 	D_ASSERT(source_offset <= source_count);
@@ -90,20 +101,12 @@ void VectorOperations::Copy(const Vector &source_p, Vector &target, const Select
 			tmask.Set(target_offset + i, valid);
 		}
 	} else {
-		const ValidityMask *smask;
-		if (source->GetVectorType() == VectorType::FLAT_VECTOR) {
-			smask = &(FlatVector::Validity(*source));
-		} else if (source->GetVectorType() == VectorType::FSST_VECTOR) {
-			smask = &(FSSTVector::Validity(*source));
-		} else {
-			throw InternalException("Unsupported vector type in vector copy");
-		}
-
-		if (smask->IsMaskSet()) {
+		auto &smask = CopyValidityMask(*source);
+		if (smask.IsMaskSet()) {
 			for (idx_t i = 0; i < copy_count; i++) {
 				auto idx = sel->get_index(source_offset + i);
 
-				if (smask->RowIsValid(idx)) {
+				if (smask.RowIsValid(idx)) {
 					// set valid
 					if (!tmask.AllValid()) {
 						tmask.SetValidUnsafe(target_offset + i);

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

@@ -113,7 +113,7 @@ DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionIn
 	}
 }
 
-using aggr_ref_t = std::reference_wrapper<BoundAggregateExpression>;
+using aggr_ref_t = reference<BoundAggregateExpression>;
 
 struct FindMatchingAggregate {
 	explicit FindMatchingAggregate(const aggr_ref_t &aggr) : aggr_r(aggr) {

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

@@ -18,6 +18,7 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
 #include "duckdb/common/radix_partitioning.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <algorithm>
 #include <cmath>
@@ -140,14 +141,14 @@ static idx_t FindPrevStart(const ValidityMask &mask, const idx_t l, idx_t r, idx
 	return l;
 }
 
-static void PrepareInputExpressions(Expression **exprs, idx_t expr_count, ExpressionExecutor &executor,
+static void PrepareInputExpressions(vector<unique_ptr<Expression>> &exprs, ExpressionExecutor &executor,
                                     DataChunk &chunk) {
-	if (expr_count == 0) {
+	if (exprs.empty()) {
 		return;
 	}
 
 	vector<LogicalType> types;
-	for (idx_t expr_idx = 0; expr_idx < expr_count; ++expr_idx) {
+	for (idx_t expr_idx = 0; expr_idx < exprs.size(); ++expr_idx) {
 		types.push_back(exprs[expr_idx]->return_type);
 		executor.AddExpression(*exprs[expr_idx]);
 	}
@@ -158,15 +159,20 @@ static void PrepareInputExpressions(Expression **exprs, idx_t expr_count, Expres
 	}
 }
 
-static void PrepareInputExpression(Expression *expr, ExpressionExecutor &executor, DataChunk &chunk) {
-	PrepareInputExpressions(&expr, 1, executor, chunk);
+static void PrepareInputExpression(Expression &expr, ExpressionExecutor &executor, DataChunk &chunk) {
+	vector<LogicalType> types;
+	types.push_back(expr.return_type);
+	executor.AddExpression(expr);
+
+	auto &allocator = executor.GetAllocator();
+	chunk.Initialize(allocator, types);
 }
 
 struct WindowInputExpression {
-	WindowInputExpression(Expression *expr_p, ClientContext &context)
+	WindowInputExpression(optional_ptr<Expression> expr_p, ClientContext &context)
 	    : expr(expr_p), ptype(PhysicalType::INVALID), scalar(true), executor(context) {
 		if (expr) {
-			PrepareInputExpression(expr, executor, chunk);
+			PrepareInputExpression(*expr, executor, chunk);
 			ptype = expr->return_type.InternalType();
 			scalar = expr->IsScalar();
 		}
@@ -202,7 +208,7 @@ struct WindowInputExpression {
 		VectorOperations::Copy(source, target, source_offset + 1, source_offset, target_offset);
 	}
 
-	Expression *expr;
+	optional_ptr<Expression> expr;
 	PhysicalType ptype;
 	bool scalar;
 	ExpressionExecutor executor;
@@ -235,7 +241,7 @@ struct WindowInputColumn {
 	}
 
 	template <typename T>
-	inline T GetCell(idx_t i) {
+	inline T GetCell(idx_t i) const {
 		D_ASSERT(target);
 		D_ASSERT(i < count);
 		const auto data = FlatVector::GetData<T>(*target);
@@ -266,15 +272,15 @@ struct WindowBoundariesState {
 		return expr ? expr->IsScalar() : true;
 	}
 
-	WindowBoundariesState(BoundWindowExpression *wexpr, const idx_t input_size)
-	    : type(wexpr->type), input_size(input_size), start_boundary(wexpr->start), end_boundary(wexpr->end),
-	      partition_count(wexpr->partitions.size()), order_count(wexpr->orders.size()),
-	      range_sense(wexpr->orders.empty() ? OrderType::INVALID : wexpr->orders[0].type),
-	      has_preceding_range(wexpr->start == WindowBoundary::EXPR_PRECEDING_RANGE ||
-	                          wexpr->end == WindowBoundary::EXPR_PRECEDING_RANGE),
-	      has_following_range(wexpr->start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
-	                          wexpr->end == WindowBoundary::EXPR_FOLLOWING_RANGE),
-	      needs_peer(BoundaryNeedsPeer(wexpr->end) || wexpr->type == ExpressionType::WINDOW_CUME_DIST) {
+	WindowBoundariesState(BoundWindowExpression &wexpr, const idx_t input_size)
+	    : type(wexpr.type), input_size(input_size), start_boundary(wexpr.start), end_boundary(wexpr.end),
+	      partition_count(wexpr.partitions.size()), order_count(wexpr.orders.size()),
+	      range_sense(wexpr.orders.empty() ? OrderType::INVALID : wexpr.orders[0].type),
+	      has_preceding_range(wexpr.start == WindowBoundary::EXPR_PRECEDING_RANGE ||
+	                          wexpr.end == WindowBoundary::EXPR_PRECEDING_RANGE),
+	      has_following_range(wexpr.start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
+	                          wexpr.end == WindowBoundary::EXPR_FOLLOWING_RANGE),
+	      needs_peer(BoundaryNeedsPeer(wexpr.end) || wexpr.type == ExpressionType::WINDOW_CUME_DIST) {
 	}
 
 	void Update(const idx_t row_idx, WindowInputColumn &range_collection, const idx_t source_offset,
@@ -305,9 +311,9 @@ struct WindowBoundariesState {
 	bool is_peer = false;
 };
 
-static bool WindowNeedsRank(BoundWindowExpression *wexpr) {
-	return wexpr->type == ExpressionType::WINDOW_PERCENT_RANK || wexpr->type == ExpressionType::WINDOW_RANK ||
-	       wexpr->type == ExpressionType::WINDOW_RANK_DENSE || wexpr->type == ExpressionType::WINDOW_CUME_DIST;
+static bool WindowNeedsRank(const BoundWindowExpression &wexpr) {
+	return wexpr.type == ExpressionType::WINDOW_PERCENT_RANK || wexpr.type == ExpressionType::WINDOW_RANK ||
+	       wexpr.type == ExpressionType::WINDOW_RANK_DENSE || wexpr.type == ExpressionType::WINDOW_CUME_DIST;
 }
 
 template <typename T>
@@ -367,7 +373,7 @@ struct WindowColumnIterator {
 	}
 
 private:
-	WindowInputColumn *coll;
+	optional_ptr<WindowInputColumn> coll;
 	pointer pos;
 };
 
@@ -610,7 +616,7 @@ void WindowBoundariesState::Update(const idx_t row_idx, WindowInputColumn &range
 struct WindowExecutor {
 	static bool IsConstantAggregate(const BoundWindowExpression &wexpr);
 
-	WindowExecutor(BoundWindowExpression *wexpr, ClientContext &context, const ValidityMask &partition_mask,
+	WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, const ValidityMask &partition_mask,
 	               const idx_t count);
 
 	void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count);
@@ -620,7 +626,7 @@ struct WindowExecutor {
 	              const ValidityMask &order_mask);
 
 	// The function
-	BoundWindowExpression *wexpr;
+	BoundWindowExpression &wexpr;
 
 	// Frame management
 	WindowBoundariesState bounds;
@@ -714,41 +720,36 @@ bool WindowExecutor::IsConstantAggregate(const BoundWindowExpression &wexpr) {
 	return true;
 }
 
-WindowExecutor::WindowExecutor(BoundWindowExpression *wexpr, ClientContext &context, const ValidityMask &partition_mask,
+WindowExecutor::WindowExecutor(BoundWindowExpression &wexpr, ClientContext &context, const ValidityMask &partition_mask,
                                const idx_t count)
     : wexpr(wexpr), bounds(wexpr, count), payload_collection(), payload_executor(context), filter_executor(context),
-      leadlag_offset(wexpr->offset_expr.get(), context), leadlag_default(wexpr->default_expr.get(), context),
-      boundary_start(wexpr->start_expr.get(), context), boundary_end(wexpr->end_expr.get(), context),
-      range((bounds.has_preceding_range || bounds.has_following_range) ? wexpr->orders[0].expression.get() : nullptr,
+      leadlag_offset(wexpr.offset_expr.get(), context), leadlag_default(wexpr.default_expr.get(), context),
+      boundary_start(wexpr.start_expr.get(), context), boundary_end(wexpr.end_expr.get(), context),
+      range((bounds.has_preceding_range || bounds.has_following_range) ? wexpr.orders[0].expression.get() : nullptr,
             context, count)
 
 {
 	// TODO we could evaluate those expressions in parallel
 
 	//	Check for constant aggregate
-	if (IsConstantAggregate(*wexpr)) {
+	if (IsConstantAggregate(wexpr)) {
 		constant_aggregate =
-		    make_uniq<WindowConstantAggregate>(AggregateObject(*wexpr), wexpr->return_type, partition_mask, count);
+		    make_uniq<WindowConstantAggregate>(AggregateObject(wexpr), wexpr.return_type, partition_mask, count);
 	}
 
 	// evaluate the FILTER clause and stuff it into a large mask for compactness and reuse
-	if (wexpr->filter_expr) {
+	if (wexpr.filter_expr) {
 		// 	Start with all invalid and set the ones that pass
 		filter_bits.resize(ValidityMask::ValidityMaskSize(count), 0);
 		filter_mask.Initialize(filter_bits.data());
-		filter_executor.AddExpression(*wexpr->filter_expr);
+		filter_executor.AddExpression(*wexpr.filter_expr);
 		filter_sel.Initialize(STANDARD_VECTOR_SIZE);
 	}
 
 	// TODO: child may be a scalar, don't need to materialize the whole collection then
 
 	// evaluate inner expressions of window functions, could be more complex
-	vector<Expression *> exprs;
-	exprs.reserve(wexpr->children.size());
-	for (auto &child : wexpr->children) {
-		exprs.push_back(child.get());
-	}
-	PrepareInputExpressions(exprs.data(), exprs.size(), payload_executor, payload_chunk);
+	PrepareInputExpressions(wexpr.children, payload_executor, payload_chunk);
 
 	auto types = payload_chunk.GetTypes();
 	if (!types.empty()) {
@@ -762,8 +763,8 @@ void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, const i
 
 	// Set up a validity mask for IGNORE NULLS
 	bool check_nulls = false;
-	if (wexpr->ignore_nulls) {
-		switch (wexpr->type) {
+	if (wexpr.ignore_nulls) {
+		switch (wexpr.type) {
 		case ExpressionType::WINDOW_LEAD:
 		case ExpressionType::WINDOW_LAG:
 		case ExpressionType::WINDOW_FIRST_VALUE:
@@ -780,7 +781,7 @@ void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, const i
 
 	idx_t filtered = 0;
 	SelectionVector *filtering = nullptr;
-	if (wexpr->filter_expr) {
+	if (wexpr.filter_expr) {
 		filtering = &filter_sel;
 		filtered = filter_executor.SelectExpression(input_chunk, filter_sel);
 		for (idx_t f = 0; f < filtered; ++f) {
@@ -788,7 +789,7 @@ void WindowExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, const i
 		}
 	}
 
-	if (!wexpr->children.empty()) {
+	if (!wexpr.children.empty()) {
 		payload_chunk.Reset();
 		payload_executor.Execute(input_chunk, payload_chunk);
 		payload_chunk.Verify();
@@ -833,8 +834,8 @@ void WindowExecutor::Finalize(WindowAggregationMode mode) {
 	// see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf
 	if (constant_aggregate) {
 		constant_aggregate->Finalize();
-	} else if (wexpr->aggregate) {
-		segment_tree = make_uniq<WindowSegmentTree>(AggregateObject(*wexpr), wexpr->return_type, &payload_collection,
+	} else if (wexpr.aggregate) {
+		segment_tree = make_uniq<WindowSegmentTree>(AggregateObject(wexpr), wexpr.return_type, &payload_collection,
 		                                            filter_mask, mode);
 	}
 }
@@ -871,7 +872,7 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 			continue;
 		}
 
-		switch (wexpr->type) {
+		switch (wexpr.type) {
 		case ExpressionType::WINDOW_AGGREGATE: {
 			if (constant_aggregate) {
 				constant_aggregate->Compute(result, output_offset, bounds.window_start, bounds.window_end);
@@ -951,11 +952,11 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 		case ExpressionType::WINDOW_LEAD:
 		case ExpressionType::WINDOW_LAG: {
 			int64_t offset = 1;
-			if (wexpr->offset_expr) {
+			if (wexpr.offset_expr) {
 				offset = leadlag_offset.GetCell<int64_t>(output_offset);
 			}
 			int64_t val_idx = (int64_t)row_idx;
-			if (wexpr->type == ExpressionType::WINDOW_LEAD) {
+			if (wexpr.type == ExpressionType::WINDOW_LEAD) {
 				val_idx += offset;
 			} else {
 				val_idx -= offset;
@@ -974,7 +975,7 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 
 			if (!delta) {
 				CopyCell(payload_collection, 0, val_idx, result, output_offset);
-			} else if (wexpr->default_expr) {
+			} else if (wexpr.default_expr) {
 				leadlag_default.CopyCell(result, output_offset);
 			} else {
 				FlatVector::SetNull(result, output_offset, true);
@@ -1025,7 +1026,7 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 			break;
 		}
 		default:
-			throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr->type));
+			throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.type));
 		}
 	}
 
@@ -1147,7 +1148,7 @@ void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, co
 	for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) {
 		D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
 		auto &wexpr = op.select_list[expr_idx]->Cast<BoundWindowExpression>();
-		auto wexec = make_uniq<WindowExecutor>(&wexpr, context, partition_mask, count);
+		auto wexec = make_uniq<WindowExecutor>(wexpr, context, partition_mask, count);
 		window_execs.emplace_back(std::move(wexec));
 	}