duckdb 0.8.2-dev1573.0 → 0.8.2-dev1724.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1573.0",
+  "version": "0.8.2-dev1724.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/json_functions/json_create.cpp

@@ -333,8 +333,22 @@ static void CreateValuesMap(const StructNames &names, yyjson_mut_doc *doc, yyjso
 static void CreateValuesUnion(const StructNames &names, yyjson_mut_doc *doc, yyjson_mut_val *vals[], Vector &value_v,
                               idx_t count) {
 	// Structs become values, therefore we initialize vals to JSON values
-	for (idx_t i = 0; i < count; i++) {
-		vals[i] = yyjson_mut_obj(doc);
+	UnifiedVectorFormat value_data;
+	value_v.ToUnifiedFormat(count, value_data);
+	if (value_data.validity.AllValid()) {
+		for (idx_t i = 0; i < count; i++) {
+			vals[i] = yyjson_mut_obj(doc);
+		}
+	} else {
+		for (idx_t i = 0; i < count; i++) {
+			auto index = value_data.sel->get_index(i);
+			if (!value_data.validity.RowIsValid(index)) {
+				// Make the entry NULL if the Union value is NULL
+				vals[i] = yyjson_mut_null(doc);
+			} else {
+				vals[i] = yyjson_mut_obj(doc);
+			}
+		}
 	}
 
 	// Initialize re-usable array for the nested values
@@ -361,6 +375,11 @@ static void CreateValuesUnion(const StructNames &names, yyjson_mut_doc *doc, yyj
 		auto keys = UnifiedVectorFormat::GetData<string_t>(key_data);
 
 		for (idx_t i = 0; i < count; i++) {
+			auto value_index = value_data.sel->get_index(i);
+			if (!value_data.validity.RowIsValid(value_index)) {
+				// This entry is just NULL in it's entirety
+				continue;
+			}
 			auto tag_idx = tag_data.sel->get_index(i);
 			if (!tag_data.validity.RowIsValid(tag_idx)) {
 				continue;

package/src/duckdb/extension/json/json_functions/json_transform.cpp

@@ -669,6 +669,77 @@ bool TransformToJSON(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const
 	return true;
 }
 
+bool TransformValueIntoUnion(yyjson_val **vals, yyjson_alc *alc, Vector &result, const idx_t count,
+                             JSONTransformOptions &options) {
+	auto type = result.GetType();
+
+	auto fields = UnionType::CopyMemberTypes(type);
+	vector<string> names;
+	for (const auto &field : fields) {
+		names.push_back(field.first);
+	}
+
+	bool success = true;
+
+	auto &validity = FlatVector::Validity(result);
+
+	auto set_error = [&](idx_t i, const string &message) {
+		validity.SetInvalid(i);
+		result.SetValue(i, Value(nullptr));
+		if (success && options.strict_cast) {
+			options.error_message = message;
+			options.object_index = i;
+			success = false;
+		}
+	};
+
+	for (idx_t i = 0; i < count; i++) {
+		const auto &obj = vals[i];
+
+		if (!obj || unsafe_yyjson_is_null(vals[i])) {
+			validity.SetInvalid(i);
+			result.SetValue(i, Value(nullptr));
+			continue;
+		}
+
+		if (!unsafe_yyjson_is_obj(obj)) {
+			set_error(i,
+			          StringUtil::Format("Expected an object representing a union, got %s", yyjson_get_type_desc(obj)));
+			continue;
+		}
+
+		auto len = unsafe_yyjson_get_len(obj);
+		if (len > 1) {
+			set_error(i, "Found object containing more than one key, instead of union");
+			continue;
+		} else if (len == 0) {
+			set_error(i, "Found empty object, instead of union");
+			continue;
+		}
+
+		auto key = unsafe_yyjson_get_first(obj);
+		auto val = yyjson_obj_iter_get_val(key);
+
+		auto tag = std::find(names.begin(), names.end(), unsafe_yyjson_get_str(key));
+		if (tag == names.end()) {
+			set_error(i, StringUtil::Format("Found object containing unknown key, instead of union: %s",
+			                                unsafe_yyjson_get_str(key)));
+			continue;
+		}
+
+		idx_t actual_tag = tag - names.begin();
+
+		Vector single(UnionType::GetMemberType(type, actual_tag), 1);
+		if (!JSONTransform::Transform(&val, alc, single, 1, options)) {
+			success = false;
+		}
+
+		result.SetValue(i, Value::UNION(fields, actual_tag, single.GetValue(0)));
+	}
+
+	return success;
+}
+
 bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &result, const idx_t count,
                               JSONTransformOptions &options) {
 	auto result_type = result.GetType();
@@ -747,8 +818,10 @@ bool JSONTransform::Transform(yyjson_val *vals[], yyjson_alc *alc, Vector &resul
 		return TransformArray(vals, alc, result, count, options);
 	case LogicalTypeId::MAP:
 		return TransformObjectToMap(vals, alc, result, count, options);
+	case LogicalTypeId::UNION:
+		return TransformValueIntoUnion(vals, alc, result, count, options);
 	default:
-		throw InternalException("Unexpected type at JSON Transform %s", result_type.ToString());
+		throw NotImplementedException("Cannot read a value of type %s from a json file", result_type.ToString());
 	}
 }
 

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -152,10 +152,12 @@ BindInfo ParquetGetBatchInfo(const FunctionData *bind_data) {
 	for (auto &path : parquet_bind.files) {
 		file_path.emplace_back(path);
 	}
+	// LCOV_EXCL_START
 	bind_info.InsertOption("file_path", Value::LIST(LogicalType::VARCHAR, file_path));
 	bind_info.InsertOption("binary_as_string", Value::BOOLEAN(parquet_bind.parquet_options.binary_as_string));
 	bind_info.InsertOption("file_row_number", Value::BOOLEAN(parquet_bind.parquet_options.file_row_number));
 	parquet_bind.parquet_options.file_options.AddBatchInfo(bind_info);
+	// LCOV_EXCL_STOP
 	return bind_info;
 }
 

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

@@ -394,6 +394,76 @@ struct ArrowVarcharData {
 	}
 };
 
+//===--------------------------------------------------------------------===//
+// Unions
+//===--------------------------------------------------------------------===//
+/**
+ * Based on https://arrow.apache.org/docs/format/Columnar.html#union-layout &
+ * https://arrow.apache.org/docs/format/CDataInterface.html
+ */
+struct ArrowUnionData {
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
+		result.main_buffer.reserve(capacity * sizeof(int8_t));
+
+		for (auto &child : UnionType::CopyMemberTypes(type)) {
+			auto child_buffer = InitializeArrowChild(child.second, capacity, result.options);
+			result.child_data.push_back(std::move(child_buffer));
+		}
+	}
+
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
+		UnifiedVectorFormat format;
+		input.ToUnifiedFormat(input_size, format);
+		idx_t size = to - from;
+
+		auto &types_buffer = append_data.main_buffer;
+
+		duckdb::vector<Vector> child_vectors;
+		for (const auto &child : UnionType::CopyMemberTypes(input.GetType())) {
+			child_vectors.emplace_back(child.second);
+		}
+
+		for (idx_t input_idx = from; input_idx < to; input_idx++) {
+			const auto &val = input.GetValue(input_idx);
+
+			idx_t tag = 0;
+			Value resolved_value(nullptr);
+			if (!val.IsNull()) {
+				tag = UnionValue::GetTag(val);
+
+				resolved_value = UnionValue::GetValue(val);
+			}
+
+			for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
+				child_vectors[child_idx].SetValue(input_idx, child_idx == tag ? resolved_value : Value(nullptr));
+			}
+
+			types_buffer.data()[input_idx] = tag;
+		}
+
+		for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {
+			auto &child_buffer = append_data.child_data[child_idx];
+			auto &child = child_vectors[child_idx];
+			child_buffer->append_vector(*child_buffer, child, from, to, size);
+		}
+		append_data.row_count += size;
+	}
+
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
+		result->n_buffers = 2;
+		result->buffers[1] = append_data.main_buffer.data();
+
+		auto &child_types = UnionType::CopyMemberTypes(type);
+		append_data.child_pointers.resize(child_types.size());
+		result->children = append_data.child_pointers.data();
+		result->n_children = child_types.size();
+		for (idx_t i = 0; i < child_types.size(); i++) {
+			auto &child_type = child_types[i].second;
+			append_data.child_pointers[i] = FinalizeArrowChild(child_type, *append_data.child_data[i]);
+		}
+	}
+};
+
 //===--------------------------------------------------------------------===//
 // Structs
 //===--------------------------------------------------------------------===//
