duckdb 1.3.1-dev6.0 → 1.3.1

package/src/duckdb/src/planner/logical_operator.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/planner/logical_operator.hpp"
 
+#include "duckdb/original/std/sstream.hpp"
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/serializer/binary_deserializer.hpp"
@@ -126,7 +127,7 @@ vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &
 
 string LogicalOperator::ToString(ExplainFormat format) const {
 	auto renderer = TreeRenderer::CreateRenderer(format);
-	stringstream ss;
+	duckdb::stringstream ss;
 	auto tree = RenderTree::CreateRenderTree(*this);
 	renderer->ToStream(*tree, ss);
 	return ss.str();

package/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp

@@ -423,7 +423,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		}
 
 		base_binding.table_index = proj.table_index;
-		this->delim_offset = base_binding.column_index = plan->expressions.size() - correlated_columns.size();
+		base_binding.column_index = plan->expressions.size() - correlated_columns.size();
+		this->delim_offset = base_binding.column_index;
 		this->data_offset = 0;
 		return plan;
 	}
@@ -656,6 +657,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		// push into both sides
 		plan->children[0] =
 		    PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth);
+		auto left_delim_offset = delim_offset;
 		auto left_binding = this->base_binding;
 		plan->children[1] =
 		    PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values, lateral_depth);
