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

package/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp

@@ -22,9 +22,9 @@ class SelectNode;
 class OrderBinder {
 public:
 	OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-	            expression_map_t<idx_t> &projection_map, idx_t max_count);
+	            parsed_expression_map_t<idx_t> &projection_map, idx_t max_count);
 	OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-	            case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map);
+	            case_insensitive_map_t<idx_t> &alias_map, parsed_expression_map_t<idx_t> &projection_map);
 
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
@@ -51,7 +51,7 @@ private:
 	idx_t max_count;
 	vector<unique_ptr<ParsedExpression>> *extra_list;
 	case_insensitive_map_t<idx_t> &alias_map;
-	expression_map_t<idx_t> &projection_map;
+	parsed_expression_map_t<idx_t> &projection_map;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp

@@ -26,8 +26,7 @@ struct BufferPoolReservation {
 	idx_t size {0};
 	BufferPool &pool;
 
-	BufferPoolReservation(BufferPool &pool) : pool(pool) {
-	}
+	BufferPoolReservation(BufferPool &pool);
 	BufferPoolReservation(const BufferPoolReservation &) = delete;
 	BufferPoolReservation &operator=(const BufferPoolReservation &) = delete;
 
@@ -55,6 +54,7 @@ class BlockHandle {
 	friend struct BufferEvictionNode;
 	friend class BufferHandle;
 	friend class BufferManager;
+	friend class StandardBufferManager;
 	friend class BufferPool;
 
 public:
@@ -70,6 +70,14 @@ public:
 		return block_id;
 	}
 
+	void ResizeBuffer(idx_t block_size, int64_t memory_delta) {
+		D_ASSERT(buffer);
+		// resize and adjust current memory
+		buffer->Resize(block_size);
+		memory_usage += memory_delta;
+		D_ASSERT(memory_usage == buffer->AllocSize());
+	}
+
 	int32_t Readers() const {
 		return readers;
 	}

package/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp

@@ -30,6 +30,7 @@ class BufferPool {
 	friend class BlockHandle;
 	friend class BlockManager;
 	friend class BufferManager;
+	friend class StandardBufferManager;
 
 public:
 	explicit BufferPool(idx_t maximum_memory);

package/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp

@@ -8,156 +8,79 @@
 
 #pragma once
 
-#include "duckdb/common/allocator.hpp"
-#include "duckdb/common/atomic.hpp"
-#include "duckdb/common/file_system.hpp"
-#include "duckdb/common/mutex.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/storage/block_manager.hpp"
-#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/buffer/buffer_handle.hpp"
-#include "duckdb/storage/buffer/buffer_pool.hpp"
+#include "duckdb/storage/block_manager.hpp"
+#include "duckdb/common/file_system.hpp"
 #include "duckdb/storage/buffer/temporary_file_information.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
-class BlockManager;
-class DatabaseInstance;
-class TemporaryDirectoryHandle;
-struct EvictionQueue;
 
-//! The BufferManager is in charge of handling memory management for a single database. It cooperatively shares a
-//! BufferPool with other BufferManagers, belonging to different databases. It hands out memory buffers that can
-//! be used by the database internally, and offers configuration options specific to a database, which need not be
-//! shared by the BufferPool, including whether to support swapping temp buffers to disk, and where to swap them to.
+class Allocator;
+class BufferPool;
+
 class BufferManager {
 	friend class BufferHandle;
 	friend class BlockHandle;
 	friend class BlockManager;
 
 public:
-	BufferManager(DatabaseInstance &db, string temp_directory);
-	virtual ~BufferManager();
-
-	//! Registers an in-memory buffer that cannot be unloaded until it is destroyed
-	//! This buffer can be small (smaller than BLOCK_SIZE)
-	//! Unpin and pin are nops on this block of memory
-	shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size);
-
-	//! Allocate an in-memory buffer with a single pin.
-	//! The allocated memory is released when the buffer handle is destroyed.
-	DUCKDB_API BufferHandle Allocate(idx_t block_size, bool can_destroy = true,
-	                                 shared_ptr<BlockHandle> *block = nullptr);
+	BufferManager() {
+	}
+	virtual ~BufferManager() {
+	}
 
+public:
+	static unique_ptr<BufferManager> CreateStandardBufferManager(DatabaseInstance &db, DBConfig &config);
+	virtual BufferHandle Allocate(idx_t block_size, bool can_destroy = true,
+	                              shared_ptr<BlockHandle> *block = nullptr) = 0;
 	//! Reallocate an in-memory buffer that is pinned.
-	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size);
-
-	BufferHandle Pin(shared_ptr<BlockHandle> &handle);
-	void Unpin(shared_ptr<BlockHandle> &handle);
-
-	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
-	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
-	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);
-
+	virtual void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) = 0;
+	virtual BufferHandle Pin(shared_ptr<BlockHandle> &handle) = 0;
+	virtual void Unpin(shared_ptr<BlockHandle> &handle) = 0;
 	//! Returns the currently allocated memory