@@ -716,6 +786,9 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::INTERVAL:
 		InitializeFunctionPointers<ArrowScalarData<ArrowInterval, interval_t, ArrowIntervalConverter>>(append_data);
 		break;
+	case LogicalTypeId::UNION:
+		InitializeFunctionPointers<ArrowUnionData>(append_data);
+		break;
 	case LogicalTypeId::STRUCT:
 		InitializeFunctionPointers<ArrowStructData>(append_data);
 		break;
@@ -726,7 +799,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		InitializeFunctionPointers<ArrowMapData>(append_data);
 		break;
 	default:
-		throw InternalException("Unsupported type in DuckDB -> Arrow Conversion: %s\n", type.ToString());
+		throw NotImplementedException("Unsupported type in DuckDB -> Arrow Conversion: %s\n", type.ToString());
 	}
 }
 

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

@@ -76,6 +76,15 @@ void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child,
 	SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options);
 }
 
+unsafe_unique_array<char> AddName(const string &name) {
+	auto name_ptr = make_unsafe_uniq_array<char>(name.size() + 1);
+	for (size_t i = 0; i < name.size(); i++) {
+		name_ptr[i] = name[i];
+	}
+	name_ptr[name.size()] = '\0';
+	return name_ptr;
+}
+
 void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
                     const ArrowOptions &options) {
 	switch (type.id()) {
@@ -135,12 +144,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	case LogicalTypeId::TIMESTAMP_TZ: {
 		string format = "tsu:" + options.time_zone;
-		auto format_ptr = make_unsafe_uniq_array<char>(format.size() + 1);
-		for (size_t i = 0; i < format.size(); i++) {
-			format_ptr[i] = format[i];
-		}
-		format_ptr[format.size()] = '\0';
-		root_holder.owned_type_names.push_back(std::move(format_ptr));
+		root_holder.owned_type_names.push_back(AddName(format));
 		child.format = root_holder.owned_type_names.back().get();
 		break;
 	}
@@ -160,12 +164,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		uint8_t width, scale;
 		type.GetDecimalProperties(width, scale);
 		string format = "d:" + to_string(width) + "," + to_string(scale);
-		auto format_ptr = make_unsafe_uniq_array<char>(format.size() + 1);
-		for (size_t i = 0; i < format.size(); i++) {
-			format_ptr[i] = format[i];
-		}
-		format_ptr[format.size()] = '\0';
-		root_holder.owned_type_names.push_back(std::move(format_ptr));
+		root_holder.owned_type_names.push_back(AddName(format));
 		child.format = root_holder.owned_type_names.back().get();
 		break;
 	}
@@ -211,13 +210,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 
 			InitializeChild(*child.children[type_idx]);
 
-			auto &struct_col_name = child_types[type_idx].first;
-			auto name_ptr = make_unsafe_uniq_array<char>(struct_col_name.size() + 1);
-			for (size_t i = 0; i < struct_col_name.size(); i++) {
-				name_ptr[i] = struct_col_name[i];
-			}
-			name_ptr[struct_col_name.size()] = '\0';
-			root_holder.owned_type_names.push_back(std::move(name_ptr));
+			root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
 
 			child.children[type_idx]->name = root_holder.owned_type_names.back().get();
 			SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options);
