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

package/src/duckdb/src/common/arrow/arrow_type_extension.cpp

@@ -0,0 +1,361 @@
+#include "duckdb/common/arrow/arrow_type_extension.hpp"
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/arrow/arrow_converter.hpp"
+#include "duckdb/common/arrow/schema_metadata.hpp"
+#include "duckdb/common/types/vector.hpp"
+
+namespace duckdb {
+
+ArrowTypeExtension::ArrowTypeExtension(string extension_name, string arrow_format,
+                                       shared_ptr<ArrowTypeExtensionData> type)
+    : extension_metadata(std::move(extension_name), {}, {}, std::move(arrow_format)), type_extension(std::move(type)) {
+}
+
+ArrowExtensionMetadata::ArrowExtensionMetadata(string extension_name, string vendor_name, string type_name,
+                                               string arrow_format)
+    : extension_name(std::move(extension_name)), vendor_name(std::move(vendor_name)), type_name(std::move(type_name)),
+      arrow_format(std::move(arrow_format)) {
+}
+
+hash_t ArrowExtensionMetadata::GetHash() const {
+	const auto h_extension = Hash(extension_name.c_str());
+	const auto h_vendor = Hash(vendor_name.c_str());
+	const auto h_type = Hash(type_name.c_str());
+	// Most arrow extensions are unique on the extension name
+	// However we use arrow.opaque as all the non-canonical extensions, hence we do a hash-aroo of all.
+	return CombineHash(h_extension, CombineHash(h_vendor, h_type));
+}
+
+TypeInfo::TypeInfo() : type() {
+}
+
+TypeInfo::TypeInfo(const LogicalType &type_p) : alias(type_p.GetAlias()), type(type_p.id()) {
+}
+
+TypeInfo::TypeInfo(string alias) : alias(std::move(alias)), type(LogicalTypeId::ANY) {
+}
+
+hash_t TypeInfo::GetHash() const {
+	const auto h_type_id = Hash(type);
+	const auto h_alias = Hash(alias.c_str());
+	return CombineHash(h_type_id, h_alias);
+}
+
+bool TypeInfo::operator==(const TypeInfo &other) const {
+	return alias == other.alias && type == other.type;
+}
+
+string ArrowExtensionMetadata::ToString() const {
+	std::ostringstream info;
+	info << "Extension Name: " << extension_name << "\n";
+	if (!vendor_name.empty()) {
+		info << "Vendor: " << vendor_name << "\n";
+	}
+	if (!type_name.empty()) {
+		info << "Type: " << type_name << "\n";
+	}
+	if (!arrow_format.empty()) {
+		info << "Format: " << arrow_format << "\n";
+	}
+	return info.str();
+}
+
+string ArrowExtensionMetadata::GetExtensionName() const {
+	return extension_name;
+}
+
+string ArrowExtensionMetadata::GetVendorName() const {
+	return vendor_name;
+}
+
+string ArrowExtensionMetadata::GetTypeName() const {
+	return type_name;
+}
+
+string ArrowExtensionMetadata::GetArrowFormat() const {
+	return arrow_format;
+}
+
+void ArrowExtensionMetadata::SetArrowFormat(string arrow_format_p) {
+	arrow_format = std::move(arrow_format_p);
+}
+
+bool ArrowExtensionMetadata::IsCanonical() const {
+	D_ASSERT((!vendor_name.empty() && !type_name.empty()) || (vendor_name.empty() && type_name.empty()));
+	return vendor_name.empty();
+}
+
+bool ArrowExtensionMetadata::operator==(const ArrowExtensionMetadata &other) const {
+	return extension_name == other.extension_name && type_name == other.type_name && vendor_name == other.vendor_name;
+}
+
+ArrowTypeExtension::ArrowTypeExtension(string vendor_name, string type_name, string arrow_format,
+                                       shared_ptr<ArrowTypeExtensionData> type)
+    : extension_metadata(ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL, std::move(vendor_name),
+                         std::move(type_name), std::move(arrow_format)),
+      type_extension(std::move(type)) {
+}
+
+ArrowTypeExtension::ArrowTypeExtension(string extension_name, populate_arrow_schema_t populate_arrow_schema,
+                                       get_type_t get_type, shared_ptr<ArrowTypeExtensionData> type)
+    : populate_arrow_schema(populate_arrow_schema), get_type(get_type),
+      extension_metadata(std::move(extension_name), {}, {}, {}), type_extension(std::move(type)) {
+}
+
+ArrowTypeExtension::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)
+    : populate_arrow_schema(populate_arrow_schema), get_type(get_type),
+      extension_metadata(ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL, std::move(vendor_name),
+                         std::move(type_name), {}),
+      type_extension(std::move(type)) {
+	type_extension->arrow_to_duckdb = arrow_to_duckdb;
+	type_extension->duckdb_to_arrow = duckdb_to_arrow;
+}
+
+ArrowExtensionMetadata ArrowTypeExtension::GetInfo() const {
+	return extension_metadata;
+}
+
+shared_ptr<ArrowType> ArrowTypeExtension::GetType(const ArrowSchema &schema,
+                                                  const ArrowSchemaMetadata &schema_metadata) const {
+	if (get_type) {
+		return get_type(schema, schema_metadata);
+	}
+	// FIXME: THis is not good
+	auto duckdb_type = type_extension->GetDuckDBType();
+	return make_shared_ptr<ArrowType>(duckdb_type);
+}
+
+shared_ptr<ArrowTypeExtensionData> ArrowTypeExtension::GetTypeExtension() const {
+	return type_extension;
+}
+
+LogicalTypeId ArrowTypeExtension::GetLogicalTypeId() const {
+	return type_extension->GetDuckDBType().id();
+}
+
+LogicalType ArrowTypeExtension::GetLogicalType() const {
+	return type_extension->GetDuckDBType();
+}
+
+bool ArrowTypeExtension::HasType() const {
+	return type_extension.get() != nullptr;
+}
+
+void ArrowTypeExtension::PopulateArrowSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child,
+                                             const LogicalType &duckdb_type, ClientContext &context,
+                                             const ArrowTypeExtension &extension) {
+	if (extension.populate_arrow_schema) {
+		extension.populate_arrow_schema(root_holder, child, duckdb_type, context, extension);
+		return;
+	}
+
+	auto format = make_unsafe_uniq_array<char>(extension.extension_metadata.GetArrowFormat().size() + 1);
+	idx_t i = 0;
+	for (const auto &c : extension.extension_metadata.GetArrowFormat()) {
+		format[i++] = c;
+	}
+	format[i++] = '\0';
+	// We do the default way of populating the schema
+	root_holder.extension_format.emplace_back(std::move(format));
+
+	child.format = root_holder.extension_format.back().get();
+	ArrowSchemaMetadata schema_metadata;
+	if (extension.extension_metadata.IsCanonical()) {
+		schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType(extension.extension_metadata.GetExtensionName());
+	} else {
+		schema_metadata = ArrowSchemaMetadata::NonCanonicalType(extension.extension_metadata.GetTypeName(),
+		                                                        extension.extension_metadata.GetVendorName());
+	}
+	root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+	child.metadata = root_holder.metadata_info.back().get();
+}
+
+void DBConfig::RegisterArrowExtension(const ArrowTypeExtension &extension) const {
+	lock_guard<mutex> l(encoding_functions->lock);
+	auto extension_info = extension.GetInfo();
+	if (arrow_extensions->type_extensions.find(extension_info) != arrow_extensions->type_extensions.end()) {
+		throw NotImplementedException("Arrow Extension with configuration %s is already registered",
+		                              extension_info.ToString());
+	}
+	arrow_extensions->type_extensions[extension_info] = extension;
+	if (extension.HasType()) {
+		const TypeInfo type_info(extension.GetLogicalType());
+		arrow_extensions->type_to_info[type_info].push_back(extension_info);
+		return;
+	}
+	const TypeInfo type_info(extension.GetInfo().GetExtensionName());
+	arrow_extensions->type_to_info[type_info].push_back(extension_info);
+}
+
+ArrowTypeExtension DBConfig::GetArrowExtension(ArrowExtensionMetadata info) const {
+	if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) {
+		info.SetArrowFormat("");
+		if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) {
+			throw NotImplementedException("Arrow Extension with configuration:\n%s not yet registered",
+			                              info.ToString());
+		}
+	}
+	return arrow_extensions->type_extensions[info];
+}
+
+ArrowTypeExtension DBConfig::GetArrowExtension(const LogicalType &type) const {
+	TypeInfo type_info(type);
+	if (!arrow_extensions->type_to_info[type_info].empty()) {
+		return GetArrowExtension(arrow_extensions->type_to_info[type_info].front());
+	}
+	type_info.type = LogicalTypeId::ANY;
+	return GetArrowExtension(arrow_extensions->type_to_info[type_info].front());
+}
+
+bool DBConfig::HasArrowExtension(const LogicalType &type) const {
+	TypeInfo type_info(type);
+	if (!arrow_extensions->type_to_info[type_info].empty()) {
+		return true;
+	}
+	type_info.type = LogicalTypeId::ANY;
+	return !arrow_extensions->type_to_info[type_info].empty();
+}
+
+struct ArrowJson {
+	static shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
+		const auto format = string(schema.format);
+		if (format == "u") {
+			return make_shared_ptr<ArrowType>(LogicalType::JSON(),
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+		} else if (format == "U") {
+			return make_shared_ptr<ArrowType>(LogicalType::JSON(),
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+		} else if (format == "vu") {
+			return make_shared_ptr<ArrowType>(LogicalType::JSON(),
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+		}
+		throw InvalidInputException("Arrow extension type \"%s\" not supported for arrow.json", format.c_str());
+	}
+
+	static void PopulateSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type,
+	                           ClientContext &context, const ArrowTypeExtension &extension) {
+		const ArrowSchemaMetadata schema_metadata =
+		    ArrowSchemaMetadata::ArrowCanonicalType(extension.GetInfo().GetExtensionName());
+		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+		schema.metadata = root_holder.metadata_info.back().get();
+		const auto options = context.GetClientProperties();
+		if (options.produce_arrow_string_view) {
+			schema.format = "vu";
+		} else {
+			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+				schema.format = "U";
+			} else {
+				schema.format = "u";
+			}
+		}
+	}
+};
+
+struct ArrowBit {
+	static shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
+		const auto format = string(schema.format);
+		if (format == "z") {
+			return make_shared_ptr<ArrowType>(LogicalType::BIT,
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+		} else if (format == "Z") {
+			return make_shared_ptr<ArrowType>(LogicalType::BIT,
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
+		}
+		throw InvalidInputException("Arrow extension type \"%s\" not supported for BIT type", format.c_str());
+	}
+
+	static void PopulateSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type,
+	                           ClientContext &context, const ArrowTypeExtension &extension) {
+		const ArrowSchemaMetadata schema_metadata = ArrowSchemaMetadata::NonCanonicalType(
+		    extension.GetInfo().GetTypeName(), extension.GetInfo().GetVendorName());
+		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+		schema.metadata = root_holder.metadata_info.back().get();
+		const auto options = context.GetClientProperties();
+		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+			schema.format = "Z";
+		} else {
+			schema.format = "z";
+		}
+	}
+};
+
+struct ArrowVarint {
+	static shared_ptr<ArrowType> GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) {
+		const auto format = string(schema.format);
+		if (format == "z") {
+			return make_shared_ptr<ArrowType>(LogicalType::VARINT,
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
+		} else if (format == "Z") {
+			return make_shared_ptr<ArrowType>(LogicalType::VARINT,
+			                                  make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
+		}
+		throw InvalidInputException("Arrow extension type \"%s\" not supported for Varint", format.c_str());
+	}
+
+	static void PopulateSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type,
+	                           ClientContext &context, const ArrowTypeExtension &extension) {
+		const ArrowSchemaMetadata schema_metadata = ArrowSchemaMetadata::NonCanonicalType(
+		    extension.GetInfo().GetTypeName(), extension.GetInfo().GetVendorName());
+		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+		schema.metadata = root_holder.metadata_info.back().get();
+		const auto options = context.GetClientProperties();
+		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+			schema.format = "Z";
+		} else {
+			schema.format = "z";
+		}
+	}
+};
+
+struct ArrowBool8 {
+	static void ArrowToDuck(ClientContext &context, Vector &source, Vector &result, idx_t count) {
+		auto source_ptr = reinterpret_cast<int8_t *>(FlatVector::GetData(source));
+		auto result_ptr = reinterpret_cast<bool *>(FlatVector::GetData(result));
+		for (idx_t i = 0; i < count; i++) {
+			result_ptr[i] = source_ptr[i];
+		}
+	}
+	static void DuckToArrow(ClientContext &context, Vector &source, Vector &result, idx_t count) {
+		UnifiedVectorFormat format;
+		source.ToUnifiedFormat(count, format);
+		FlatVector::SetValidity(result, format.validity);
+		auto source_ptr = reinterpret_cast<bool *>(format.data);
+		auto result_ptr = reinterpret_cast<int8_t *>(FlatVector::GetData(result));
+		for (idx_t i = 0; i < count; i++) {
+			result_ptr[i] = static_cast<int8_t>(source_ptr[i]);
+		}
+	}
+};
+
+void ArrowTypeExtensionSet::Initialize(const DBConfig &config) {
+	// Types that are 1:1
+	config.RegisterArrowExtension({"arrow.uuid", "w:16", make_shared_ptr<ArrowTypeExtensionData>(LogicalType::UUID)});
+	config.RegisterArrowExtension(
+	    {"arrow.bool8", "c",
+	     make_shared_ptr<ArrowTypeExtensionData>(LogicalType::BOOLEAN, LogicalType::TINYINT, ArrowBool8::ArrowToDuck,
+	                                             ArrowBool8::DuckToArrow)});
+
+	config.RegisterArrowExtension(
+	    {"DuckDB", "hugeint", "w:16", make_shared_ptr<ArrowTypeExtensionData>(LogicalType::HUGEINT)});
+	config.RegisterArrowExtension(
+	    {"DuckDB", "uhugeint", "w:16", make_shared_ptr<ArrowTypeExtensionData>(LogicalType::UHUGEINT)});
+	config.RegisterArrowExtension(
+	    {"DuckDB", "time_tz", "w:8", make_shared_ptr<ArrowTypeExtensionData>(LogicalType::TIME_TZ)});
+
+	// Types that are 1:n
+	config.RegisterArrowExtension({"arrow.json", &ArrowJson::PopulateSchema, &ArrowJson::GetType,
+	                               make_shared_ptr<ArrowTypeExtensionData>(LogicalType::VARCHAR)});
+
+	config.RegisterArrowExtension({"DuckDB", "bit", &ArrowBit::PopulateSchema, &ArrowBit::GetType,
+	                               make_shared_ptr<ArrowTypeExtensionData>(LogicalType::BIT), nullptr, nullptr});
+
+	config.RegisterArrowExtension({"DuckDB", "varint", &ArrowVarint::PopulateSchema, &ArrowVarint::GetType,
+	                               make_shared_ptr<ArrowTypeExtensionData>(LogicalType::VARINT), nullptr, nullptr});
+}
+} // namespace duckdb