-	idx_t GetUsedMemory() {
-		return buffer_pool.current_memory;
-	}
+	virtual idx_t GetUsedMemory() const = 0;
 	//! Returns the maximum available memory
-	idx_t GetMaxMemory() {
-		return buffer_pool.maximum_memory;
-	}
-
+	virtual idx_t GetMaxMemory() const = 0;
+	virtual shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size);
+	virtual DUCKDB_API Allocator &GetBufferAllocator();
+	virtual DUCKDB_API void ReserveMemory(idx_t size);
+	virtual DUCKDB_API void FreeReservedMemory(idx_t size);
+	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
+	//! blocks can be evicted
+	virtual void SetLimit(idx_t limit = (idx_t)-1);
+	virtual vector<TemporaryFileInformation> GetTemporaryFiles();
+	virtual const string &GetTemporaryDirectory();
+	virtual void SetTemporaryDirectory(const string &new_dir);
+	virtual DatabaseInstance &GetDatabase();
+	virtual bool HasTemporaryDirectory() const;
+	//! Construct a managed buffer.
+	virtual unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
+	                                                      FileBufferType type = FileBufferType::MANAGED_BUFFER);
 	//! Increases the currently allocated memory, but the actual allocation does not go through the buffer manager
-	void IncreaseUsedMemory(idx_t size);
+	virtual void IncreaseUsedMemory(idx_t size, bool unsafe = false) = 0;
 	//! Decrease the currently allocated memory, but the actual deallocation does not go through the buffer manager
-	void DecreaseUsedMemory(idx_t size);
-
-	const string &GetTemporaryDirectory() {
-		return temp_directory;
-	}
-
-	void SetTemporaryDirectory(string new_dir);
-
-	DUCKDB_API Allocator &GetBufferAllocator();
+	virtual void DecreaseUsedMemory(idx_t size) = 0;
+	//! Get the underlying buffer pool responsible for managing the buffers
+	virtual BufferPool &GetBufferPool();
 
-	DatabaseInstance &GetDatabase() {
-		return db;
-	}
+	// Static methods
 
-	BufferPool &GetBufferPool() {
-		return buffer_pool;
-	}
+	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
+	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
+	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);
 
 	static idx_t GetAllocSize(idx_t block_size) {
 		return AlignValue<idx_t, Storage::SECTOR_SIZE>(block_size + Storage::BLOCK_HEADER_SIZE);
 	}
 