@@ -228,6 +221,38 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		SetArrowMapFormat(root_holder, child, type, options);
 		break;
 	}
+	case LogicalTypeId::UNION: {
+		std::string format = "+us:";
+
+		auto &child_types = UnionType::CopyMemberTypes(type);
+		child.n_children = child_types.size();
+		root_holder.nested_children.emplace_back();
+		root_holder.nested_children.back().resize(child_types.size());
+		root_holder.nested_children_ptr.emplace_back();
+		root_holder.nested_children_ptr.back().resize(child_types.size());
+		for (idx_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
+			root_holder.nested_children_ptr.back()[type_idx] = &root_holder.nested_children.back()[type_idx];
+		}
+		child.children = &root_holder.nested_children_ptr.back()[0];
+		for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
+
+			InitializeChild(*child.children[type_idx]);
+
+			root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
+
+			child.children[type_idx]->name = root_holder.owned_type_names.back().get();
+			SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options);
+
+			format += to_string(type_idx) + ",";
+		}
+
+		format.pop_back();
+
+		root_holder.owned_type_names.push_back(AddName(format));
+		child.format = root_holder.owned_type_names.back().get();
+
+		break;
+	}
 	case LogicalTypeId::ENUM: {
 		// TODO what do we do with pointer enums here?
 		switch (EnumType::GetPhysicalType(type)) {

package/src/duckdb/src/common/types/value.cpp

@@ -678,7 +678,7 @@ Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value)
 	result.is_null = false;
 	// add the tag to the front of the struct
 	vector<Value> union_values;
-	union_values.emplace_back(Value::TINYINT(tag));
+	union_values.emplace_back(Value::UTINYINT(tag));
 	for (idx_t i = 0; i < members.size(); i++) {
 		if (i != tag) {
 			union_values.emplace_back(members[i].second);
@@ -1465,20 +1465,25 @@ const vector<Value> &ListValue::GetChildren(const Value &value) {
 }
 
 const Value &UnionValue::GetValue(const Value &value) {
-	D_ASSERT(value.type() == LogicalTypeId::UNION);
+	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
 	auto &children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<uint8_t>();
+	auto tag = children[0].GetValueUnsafe<union_tag_t>();
 	D_ASSERT(tag < children.size() - 1);
 	return children[tag + 1];
 }
 
-uint8_t UnionValue::GetTag(const Value &value) {
-	D_ASSERT(value.type() == LogicalTypeId::UNION);
+union_tag_t UnionValue::GetTag(const Value &value) {
+	D_ASSERT(value.type().id() == LogicalTypeId::UNION);
 	auto children = StructValue::GetChildren(value);
-	auto tag = children[0].GetValueUnsafe<uint8_t>();
+	auto tag = children[0].GetValueUnsafe<union_tag_t>();
+	D_ASSERT(tag < children.size() - 1);
 	return tag;
 }
 
+const LogicalType &UnionValue::GetType(const Value &value) {
+	return UnionType::GetMemberType(value.type(), UnionValue::GetTag(value));
+}
+
 hugeint_t IntegralValue::Get(const Value &value) {
 	switch (value.type().InternalType()) {
 	case PhysicalType::INT8:

package/src/duckdb/src/common/types.cpp

@@ -948,7 +948,7 @@ LogicalType LogicalType::UNION(child_list_t<LogicalType> members) {
 	D_ASSERT(!members.empty());
 	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
 	// union types always have a hidden "tag" field in front
-	members.insert(members.begin(), {"", LogicalType::TINYINT});
+	members.insert(members.begin(), {"", LogicalType::UTINYINT});
 	auto info = make_shared<StructTypeInfo>(std::move(members));
 	return LogicalType(LogicalTypeId::UNION, std::move(info));
 }

package/src/duckdb/src/function/table/arrow.cpp

@@ -127,6 +127,25 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		}
 		return LogicalType::STRUCT(child_types);
 
+	} else if (format[0] == '+' && format[1] == 'u') {
+		if (format[2] != 's') {
+			throw NotImplementedException("Unsupported Internal Arrow Type: \"%c\" Union", format[2]);
+		}
+		D_ASSERT(format[3] == ':');
+
+		std::string prefix = "+us:";
+		// TODO: what are these type ids actually for?
+		auto type_ids = StringUtil::Split(format.substr(prefix.size()), ',');
+
+		child_list_t<LogicalType> members;
+		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
+			auto type = schema.children[type_idx];
+
+			members.emplace_back(type->name, GetArrowLogicalType(*type, arrow_convert_data, col_idx));
+		}
+
+		return LogicalType::UNION(members);
+
 	} else if (format == "+m") {
 		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 

package/src/duckdb/src/function/table/arrow_conversion.cpp

@@ -644,8 +644,42 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 		}
 		break;
 	}
+	case LogicalTypeId::UNION: {
+		auto type_ids = ArrowBufferData<int8_t>(array, array.n_buffers == 1 ? 0 : 1);
+		D_ASSERT(type_ids);
+		auto members = UnionType::CopyMemberTypes(vector.GetType());
+
+		auto &validity_mask = FlatVector::Validity(vector);
+
+		duckdb::vector<Vector> children;
+		for (idx_t type_idx = 0; type_idx < (::idx_t)array.n_children; type_idx++) {
+			Vector child(members[type_idx].second);
+			auto arrow_array = array.children[type_idx];
+
+			SetValidityMask(child, *arrow_array, scan_state, size, nested_offset);
+
+			ColumnArrowToDuckDB(child, *arrow_array, scan_state, size, arrow_convert_data, col_idx, arrow_convert_idx,
+			                    nested_offset, &validity_mask);
+
+			children.push_back(std::move(child));
+		}
+
+		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
+			auto tag = type_ids[row_idx];
+
+			auto out_of_range = tag < 0 || tag >= array.n_children;
+			if (out_of_range) {
+				throw InvalidInputException("Arrow union tag out of range: %d", tag);
+			}
+
+			const Value &value = children[tag].GetValue(row_idx);
+			vector.SetValue(row_idx, value.IsNull() ? Value() : Value::UNION(members, tag, value));
+		}
+
+		break;
+	}
 	default:
-		throw NotImplementedException("Unsupported type %s", vector.GetType().ToString());
+		throw NotImplementedException("Unsupported type for arrow conversion: %s", vector.GetType().ToString());
 	}
 }
 

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -204,6 +204,13 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	auto max_map_value = Value::MAP(ListType::GetChildType(map_type), map_values);
 	result.emplace_back(map_type, "map", std::move(min_map_value), std::move(max_map_value));
 