@@ -665,6 +667,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		// because the RIGHT binding might contain NULL values
 		if (join.join_type == JoinType::LEFT) {
 			this->base_binding = left_binding;
+			delim_offset = left_delim_offset;
 		} else if (join.join_type == JoinType::RIGHT) {
 			this->base_binding = right_binding;
 			delim_offset += plan->children[0]->GetColumnBindings().size();

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -206,6 +206,14 @@ bool BlockHandle::CanUnload() const {
 void BlockHandle::ConvertToPersistent(BlockLock &l, BlockHandle &new_block, unique_ptr<FileBuffer> new_buffer) {
 	VerifyMutex(l);
 
+	D_ASSERT(tag == memory_charge.tag);
+	if (tag != new_block.tag) {
+		const auto memory_charge_size = memory_charge.size;
+		memory_charge.Resize(0);
+		memory_charge.tag = new_block.tag;
+		memory_charge.Resize(memory_charge_size);
+	}
+
 	// move the data from the old block into data for the new block
 	new_block.state = BlockState::BLOCK_LOADED;
 	new_block.buffer = std::move(new_buffer);

package/src/duckdb/src/storage/buffer/buffer_pool.cpp

@@ -10,6 +10,33 @@
 
 namespace duckdb {
 
+static idx_t FileBufferTypeToEvictionQueueTypeIdx(const FileBufferType &type) {
+	switch (type) {
+	case FileBufferType::BLOCK:
+	case FileBufferType::EXTERNAL_FILE:
+		return 0; // Evict these first (cheap, just free)
+	case FileBufferType::MANAGED_BUFFER:
+		return 1; // Then these (have to write to storage)
+	case FileBufferType::TINY_BUFFER:
+		return 2; // Evict tiny buffers last (last resort)
+	default:
+		throw InternalException("Unknown FileBufferType in FileBufferTypeToEvictionQueueTypeIdx");
+	}
+}
+
+static vector<FileBufferType> EvictionQueueTypeIdxToFileBufferTypes(const idx_t &queue_type_idx) {
+	switch (queue_type_idx) {
+	case 0:
+		return {FileBufferType::BLOCK, FileBufferType::EXTERNAL_FILE};
+	case 1:
+		return {FileBufferType::MANAGED_BUFFER};
+	case 2:
+		return {FileBufferType::TINY_BUFFER};
+	default:
+		throw InternalException("Unknown queue type index in EvictionQueueTypeIdxToFileBufferTypes");
+	}
+}
+
 BufferEvictionNode::BufferEvictionNode(weak_ptr<BlockHandle> handle_p, idx_t eviction_seq_num)
     : handle(std::move(handle_p)), handle_sequence_number(eviction_seq_num) {
 	D_ASSERT(!handle.expired());
@@ -41,8 +68,8 @@ typedef duckdb_moodycamel::ConcurrentQueue<BufferEvictionNode> eviction_queue_t;
 
 struct EvictionQueue {
 public:
-	explicit EvictionQueue(const FileBufferType file_buffer_type_p)
-	    : file_buffer_type(file_buffer_type_p), evict_queue_insertions(0), total_dead_nodes(0) {
+	explicit EvictionQueue(const vector<FileBufferType> &file_buffer_types_p)
+	    : file_buffer_types(file_buffer_types_p), evict_queue_insertions(0), total_dead_nodes(0) {
 	}
 
 public:
@@ -70,8 +97,11 @@ private:
 	void PurgeIteration(const idx_t purge_size);
 
 public:
-	//! The type of the buffers in this queue
-	const FileBufferType file_buffer_type;
+	//! The type of the buffers in this queue and helper function (both for verification only)
+	const vector<FileBufferType> file_buffer_types;
+	bool HasFileBufferType(const FileBufferType &type) const {
+		return std::find(file_buffer_types.begin(), file_buffer_types.end(), type) != file_buffer_types.end();
+	}
 	//! The concurrent queue
 	eviction_queue_t q;
 
@@ -199,16 +229,16 @@ void EvictionQueue::PurgeIteration(const idx_t purge_size) {
 
 BufferPool::BufferPool(idx_t maximum_memory, bool track_eviction_timestamps,
                        idx_t allocator_bulk_deallocation_flush_threshold)
-    : eviction_queue_sizes({BLOCK_QUEUE_SIZE, MANAGED_BUFFER_QUEUE_SIZE, TINY_BUFFER_QUEUE_SIZE}),
+    : eviction_queue_sizes({BLOCK_AND_EXTERNAL_FILE_QUEUE_SIZE, MANAGED_BUFFER_QUEUE_SIZE, TINY_BUFFER_QUEUE_SIZE}),
       maximum_memory(maximum_memory),
       allocator_bulk_deallocation_flush_threshold(allocator_bulk_deallocation_flush_threshold),
       track_eviction_timestamps(track_eviction_timestamps),
       temporary_memory_manager(make_uniq<TemporaryMemoryManager>()) {
-	for (uint8_t type_idx = 0; type_idx < FILE_BUFFER_TYPE_COUNT; type_idx++) {
-		const auto type = static_cast<FileBufferType>(type_idx + 1);
-		const auto &type_queue_size = eviction_queue_sizes[type_idx];
+	for (idx_t queue_type_idx = 0; queue_type_idx < EVICTION_QUEUE_TYPES; queue_type_idx++) {
+		const auto types = EvictionQueueTypeIdxToFileBufferTypes(queue_type_idx);
+		const auto &type_queue_size = eviction_queue_sizes[queue_type_idx];
 		for (idx_t queue_idx = 0; queue_idx < type_queue_size; queue_idx++) {
-			queues.push_back(make_uniq<EvictionQueue>(type));
+			queues.push_back(make_uniq<EvictionQueue>(types));
 		}
 	}
 }
@@ -243,23 +273,19 @@ EvictionQueue &BufferPool::GetEvictionQueueForBlockHandle(const BlockHandle &han
 
 	// Get offset into eviction queues for this FileBufferType
 	idx_t queue_index = 0;
-	for (uint8_t type_idx = 0; type_idx < FILE_BUFFER_TYPE_COUNT; type_idx++) {
-		const auto queue_buffer_type = static_cast<FileBufferType>(type_idx + 1);
-		if (handle_buffer_type == queue_buffer_type) {
-			break;
-		}
-		const auto &type_queue_size = eviction_queue_sizes[type_idx];
-		queue_index += type_queue_size;
+	const auto handle_queue_type_idx = FileBufferTypeToEvictionQueueTypeIdx(handle_buffer_type);
+	for (idx_t type_idx = 0; type_idx < handle_queue_type_idx; type_idx++) {
+		queue_index += eviction_queue_sizes[type_idx];
 	}
 
-	const auto &queue_size = eviction_queue_sizes[static_cast<uint8_t>(handle_buffer_type) - 1];
+	const auto &queue_size = eviction_queue_sizes[handle_queue_type_idx];
 	// Adjust if eviction_queue_idx is set (idx == 0 -> add at back, idx >= queue_size -> add at front)
 	auto eviction_queue_idx = handle.GetEvictionQueueIndex();
 	if (eviction_queue_idx < queue_size) {
 		queue_index += queue_size - eviction_queue_idx - 1;
 	}
 
-	D_ASSERT(queues[queue_index]->file_buffer_type == handle_buffer_type);
+	D_ASSERT(queues[queue_index]->HasFileBufferType(handle_buffer_type));
 	return *queues[queue_index];
 }
 

package/src/duckdb/src/storage/caching_file_system.cpp

@@ -113,7 +113,7 @@ BufferHandle CachingFileHandle::Read(data_ptr_t &buffer, idx_t &nr_bytes) {
 
 	// If we can't seek, we can't use the cache for these calls,
 	// because we won't be able to seek over any parts we skipped by reading from the cache
-	if (!external_file_cache.IsEnabled() || !GetFileHandle().CanSeek()) {
+	if (!external_file_cache.IsEnabled() || !CanSeek()) {
 		result = external_file_cache.GetBufferManager().Allocate(MemoryTag::EXTERNAL_FILE_CACHE, nr_bytes);
 		buffer = result.Ptr();
 		nr_bytes = NumericCast<idx_t>(GetFileHandle().Read(buffer, nr_bytes));
@@ -285,11 +285,16 @@ BufferHandle CachingFileHandle::TryInsertFileRange(BufferHandle &pin, data_ptr_t
 	auto &ranges = cached_file.Ranges(guard);
 
 	// Start at lower_bound (first range with location not less than location of newly created range)
+	const auto this_end = location + nr_bytes;
 	auto it = ranges.lower_bound(location);
 	if (it != ranges.begin()) {
 		--it;
 	}
 	while (it != ranges.end()) {
+		if (it->second->location >= this_end) {
+			// We're past the requested location
+			break;
+		}
 		if (it->second->GetOverlap(*new_file_range) == CachedFileRangeOverlap::FULL) {
 			// Another thread has read a range that fully contains the requested range in the meantime
 			auto other_pin = TryReadFromFileRange(guard, *it->second, buffer, nr_bytes, location);
@@ -300,11 +305,9 @@ BufferHandle CachingFileHandle::TryInsertFileRange(BufferHandle &pin, data_ptr_t
 			continue;
 		}
 		// Check if the new range overlaps with a cached one
-		bool break_loop = false;
 		switch (new_file_range->GetOverlap(*it->second)) {
 		case CachedFileRangeOverlap::NONE:
-			break_loop = true; // We iterated past potential overlaps
-			break;
+			break; // No overlap, still useful
 		case CachedFileRangeOverlap::PARTIAL:
 			break; // The newly created range does not fully contain this range, so it is still useful
 		case CachedFileRangeOverlap::FULL:
@@ -315,9 +318,6 @@ BufferHandle CachingFileHandle::TryInsertFileRange(BufferHandle &pin, data_ptr_t
 		default:
 			throw InternalException("Unknown CachedFileRangeOverlap");
 		}
-		if (break_loop) {
-			break;
-		}
 
 		++it;
 	}

package/src/duckdb/src/storage/standard_buffer_manager.cpp

@@ -168,9 +168,10 @@ shared_ptr<BlockHandle> StandardBufferManager::RegisterMemory(MemoryTag tag, idx
 	                              StringUtil::BytesToHumanReadableString(alloc_size));
 
 	// Create a new buffer and a block to hold the buffer.
-	auto buffer = ConstructManagedBuffer(block_size, block_header_size, std::move(reusable_buffer),
-	                                     FileBufferType::MANAGED_BUFFER);
-	DestroyBufferUpon destroy_buffer_upon = can_destroy ? DestroyBufferUpon::EVICTION : DestroyBufferUpon::BLOCK;
+	const auto file_buffer_type =
+	    tag == MemoryTag::EXTERNAL_FILE_CACHE ? FileBufferType::EXTERNAL_FILE : FileBufferType::MANAGED_BUFFER;
+	auto buffer = ConstructManagedBuffer(block_size, block_header_size, std::move(reusable_buffer), file_buffer_type);
+	const auto destroy_buffer_upon = can_destroy ? DestroyBufferUpon::EVICTION : DestroyBufferUpon::BLOCK;
 	return make_shared_ptr<BlockHandle>(*temp_block_manager, ++temporary_id, tag, std::move(buffer),
 	                                    destroy_buffer_upon, alloc_size, std::move(res));
 }

package/src/duckdb/src/storage/storage_info.cpp

@@ -80,6 +80,7 @@ static const StorageVersionInfo storage_version_info[] = {
 	{"v1.2.1", 65},
 	{"v1.2.2", 65},
 	{"v1.3.0", 66},
+	{"v1.3.1", 66},
 	{nullptr, 0}
 };
 // END OF STORAGE VERSION INFO
@@ -102,6 +103,7 @@ static const SerializationVersionInfo serialization_version_info[] = {
 	{"v1.2.1", 4},
 	{"v1.2.2", 4},
 	{"v1.3.0", 5},
+	{"v1.3.1", 5},
 	{"latest", 5},
 	{nullptr, 0}
 };

package/src/duckdb/src/storage/wal_replay.cpp

@@ -816,19 +816,24 @@ void WriteAheadLogDeserializer::ReplayDelete() {
 		return;
 	}
 	if (!state.current_table) {
-		throw InternalException("Corrupt WAL: delete without table");
+		throw SerializationException("delete without a table");
 	}
 
 	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
 	row_t row_ids[1];
 	Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_ids));
-
 	auto source_ids = FlatVector::GetData<row_t>(chunk.data[0]);
-	// delete the tuples from the current table
+
+	// Delete the row IDs from the current table.
+	auto &storage = state.current_table->GetStorage();
+	auto total_rows = storage.GetTotalRows();
 	TableDeleteState delete_state;
 	for (idx_t i = 0; i < chunk.size(); i++) {
+		if (source_ids[i] >= UnsafeNumericCast<row_t>(total_rows)) {
+			throw SerializationException("invalid row ID delete in WAL");
+		}
 		row_ids[0] = source_ids[i];
-		state.current_table->GetStorage().Delete(delete_state, context, row_identifiers, 1);
+		storage.Delete(delete_state, context, row_identifiers, 1);
 	}
 }
 

package/src/duckdb/third_party/fmt/include/fmt/format.h

@@ -34,6 +34,7 @@
 #define FMT_FORMAT_H_
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/original/std/memory.hpp"
 #include "fmt/core.h"
 
 #include <algorithm>
@@ -44,6 +45,12 @@
 #include <memory>
 #include <stdexcept>
 
+#ifndef DUCKDB_BASE_STD
+namespace duckdb_base_std {
+	using ::std::unique_ptr;
+}
+#endif
+
 #ifdef __clang__
 #  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
 #else
@@ -3052,7 +3059,7 @@ typename Context::iterator vformat_to(
 // Example:
 //   auto s = format("{}", ptr(p));
 template <typename T> inline const void* ptr(const T* p) { return p; }
-template <typename T> inline const void* ptr(const std::unique_ptr<T>& p) {
+template <typename T> inline const void* ptr(const duckdb_base_std::unique_ptr<T>& p) {
   return p.get();
 }
 template <typename T> inline const void* ptr(const std::shared_ptr<T>& p) {

package/src/duckdb/third_party/fsst/libfsst.cpp

@@ -16,6 +16,7 @@
 //
 // You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
 #include "libfsst.hpp"
+#include "duckdb/common/unique_ptr.hpp"
 
 Symbol concat(Symbol a, Symbol b) {
 	Symbol s;
@@ -320,7 +321,7 @@ static inline size_t compressBulk(SymbolTable &symbolTable, size_t nlines, size_
 
 // quickly select a uniformly random set of lines such that we have between [FSST_SAMPLETARGET,FSST_SAMPLEMAXSZ) string bytes
 vector<u8*> makeSample(u8* sampleBuf, u8* strIn[], size_t *lenIn, size_t nlines,
-                                                    unique_ptr<vector<size_t>>& sample_len_out) {
+                                                    duckdb::unique_ptr<vector<size_t>>& sample_len_out) {
 	size_t totSize = 0;
 	vector<u8*> sample;
 
@@ -333,7 +334,7 @@ vector<u8*> makeSample(u8* sampleBuf, u8* strIn[], size_t *lenIn, size_t nlines,
 		size_t sampleRnd = FSST_HASH(4637947);
 		u8* sampleLim = sampleBuf + FSST_SAMPLETARGET;
 
-		sample_len_out = unique_ptr<vector<size_t>>(new vector<size_t>());
+		sample_len_out = duckdb::unique_ptr<vector<size_t>>(new vector<size_t>());
 		sample_len_out->reserve(nlines + FSST_SAMPLEMAXSZ/FSST_SAMPLELINE);
 
 		// This fails if we have a lot of small strings and a few big ones?
@@ -363,7 +364,7 @@ vector<u8*> makeSample(u8* sampleBuf, u8* strIn[], size_t *lenIn, size_t nlines,
 
 extern "C" duckdb_fsst_encoder_t* duckdb_fsst_create(size_t n, size_t lenIn[], u8 *strIn[], int zeroTerminated) {
 	u8* sampleBuf = new u8[FSST_SAMPLEMAXSZ];
-	unique_ptr<vector<size_t>> sample_sizes;
+	duckdb::unique_ptr<vector<size_t>> sample_sizes;
 	vector<u8*> sample = makeSample(sampleBuf, strIn, lenIn, n?n:1, sample_sizes); // careful handling of input to get a right-size and representative sample
 	Encoder *encoder = new Encoder();
 	size_t* sampleLen = sample_sizes ? sample_sizes->data() : &lenIn[0];

package/src/duckdb/third_party/httplib/httplib.hpp

@@ -13,6 +13,9 @@
 
 #define CPPHTTPLIB_VERSION "0.14.3"
 
+#include "duckdb/original/std/memory.hpp"
+#include "duckdb/common/string.hpp"
+
 /*
  * Configuration
  */
@@ -317,16 +320,16 @@ namespace detail {
  */
 
 template <class T, class... Args>
-typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
+typename std::enable_if<!std::is_array<T>::value, duckdb::unique_ptr<T>>::type
 make_unique(Args &&...args) {
-  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+  return duckdb::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 
 template <class T>
-typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
+typename std::enable_if<std::is_array<T>::value, duckdb::unique_ptr<T>>::type
 make_unique(std::size_t n) {
   typedef typename std::remove_extent<T>::type RT;
-  return std::unique_ptr<T>(new RT[n]);
+  return duckdb::unique_ptr<T>(new RT[n]);
 }
 
 struct ci {
@@ -947,7 +950,7 @@ private:
   using HandlersForContentReader =
       std::vector<std::pair<Regex, HandlerWithContentReader>>;
 
-  static std::unique_ptr<detail::MatcherBase>
+  static duckdb::unique_ptr<detail::MatcherBase>
   make_matcher(const std::string &pattern);
 
   socket_t create_server_socket(const std::string &host, int port,
@@ -1060,7 +1063,7 @@ std::ostream &operator<<(std::ostream &os, const Error &obj);
 class Result {
 public:
   Result() = default;
-  Result(std::unique_ptr<Response> &&res, Error err,
+  Result(duckdb::unique_ptr<Response> &&res, Error err,
          Headers &&request_headers = Headers{})
       : res_(std::move(res)), err_(err),
         request_headers_(std::move(request_headers)) {}
@@ -1087,7 +1090,7 @@ public:
   size_t get_request_header_value_count(const std::string &key) const;
 
 private:
-  std::unique_ptr<Response> res_;
+  duckdb::unique_ptr<Response> res_;
   Error err_ = Error::Unknown;
   Headers request_headers_;
 };
@@ -1445,7 +1448,7 @@ private:
   bool redirect(Request &req, Response &res, Error &error);
   bool handle_request(Stream &strm, Request &req, Response &res,
                       bool close_connection, Error &error);
-  std::unique_ptr<Response> send_with_content_provider(
+  duckdb::unique_ptr<Response> send_with_content_provider(
       Request &req, const char *body, size_t content_length,
       ContentProvider content_provider,
       ContentProviderWithoutLength content_provider_without_length,
@@ -1710,7 +1713,7 @@ public:
 #endif
 
 private:
-  std::unique_ptr<ClientImpl> cli_;
+  duckdb::unique_ptr<ClientImpl> cli_;
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
   bool is_ssl_ = false;
@@ -3953,7 +3956,7 @@ bool prepare_content_receiver(T &x, int &status,
                               bool decompress, U callback) {
   if (decompress) {
     std::string encoding = x.get_header_value("Content-Encoding");
-    std::unique_ptr<decompressor> decompressor;
+    duckdb::unique_ptr<decompressor> decompressor;
 
     if (encoding == "gzip" || encoding == "deflate") {
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
@@ -4860,7 +4863,7 @@ inline bool has_crlf(const std::string &s) {
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 inline std::string message_digest(const std::string &s, const EVP_MD *algo) {
-  auto context = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(
+  auto context = duckdb::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(
       EVP_MD_CTX_new(), EVP_MD_CTX_free);
 
   unsigned int hash_length = 0;
@@ -4870,7 +4873,7 @@ inline std::string message_digest(const std::string &s, const EVP_MD *algo) {
   EVP_DigestUpdate(context.get(), s.c_str(), s.size());
   EVP_DigestFinal_ex(context.get(), hash, &hash_length);
 
-  std::stringstream ss;
+  duckdb::stringstream ss;
   for (auto i = 0u; i < hash_length; ++i) {
     ss << std::hex << std::setw(2) << std::setfill('0')
        << static_cast<unsigned int>(hash[i]);
@@ -4924,7 +4927,7 @@ inline bool load_system_certs_on_windows(X509_STORE *store) {
 #if TARGET_OS_OSX
 template <typename T>
 using CFObjectPtr =
-    std::unique_ptr<typename std::remove_pointer<T>::type, void (*)(CFTypeRef)>;
+    duckdb::unique_ptr<typename std::remove_pointer<T>::type, void (*)(CFTypeRef)>;
 
 inline void cf_object_ptr_deleter(CFTypeRef obj) {
   if (obj) { CFRelease(obj); }
@@ -5038,7 +5041,7 @@ inline std::pair<std::string, std::string> make_digest_authentication_header(
     const std::string &password, bool is_proxy = false) {
   std::string nc;
   {
-    std::stringstream ss;
+    duckdb::stringstream ss;
     ss << std::setfill('0') << std::setw(8) << std::hex << cnonce_count;
     nc = ss.str();
   }
@@ -5627,7 +5630,7 @@ inline Server::Server()
 
 inline Server::~Server() = default;
 
-inline std::unique_ptr<detail::MatcherBase>
+inline duckdb::unique_ptr<detail::MatcherBase>
 Server::make_matcher(const std::string &pattern) {
   if (pattern.find("/:") != std::string::npos) {
     return detail::make_unique<detail::PathParamsMatcher>(pattern);
@@ -5965,7 +5968,7 @@ inline bool Server::write_response_core(Stream &strm, bool close_connection,
   if (close_connection || req.get_header_value("Connection") == "close") {
     res.set_header("Connection", "close");
   } else {
-    std::stringstream ss;
+    duckdb::stringstream ss;
     ss << "timeout=" << keep_alive_timeout_sec_
        << ", max=" << keep_alive_max_count_;
     res.set_header("Keep-Alive", ss.str());
@@ -6053,7 +6056,7 @@ Server::write_content_with_provider(Stream &strm, const Request &req,
     if (res.is_chunked_content_provider_) {
       auto type = detail::encoding_type(req, res);
 
-      std::unique_ptr<detail::compressor> compressor;
+      duckdb::unique_ptr<detail::compressor> compressor;
       if (type == detail::EncodingType::Gzip) {
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
         compressor = detail::make_unique<detail::gzip_compressor>();
@@ -6194,7 +6197,7 @@ inline bool Server::handle_file_request(const Request &req, Response &res,
             res.set_header(kv.first, kv.second);
           }
 
-          auto mm = std::make_shared<detail::mmap>(path.c_str());
+          auto mm = duckdb::make_shared_ptr<detail::mmap>(path.c_str());
           if (!mm->is_open()) { return false; }
 
           res.set_content_provider(
@@ -6266,7 +6269,7 @@ inline bool Server::listen_internal() {
   auto se = detail::scope_exit([&]() { is_running_ = false; });
 
   {
-    std::unique_ptr<TaskQueue> task_queue(new_task_queue());
+    duckdb::unique_ptr<TaskQueue> task_queue(new_task_queue());
 
     while (svr_sock_ != INVALID_SOCKET) {
 #ifndef _WIN32
@@ -6510,7 +6513,7 @@ inline void Server::apply_ranges(const Request &req, Response &res,
     }
 
     if (type != detail::EncodingType::None) {
-      std::unique_ptr<detail::compressor> compressor;
+      duckdb::unique_ptr<detail::compressor> compressor;
       std::string content_encoding;
 
       if (type == detail::EncodingType::Gzip) {
@@ -7127,7 +7130,7 @@ inline bool ClientImpl::write_content_with_provider(Stream &strm,
 
   if (req.is_chunked_content_provider_) {
     // TODO: Brotli support
-    std::unique_ptr<detail::compressor> compressor;
+    duckdb::unique_ptr<detail::compressor> compressor;
 #ifdef CPPHTTPLIB_ZLIB_SUPPORT
     if (compress_) {
       compressor = detail::make_unique<detail::gzip_compressor>();
@@ -7263,7 +7266,7 @@ inline bool ClientImpl::write_request(Stream &strm, Request &req,
   return true;
 }
 
-inline std::unique_ptr<Response> ClientImpl::send_with_content_provider(
+inline duckdb::unique_ptr<Response> ClientImpl::send_with_content_provider(
     Request &req, const char *body, size_t content_length,
     ContentProvider content_provider,
     ContentProviderWithoutLength content_provider_without_length,

package/src/duckdb/third_party/hyperloglog/sds.cpp

@@ -40,6 +40,10 @@
 
 namespace duckdb_hll {
 
+static bool CharacterIsSpace(char c) {
+       return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
 static inline int sdsHdrSize(char type) {
     switch(type&SDS_TYPE_MASK) {
         case SDS_TYPE_5:
@@ -956,7 +960,7 @@ sds *sdssplitargs(const char *line, int *argc) {
     *argc = 0;
     while(1) {
         /* skip blanks */
-        while(*p && isspace(*p)) p++;
+        while(*p && CharacterIsSpace(*p)) p++;
         if (*p) {
             /* get a token */
             int inq=0;  /* set to 1 if we are in "quotes" */
@@ -992,7 +996,7 @@ sds *sdssplitargs(const char *line, int *argc) {
                     } else if (*p == '"') {
                         /* closing quote must be followed by a space or
                          * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
+                        if (*(p+1) && !CharacterIsSpace(*(p+1))) goto err;
                         done=1;
                     } else if (!*p) {
                         /* unterminated quotes */
@@ -1007,7 +1011,7 @@ sds *sdssplitargs(const char *line, int *argc) {
                     } else if (*p == '\'') {
                         /* closing quote must be followed by a space or
                          * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
+                        if (*(p+1) && !CharacterIsSpace(*(p+1))) goto err;
                         done=1;
                     } else if (!*p) {
                         /* unterminated quotes */

package/src/duckdb/third_party/libpg_query/src_common_keywords.cpp

@@ -27,6 +27,13 @@
 #include <memory>
 #include "parser/gramparse.hpp"
 
+#define DUCKDB_BASE_STD
+ 
+namespace duckdb_base_std {
+	using ::std::unique_ptr;
+} // namespace duckdb_base_std
+
+
 #include "parser/kwlist.hpp"
 
 namespace duckdb_libpgquery {
@@ -52,7 +59,7 @@ const PGScanKeyword *ScanKeywordLookup(const char *text, const PGScanKeyword *ke
 	const PGScanKeyword *high;
 
 	len = strlen(text);
-	auto data = std::unique_ptr<char[]>(new char[len + 1]);
+	auto data = duckdb_base_std::unique_ptr<char[]>(new char[len + 1]);
 	auto word = data.get();
 	/* We assume all keywords are shorter than NAMEDATALEN. */
 

package/src/duckdb/third_party/re2/re2/filtered_re2.h

@@ -24,9 +24,15 @@
 #include <memory>
 #include <string>
 #include <vector>
-
 #include "re2/re2.h"
 
+#ifndef DUCKDB_BASE_STD
+namespace duckdb_base_std {
+	using ::std::unique_ptr;
+} // namespace duckdb_base_std
+#endif
+
+
 namespace duckdb_re2 {
 
 class PrefilterTree;
@@ -106,7 +112,7 @@ class FilteredRE2 {
   bool compiled_;
 
   // An AND-OR tree of string atoms used for filtering regexps.
-  std::unique_ptr<PrefilterTree> prefilter_tree_;
+  duckdb_base_std::unique_ptr<PrefilterTree> prefilter_tree_;
 };
 
 }  // namespace re2

package/src/duckdb/third_party/re2/re2/pod_array.h

@@ -8,6 +8,12 @@
 #include <memory>
 #include <type_traits>
 
+#ifndef DUCKDB_BASE_STD
+namespace duckdb_base_std {
+	using ::std::unique_ptr;
+} // namespace duckdb_base_std
+#endif
+
 namespace duckdb_re2 {
 
 template <typename T>
@@ -47,7 +53,7 @@ class PODArray {
     int len_;
   };
 
-  std::unique_ptr<T[], Deleter> ptr_;
+  duckdb_base_std::unique_ptr<T[], Deleter> ptr_;
 };
 
 }  // namespace re2

package/src/duckdb/third_party/re2/re2/re2.cc

@@ -36,6 +36,10 @@
 
 namespace duckdb_re2 {
 
+static bool CharacterIsSpace(char c) {
+	return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
 // Controls the maximum count permitted by GlobalReplace(); -1 is unlimited.
 static int maximum_global_replace_count = -1;
 
@@ -1121,13 +1125,13 @@ static const char* TerminateNumber(char* buf, size_t nbuf, const char* str,
                                    size_t* np, bool accept_spaces) {
   size_t n = *np;
   if (n == 0) return "";
-  if (n > 0 && isspace(*str)) {
+  if (n > 0 && CharacterIsSpace(*str)) {
     // We are less forgiving than the strtoxxx() routines and do not
     // allow leading spaces. We do allow leading spaces for floats.
     if (!accept_spaces) {
       return "";
     }
-    while (n > 0 && isspace(*str)) {
+    while (n > 0 && CharacterIsSpace(*str)) {
       n--;
       str++;
     }