duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -162,6 +162,9 @@ static DefaultMacro internal_macros[] = {
 	// date functions
 	{DEFAULT_SCHEMA, "date_add", {"date", "interval", nullptr}, "date + interval"},
 
+	// regexp functions
+	{DEFAULT_SCHEMA, "regexp_split_to_table", {"text", "pattern", nullptr}, "unnest(string_split_regex(text, pattern))"},
+
     // storage helper functions
     {DEFAULT_SCHEMA, "get_block_size", {"db_name"}, "(SELECT block_size FROM pragma_database_size() WHERE database_name = db_name)"},
 

package/src/duckdb/src/catalog/default/default_views.cpp

@@ -46,11 +46,11 @@ static DefaultView internal_views[] = {
     {"pg_catalog", "pg_tablespace", "SELECT 0 oid, 'pg_default' spcname, 0 spcowner, NULL spcacl, NULL spcoptions"},
     {"pg_catalog", "pg_type", "SELECT type_oid oid, format_pg_type(type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, CASE WHEN logical_type='ENUM' THEN 'e' else 'b' end typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types() WHERE type_size IS NOT NULL;"},
     {"pg_catalog", "pg_views", "SELECT schema_name schemaname, view_name viewname, 'duckdb' viewowner, sql definition FROM duckdb_views()"},
-    {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL datetime_precision, NULL interval_type, NULL interval_precision, NULL character_set_catalog, NULL character_set_schema, NULL character_set_name, NULL collation_catalog, NULL collation_schema, NULL collation_name, NULL domain_catalog, NULL domain_schema, NULL domain_name, NULL udt_catalog, NULL udt_schema, NULL udt_name, NULL scope_catalog, NULL scope_schema, NULL scope_name, NULL maximum_cardinality, NULL dtd_identifier, NULL is_self_referencing, NULL is_identity, NULL identity_generation, NULL identity_start, NULL identity_increment, NULL identity_maximum, NULL identity_minimum, NULL identity_cycle, NULL is_generated, NULL generation_expression, NULL is_updatable FROM duckdb_columns;"},
+    {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL datetime_precision, NULL interval_type, NULL interval_precision, NULL character_set_catalog, NULL character_set_schema, NULL character_set_name, NULL collation_catalog, NULL collation_schema, NULL collation_name, NULL domain_catalog, NULL domain_schema, NULL domain_name, NULL udt_catalog, NULL udt_schema, NULL udt_name, NULL scope_catalog, NULL scope_schema, NULL scope_name, NULL maximum_cardinality, NULL dtd_identifier, NULL is_self_referencing, NULL is_identity, NULL identity_generation, NULL identity_start, NULL identity_increment, NULL identity_maximum, NULL identity_minimum, NULL identity_cycle, NULL is_generated, NULL generation_expression, NULL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"},
     {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL default_character_set_catalog, NULL default_character_set_schema, NULL default_character_set_name, sql sql_path FROM duckdb_schemas()"},
-    {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action FROM duckdb_views;"},
+    {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"},
 	{"information_schema", "character_sets", "SELECT NULL character_set_catalog, NULL character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"},
-	{"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, concat(f.source, '_', f.target, '_', f.target_column, '_fkey') constraint_name, current_database() unique_constraint_catalog, c.schema_name unique_constraint_schema, concat(c.table_name, '_', f.target_column, '_', CASE WHEN c.constraint_type == 'UNIQUE' THEN 'key' ELSE 'pkey' END) unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c JOIN (SELECT *, name_extract['source'] source, name_extract['target'] target, name_extract['target_column'] target_column FROM (SELECT *, regexp_extract(constraint_text, 'FOREIGN KEY \\(([a-zA-Z_0-9]+)\\) REFERENCES ([a-zA-Z_0-9]+)\\(([a-zA-Z_0-9]+)\\)', ['source', 'target', 'target_column']) name_extract FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY')) f ON name_extract['target'] = c.table_name AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY')"},
+	{"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, concat(f.source, '_', f.target, '_', f.target_column, '_fkey') constraint_name, current_database() unique_constraint_catalog, c.schema_name unique_constraint_schema, concat(c.table_name, '_', f.target_column, '_', CASE WHEN c.constraint_type == 'UNIQUE' THEN 'key' ELSE 'pkey' END) unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c JOIN (SELECT *, name_extract['source'] as source, name_extract['target'] as target, name_extract['target_column'] as target_column FROM (SELECT *, regexp_extract(constraint_text, 'FOREIGN KEY \\(([a-zA-Z_0-9]+)\\) REFERENCES ([a-zA-Z_0-9]+)\\(([a-zA-Z_0-9]+)\\)', ['source', 'target', 'target_column']) name_extract FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY')) f ON name_extract['target'] = c.table_name AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY')"},
 	{"information_schema", "key_column_usage", "SELECT current_database() constraint_catalog, schema_name constraint_schema, concat(table_name, '_', constraint_column_names[1], CASE constraint_type WHEN 'FOREIGN KEY' THEN '_fkey' WHEN 'PRIMARY KEY' THEN '_pkey' ELSE '_key' END) constraint_name, current_database() table_catalog, schema_name table_schema, table_name, constraint_column_names[1] column_name, 1 ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN 1 ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"},
 	{"information_schema", "table_constraints", "SELECT current_database() constraint_catalog, schema_name constraint_schema, concat(table_name, '_', CASE WHEN length(constraint_column_names) > 1 THEN NULL ELSE constraint_column_names[1] || '_' END, CASE constraint_type WHEN 'FOREIGN KEY' THEN 'fkey' WHEN 'PRIMARY KEY' THEN 'pkey' WHEN 'UNIQUE' THEN 'key' WHEN 'CHECK' THEN 'check' WHEN 'NOT NULL' THEN 'not_null'  END) constraint_name, current_database() table_catalog, schema_name table_schema, table_name, CASE constraint_type WHEN 'NOT NULL' THEN 'CHECK' ELSE constraint_type END constraint_type, 'NO' is_deferrable, 'NO' initially_deferred, 'YES' enforced, 'YES' nulls_distinct FROM duckdb_constraints() WHERE constraint_type = 'PRIMARY KEY' OR constraint_type = 'FOREIGN KEY' OR constraint_type = 'UNIQUE' OR constraint_type = 'CHECK' OR constraint_type = 'NOT NULL';"},
     {nullptr, nullptr, nullptr}};

package/src/duckdb/src/catalog/default/ub_duckdb_catalog_default_entries.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/catalog/default/default_functions.cpp>
+#include </Users/carlo/duckdb/src/catalog/default/default_schemas.cpp>
+#include </Users/carlo/duckdb/src/catalog/default/default_types.cpp>
+#include </Users/carlo/duckdb/src/catalog/default/default_views.cpp>

package/src/duckdb/src/catalog/dependency_catalog_set.cpp

@@ -11,9 +11,7 @@ MangledDependencyName DependencyCatalogSet::ApplyPrefix(const MangledEntryName &
 bool DependencyCatalogSet::CreateEntry(CatalogTransaction transaction, const MangledEntryName &name,
                                        unique_ptr<CatalogEntry> value) {
 	auto new_name = ApplyPrefix(name);
-
-	static const DependencyList EMPTY_DEPENDENCIES;
-	return set.CreateEntry(transaction, new_name.name, std::move(value), EMPTY_DEPENDENCIES);
+	return set.CreateEntry(transaction, new_name.name, std::move(value), DependencyList());
 }
 
 CatalogSet::EntryLookup DependencyCatalogSet::GetEntryDetailed(CatalogTransaction transaction,

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -27,19 +27,16 @@ static void AssertMangledName(const string &mangled_name, idx_t expected_null_by
 }
 
 MangledEntryName::MangledEntryName(const CatalogEntryInfo &info) {
-	static const auto NULL_BYTE = string(1, '\0');
-
 	auto &type = info.type;
 	auto &schema = info.schema;
 	auto &name = info.name;
 
-	this->name = CatalogTypeToString(type) + NULL_BYTE + schema + NULL_BYTE + name;
+	this->name = CatalogTypeToString(type) + '\0' + schema + '\0' + name;
 	AssertMangledName(this->name, 2);
 }
 
 MangledDependencyName::MangledDependencyName(const MangledEntryName &from, const MangledEntryName &to) {
-	static const auto NULL_BYTE = string(1, '\0');
-	this->name = from.name + NULL_BYTE + to.name;
+	this->name = from.name + '\0' + to.name;
 	AssertMangledName(this->name, 5);
 }
 

package/src/duckdb/src/catalog/ub_duckdb_catalog.cpp

@@ -0,0 +1,10 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/catalog/catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_search_path.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_set.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_transaction.cpp>
+#include </Users/carlo/duckdb/src/catalog/duck_catalog.cpp>
+#include </Users/carlo/duckdb/src/catalog/dependency_list.cpp>
+#include </Users/carlo/duckdb/src/catalog/dependency_manager.cpp>
+#include </Users/carlo/duckdb/src/catalog/similar_catalog_entry.cpp>

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -437,7 +437,7 @@ AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, const uint32
 	duckdb::string results = "";
 
 	for (size_t i = 0; i < length; i++) {
-		uint32_t code = info_codes ? info_codes[i] : i;
+		auto code = duckdb::NumericCast<uint32_t>(info_codes ? info_codes[i] : i);
 		auto info_code = ConvertToInfoCode(code);
 		switch (info_code) {
 		case AdbcInfoCode::VENDOR_NAME: {

package/src/duckdb/src/common/adbc/driver_manager.cpp

@@ -21,6 +21,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/adbc/driver_manager.h"
 #include "duckdb/common/adbc/adbc.h"
 #include "duckdb/common/adbc/adbc.hpp"
@@ -513,7 +514,7 @@ std::string AdbcDriverManagerDefaultEntrypoint(const std::string &driver) {
 		// if pos == npos this is the entire filename
 		std::string token = filename.substr(prev, pos - prev);
 		// capitalize first letter
-		token[0] = std::toupper(static_cast<unsigned char>(token[0]));
+		token[0] = duckdb::NumericCast<char>(std::toupper(static_cast<unsigned char>(token[0])));
 
 		entrypoint += token;
 

package/src/duckdb/src/common/adbc/nanoarrow/ub_duckdb_adbc_nanoarrow.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/adbc/nanoarrow/metadata.cpp>
+#include </Users/carlo/duckdb/src/common/adbc/nanoarrow/schema.cpp>
+#include </Users/carlo/duckdb/src/common/adbc/nanoarrow/allocator.cpp>
+#include </Users/carlo/duckdb/src/common/adbc/nanoarrow/single_batch_array_stream.cpp>

package/src/duckdb/src/common/adbc/ub_duckdb_adbc.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/adbc/adbc.cpp>
+#include </Users/carlo/duckdb/src/common/adbc/driver_manager.cpp>

package/src/duckdb/src/common/allocator.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/helper.hpp"
 
 #include <cstdint>
 
@@ -95,15 +96,9 @@ PrivateAllocatorData::~PrivateAllocatorData() {
 //===--------------------------------------------------------------------===//
 // Allocator
 //===--------------------------------------------------------------------===//
-#ifdef USE_JEMALLOC
-Allocator::Allocator()
-    : Allocator(JemallocExtension::Allocate, JemallocExtension::Free, JemallocExtension::Reallocate, nullptr) {
-}
-#else
 Allocator::Allocator()
     : Allocator(Allocator::DefaultAllocate, Allocator::DefaultFree, Allocator::DefaultReallocate, nullptr) {
 }
-#endif
 
 Allocator::Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
                      reallocate_function_ptr_t reallocate_function_p, unique_ptr<PrivateAllocatorData> private_data_p)
@@ -136,7 +131,7 @@ data_ptr_t Allocator::AllocateData(idx_t size) {
 	private_data->debug_info->AllocateData(result, size);
 #endif
 	if (!result) {
-		throw OutOfMemoryException("Failed to allocate block of %llu bytes", size);
+		throw OutOfMemoryException("Failed to allocate block of %llu bytes (bad allocation)", size);
 	}
 	return result;
 }
@@ -169,11 +164,36 @@ data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t s
 	private_data->debug_info->ReallocateData(pointer, new_pointer, old_size, size);
 #endif
 	if (!new_pointer) {
-		throw OutOfMemoryException("Failed to re-allocate block of %llu bytes", size);
+		throw OutOfMemoryException("Failed to re-allocate block of %llu bytes (bad allocation)", size);
 	}
 	return new_pointer;
 }
 
+data_ptr_t Allocator::DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) {
+#ifdef USE_JEMALLOC
+	return JemallocExtension::Allocate(private_data, size);
+#else
+	return data_ptr_cast(malloc(size));
+#endif
+}
+
+void Allocator::DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
+#ifdef USE_JEMALLOC
+	JemallocExtension::Free(private_data, pointer, size);
+#else
+	free(pointer);
+#endif
+}
+
+data_ptr_t Allocator::DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
+                                        idx_t size) {
+#ifdef USE_JEMALLOC
+	return JemallocExtension::Reallocate(private_data, pointer, old_size, size);
+#else
+	return data_ptr_cast(realloc(pointer, size));
+#endif
+}
+
 shared_ptr<Allocator> &Allocator::DefaultAllocatorReference() {
 	static shared_ptr<Allocator> DEFAULT_ALLOCATOR = make_shared<Allocator>();
 	return DEFAULT_ALLOCATOR;
@@ -189,6 +209,12 @@ void Allocator::ThreadFlush(idx_t threshold) {
 #endif
 }
 
+void Allocator::FlushAll() {
+#ifdef USE_JEMALLOC
+	JemallocExtension::FlushAll();
+#endif
+}
+
 //===--------------------------------------------------------------------===//
 // Debug Info (extended)
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/common/arrow/appender/fixed_size_list_data.cpp

@@ -0,0 +1,39 @@
+#include "duckdb/common/arrow/arrow_appender.hpp"
+#include "duckdb/common/arrow/appender/fixed_size_list_data.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Arrays
+//===--------------------------------------------------------------------===//
+void ArrowFixedSizeListData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
+	auto &child_type = ArrayType::GetChildType(type);
+	auto array_size = ArrayType::GetSize(type);
+	auto child_buffer = ArrowAppender::InitializeChild(child_type, capacity * array_size, result.options);
+	result.child_data.push_back(std::move(child_buffer));
+}
+
+void ArrowFixedSizeListData::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;
+	AppendValidity(append_data, format, from, to);
+
+	auto array_size = ArrayType::GetSize(input.GetType());
+	auto &child_vector = ArrayVector::GetEntry(input);
+	auto &child_data = *append_data.child_data[0];
+	child_data.append_vector(child_data, child_vector, from * array_size, to * array_size, size * array_size);
+	append_data.row_count += size;
+}
+
+void ArrowFixedSizeListData::Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
+	result->n_buffers = 1;
+	auto &child_type = ArrayType::GetChildType(type);
+	ArrowAppender::AddChildren(append_data, 1);
+	result->children = append_data.child_pointers.data();
+	result->n_children = 1;
+	append_data.child_arrays[0] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[0]));
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/arrow/appender/ub_duckdb_common_arrow_appender.cpp

@@ -0,0 +1,6 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/arrow/appender/bool_data.cpp>
+#include </Users/carlo/duckdb/src/common/arrow/appender/list_data.cpp>
+#include </Users/carlo/duckdb/src/common/arrow/appender/map_data.cpp>
+#include </Users/carlo/duckdb/src/common/arrow/appender/struct_data.cpp>
+#include </Users/carlo/duckdb/src/common/arrow/appender/union_data.cpp>

package/src/duckdb/src/common/arrow/appender/union_data.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/arrow/arrow_appender.hpp"
 #include "duckdb/common/arrow/appender/union_data.hpp"
 
@@ -42,7 +43,7 @@ void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t f
 			child_vectors[child_idx].SetValue(input_idx, child_idx == tag ? resolved_value : Value(nullptr));
 		}
 
-		types_buffer.data()[input_idx] = tag;
+		types_buffer.data()[input_idx] = NumericCast<data_t>(tag);
 	}
 
 	for (idx_t child_idx = 0; child_idx < child_vectors.size(); child_idx++) {

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

@@ -227,6 +227,9 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::STRUCT:
 		InitializeAppenderForType<ArrowStructData>(append_data);
 		break;
+	case LogicalTypeId::ARRAY:
+		InitializeAppenderForType<ArrowFixedSizeListData>(append_data);
+		break;
 	case LogicalTypeId::LIST: {
 		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			InitializeAppenderForType<ArrowListData<int64_t>>(append_data);
@@ -236,11 +239,8 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		break;
 	}
 	case LogicalTypeId::MAP:
-		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
-			InitializeAppenderForType<ArrowMapData<int64_t>>(append_data);
-		} else {
-			InitializeAppenderForType<ArrowMapData<int32_t>>(append_data);
-		}
+		// Arrow MapArray only supports 32-bit offsets. There is no LargeMapArray type in Arrow.
+		InitializeAppenderForType<ArrowMapData<int32_t>>(append_data);
 		break;
 	default:
 		throw NotImplementedException("Unsupported type in DuckDB -> Arrow Conversion: %s\n", type.ToString());

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

@@ -226,6 +226,23 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		}
 		break;
 	}
+	case LogicalTypeId::ARRAY: {
+		auto array_size = ArrayType::GetSize(type);
+		auto &child_type = ArrayType::GetChildType(type);
+		auto format = "+w:" + to_string(array_size);
+		root_holder.owned_type_names.push_back(AddName(format));
+		child.format = root_holder.owned_type_names.back().get();
+
+		child.n_children = 1;
+		root_holder.nested_children.emplace_back();
+		root_holder.nested_children.back().resize(1);
+		root_holder.nested_children_ptr.emplace_back();
+		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
+		InitializeChild(root_holder.nested_children.back()[0], root_holder);
+		child.children = &root_holder.nested_children_ptr.back()[0];
+		SetArrowFormat(root_holder, **child.children, child_type, options);
+		break;
+	}
 	case LogicalTypeId::MAP: {
 		SetArrowMapFormat(root_holder, child, type, options);
 		break;

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

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/arrow/arrow_appender.cpp>
+#include </Users/carlo/duckdb/src/common/arrow/arrow_converter.cpp>
+#include </Users/carlo/duckdb/src/common/arrow/arrow_wrapper.cpp>

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -113,6 +113,7 @@ void CompressedFile::Close() {
 	stream_data.in_buff_end = nullptr;
 	stream_data.in_buf_size = 0;
 	stream_data.out_buf_size = 0;
+	stream_data.refresh = false;
 }
 
 int64_t CompressedFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {

package/src/duckdb/src/common/crypto/ub_duckdb_common_crypto.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/crypto/md5.cpp>

package/src/duckdb/src/common/enum_util.cpp

@@ -15,6 +15,7 @@
 #include "duckdb/common/box_renderer.hpp"
 #include "duckdb/common/enums/access_mode.hpp"
 #include "duckdb/common/enums/aggregate_handling.hpp"
+#include "duckdb/common/enums/catalog_lookup_behavior.hpp"
 #include "duckdb/common/enums/catalog_type.hpp"
 #include "duckdb/common/enums/compression_type.hpp"
 #include "duckdb/common/enums/cte_materialize.hpp"
@@ -38,6 +39,7 @@
 #include "duckdb/common/enums/output_type.hpp"
 #include "duckdb/common/enums/pending_execution_result.hpp"
 #include "duckdb/common/enums/physical_operator_type.hpp"
+#include "duckdb/common/enums/prepared_statement_mode.hpp"
 #include "duckdb/common/enums/profiler_format.hpp"
 #include "duckdb/common/enums/relation_type.hpp"
 #include "duckdb/common/enums/scan_options.hpp"
@@ -70,9 +72,9 @@
 #include "duckdb/core_functions/aggregate/quantile_enum.hpp"
 #include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/csv_option.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp"
-#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_state.hpp"
+#include "duckdb/execution/operator/csv_scanner/quote_rules.hpp"
 #include "duckdb/function/aggregate_state.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/function/macro_function.hpp"
@@ -86,6 +88,7 @@
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/main/secret/secret.hpp"
+#include "duckdb/main/settings.hpp"
 #include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/parallel/task.hpp"
 #include "duckdb/parser/constraint.hpp"
@@ -408,6 +411,8 @@ const char* EnumUtil::ToChars<AlterType>(AlterType value) {
 		return "ALTER_TABLE_FUNCTION";
 	case AlterType::SET_COMMENT:
 		return "SET_COMMENT";
+	case AlterType::SET_COLUMN_COMMENT:
+		return "SET_COLUMN_COMMENT";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -439,6 +444,9 @@ AlterType EnumUtil::FromString<AlterType>(const char *value) {
 	if (StringUtil::Equals(value, "SET_COMMENT")) {
 		return AlterType::SET_COMMENT;
 	}
+	if (StringUtil::Equals(value, "SET_COLUMN_COMMENT")) {
+		return AlterType::SET_COLUMN_COMMENT;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
@@ -782,6 +790,34 @@ CTEMaterialize EnumUtil::FromString<CTEMaterialize>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<CatalogLookupBehavior>(CatalogLookupBehavior value) {
+	switch(value) {
+	case CatalogLookupBehavior::STANDARD:
+		return "STANDARD";
+	case CatalogLookupBehavior::LOWER_PRIORITY:
+		return "LOWER_PRIORITY";
+	case CatalogLookupBehavior::NEVER_LOOKUP:
+		return "NEVER_LOOKUP";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+CatalogLookupBehavior EnumUtil::FromString<CatalogLookupBehavior>(const char *value) {
+	if (StringUtil::Equals(value, "STANDARD")) {
+		return CatalogLookupBehavior::STANDARD;
+	}
+	if (StringUtil::Equals(value, "LOWER_PRIORITY")) {
+		return CatalogLookupBehavior::LOWER_PRIORITY;
+	}
+	if (StringUtil::Equals(value, "NEVER_LOOKUP")) {
+		return CatalogLookupBehavior::NEVER_LOOKUP;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<CatalogType>(CatalogType value) {
 	switch(value) {
@@ -2805,6 +2841,44 @@ KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<LimitNodeType>(LimitNodeType value) {
+	switch(value) {
+	case LimitNodeType::UNSET:
+		return "UNSET";
+	case LimitNodeType::CONSTANT_VALUE:
+		return "CONSTANT_VALUE";
+	case LimitNodeType::CONSTANT_PERCENTAGE:
+		return "CONSTANT_PERCENTAGE";
+	case LimitNodeType::EXPRESSION_VALUE:
+		return "EXPRESSION_VALUE";
+	case LimitNodeType::EXPRESSION_PERCENTAGE:
+		return "EXPRESSION_PERCENTAGE";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+LimitNodeType EnumUtil::FromString<LimitNodeType>(const char *value) {
+	if (StringUtil::Equals(value, "UNSET")) {
+		return LimitNodeType::UNSET;
+	}
+	if (StringUtil::Equals(value, "CONSTANT_VALUE")) {
+		return LimitNodeType::CONSTANT_VALUE;
+	}
+	if (StringUtil::Equals(value, "CONSTANT_PERCENTAGE")) {
+		return LimitNodeType::CONSTANT_PERCENTAGE;
+	}
+	if (StringUtil::Equals(value, "EXPRESSION_VALUE")) {
+		return LimitNodeType::EXPRESSION_VALUE;
+	}
+	if (StringUtil::Equals(value, "EXPRESSION_PERCENTAGE")) {
+		return LimitNodeType::EXPRESSION_PERCENTAGE;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<LoadType>(LoadType value) {
 	switch(value) {
@@ -2860,8 +2934,6 @@ const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value) {
 		return "LOGICAL_DISTINCT";
 	case LogicalOperatorType::LOGICAL_SAMPLE:
 		return "LOGICAL_SAMPLE";
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		return "LOGICAL_LIMIT_PERCENT";
 	case LogicalOperatorType::LOGICAL_PIVOT:
 		return "LOGICAL_PIVOT";
 	case LogicalOperatorType::LOGICAL_COPY_DATABASE:
@@ -3001,9 +3073,6 @@ LogicalOperatorType EnumUtil::FromString<LogicalOperatorType>(const char *value)
 	if (StringUtil::Equals(value, "LOGICAL_SAMPLE")) {
 		return LogicalOperatorType::LOGICAL_SAMPLE;
 	}
-	if (StringUtil::Equals(value, "LOGICAL_LIMIT_PERCENT")) {
-		return LogicalOperatorType::LOGICAL_LIMIT_PERCENT;
-	}
 	if (StringUtil::Equals(value, "LOGICAL_PIVOT")) {
 		return LogicalOperatorType::LOGICAL_PIVOT;
 	}
@@ -3461,6 +3530,12 @@ const char* EnumUtil::ToChars<MapInvalidReason>(MapInvalidReason value) {
 		return "NULL_KEY";
 	case MapInvalidReason::DUPLICATE_KEY:
 		return "DUPLICATE_KEY";
+	case MapInvalidReason::NULL_VALUE_LIST:
+		return "NULL_VALUE_LIST";
+	case MapInvalidReason::NOT_ALIGNED:
+		return "NOT_ALIGNED";
+	case MapInvalidReason::INVALID_PARAMS:
+		return "INVALID_PARAMS";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -3480,6 +3555,15 @@ MapInvalidReason EnumUtil::FromString<MapInvalidReason>(const char *value) {
 	if (StringUtil::Equals(value, "DUPLICATE_KEY")) {
 		return MapInvalidReason::DUPLICATE_KEY;
 	}
+	if (StringUtil::Equals(value, "NULL_VALUE_LIST")) {
+		return MapInvalidReason::NULL_VALUE_LIST;
+	}
+	if (StringUtil::Equals(value, "NOT_ALIGNED")) {
+		return MapInvalidReason::NOT_ALIGNED;
+	}
+	if (StringUtil::Equals(value, "INVALID_PARAMS")) {
+		return MapInvalidReason::INVALID_PARAMS;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
@@ -4033,6 +4117,8 @@ const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value) {
 		return "VACUUM_INFO";
 	case ParseInfoType::COMMENT_ON_INFO:
 		return "COMMENT_ON_INFO";
+	case ParseInfoType::COMMENT_ON_COLUMN_INFO:
+		return "COMMENT_ON_COLUMN_INFO";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -4082,6 +4168,9 @@ ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value) {
 	if (StringUtil::Equals(value, "COMMENT_ON_INFO")) {
 		return ParseInfoType::COMMENT_ON_INFO;
 	}
+	if (StringUtil::Equals(value, "COMMENT_ON_COLUMN_INFO")) {
+		return ParseInfoType::COMMENT_ON_COLUMN_INFO;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
@@ -4273,8 +4362,6 @@ const char* EnumUtil::ToChars<PhysicalOperatorType>(PhysicalOperatorType value)
 		return "COPY_TO_FILE";
 	case PhysicalOperatorType::BATCH_COPY_TO_FILE:
 		return "BATCH_COPY_TO_FILE";
-	case PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE:
-		return "FIXED_BATCH_COPY_TO_FILE";
 	case PhysicalOperatorType::RESERVOIR_SAMPLE:
 		return "RESERVOIR_SAMPLE";
 	case PhysicalOperatorType::STREAMING_SAMPLE:
@@ -4393,6 +4480,8 @@ const char* EnumUtil::ToChars<PhysicalOperatorType>(PhysicalOperatorType value)
 		return "RESET";
 	case PhysicalOperatorType::EXTENSION:
 		return "EXTENSION";
+	case PhysicalOperatorType::VERIFY_VECTOR:
+		return "VERIFY_VECTOR";
 	case PhysicalOperatorType::CREATE_SECRET:
 		return "CREATE_SECRET";
 	default:
@@ -4447,9 +4536,6 @@ PhysicalOperatorType EnumUtil::FromString<PhysicalOperatorType>(const char *valu
 	if (StringUtil::Equals(value, "BATCH_COPY_TO_FILE")) {
 		return PhysicalOperatorType::BATCH_COPY_TO_FILE;
 	}
-	if (StringUtil::Equals(value, "FIXED_BATCH_COPY_TO_FILE")) {
-		return PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE;
-	}
 	if (StringUtil::Equals(value, "RESERVOIR_SAMPLE")) {
 		return PhysicalOperatorType::RESERVOIR_SAMPLE;
 	}
@@ -4627,6 +4713,9 @@ PhysicalOperatorType EnumUtil::FromString<PhysicalOperatorType>(const char *valu
 	if (StringUtil::Equals(value, "EXTENSION")) {
 		return PhysicalOperatorType::EXTENSION;
 	}
+	if (StringUtil::Equals(value, "VERIFY_VECTOR")) {
+		return PhysicalOperatorType::VERIFY_VECTOR;
+	}
 	if (StringUtil::Equals(value, "CREATE_SECRET")) {
 		return PhysicalOperatorType::CREATE_SECRET;
 	}
@@ -4807,6 +4896,29 @@ PreparedParamType EnumUtil::FromString<PreparedParamType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<PreparedStatementMode>(PreparedStatementMode value) {
+	switch(value) {
+	case PreparedStatementMode::PREPARE_ONLY:
+		return "PREPARE_ONLY";
+	case PreparedStatementMode::PREPARE_AND_EXECUTE:
+		return "PREPARE_AND_EXECUTE";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+PreparedStatementMode EnumUtil::FromString<PreparedStatementMode>(const char *value) {
+	if (StringUtil::Equals(value, "PREPARE_ONLY")) {
+		return PreparedStatementMode::PREPARE_ONLY;
+	}
+	if (StringUtil::Equals(value, "PREPARE_AND_EXECUTE")) {
+		return PreparedStatementMode::PREPARE_AND_EXECUTE;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<ProfilerPrintFormat>(ProfilerPrintFormat value) {
 	switch(value) {
@@ -5377,6 +5489,34 @@ SetType EnumUtil::FromString<SetType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<SettingScope>(SettingScope value) {
+	switch(value) {
+	case SettingScope::GLOBAL:
+		return "GLOBAL";
+	case SettingScope::LOCAL:
+		return "LOCAL";
+	case SettingScope::INVALID:
+		return "INVALID";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+SettingScope EnumUtil::FromString<SettingScope>(const char *value) {
+	if (StringUtil::Equals(value, "GLOBAL")) {
+		return SettingScope::GLOBAL;
+	}
+	if (StringUtil::Equals(value, "LOCAL")) {
+		return SettingScope::LOCAL;
+	}
+	if (StringUtil::Equals(value, "INVALID")) {
+		return SettingScope::INVALID;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<ShowType>(ShowType value) {
 	switch(value) {