+	// union
+	child_list_t<LogicalType> members = {{"name", LogicalType::VARCHAR}, {"age", LogicalType::SMALLINT}};
+	auto union_type = LogicalType::UNION(members);
+	const Value &min = Value::UNION(members, 0, Value("Frank"));
+	const Value &max = Value::UNION(members, 1, Value::SMALLINT(5));
+	result.emplace_back(union_type, "union", min, max);
+
 	return result;
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev1573"
+#define DUCKDB_VERSION "0.8.2-dev1724"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "c277db819b"
+#define DUCKDB_SOURCE_ID "0e0fd210cd"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -99,11 +99,11 @@ public:
 	bool IsPipe(const string &filename) override {
 		return GetFileSystem().IsPipe(filename);
 	}
-	virtual void RemoveFile(const string &filename) override {
+	void RemoveFile(const string &filename) override {
 		GetFileSystem().RemoveFile(filename);
 	}
 
-	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
+	vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
 		if (opener) {
 			throw InternalException("OpenerFileSystem cannot take an opener - the opener is pushed automatically");
 		}

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

@@ -394,6 +394,7 @@ struct ListValue {
 struct UnionValue {
 	DUCKDB_API static const Value &GetValue(const Value &value);
 	DUCKDB_API static uint8_t GetTag(const Value &value);
+	DUCKDB_API static const LogicalType &GetType(const Value &value);
 };
 
 //! Return the internal integral value for any type that is stored as an integral value internally

package/src/duckdb/src/include/duckdb/main/extension/generated_extension_loader.hpp

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension/generated_extension_loader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#if defined(GENERATED_EXTENSION_HEADERS) and !defined(DUCKDB_AMALGAMATION)
+#include "generated_extension_headers.hpp"
+
+namespace duckdb {
+
+//! Looks through the CMake-generated list of extensions that are linked into DuckDB currently to try load <extension>
+bool TryLoadLinkedExtension(DuckDB &db, const std::string &extension);
+extern vector<string> linked_extensions;
+extern vector<string> loaded_extension_test_paths;
+
+} // namespace duckdb
+#endif

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -58,6 +58,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"json_deserialize_sql", "json"},
                                                          {"json_serialize_sql", "json"},
                                                          {"json_execute_serialized_sql", "json"},
+                                                         {"load_aws_credentials", "aws"},
                                                          {"make_timestamptz", "icu"},
                                                          {"parquet_metadata", "parquet"},
                                                          {"parquet_scan", "parquet"},
@@ -161,6 +162,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"st_numpoints", "spatial"}};
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
+    {"azure_storage_connection_string", "azure"},
     {"binary_as_string", "parquet"},
     {"calendar", "icu"},
     {"http_retries", "httpfs"},

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -46,7 +46,7 @@
 
 // Load the generated header file containing our list of extension headers
 #if defined(GENERATED_EXTENSION_HEADERS) && GENERATED_EXTENSION_HEADERS && !defined(DUCKDB_AMALGAMATION)
