duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/include/duckdb/common/tree_renderer/html_tree_renderer.hpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/html_tree_renderer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/main/profiling_node.hpp"
+#include "duckdb/common/tree_renderer.hpp"
+#include "duckdb/common/render_tree.hpp"
+
+namespace duckdb {
+class LogicalOperator;
+class PhysicalOperator;
+class Pipeline;
+struct PipelineRenderNode;
+
+class HTMLTreeRenderer : public TreeRenderer {
+public:
+	explicit HTMLTreeRenderer() {
+	}
+	~HTMLTreeRenderer() override {
+	}
+
+public:
+	string ToString(const LogicalOperator &op);
+	string ToString(const PhysicalOperator &op);
+	string ToString(const ProfilingNode &op);
+	string ToString(const Pipeline &op);
+
+	void Render(const LogicalOperator &op, std::ostream &ss);
+	void Render(const PhysicalOperator &op, std::ostream &ss);
+	void Render(const ProfilingNode &op, std::ostream &ss);
+	void Render(const Pipeline &op, std::ostream &ss);
+
+	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/tree_renderer/json_tree_renderer.hpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/json_renderer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/main/profiling_node.hpp"
+#include "duckdb/common/tree_renderer.hpp"
+#include "duckdb/common/render_tree.hpp"
+
+namespace duckdb {
+class LogicalOperator;
+class PhysicalOperator;
+class Pipeline;
+struct PipelineRenderNode;
+
+class JSONTreeRenderer : public TreeRenderer {
+public:
+	explicit JSONTreeRenderer() {
+	}
+	~JSONTreeRenderer() override {
+	}
+
+public:
+	string ToString(const LogicalOperator &op);
+	string ToString(const PhysicalOperator &op);
+	string ToString(const ProfilingNode &op);
+	string ToString(const Pipeline &op);
+
+	void Render(const LogicalOperator &op, std::ostream &ss);
+	void Render(const PhysicalOperator &op, std::ostream &ss);
+	void Render(const ProfilingNode &op, std::ostream &ss);
+	void Render(const Pipeline &op, std::ostream &ss);
+
+	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/tree_renderer/text_tree_renderer.hpp

@@ -0,0 +1,119 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/tree_renderer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/main/profiling_node.hpp"
+#include "duckdb/common/tree_renderer.hpp"
+#include "duckdb/common/render_tree.hpp"
+
+namespace duckdb {
+class LogicalOperator;
+class PhysicalOperator;
+class Pipeline;
+struct PipelineRenderNode;
+
+struct TextTreeRendererConfig {
+	void EnableDetailed() {
+		max_extra_lines = 1000;
+		detailed = true;
+	}
+
+	void EnableStandard() {
+		max_extra_lines = 30;
+		detailed = false;
+	}
+
+	idx_t maximum_render_width = 240;
+	idx_t node_render_width = 29;
+	idx_t minimum_render_width = 15;
+	idx_t max_extra_lines = 30;
+	bool detailed = false;
+
+#ifndef DUCKDB_ASCII_TREE_RENDERER
+	const char *LTCORNER = "\342\224\214"; // NOLINT "┌";
+	const char *RTCORNER = "\342\224\220"; // NOLINT "┐";
+	const char *LDCORNER = "\342\224\224"; // NOLINT "└";
+	const char *RDCORNER = "\342\224\230"; // NOLINT "┘";
+
+	const char *MIDDLE = "\342\224\274";  // NOLINT "┼";
+	const char *TMIDDLE = "\342\224\254"; // NOLINT "┬";
+	const char *LMIDDLE = "\342\224\234"; // NOLINT "├";
+	const char *RMIDDLE = "\342\224\244"; // NOLINT "┤";
+	const char *DMIDDLE = "\342\224\264"; // NOLINT "┴";
+
+	const char *VERTICAL = "\342\224\202";   // NOLINT "│";
+	const char *HORIZONTAL = "\342\224\200"; // NOLINT "─";
+#else
+	// ASCII version
+	const char *LTCORNER = "<";
+	const char *RTCORNER = ">";
+	const char *LDCORNER = "<";
+	const char *RDCORNER = ">";
+
+	const char *MIDDLE = "+";
+	const char *TMIDDLE = "+";
+	const char *LMIDDLE = "+";
+	const char *RMIDDLE = "+";
+	const char *DMIDDLE = "+";
+
+	const char *VERTICAL = "|";
+	const char *HORIZONTAL = "-";
+#endif
+};
+
+class TextTreeRenderer : public TreeRenderer {
+public:
+	explicit TextTreeRenderer(TextTreeRendererConfig config_p = TextTreeRendererConfig()) : config(config_p) {
+	}
+	~TextTreeRenderer() override {
+	}
+
+public:
+	string ToString(const LogicalOperator &op);
+	string ToString(const PhysicalOperator &op);
+	string ToString(const ProfilingNode &op);
+	string ToString(const Pipeline &op);
+
+	void Render(const LogicalOperator &op, std::ostream &ss);
+	void Render(const PhysicalOperator &op, std::ostream &ss);
+	void Render(const ProfilingNode &op, std::ostream &ss);
+	void Render(const Pipeline &op, std::ostream &ss);
+
+	void ToStreamInternal(RenderTree &root, std::ostream &ss) override;
+
+	void EnableDetailed() {
+		config.EnableDetailed();
+	}
+	void EnableStandard() {
+		config.EnableStandard();
+	}
+	bool UsesRawKeyNames() override {
+		return true;
+	}
+
+private:
+	//! The configuration used for rendering
+	TextTreeRendererConfig config;
+
+private:
+	string ExtraInfoSeparator();
+	void RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y);
+	void RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y);
+	void RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y);
+
+	bool CanSplitOnThisChar(char l);
+	bool IsPadding(char l);
+	string RemovePadding(string l);
+	void SplitUpExtraInfo(const InsertionOrderPreservingMap<string> &extra_info, vector<string> &result);
+	void SplitStringBuffer(const string &source, vector<string> &result);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/tree_renderer.hpp

@@ -10,140 +10,26 @@
 
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/vector.hpp"
-#include "duckdb/main/query_profiler.hpp"
+#include "duckdb/main/profiling_node.hpp"
+#include "duckdb/common/render_tree.hpp"
 
 namespace duckdb {
-class LogicalOperator;
-class PhysicalOperator;
-class Pipeline;
-struct PipelineRenderNode;
-
-struct RenderTreeNode {
-	string name;
-	string extra_text;
-};
-
-struct RenderTree {
-	RenderTree(idx_t width, idx_t height);
-
-	unique_ptr<unique_ptr<RenderTreeNode>[]> nodes;
-	idx_t width;
-	idx_t height;
 
+class TreeRenderer {
 public:
-	RenderTreeNode *GetNode(idx_t x, idx_t y);
-	void SetNode(idx_t x, idx_t y, unique_ptr<RenderTreeNode> node);
-	bool HasNode(idx_t x, idx_t y);
-
-	idx_t GetPosition(idx_t x, idx_t y);
-};
-
-struct TreeRendererConfig {
-	void EnableDetailed() {
-		max_extra_lines = 1000;
-		detailed = true;
+	explicit TreeRenderer() {
 	}
-
-	void EnableStandard() {
-		max_extra_lines = 30;
-		detailed = false;
+	virtual ~TreeRenderer() {
 	}
 
-	idx_t maximum_render_width = 240;
-	idx_t node_render_width = 29;
-	idx_t minimum_render_width = 15;
-	idx_t max_extra_lines = 30;
-	bool detailed = false;
-
-#ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "\342\224\214"; // NOLINT "┌";
-	const char *RTCORNER = "\342\224\220"; // NOLINT "┐";
-	const char *LDCORNER = "\342\224\224"; // NOLINT "└";
-	const char *RDCORNER = "\342\224\230"; // NOLINT "┘";
-
-	const char *MIDDLE = "\342\224\274";  // NOLINT "┼";
-	const char *TMIDDLE = "\342\224\254"; // NOLINT "┬";
-	const char *LMIDDLE = "\342\224\234"; // NOLINT "├";
-	const char *RMIDDLE = "\342\224\244"; // NOLINT "┤";
-	const char *DMIDDLE = "\342\224\264"; // NOLINT "┴";
-
-	const char *VERTICAL = "\342\224\202";   // NOLINT "│";
-	const char *HORIZONTAL = "\342\224\200"; // NOLINT "─";
-#else
-	// ASCII version
-	const char *LTCORNER = "<";
-	const char *RTCORNER = ">";
-	const char *LDCORNER = "<";
-	const char *RDCORNER = ">";
-
-	const char *MIDDLE = "+";
-	const char *TMIDDLE = "+";
-	const char *LMIDDLE = "+";
-	const char *RMIDDLE = "+";
-	const char *DMIDDLE = "+";
-
-	const char *VERTICAL = "|";
-	const char *HORIZONTAL = "-";
-#endif
-};
-
-class TreeRenderer {
 public:
-	explicit TreeRenderer(TreeRendererConfig config_p = TreeRendererConfig()) : config(config_p) {
-	}
-
-	string ToString(const LogicalOperator &op);
-	string ToString(const PhysicalOperator &op);
-	string ToString(const QueryProfiler::TreeNode &op);
-	string ToString(const Pipeline &op);
-
-	void Render(const LogicalOperator &op, std::ostream &ss);
-	void Render(const PhysicalOperator &op, std::ostream &ss);
-	void Render(const QueryProfiler::TreeNode &op, std::ostream &ss);
-	void Render(const Pipeline &op, std::ostream &ss);
-
 	void ToStream(RenderTree &root, std::ostream &ss);
+	virtual void ToStreamInternal(RenderTree &root, std::ostream &ss) = 0;
+	static unique_ptr<TreeRenderer> CreateRenderer(ExplainFormat format);
 
-	void EnableDetailed() {
-		config.EnableDetailed();
-	}
-	void EnableStandard() {
-		config.EnableStandard();
+	virtual bool UsesRawKeyNames() {
+		return false;
 	}
-
-private:
-	unique_ptr<RenderTree> CreateTree(const LogicalOperator &op);
-	unique_ptr<RenderTree> CreateTree(const PhysicalOperator &op);
-	unique_ptr<RenderTree> CreateTree(const QueryProfiler::TreeNode &op);
-	unique_ptr<RenderTree> CreateTree(const Pipeline &op);
-
-	string ExtraInfoSeparator();
-	unique_ptr<RenderTreeNode> CreateRenderNode(string name, string extra_info);
-	unique_ptr<RenderTreeNode> CreateNode(const LogicalOperator &op);
-	unique_ptr<RenderTreeNode> CreateNode(const PhysicalOperator &op);
-	unique_ptr<RenderTreeNode> CreateNode(const QueryProfiler::TreeNode &op);
-	unique_ptr<RenderTreeNode> CreateNode(const PipelineRenderNode &op);
-
-private:
-	//! The configuration used for rendering
-	TreeRendererConfig config;
-
-private:
-	void RenderTopLayer(RenderTree &root, std::ostream &ss, idx_t y);
-	void RenderBoxContent(RenderTree &root, std::ostream &ss, idx_t y);
-	void RenderBottomLayer(RenderTree &root, std::ostream &ss, idx_t y);
-
-	bool CanSplitOnThisChar(char l);
-	bool IsPadding(char l);
-	string RemovePadding(string l);
-	void SplitUpExtraInfo(const string &extra_info, vector<string> &result);
-	void SplitStringBuffer(const string &source, vector<string> &result);
-
-	template <class T>
-	idx_t CreateRenderTreeRecursive(RenderTree &result, const T &op, idx_t x, idx_t y);
-
-	template <class T>
-	unique_ptr<RenderTree> CreateRenderTree(const T &op);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/type_visitor.hpp

@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/type_visitor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+
+namespace duckdb {
+
+struct TypeVisitor {
+	template <class F>
+	static bool Contains(const LogicalType &type, F &&predicate);
+
+	static bool Contains(const LogicalType &type, LogicalTypeId type_id);
+
+	template <class F>
+	static LogicalType VisitReplace(const LogicalType &type, F &&func);
+};
+
+template <class F>
+inline LogicalType TypeVisitor::VisitReplace(const LogicalType &type, F &&func) {
+	switch (type.id()) {
+	case LogicalTypeId::STRUCT: {
+		auto children = StructType::GetChildTypes(type);
+		for (auto &child : children) {
+			child.second = VisitReplace(child.second, func);
+		}
+		return func(LogicalType::STRUCT(children));
+	}
+	case LogicalTypeId::UNION: {
+		auto children = UnionType::CopyMemberTypes(type);
+		for (auto &child : children) {
+			child.second = VisitReplace(child.second, func);
+		}
+		return func(LogicalType::UNION(children));
+	}
+	case LogicalTypeId::LIST: {
+		auto child = ListType::GetChildType(type);
+		return func(LogicalType::LIST(VisitReplace(child, func)));
+	}
+	case LogicalTypeId::ARRAY: {
+		auto child = ArrayType::GetChildType(type);
+		return func(LogicalType::ARRAY(VisitReplace(child, func), ArrayType::GetSize(type)));
+	}
+	case LogicalTypeId::MAP: {
+		auto key = MapType::KeyType(type);
+		auto value = MapType::ValueType(type);
+		return func(LogicalType::MAP(VisitReplace(key, func), VisitReplace(value, func)));
+	}
+	default:
+		return func(type);
+	}
+}
+
+template <class F>
+inline bool TypeVisitor::Contains(const LogicalType &type, F &&predicate) {
+	if (predicate(type)) {
+		return true;
+	}
+	switch (type.id()) {
+	case LogicalTypeId::STRUCT: {
+		for (const auto &child : StructType::GetChildTypes(type)) {
+			if (Contains(child.second, predicate)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	case LogicalTypeId::UNION:
+		for (const auto &child : UnionType::CopyMemberTypes(type)) {
+			if (Contains(child.second, predicate)) {
+				return true;
+			}
+		}
+		return false;
+	case LogicalTypeId::LIST:
+		return Contains(ListType::GetChildType(type), predicate);
+	case LogicalTypeId::ARRAY:
+		return Contains(ArrayType::GetChildType(type), predicate);
+	case LogicalTypeId::MAP:
+		return Contains(MapType::KeyType(type), predicate) || Contains(MapType::ValueType(type), predicate);
+	default:
+		return false;
+	}
+}
+
+inline bool TypeVisitor::Contains(const LogicalType &type, LogicalTypeId type_id) {
+	return Contains(type, [&](const LogicalType &ty) { return ty.id() == type_id; });
+}
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/typedefs.hpp

@@ -63,7 +63,17 @@ const unsigned char *const_uchar_ptr_cast(const SRC *src) { // NOLINT: naming
 
 template <class SRC>
 uintptr_t CastPointerToValue(SRC *src) {
-	return uintptr_t(src);
+	return reinterpret_cast<uintptr_t>(src);
+}
+
+template <class SRC>
+uint64_t cast_pointer_to_uint64(SRC *src) {
+	return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(src));
+}
+
+template <class SRC = data_t>
+SRC *cast_uint64_to_pointer(uint64_t value) {
+	return reinterpret_cast<SRC *>(static_cast<uintptr_t>(value));
 }
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/arrow_string_view_type.hpp

@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/arrow_string_view_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/numeric_utils.hpp"
+
+namespace duckdb {
+
+struct ArrowStringViewConstants {
+public:
+	static constexpr uint8_t MAX_INLINED_BYTES = 12 * sizeof(char);
+	static constexpr uint8_t PREFIX_BYTES = 4 * sizeof(char);
+
+public:
+	ArrowStringViewConstants() = delete;
+};
+
+union arrow_string_view_t {
+	arrow_string_view_t() {
+	}
+
+	//! Constructor for inlined arrow string views
+	arrow_string_view_t(int32_t length, const char *data) {
+		D_ASSERT(length <= ArrowStringViewConstants::MAX_INLINED_BYTES);
+		inlined.length = length;
+		memcpy(inlined.data, data, UnsafeNumericCast<idx_t>(length));
+		if (length < ArrowStringViewConstants::MAX_INLINED_BYTES) {
+			// have to 0 pad
+			uint8_t remaining_bytes = ArrowStringViewConstants::MAX_INLINED_BYTES - NumericCast<uint8_t>(length);
+
+			memset(&inlined.data[length], '\0', remaining_bytes);
+		}
+	}
+
+	//! Constructor for non-inlined arrow string views
+	arrow_string_view_t(int32_t length, const char *data, int32_t buffer_idx, int32_t offset) {
+		D_ASSERT(length > ArrowStringViewConstants::MAX_INLINED_BYTES);
+		ref.length = length;
+		memcpy(ref.prefix, data, ArrowStringViewConstants::PREFIX_BYTES);
+		ref.buffer_index = buffer_idx;
+		ref.offset = offset;
+	}
+
+	//! Representation of inlined arrow string views
+	struct {
+		int32_t length;
+		char data[ArrowStringViewConstants::MAX_INLINED_BYTES];
+	} inlined;
+
+	//! Representation of non-inlined arrow string views
+	struct {
+		int32_t length;
+		char prefix[ArrowStringViewConstants::PREFIX_BYTES];
+		int32_t buffer_index;
+		int32_t offset;
+	} ref;
+
+	int32_t Length() const {
+		return inlined.length;
+	}
+	bool IsInline() const {
+		return Length() <= ArrowStringViewConstants::MAX_INLINED_BYTES;
+	}
+
+	const char *GetInlineData() const {
+		return IsInline() ? inlined.data : ref.prefix;
+	}
+	int32_t GetBufferIndex() {
+		D_ASSERT(!IsInline());
+		return ref.buffer_index;
+	}
+	int32_t GetOffset() {
+		D_ASSERT(!IsInline());
+		return ref.offset;
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/batched_data_collection.hpp

@@ -15,8 +15,16 @@ namespace duckdb {
 class BufferManager;
 class ClientContext;
 
+using batch_map_t = map<idx_t, unique_ptr<ColumnDataCollection>>;
+using batch_iterator_t = typename batch_map_t::iterator;
+
+struct BatchedChunkIteratorRange {
+	batch_iterator_t begin;
+	batch_iterator_t end;
+};
+
 struct BatchedChunkScanState {
-	map<idx_t, unique_ptr<ColumnDataCollection>>::iterator iterator;
+	BatchedChunkIteratorRange range;
 	ColumnDataScanState scan_state;
 };
 
@@ -25,6 +33,8 @@ struct BatchedChunkScanState {
 class BatchedDataCollection {
 public:
 	DUCKDB_API BatchedDataCollection(ClientContext &context, vector<LogicalType> types, bool buffer_managed = false);
+	DUCKDB_API BatchedDataCollection(ClientContext &context, vector<LogicalType> types, batch_map_t batches,
+	                                 bool buffer_managed = false);
 
 	//! Appends a datachunk with the given batch index to the batched collection
 	DUCKDB_API void Append(DataChunk &input, idx_t batch_index);
@@ -32,6 +42,9 @@ public:
 	//! Merge the other batched chunk collection into this batched collection
 	DUCKDB_API void Merge(BatchedDataCollection &other);
 
+	// Initialize a scan over a range of batches of the batched chunk collection
+	void InitializeScan(BatchedChunkScanState &state, const BatchedChunkIteratorRange &range);
+
 	//! Initialize a scan over the batched chunk collection
 	DUCKDB_API void InitializeScan(BatchedChunkScanState &state);
 
@@ -41,6 +54,27 @@ public:
 	//! Fetch a column data collection from the batched data collection - this consumes all of the data stored within
 	DUCKDB_API unique_ptr<ColumnDataCollection> FetchCollection();
 
+	//! Inspect how many tuples this batched data collection contains
+	DUCKDB_API idx_t Count() const;
+
+	//! Inspect the types of the collection
+	DUCKDB_API const vector<LogicalType> &Types() const;
+
+	//! Inspect how many batches this collection contains
+	DUCKDB_API idx_t BatchCount() const;
+
+	//! Retrieve the batch index of the nth batch in the collection
+	DUCKDB_API idx_t IndexToBatchIndex(idx_t index) const;
+
+	//! Inspect how big a given batch is
+	DUCKDB_API idx_t BatchSize(idx_t batch_index) const;
+
+	//! Inspect a given batch through a const reference
+	const ColumnDataCollection &Batch(idx_t batch_index) const;
+
+	//! Create an iterator range from the provided indices
+	BatchedChunkIteratorRange BatchRange(idx_t begin = 0, idx_t end = DConstants::INVALID_INDEX);
+
 	DUCKDB_API string ToString() const;
 	DUCKDB_API void Print() const;
 
@@ -59,4 +93,5 @@ private:
 	//! The last batch collection that was inserted into
 	CachedCollection last_collection;
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/bit.hpp

@@ -112,7 +112,7 @@ void Bit::NumericToBit(T numeric, string_t &output_str) {
 template <class T>
 string Bit::NumericToBit(T numeric) {
 	auto bit_len = sizeof(T) + 1;
-	auto buffer = make_unsafe_uniq_array<char>(bit_len);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(bit_len);
 	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit_len));
 	Bit::NumericToBit(numeric, output_str);
 	return output_str.GetString();

package/src/duckdb/src/include/duckdb/common/types/cast_helpers.hpp

@@ -228,7 +228,7 @@ struct DateToStringCast {
 			ptr[0] = '-';
 			if (date[i] < 10) {
 				ptr[1] = '0';
-				ptr[2] = '0' + UnsafeNumericCast<char>(date[i]);
+				ptr[2] = UnsafeNumericCast<char>('0' + date[i]);
 			} else {
 				auto index = UnsafeNumericCast<idx_t>(date[i] * 2);
 				ptr[1] = duckdb_fmt::internal::data::digits[index];
@@ -285,7 +285,7 @@ struct TimeToStringCast {
 		D_ASSERT(value >= 0 && value <= 99);
 		if (value < 10) {
 			ptr[0] = '0';
-			ptr[1] = '0' + UnsafeNumericCast<char>(value);
+			ptr[1] = UnsafeNumericCast<char>('0' + value);
 		} else {
 			auto index = UnsafeNumericCast<unsigned>(value * 2);
 			ptr[0] = duckdb_fmt::internal::data::digits[index];

package/src/duckdb/src/include/duckdb/common/types/column/column_data_allocator.hpp

@@ -36,6 +36,8 @@ public:
 	//! Returns an allocator object to allocate with. This returns the allocator in IN_MEMORY_ALLOCATOR, and a buffer
 	//! allocator in case of BUFFER_MANAGER_ALLOCATOR.
 	Allocator &GetAllocator();
+	//! Returns the buffer manager, if this is not an in-memory allocation.
+	BufferManager &GetBufferManager();
 	//! Returns the allocator type
 	ColumnDataAllocatorType GetType() {
 		return type;
@@ -69,8 +71,8 @@ public:
 	void UnswizzlePointers(ChunkManagementState &state, Vector &result, idx_t v_offset, uint16_t count,
 	                       uint32_t block_id, uint32_t offset);
 
-	//! Deletes the block with the given id
-	void DeleteBlock(uint32_t block_id);
+	//! Prevents the block with the given id from being added to the eviction queue
+	void SetDestroyBufferUponUnpin(uint32_t block_id);
 
 private:
 	void AllocateEmptyBlock(idx_t size);