-	//! Construct a managed buffer.
-	unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
-	                                              FileBufferType type = FileBufferType::MANAGED_BUFFER);
-
-	DUCKDB_API void ReserveMemory(idx_t size);
-	DUCKDB_API void FreeReservedMemory(idx_t size);
-
-	//! Set a new memory limit to the buffer pool, throws an exception if the new limit is too low and not enough
-	//! blocks can be evicted. (Sugar for calling method directly on the BufferPool.)
-	void SetLimit(idx_t limit = (idx_t)-1) {
-		buffer_pool.SetLimit(limit, InMemoryWarning());
-	}
-	//! Returns a list of all temporary files
-	vector<TemporaryFileInformation> GetTemporaryFiles();
-
-private:
-	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
-	//! not the buffer can be destroyed when unpinned, or whether or not it needs to be written to a temporary file so
-	//! it can be reloaded. The resulting buffer will already be allocated, but needs to be pinned in order to be used.
-	//! This needs to be private to prevent creating blocks without ever pinning them:
-	//! blocks that are never pinned are never added to the eviction queue
-	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
-
-	//! Write a temporary buffer to disk
-	void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer);
-	//! Read a temporary buffer from disk
-	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer = nullptr);
-	//! Get the path of the temporary buffer
-	string GetTemporaryPath(block_id_t id);
-
-	void DeleteTemporaryFile(block_id_t id);
-
-	void RequireTemporaryDirectory();
-
-	const char *InMemoryWarning();
-
-	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
-	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
-	static data_ptr_t BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                         idx_t size);
-
-	//! When the BlockHandle reaches 0 readers, this creates a new FileBuffer for this BlockHandle and
-	//! overwrites the data within with garbage. Any readers that do not hold the pin will notice
-	void VerifyZeroReaders(shared_ptr<BlockHandle> &handle);
-
-	//! Helper
-	template <typename... ARGS>
-	TempBufferPoolReservation EvictBlocksOrThrow(idx_t extra_memory, unique_ptr<FileBuffer> *buffer, ARGS...);
-
-private:
-	//! The database instance
-	DatabaseInstance &db;
-	//! The buffer pool
-	BufferPool &buffer_pool;
-	//! The directory name where temporary files are stored
-	string temp_directory;
-	//! Lock for creating the temp handle
-	mutex temp_handle_lock;
-	//! Handle for the temporary directory
-	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
-	//! The temporary id used for managed buffers
-	atomic<block_id_t> temporary_id;
-	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
-	Allocator buffer_allocator;
-	//! Block manager for temp data
-	unique_ptr<BlockManager> temp_block_manager;
+protected:
+	virtual void PurgeQueue() = 0;
+	virtual void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
+	virtual void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer);
+	virtual unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer);
+	virtual void DeleteTemporaryFile(block_id_t id);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/meta_block_reader.hpp

@@ -37,13 +37,13 @@ public:
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
 
 	ClientContext &GetContext() override;
-	Catalog *GetCatalog() override;
-	void SetCatalog(Catalog *catalog_p);
-	void SetContext(ClientContext *context_p);
+	optional_ptr<Catalog> GetCatalog() override;
+	void SetCatalog(Catalog &catalog_p);
+	void SetContext(ClientContext &context_p);
 
 private:
 	void ReadNewBlock(block_id_t id);
-	Catalog *catalog = nullptr;
-	ClientContext *context = nullptr;
+	optional_ptr<ClientContext> context;
+	optional_ptr<Catalog> catalog;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp

@@ -0,0 +1,159 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/standard_buffer_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/allocator.hpp"
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/storage/block_manager.hpp"
+
+#include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
+
+namespace duckdb {
+class BlockManager;
+class DatabaseInstance;
+class TemporaryDirectoryHandle;
+struct EvictionQueue;
+
+//! The BufferManager is in charge of handling memory management for a single database. It cooperatively shares a
+//! BufferPool with other BufferManagers, belonging to different databases. It hands out memory buffers that can
+//! be used by the database internally, and offers configuration options specific to a database, which need not be
+//! shared by the BufferPool, including whether to support swapping temp buffers to disk, and where to swap them to.
+class StandardBufferManager : public BufferManager {
+	friend class BufferHandle;
+	friend class BlockHandle;
+	friend class BlockManager;
+
+public:
+	StandardBufferManager(DatabaseInstance &db, string temp_directory);
+	virtual ~StandardBufferManager();
+
+public:
+	static unique_ptr<StandardBufferManager> CreateBufferManager(DatabaseInstance &db, string temp_directory);
+	//! Registers an in-memory buffer that cannot be unloaded until it is destroyed
+	//! This buffer can be small (smaller than BLOCK_SIZE)
+	//! Unpin and pin are nops on this block of memory
+	shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size) final override;
+
+	idx_t GetUsedMemory() const final override;
+	void IncreaseUsedMemory(idx_t amount, bool unsafe = false) final override;
+	void DecreaseUsedMemory(idx_t amount) final override;
+	idx_t GetMaxMemory() const final override;
+
+	//! Allocate an in-memory buffer with a single pin.
+	//! The allocated memory is released when the buffer handle is destroyed.
+	DUCKDB_API BufferHandle Allocate(idx_t block_size, bool can_destroy = true,
+	                                 shared_ptr<BlockHandle> *block = nullptr) final override;
+
+	//! Reallocate an in-memory buffer that is pinned.
+	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) final override;
+
+	BufferHandle Pin(shared_ptr<BlockHandle> &handle) final override;
+	void Unpin(shared_ptr<BlockHandle> &handle) final override;
+
+	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
+	//! blocks can be evicted
+	void SetLimit(idx_t limit = (idx_t)-1) final override;
+
+	//! Returns a list of all temporary files
+	vector<TemporaryFileInformation> GetTemporaryFiles() final override;
+
+	const string &GetTemporaryDirectory() final override {
+		return temp_directory;
+	}
+
+	void SetTemporaryDirectory(const string &new_dir) final override;
+
+	DUCKDB_API Allocator &GetBufferAllocator() final override;
+
+	DatabaseInstance &GetDatabase() final override {
+		return db;
+	}
+
+	//! Construct a managed buffer.
+	unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
+	                                              FileBufferType type = FileBufferType::MANAGED_BUFFER) override;
+
+	DUCKDB_API void ReserveMemory(idx_t size) final override;
+	DUCKDB_API void FreeReservedMemory(idx_t size) final override;
+	bool HasTemporaryDirectory() const final override;
+
+protected:
+	//! Helper
+	template <typename... ARGS>
+	TempBufferPoolReservation EvictBlocksOrThrow(idx_t memory_delta, unique_ptr<FileBuffer> *buffer, ARGS...);
+
+	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
+	//! not the buffer can be destroyed when unpinned, or whether or not it needs to be written to a temporary file so
+	//! it can be reloaded. The resulting buffer will already be allocated, but needs to be pinned in order to be used.
+	//! This needs to be private to prevent creating blocks without ever pinning them:
+	//! blocks that are never pinned are never added to the eviction queue
+	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
+
+	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
+	//! (i.e. not enough blocks could be evicted)
+	//! If the "buffer" argument is specified AND the system can find a buffer to re-use for the given allocation size
+	//! "buffer" will be made to point to the re-usable memory. Note that this is not guaranteed.
+	//! Returns a pair. result.first indicates if eviction was successful. result.second contains the
+	//! reservation handle, which can be moved to the BlockHandle that will own the reservation.
+	BufferPool::EvictionResult EvictBlocks(idx_t extra_memory, idx_t memory_limit,
+	                                       unique_ptr<FileBuffer> *buffer = nullptr);
+
+	//! Garbage collect eviction queue
+	void PurgeQueue() final override;
+
+	BufferPool &GetBufferPool() final override;
+
+	//! Write a temporary buffer to disk
+	void WriteTemporaryBuffer(block_id_t block_id, FileBuffer &buffer) final override;
+	//! Read a temporary buffer from disk
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id, unique_ptr<FileBuffer> buffer = nullptr) final override;
+	//! Get the path of the temporary buffer
+	string GetTemporaryPath(block_id_t id);
+
+	void DeleteTemporaryFile(block_id_t id) final override;
+
+	void RequireTemporaryDirectory();
+
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle) final override;
+
+	const char *InMemoryWarning();
+
+	static data_ptr_t BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size);
+	static void BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
+	static data_ptr_t BufferAllocatorRealloc(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
+	                                         idx_t size);
+
+	//! When the BlockHandle reaches 0 readers, this creates a new FileBuffer for this BlockHandle and
+	//! overwrites the data within with garbage. Any readers that do not hold the pin will notice
+	void VerifyZeroReaders(shared_ptr<BlockHandle> &handle);
+
+protected:
+	//! The database instance
+	DatabaseInstance &db;
+	//! The buffer pool
+	BufferPool &buffer_pool;
+	//! The directory name where temporary files are stored
+	string temp_directory;
+	//! Lock for creating the temp handle
+	mutex temp_handle_lock;
+	//! Handle for the temporary directory
+	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
+	//! The temporary id used for managed buffers
+	atomic<block_id_t> temporary_id;
+	//! Allocator associated with the buffer manager, that passes all allocations through this buffer manager
+	Allocator buffer_allocator;
+	//! Block manager for temp data
+	unique_ptr<BlockManager> temp_block_manager;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp

@@ -16,6 +16,7 @@
 #include "duckdb/storage/storage_lock.hpp"
 #include "duckdb/function/compression_function.hpp"
 #include "duckdb/storage/table/segment_base.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {
 class ColumnSegment;

package/src/duckdb/src/include/duckdb/transaction/meta_transaction.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/main/valid_checker.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -42,7 +43,7 @@ public:
 		return start_timestamp;
 	}
 
-	Transaction &GetTransaction(AttachedDatabase *db);
+	Transaction &GetTransaction(AttachedDatabase &db);
 
 	string Commit();
 	void Rollback();
@@ -50,8 +51,8 @@ public:
 	idx_t GetActiveQuery();
 	void SetActiveQuery(transaction_t query_number);
 
-	void ModifyDatabase(AttachedDatabase *db);
-	AttachedDatabase *ModifiedDatabase() {
+	void ModifyDatabase(AttachedDatabase &db);
+	optional_ptr<AttachedDatabase> ModifiedDatabase() {
 		return modified_database;
 	}
 
@@ -59,9 +60,9 @@ private:
 	//! The set of active transactions for each database
 	unordered_map<AttachedDatabase *, Transaction *> transactions;
 	//! The set of transactions in order of when they were started
-	vector<AttachedDatabase *> all_transactions;
+	vector<optional_ptr<AttachedDatabase>> all_transactions;
 	//! The database we are modifying - we can only modify one database per transaction
-	AttachedDatabase *modified_database;
+	optional_ptr<AttachedDatabase> modified_database;
 };
 
 } // namespace duckdb

package/src/duckdb/src/main/client_context.cpp

@@ -390,7 +390,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 			    "Cannot execute statement of type \"%s\" on database \"%s\" which is attached in read-only mode!",
 			    StatementTypeToString(statement.statement_type), modified_database));
 		}
-		transaction.ModifyDatabase(entry);
+		transaction.ModifyDatabase(*entry);
 	}
 
 	// bind the bound values before execution
@@ -1144,9 +1144,11 @@ bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result)
 }
 
 ParserOptions ClientContext::GetParserOptions() const {
+	auto &client_config = ClientConfig::GetConfig(*this);
 	ParserOptions options;
-	options.preserve_identifier_case = ClientConfig::GetConfig(*this).preserve_identifier_case;
-	options.max_expression_depth = ClientConfig::GetConfig(*this).max_expression_depth;
+	options.preserve_identifier_case = client_config.preserve_identifier_case;
+	options.integer_division = client_config.integer_division;
+	options.max_expression_depth = client_config.max_expression_depth;
 	options.extensions = &DBConfig::GetConfig(*this).parser_extensions;
 	return options;
 }

package/src/duckdb/src/main/config.cpp

@@ -78,10 +78,12 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_LOCAL(HomeDirectorySetting),
                                                  DUCKDB_LOCAL(LogQueryPathSetting),
                                                  DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
+                                                 DUCKDB_LOCAL(IntegerDivisionSetting),
                                                  DUCKDB_LOCAL(MaximumExpressionDepthSetting),
                                                  DUCKDB_GLOBAL(MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
+                                                 DUCKDB_LOCAL(OrderedAggregateThreshold),
                                                  DUCKDB_GLOBAL(PasswordSetting),
                                                  DUCKDB_LOCAL(PerfectHashThresholdSetting),
                                                  DUCKDB_LOCAL(PivotLimitSetting),

package/src/duckdb/src/main/database.cpp

@@ -18,6 +18,7 @@
 #include "duckdb/storage/magic_bytes.hpp"
 #include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/execution/operator/helper/physical_set.hpp"
+#include "duckdb/storage/standard_buffer_manager.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -200,7 +201,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	}
 
 	db_manager = make_uniq<DatabaseManager>(*this);
-	buffer_manager = make_uniq<BufferManager>(*this, config.options.temporary_directory);
+	buffer_manager = make_uniq<StandardBufferManager>(*this, config.options.temporary_directory);
 	scheduler = make_uniq<TaskScheduler>(*this);
 	object_cache = make_uniq<ObjectCache>();
 	connection_manager = make_uniq<ConnectionManager>();

package/src/duckdb/src/main/database_manager.cpp

@@ -23,7 +23,7 @@ void DatabaseManager::InitializeSystemCatalog() {
 	system->Initialize();
 }
 
-AttachedDatabase *DatabaseManager::GetDatabase(ClientContext &context, const string &name) {
+optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &context, const string &name) {
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
 		return context.client_data->temporary_objects.get();
 	}
@@ -50,7 +50,7 @@ void DatabaseManager::DetachDatabase(ClientContext &context, const string &name,
 	}
 }
 