-#include "generated_extension_loader.hpp"
+#include "duckdb/main/extension/generated_extension_loader.hpp"
 #else
 // TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that
 //		 these can be removed
@@ -150,10 +150,8 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	}
 
 #if defined(GENERATED_EXTENSION_HEADERS) && GENERATED_EXTENSION_HEADERS
-	for (auto &ext : LINKED_EXTENSIONS) {
-		if (extensions.find(ext) != extensions.end()) {
-			LoadExtensionInternal(db, ext, true);
-		}
+	for (auto &ext : linked_extensions) {
+		LoadExtensionInternal(db, ext, true);
 	}
 #endif
 }

package/test/columns.test.ts

@@ -12,7 +12,7 @@ describe('Column Types', function() {
 
           let cols = stmt.columns();
           
-          assert.equal(cols.length, 41);
+          assert.equal(cols.length, 42);
 
           var expected = [
             { name: 'bool', type: { id: 'BOOLEAN',  sql_type: 'BOOLEAN' } },
@@ -232,6 +232,29 @@ describe('Column Types', function() {
                   sql_type: 'VARCHAR'
                 }
               }
+            },
+            {
+              name: "union",
+              type: {
+                id: "UNION",
+                sql_type: "UNION(name VARCHAR, age SMALLINT)",
+                children: [
+                  {
+                    name: "name",
+                    type: {
+                      id: "VARCHAR",
+                      sql_type: "VARCHAR"
+                    }
+                  },
+                  {
+                    name: "age",
+                    type: {
+                      id: "SMALLINT",
+                      sql_type: "SMALLINT",
+                    }
+                  }
+                ],
+              }
             }
         ]
 

package/test/test_all_types.test.ts

@@ -157,6 +157,7 @@ const correct_answer_map: Record<string, any[]> = {
     null,
   ],
   map: ["{}", "{key1=🦆🦆🦆🦆🦆🦆, key2=goose}", null],
+  union: ['Frank', '5', null],
 
   time_tz: ["00:00:00+00", "23:59:59.999999+00", null],
   interval: [