package/src/duckdb/src/common/arrow/arrow_util.cpp

@@ -1,14 +1,17 @@
+#include <utility>
+
 #include "duckdb/common/arrow/arrow_util.hpp"
 #include "duckdb/common/arrow/arrow_appender.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 namespace duckdb {
 
 bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t batch_size, ArrowArray *out,
-                              idx_t &count, ErrorData &error) {
+                              idx_t &count, ErrorData &error,
+                              unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> extension_type_cast) {
 	count = 0;
-	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options));
-	auto remaining_tuples_in_chunk = scan_state.RemainingInChunk();
+	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options), std::move(extension_type_cast));
+	const auto remaining_tuples_in_chunk = scan_state.RemainingInChunk();
 	if (remaining_tuples_in_chunk) {
 		// We start by scanning the non-finished current chunk
 		idx_t cur_consumption = MinValue(remaining_tuples_in_chunk, batch_size);
@@ -48,10 +51,11 @@ bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties optio
 	return true;
 }
 
-idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out) {
+idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out,
+                            const unordered_map<idx_t, const shared_ptr<ArrowTypeExtensionData>> &extension_type_cast) {
 	ErrorData error;
 	idx_t result_count;
-	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) {
+	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error, extension_type_cast)) {
 		error.Throw();
 	}
 	return result_count;

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/arrow/arrow_appender.hpp"
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/main/chunk_scan_state/query_result.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 
 namespace duckdb {
 
@@ -131,8 +132,8 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	}
 	idx_t result_count;
 	ErrorData error;