-AttachedDatabase *DatabaseManager::GetDatabaseFromPath(ClientContext &context, const string &path) {
+optional_ptr<AttachedDatabase> DatabaseManager::GetDatabaseFromPath(ClientContext &context, const string &path) {
 	auto databases = GetDatabases(context);
 	for (auto db : databases) {
 		if (db->IsSystem()) {
@@ -81,8 +81,8 @@ const string &DatabaseManager::GetDefaultDatabase(ClientContext &context) {
 	return default_entry.catalog;
 }
 
-vector<AttachedDatabase *> DatabaseManager::GetDatabases(ClientContext &context) {
-	vector<AttachedDatabase *> result;
+vector<optional_ptr<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext &context) {
+	vector<optional_ptr<AttachedDatabase>> result;
 	databases->Scan(context, [&](CatalogEntry *entry) { result.push_back((AttachedDatabase *)entry); });
 	result.push_back(system.get());
 	result.push_back(context.client_data->temporary_objects.get());

package/src/duckdb/src/main/settings/settings.cpp

@@ -141,6 +141,26 @@ Value DebugForceNoCrossProduct::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(ClientConfig::GetConfig(context).force_no_cross_product);
 }
 
+//===--------------------------------------------------------------------===//
+// Debug Ordered Aggregate Threshold
+//===--------------------------------------------------------------------===//
+
+void OrderedAggregateThreshold::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).ordered_aggregate_threshold = ClientConfig().ordered_aggregate_threshold;
+}
+
+void OrderedAggregateThreshold::SetLocal(ClientContext &context, const Value &input) {
+	const auto param = input.GetValue<uint64_t>();
+	if (!param) {
+		throw ParserException("Invalid option for PRAGMA ordered_aggregate_threshold, value must be positive");
+	}
+	ClientConfig::GetConfig(context).ordered_aggregate_threshold = param;
+}
+
+Value OrderedAggregateThreshold::GetSetting(ClientContext &context) {
+	return Value::UBIGINT(ClientConfig::GetConfig(context).ordered_aggregate_threshold);
+}
+
 //===--------------------------------------------------------------------===//
 // Debug Window Mode
 //===--------------------------------------------------------------------===//
@@ -660,6 +680,22 @@ Value HomeDirectorySetting::GetSetting(ClientContext &context) {
 	return Value(config.home_directory);
 }
 
+//===--------------------------------------------------------------------===//
+// Integer Division
+//===--------------------------------------------------------------------===//
+void IntegerDivisionSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).integer_division = ClientConfig().integer_division;
+}
+
+void IntegerDivisionSetting::SetLocal(ClientContext &context, const Value &input) {
+	auto &config = ClientConfig::GetConfig(context);
+	config.integer_division = input.GetValue<bool>();
+}
+
+Value IntegerDivisionSetting::GetSetting(ClientContext &context) {
+	auto &config = ClientConfig::GetConfig(context);
+	return Value(config.integer_division);
+}
 //===--------------------------------------------------------------------===//
 // Log Query Path
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp

@@ -33,10 +33,10 @@ void CommonAggregateOptimizer::ExtractCommonAggregates(LogicalAggregate &aggr) {
 	idx_t total_erased = 0;
 	for (idx_t i = 0; i < aggr.expressions.size(); i++) {
 		idx_t original_index = i + total_erased;
-		auto entry = aggregate_remap.find(aggr.expressions[i].get());
+		auto entry = aggregate_remap.find(*aggr.expressions[i]);
 		if (entry == aggregate_remap.end()) {
 			// aggregate does not exist yet: add it to the map
-			aggregate_remap[aggr.expressions[i].get()] = i;
+			aggregate_remap[*aggr.expressions[i]] = i;
 			if (i != original_index) {
 				// this aggregate is not erased, however an agregate BEFORE it has been erased
 				// so we need to remap this aggregaet