duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

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

@@ -1,3 +1,11 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/array_ptr.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/exception.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp

@@ -6,6 +6,7 @@
 #include "duckdb/common/arrow/arrow_buffer.hpp"
 #include "duckdb/main/client_properties.hpp"
 #include "duckdb/common/array.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 
 namespace duckdb {
 
@@ -28,7 +29,7 @@ typedef void (*finalize_t)(ArrowAppendData &append_data, const LogicalType &type
 // FIXME: we should separate the append state variables from the variables required by the ArrowArray into
 // ArrowAppendState
 struct ArrowAppendData {
-	explicit ArrowAppendData(ClientProperties &options_p) : options(options_p) {
+	explicit ArrowAppendData(const ClientProperties &options_p) : options(options_p) {
 		dictionary.release = nullptr;
 		arrow_buffers.resize(3);
 	}
@@ -60,6 +61,8 @@ struct ArrowAppendData {
 	//! function pointers for construction
 	initialize_t initialize = nullptr;
 	append_vector_t append_vector = nullptr;
+	//! Arrow Extension Type information
+	shared_ptr<ArrowTypeExtensionData> extension_data = nullptr;
 	finalize_t finalize = nullptr;
 
 	//! child data (if any)

package/src/duckdb/src/include/duckdb/common/arrow/appender/list_data.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/common/arrow/arrow_appender.hpp"
 
 namespace duckdb {
 
@@ -74,7 +75,8 @@ public:
 			    (uint64_t)last_offset + list_length > NumericLimits<int32_t>::Maximum()) {
 				throw InvalidInputException(
 				    "Arrow Appender: The maximum combined list offset for regular list buffers is "
-				    "%u but the offset of %lu exceeds this.",
+				    "%u but the offset of %lu exceeds this.\n* SET arrow_large_buffer_size=true to use large list "
+				    "buffers",
 				    NumericLimits<int32_t>::Maximum(), last_offset);
 			}
 			last_offset += list_length;

package/src/duckdb/src/include/duckdb/common/arrow/appender/list_view_data.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/common/arrow/arrow_appender.hpp"
 
 namespace duckdb {
 
@@ -75,7 +76,8 @@ public:
 			    (uint64_t)last_offset + list_length > NumericLimits<int32_t>::Maximum()) {
 				throw InvalidInputException(
 				    "Arrow Appender: The maximum combined list offset for regular list buffers is "
-				    "%u but the offset of %lu exceeds this.",
+				    "%u but the offset of %lu exceeds this.\n* SET arrow_large_buffer_size=true to use large list "
+				    "buffers",
 				    NumericLimits<int32_t>::Maximum(), last_offset);
 			}
 			offset_data[offset_idx] = last_offset;

package/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp

@@ -87,7 +87,8 @@ struct ArrowVarcharData {
 				D_ASSERT(append_data.options.arrow_offset_size == ArrowOffsetSize::REGULAR);
 				throw InvalidInputException(
 				    "Arrow Appender: The maximum total string size for regular string buffers is "
-				    "%u but the offset of %lu exceeds this.",
+				    "%u but the offset of %lu exceeds this.\n* SET arrow_large_buffer_size=true to use large string "
+				    "buffers",
 				    NumericLimits<int32_t>::Maximum(), current_offset);
 			}
 			offset_data[offset_idx] = UnsafeNumericCast<BUFTYPE>(current_offset);

package/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp

@@ -15,10 +15,13 @@ namespace duckdb {
 
 struct ArrowAppendData;
 
+class ArrowTypeExtensionData;
+
 //! The ArrowAppender class can be used to incrementally construct an arrow array by appending data chunks into it
 class ArrowAppender {
 public:
-	DUCKDB_API ArrowAppender(vector<LogicalType> types_p, const idx_t initial_capacity, ClientProperties options);
+	DUCKDB_API ArrowAppender(vector<LogicalType> types_p, const idx_t initial_capacity, ClientProperties options,
+	                         unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> extension_type_cast);
 	DUCKDB_API ~ArrowAppender();
 
 public:
@@ -29,8 +32,9 @@ public:
 	idx_t RowCount() const;
 	static void ReleaseArray(ArrowArray *array);
 	static ArrowArray *FinalizeChild(const LogicalType &type, unique_ptr<ArrowAppendData> append_data_p);
-	static unique_ptr<ArrowAppendData> InitializeChild(const LogicalType &type, const idx_t capacity,
-	                                                   ClientProperties &options);
+	static unique_ptr<ArrowAppendData>
+	InitializeChild(const LogicalType &type, const idx_t capacity, ClientProperties &options,
+	                const shared_ptr<ArrowTypeExtensionData> &extension_type = nullptr);
 	static void AddChildren(ArrowAppendData &data, const idx_t count);
 
 private:

package/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp

@@ -11,13 +11,36 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/arrow/arrow.hpp"
 #include "duckdb/main/client_properties.hpp"
+#include <list>
 
 namespace duckdb {
-
+class ArrowTypeExtensionData;
+struct DBConfig;
 struct ArrowConverter {
 	DUCKDB_API static void ToArrowSchema(ArrowSchema *out_schema, const vector<LogicalType> &types,
-	                                     const vector<string> &names, const ClientProperties &options);
-	DUCKDB_API static void ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options);
+	                                     const vector<string> &names, ClientProperties &options);
+	DUCKDB_API static void
+	ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options,
+	             const unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> &extension_type_cast);
+};
+
+//===--------------------------------------------------------------------===//
+// Arrow Schema
+//===--------------------------------------------------------------------===//
+struct DuckDBArrowSchemaHolder {
+	// unused in children
+	vector<ArrowSchema> children;
+	// unused in children
+	vector<ArrowSchema *> children_ptrs;
+	//! used for nested structures
+	std::list<vector<ArrowSchema>> nested_children;
+	std::list<vector<ArrowSchema *>> nested_children_ptr;
+	//! This holds strings created to represent decimal types
+	vector<unsafe_unique_array<char>> owned_type_names;
+	vector<unsafe_unique_array<char>> owned_column_names;
+	//! This holds any values created for metadata info
+	vector<unsafe_unique_array<char>> metadata_info;
+	vector<unsafe_unique_array<char>> extension_format;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp

@@ -20,7 +20,7 @@ class ClientContext;
 
 class ArrowQueryResult : public QueryResult {
 public:
-	static constexpr const QueryResultType TYPE = QueryResultType::ARROW_RESULT;
+	static constexpr QueryResultType TYPE = QueryResultType::ARROW_RESULT;
 
 public:
 	friend class ClientContext;

package/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp

@@ -0,0 +1,144 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/arrow/arrow_type_extension.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/main/query_result.hpp"
+#include "duckdb/common/arrow/arrow_wrapper.hpp"
+#include "duckdb/main/chunk_scan_state.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
+#include <mutex>
+
+namespace duckdb {
+class ArrowSchemaMetadata;
+struct DuckDBArrowSchemaHolder;
+
+struct DBConfig;
+struct ArrowExtensionMetadata {
+public:
+	ArrowExtensionMetadata() {
+	}
+
+	ArrowExtensionMetadata(string extension_name, string vendor_name, string type_name, string arrow_format);
+
+	hash_t GetHash() const;
+
+	string ToString() const;
+
+	string GetExtensionName() const;
+
+	string GetVendorName() const;
+
+	string GetTypeName() const;
+
+	string GetArrowFormat() const;
+
+	void SetArrowFormat(string arrow_format);
+
+	bool IsCanonical() const;
+
+	bool operator==(const ArrowExtensionMetadata &other) const;
+
+	//! Arrow Extension for non-canonical types.
+	static constexpr const char *ARROW_EXTENSION_NON_CANONICAL = "arrow.opaque";
+
+private:
+	//! The extension name (e.g., 'arrow.uuid', 'arrow.opaque',...)
+	string extension_name {};
+	//! If the extension name is 'arrow.opaque' a vendor and type must be defined.
+	//! The vendor_name is the system that produced the type (e.g., DuckDB)
+	string vendor_name {};
+	//! The type_name is the name of the type produced by the vendor (e.g., hugeint)
+	string type_name {};
+	//! The arrow format (e.g., z)
+	string arrow_format {};
+};
+
+class ArrowTypeExtension;
+
+typedef void (*populate_arrow_schema_t)(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child,
+                                        const LogicalType &type, ClientContext &context,
+                                        const ArrowTypeExtension &extension);
+
+typedef shared_ptr<ArrowType> (*get_type_t)(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata);
+
+class ArrowTypeExtension {
+public:
+	ArrowTypeExtension() {};
+	//! We either have simple extensions where we only return one type
+	ArrowTypeExtension(string extension_name, string arrow_format, shared_ptr<ArrowTypeExtensionData> type);
+	ArrowTypeExtension(string vendor_name, string type_name, string arrow_format,
+	                   shared_ptr<ArrowTypeExtensionData> type);
+
+	//! We have complex extensions, where we can return multiple types, hence we must have callback functions to do so
+	ArrowTypeExtension(string extension_name, populate_arrow_schema_t populate_arrow_schema, get_type_t get_type,
+	                   shared_ptr<ArrowTypeExtensionData> type);
+	ArrowTypeExtension(string vendor_name, string type_name, populate_arrow_schema_t populate_arrow_schema,
+	                   get_type_t get_type, shared_ptr<ArrowTypeExtensionData> type, cast_arrow_duck_t arrow_to_duckdb,
+	                   cast_duck_arrow_t duckdb_to_arrow);
+
+	ArrowExtensionMetadata GetInfo() const;
+
+	shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) const;
+
+	shared_ptr<ArrowTypeExtensionData> GetTypeExtension() const;
+
+	LogicalTypeId GetLogicalTypeId() const;
+
+	LogicalType GetLogicalType() const;
+
+	bool HasType() const;
+
+	static void PopulateArrowSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child,
+	                                const LogicalType &duckdb_type, ClientContext &context,
+	                                const ArrowTypeExtension &extension);
+
+	//! (Optional) Callback to a function that sets up the arrow schema production
+	populate_arrow_schema_t populate_arrow_schema = nullptr;
+	//! (Optional) Callback to a function that sets up the arrow schema production
+	get_type_t get_type = nullptr;
+
+private:
+	//! Extension Info from Arrow
+	ArrowExtensionMetadata extension_metadata;
+	//! Arrow Extension Type
+	shared_ptr<ArrowTypeExtensionData> type_extension;
+};
+
+struct HashArrowTypeExtension {
+	size_t operator()(ArrowExtensionMetadata const &arrow_extension_info) const noexcept {
+		return arrow_extension_info.GetHash();
+	}
+};
+
+struct TypeInfo {
+	TypeInfo();
+	explicit TypeInfo(const LogicalType &type);
+	explicit TypeInfo(string alias);
+	string alias;
+	LogicalTypeId type;
+	hash_t GetHash() const;
+	bool operator==(const TypeInfo &other) const;
+};
+
+struct HashTypeInfo {
+	size_t operator()(TypeInfo const &type_info) const noexcept {
+		return type_info.GetHash();
+	}
+};
+
+//! The set of encoding functions
+struct ArrowTypeExtensionSet {
+	ArrowTypeExtensionSet() {};
+	static void Initialize(const DBConfig &config);
+	std::mutex lock;
+	unordered_map<ArrowExtensionMetadata, ArrowTypeExtension, HashArrowTypeExtension> type_extensions;
+	unordered_map<TypeInfo, vector<ArrowExtensionMetadata>, HashTypeInfo> type_to_info;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp

@@ -17,12 +17,15 @@ namespace duckdb {
 
 class QueryResult;
 class DataChunk;
+class ArrowTypeExtensionData;
 
 class ArrowUtil {
 public:
 	static bool TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out,
-	                          idx_t &result_count, ErrorData &error);
-	static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out);
+	                          idx_t &result_count, ErrorData &error,
+	                          unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> extension_type_cast);
+	static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out,
+	                        const unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> &extension_type_cast);
 
 private:
 	static bool TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &out, ErrorData &error);

package/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
 #include "duckdb/main/chunk_scan_state.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 
 namespace duckdb {
 class ResultArrowArrayStreamWrapper {
@@ -25,6 +26,7 @@ public:
 	vector<LogicalType> column_types;
 	vector<string> column_names;
 	unique_ptr<ChunkScanState> scan_state;
+	unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> extension_types;
 
 private:
 	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);

package/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
 #include "duckdb/main/chunk_scan_state.hpp"
+#include "duckdb/common/arrow/arrow_type_extension.hpp"
 
 namespace duckdb {
 class ArrowSchemaMetadata {
@@ -21,12 +22,14 @@ public:
 	ArrowSchemaMetadata() {};
 	//! Adds an option to the metadata
 	void AddOption(const string &key, const string &value);
-	//! Gets an option from the metadata, returns an empty string if does not exist.
+	//! Gets an option from the metadata, returns an empty string if it does not exist.
 	string GetOption(const string &key) const;
 	//! Transforms metadata to a char*, used when creating an arrow object
 	unsafe_unique_array<char> SerializeMetadata() const;
 	//! If the arrow extension is set
-	bool HasExtension();
+	bool HasExtension() const;
+
+	ArrowExtensionMetadata GetExtensionInfo(string format);
 	//! Get the extension name if set, otherwise returns empty
 	string GetExtensionName() const;
 	//! Key for encode of the extension type name
@@ -34,10 +37,14 @@ public:
 	//! Key for encode of the metadata key
 	static constexpr const char *ARROW_METADATA_KEY = "ARROW:extension:metadata";
 	//! Creates the metadata based on an extension name
-	static ArrowSchemaMetadata MetadataFromName(const string &extension_name);
+	static ArrowSchemaMetadata ArrowCanonicalType(const string &extension_name);
+	//! Creates the metadata based on an extension name
+	static ArrowSchemaMetadata NonCanonicalType(const string &type_name, const string &vendor_name);
 
 private:
 	//! The unordered map that holds the metadata
-	unordered_map<string, string> metadata_map;
+	unordered_map<string, string> schema_metadata_map;
+	//! The extension metadata map, currently only used for internal types in arrow.opaque
+	unordered_map<string, string> extension_metadata_map;
 };
 } // namespace duckdb

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

@@ -10,8 +10,19 @@
 
 #pragma once
 
-#if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT) && !defined(__MVS__)
+// clang-format off
+#if ( \
+    /* Not a debug build */ \
+    !defined(DEBUG) && \
+    /* FORCE_ASSERT is not set (enables assertions even on release mode when set to true) */ \
+    !defined(DUCKDB_FORCE_ASSERT) && \
+    /* The project is not compiled for Microsoft Visual Studio */ \
+    !defined(__MVS__) \
+)
+// clang-format on
 
+//! On most builds, NDEBUG is defined, turning the assert call into a NO-OP
+//! Only the 'else' condition is supposed to check the assertions
 #include <assert.h>
 #define D_ASSERT assert
 namespace duckdb {

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

@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/atomic_ptr.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/atomic.hpp"
+#include "duckdb/common/shared_ptr.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+
+namespace duckdb {
+
+template <class T, bool SAFE = true>
+class atomic_ptr { // NOLINT: mimic std casing
+public:
+	atomic_ptr() noexcept : ptr(nullptr) {
+	}
+	atomic_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
+	}
+	atomic_ptr(T &ref) : ptr(&ref) { // NOLINT: allow implicit creation from reference
+	}
+	atomic_ptr(const unique_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
+	}
+	atomic_ptr(const shared_ptr<T> &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from shared pointer
+	}
+
+	void CheckValid(const T *ptr) const {
+		if (MemorySafety<SAFE>::ENABLED) {
+			return;
+		}
+		if (!ptr) {
+			throw InternalException("Attempting to dereference an optional pointer that is not set");
+		}
+	}
+
+	T *GetPointer() {
+		auto res = ptr.load();
+		CheckValid(res);
+		return res;
+	}
+
+	const T *GetPointer() const {
+		auto res = ptr.load();
+		CheckValid(res);
+		return res;
+	}
+
+	operator bool() const { // NOLINT: allow implicit conversion to bool
+		return ptr;
+	}
+	T &operator*() {
+		return *GetPointer();
+	}
+	const T &operator*() const {
+		return *GetPointer();
+	}
+	T *operator->() {
+		return GetPointer();
+	}
+	const T *operator->() const {
+		return GetPointer();
+	}
+	T *get() { // NOLINT: mimic std casing
+		return GetPointer();
+	}
+	const T *get() const { // NOLINT: mimic std casing
+		return GetPointer();
+	}
+	// this looks dirty - but this is the default behavior of raw pointers
+	T *get_mutable() const { // NOLINT: mimic std casing
+		return GetPointer();
+	}
+
+	void set(T &ref) {
+		ptr = &ref;
+	}
+
+	void reset() {
+		ptr = nullptr;
+	}
+
+	bool operator==(const atomic_ptr<T> &rhs) const {
+		return ptr.load() == rhs.ptr.load();
+	}
+
+	bool operator!=(const atomic_ptr<T> &rhs) const {
+		return ptr.load() != rhs.ptr.load();
+	}
+
+private:
+	atomic<T *> ptr;
+};
+
+template <typename T>
+using unsafe_atomic_ptr = atomic_ptr<T, false>;
+
+} // namespace duckdb

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

@@ -20,6 +20,51 @@ class ColumnDataRowCollection;
 enum class ValueRenderAlignment { LEFT, MIDDLE, RIGHT };
 enum class RenderMode : uint8_t { ROWS, COLUMNS };
 
+enum class ResultRenderType { LAYOUT, COLUMN_NAME, COLUMN_TYPE, VALUE, NULL_VALUE, FOOTER };
+
+class BaseResultRenderer {
+public:
+	BaseResultRenderer();
+	virtual ~BaseResultRenderer();
+
+	virtual void RenderLayout(const string &text) = 0;
+	virtual void RenderColumnName(const string &text) = 0;
+	virtual void RenderType(const string &text) = 0;
+	virtual void RenderValue(const string &text, const LogicalType &type) = 0;
+	virtual void RenderNull(const string &text, const LogicalType &type) = 0;
+	virtual void RenderFooter(const string &text) = 0;
+
+	BaseResultRenderer &operator<<(char c);
+	BaseResultRenderer &operator<<(const string &val);
+
+	void Render(ResultRenderType render_mode, const string &val);
+	void SetValueType(const LogicalType &type);
+
+private:
+	LogicalType value_type;
+};
+
+class StringResultRenderer : public BaseResultRenderer {
+public:
+	void RenderLayout(const string &text) override;
+	void RenderColumnName(const string &text) override;
+	void RenderType(const string &text) override;
+	void RenderValue(const string &text, const LogicalType &type) override;
+	void RenderNull(const string &text, const LogicalType &type) override;
+	void RenderFooter(const string &text) override;
+
+	const string &str(); // NOLINT: mimic string stream
+
+private:
+	string result;
+};
+
+enum class LargeNumberRendering {
+	NONE = 0,   // render all numbers as-is
+	FOOTER = 1, // if there is a single row, adds a second footer row with a readable summarization of large numbers
+	ALL = 2     // renders all large numbers
+};
+
 struct BoxRendererConfig {
 	// a max_width of 0 means we default to the terminal width
 	idx_t max_width = 0;
@@ -33,8 +78,14 @@ struct BoxRendererConfig {
 	idx_t max_col_width = 20;
 	//! how to render NULL values
 	string null_value = "NULL";
+	//! Decimal separator (if any)
+	char decimal_separator = '\0';
+	//! Thousand separator (if any)
+	char thousand_separator = '\0';
 	//! Whether or not to render row-wise or column-wise
 	RenderMode render_mode = RenderMode::ROWS;
+	//! How to render large numbers
+	LargeNumberRendering large_number_rendering = LargeNumberRendering::NONE;
 
 #ifndef DUCKDB_ASCII_TREE_RENDERER
 	const char *LTCORNER = "\342\224\214"; // NOLINT: "┌";
@@ -85,7 +136,8 @@ public:
 
 	string ToString(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op);
 
-	void Render(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op, std::ostream &ss);
+	void Render(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op,
+	            BaseResultRenderer &ss);
 	void Print(ClientContext &context, const vector<string> &names, const ColumnDataCollection &op);
 
 private:
@@ -93,11 +145,12 @@ private:
 	BoxRendererConfig config;
 
 private:
-	void RenderValue(std::ostream &ss, const string &value, idx_t column_width,
+	void RenderValue(BaseResultRenderer &ss, const string &value, idx_t column_width, ResultRenderType render_mode,
 	                 ValueRenderAlignment alignment = ValueRenderAlignment::MIDDLE);
 	string RenderType(const LogicalType &type);
 	ValueRenderAlignment TypeAlignment(const LogicalType &type);
-	string GetRenderValue(ColumnDataRowCollection &rows, idx_t c, idx_t r);
+	string GetRenderValue(BaseResultRenderer &ss, ColumnDataRowCollection &rows, idx_t c, idx_t r,
+	                      const LogicalType &type, ResultRenderType &render_mode);
 	list<ColumnDataCollection> FetchRenderCollections(ClientContext &context, const ColumnDataCollection &result,
 	                                                  idx_t top_rows, idx_t bottom_rows);
 	list<ColumnDataCollection> PivotCollections(ClientContext &context, list<ColumnDataCollection> input,
@@ -108,13 +161,19 @@ private:
 	                                  vector<idx_t> &column_map, idx_t &total_length);
 	void RenderHeader(const vector<string> &names, const vector<LogicalType> &result_types,
 	                  const vector<idx_t> &column_map, const vector<idx_t> &widths, const vector<idx_t> &boundaries,
-	                  idx_t total_length, bool has_results, std::ostream &ss);
+	                  idx_t total_length, bool has_results, BaseResultRenderer &renderer);
 	void RenderValues(const list<ColumnDataCollection> &collections, const vector<idx_t> &column_map,
-	                  const vector<idx_t> &widths, const vector<LogicalType> &result_types, std::ostream &ss);
+	                  const vector<idx_t> &widths, const vector<LogicalType> &result_types, BaseResultRenderer &ss);
 	void RenderRowCount(string row_count_str, string shown_str, const string &column_count_str,
 	                    const vector<idx_t> &boundaries, bool has_hidden_rows, bool has_hidden_columns,
 	                    idx_t total_length, idx_t row_count, idx_t column_count, idx_t minimum_row_length,
-	                    std::ostream &ss);
+	                    BaseResultRenderer &ss);
+
+	string FormatNumber(const string &input);
+	string ConvertRenderValue(const string &input, const LogicalType &type);
+	string ConvertRenderValue(const string &input);
+	//! Try to format a large number in a readable way (e.g. 1234567 -> 1.23 million)
+	string TryFormatLargeNumber(const string &numeric);
 };
 
 } // namespace duckdb

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

@@ -15,6 +15,7 @@ using std::chrono::duration;
 using std::chrono::duration_cast;
 using std::chrono::high_resolution_clock;
 using std::chrono::milliseconds;
+using std::chrono::nanoseconds;
 using std::chrono::system_clock;
 using std::chrono::time_point;
 } // namespace duckdb