-	if (!ArrowUtil::TryFetchChunk(scan_state, result.client_properties, my_stream->batch_size, out, result_count,
-	                              error)) {
+	if (!ArrowUtil::TryFetchChunk(scan_state, result.client_properties, my_stream->batch_size, out, result_count, error,
+	                              my_stream->extension_types)) {
 		D_ASSERT(error.HasError());
 		my_stream->last_error = error;
 		return -1;
@@ -175,6 +176,9 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryRes
 	stream.get_next = ResultArrowArrayStreamWrapper::MyStreamGetNext;
 	stream.release = ResultArrowArrayStreamWrapper::MyStreamRelease;
 	stream.get_last_error = ResultArrowArrayStreamWrapper::MyStreamGetLastError;
+
+	extension_types =
+	    ArrowTypeExtensionData::GetExtensionTypes(*result->client_properties.client_context, result->types);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/arrow/physical_arrow_collector.cpp

@@ -37,7 +37,8 @@ SinkResultType PhysicalArrowCollector::Sink(ExecutionContext &context, DataChunk
 			auto properties = context.client.GetClientProperties();
 			D_ASSERT(processed < count);
 			auto initial_capacity = MinValue(record_batch_size, count - processed);
-			appender = make_uniq<ArrowAppender>(types, initial_capacity, properties);
+			appender = make_uniq<ArrowAppender>(types, initial_capacity, properties,
+			                                    ArrowTypeExtensionData::GetExtensionTypes(context.client, types));
 		}
 
 		// Figure out how much we can still append to this chunk

package/src/duckdb/src/common/arrow/schema_metadata.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/common/arrow/schema_metadata.hpp"
 
 namespace duckdb {
+
 ArrowSchemaMetadata::ArrowSchemaMetadata(const char *metadata) {
 	if (metadata) {
 		// Read the number of key-value pairs (int32)
@@ -27,45 +28,57 @@ ArrowSchemaMetadata::ArrowSchemaMetadata(const char *metadata) {
 			// Read the value
 			const std::string value(metadata, static_cast<idx_t>(value_length));
 			metadata += value_length;
-			metadata_map[key] = value;
+			schema_metadata_map[key] = value;
 		}
 	}
+	extension_metadata_map = StringUtil::ParseJSONMap(schema_metadata_map[ARROW_METADATA_KEY]);
 }
 
 void ArrowSchemaMetadata::AddOption(const string &key, const string &value) {
-	metadata_map[key] = value;
+	schema_metadata_map[key] = value;
 }
+
 string ArrowSchemaMetadata::GetOption(const string &key) const {
-	auto it = metadata_map.find(key);
-	if (it != metadata_map.end()) {
+	auto it = schema_metadata_map.find(key);
+	if (it != schema_metadata_map.end()) {
 		return it->second;
 	} else {
 		return "";
 	}
 }
 
-string ArrowSchemaMetadata::GetExtensionName() const {
-	return GetOption(ARROW_EXTENSION_NAME);
+ArrowSchemaMetadata ArrowSchemaMetadata::ArrowCanonicalType(const string &extension_name) {
+	ArrowSchemaMetadata metadata;
+	metadata.AddOption(ARROW_EXTENSION_NAME, extension_name);
+	metadata.AddOption(ARROW_METADATA_KEY, "");
+	return metadata;
 }
 
-ArrowSchemaMetadata ArrowSchemaMetadata::MetadataFromName(const string &extension_name) {
+ArrowSchemaMetadata ArrowSchemaMetadata::NonCanonicalType(const string &type_name, const string &vendor_name) {
 	ArrowSchemaMetadata metadata;
-	metadata.AddOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME, extension_name);
-	metadata.AddOption(ArrowSchemaMetadata::ARROW_METADATA_KEY, "");
+	metadata.AddOption(ARROW_EXTENSION_NAME, ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL);
+	// We have to set the metadata key with type_name and vendor_name.
+	metadata.extension_metadata_map["vendor_name"] = vendor_name;
+	metadata.extension_metadata_map["type_name"] = type_name;
+	metadata.AddOption(ARROW_METADATA_KEY, StringUtil::ToJSONMap(metadata.extension_metadata_map));
 	return metadata;
 }
 
-bool ArrowSchemaMetadata::HasExtension() {
+bool ArrowSchemaMetadata::HasExtension() const {
 	auto arrow_extension = GetOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME);
-	// FIXME: We are currently ignoring the ogc extensions
 	return !arrow_extension.empty() && !StringUtil::StartsWith(arrow_extension, "ogc");
 }
 
+ArrowExtensionMetadata ArrowSchemaMetadata::GetExtensionInfo(string format) {
+	return {schema_metadata_map[ARROW_EXTENSION_NAME], extension_metadata_map["vendor_name"],
+	        extension_metadata_map["type_name"], std::move(format)};
+}
+
 unsafe_unique_array<char> ArrowSchemaMetadata::SerializeMetadata() const {
 	// First we have to figure out the total size:
 	// 1. number of key-value pairs (int32)
 	idx_t total_size = sizeof(int32_t);
-	for (const auto &option : metadata_map) {
+	for (const auto &option : schema_metadata_map) {
 		// 2. Length of the key and value (2 * int32)
 		total_size += 2 * sizeof(int32_t);
 		// 3. Length of key
@@ -76,11 +89,11 @@ unsafe_unique_array<char> ArrowSchemaMetadata::SerializeMetadata() const {
 	auto metadata_array_ptr = make_unsafe_uniq_array<char>(total_size);
 	auto metadata_ptr = metadata_array_ptr.get();
 	// 1. number of key-value pairs (int32)
-	const idx_t map_size = metadata_map.size();
+	const idx_t map_size = schema_metadata_map.size();
 	memcpy(metadata_ptr, &map_size, sizeof(int32_t));
 	metadata_ptr += sizeof(int32_t);
 	// Iterate through each key-value pair in the map
-	for (const auto &pair : metadata_map) {
+	for (const auto &pair : schema_metadata_map) {
 		const std::string &key = pair.first;
 		idx_t key_size = key.size();
 		// Length of the key (int32)

package/src/duckdb/src/common/assert.cpp

@@ -10,8 +10,7 @@ void DuckDBAssertInternal(bool condition, const char *condition_name, const char
 	if (condition) {
 		return;
 	}
-	throw InternalException("Assertion triggered in file \"%s\" on line %d: %s%s", file, linenr, condition_name,
-	                        Exception::GetStackTrace());
+	throw InternalException("Assertion triggered in file \"%s\" on line %d: %s", file, linenr, condition_name);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/bind_helpers.cpp

@@ -11,7 +11,7 @@ namespace duckdb {
 
 Value ConvertVectorToValue(vector<Value> set) {
 	if (set.empty()) {
-		return Value::EMPTYLIST(LogicalType::BOOLEAN);
+		return Value::LIST(LogicalType::BOOLEAN, std::move(set));
 	}
 	return Value::LIST(std::move(set));
 }