duckdb 0.10.1-dev22.0 → 0.10.1-dev26.0

package/src/duckdb/extension/parquet/include/column_writer.hpp

@@ -25,11 +25,12 @@ public:
 	vector<uint16_t> definition_levels;
 	vector<uint16_t> repetition_levels;
 	vector<bool> is_empty;
+	idx_t null_count = 0;
 
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -51,7 +52,7 @@ public:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -74,8 +75,6 @@ public:
 	idx_t max_repeat;
 	idx_t max_define;
 	bool can_have_nulls;
-	// collected stats
-	idx_t null_count;
 
 public:
 	//! Create the column writer for a specific type recursively

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

@@ -47,7 +47,6 @@ struct ParquetReadBindData : public TableFunctionData {
 	shared_ptr<ParquetReader> initial_reader;
 	vector<string> files;
 	atomic<idx_t> chunk_count;
-	atomic<idx_t> cur_file;
 	vector<string> names;
 	vector<LogicalType> types;
 
@@ -96,7 +95,7 @@ struct ParquetReadGlobalState : public GlobalTableFunctionState {
 	bool error_opening_file = false;
 
 	//! Index of file currently up for scanning
-	idx_t file_index;
+	atomic<idx_t> file_index;
 	//! Index of row group within file currently up for scanning
 	idx_t row_group_index;
 	//! Batch index of the next row group to be scanned
@@ -389,10 +388,15 @@ public:
 					// missing metadata entry in cache, no usable stats
 					return nullptr;
 				}
-				auto handle = fs.OpenFile(file_name, FileFlags::FILE_FLAGS_READ);
-				// we need to check if the metadata cache entries are current
-				if (fs.GetLastModifiedTime(*handle) >= metadata->read_time) {
-					// missing or invalid metadata entry in cache, no usable stats overall
+				if (!fs.IsRemoteFile(file_name)) {
+					auto handle = fs.OpenFile(file_name, FileFlags::FILE_FLAGS_READ);
+					// we need to check if the metadata cache entries are current
+					if (fs.GetLastModifiedTime(*handle) >= metadata->read_time) {
+						// missing or invalid metadata entry in cache, no usable stats overall
+						return nullptr;
+					}
+				} else {
+					// for remote files we just avoid reading stats entirely
 					return nullptr;
 				}
 				ParquetReader reader(context, bind_data.parquet_options, metadata);
@@ -484,15 +488,16 @@ public:
 	static double ParquetProgress(ClientContext &context, const FunctionData *bind_data_p,
 	                              const GlobalTableFunctionState *global_state) {
 		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
+		auto &gstate = global_state->Cast<ParquetReadGlobalState>();
 		if (bind_data.files.empty()) {
 			return 100.0;
 		}
 		if (bind_data.initial_file_cardinality == 0) {
-			return (100.0 * (bind_data.cur_file + 1)) / bind_data.files.size();
+			return (100.0 * (gstate.file_index + 1)) / bind_data.files.size();
 		}
-		auto percentage = std::min(
+		auto percentage = MinValue<double>(
 		    100.0, (bind_data.chunk_count * STANDARD_VECTOR_SIZE * 100.0 / bind_data.initial_file_cardinality));
-		return (percentage + 100.0 * bind_data.cur_file) / bind_data.files.size();
+		return (percentage + 100.0 * gstate.file_index) / bind_data.files.size();
 	}
 
 	static unique_ptr<LocalTableFunctionState>

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

@@ -43,10 +43,20 @@ Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
 timestamp_t ParquetTimestampMicrosToTimestamp(const int64_t &raw_ts) {
 	return Timestamp::FromEpochMicroSeconds(raw_ts);
 }
+
 timestamp_t ParquetTimestampMsToTimestamp(const int64_t &raw_ts) {
+	timestamp_t input(raw_ts);
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	return Timestamp::FromEpochMs(raw_ts);
 }
+
 timestamp_t ParquetTimestampNsToTimestamp(const int64_t &raw_ts) {
+	timestamp_t input(raw_ts);
+	if (!Timestamp::IsFinite(input)) {
+		return input;
+	}
 	return Timestamp::FromEpochNanoSeconds(raw_ts);
 }
 

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

@@ -170,6 +170,10 @@ CopyTypeSupport ParquetWriter::TypeIsSupported(const LogicalType &type) {
 		auto &child_type = ListType::GetChildType(type);
 		return TypeIsSupported(child_type);
 	}
+	if (id == LogicalTypeId::ARRAY) {
+		auto &child_type = ArrayType::GetChildType(type);
+		return TypeIsSupported(child_type);
+	}
 	if (id == LogicalTypeId::UNION) {
 		auto count = UnionType::GetMemberCount(type);
 		for (idx_t i = 0; i < count; i++) {

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

@@ -469,14 +469,52 @@ void Catalog::AutoloadExtensionByConfigName(ClientContext &context, const string
 	throw Catalog::UnrecognizedConfigurationError(context, configuration_name);
 }
 
+static bool IsAutoloadableFunction(CatalogType type) {
+	return (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
+	        type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY);
+}
+
+static bool CompareCatalogTypes(CatalogType type_a, CatalogType type_b) {
+	if (type_a == type_b) {
+		// Types are same
+		return true;
+	}
+	if (!IsAutoloadableFunction(type_a)) {
+		D_ASSERT(IsAutoloadableFunction(type_b));
+		// Make sure that `type_a` is an autoloadable function
+		return CompareCatalogTypes(type_b, type_a);
+	}
+	if (type_a == CatalogType::TABLE_FUNCTION_ENTRY) {
+		// These are all table functions
+		return type_b == CatalogType::TABLE_MACRO_ENTRY || type_b == CatalogType::PRAGMA_FUNCTION_ENTRY;
+	} else if (type_a == CatalogType::SCALAR_FUNCTION_ENTRY) {
+		// These are all scalar functions
+		return type_b == CatalogType::MACRO_ENTRY;
+	} else if (type_a == CatalogType::PRAGMA_FUNCTION_ENTRY) {
+		// These are all table functions
+		return type_b == CatalogType::TABLE_MACRO_ENTRY || type_b == CatalogType::TABLE_FUNCTION_ENTRY;
+	}
+	return false;
+}
+
 bool Catalog::AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name) {
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 	auto &dbconfig = DBConfig::GetConfig(db);
 	if (dbconfig.options.autoload_known_extensions) {
 		string extension_name;
-		if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
-		    type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) {
-			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_FUNCTIONS);
+		if (IsAutoloadableFunction(type)) {
+			auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
+			if (lookup_result.empty()) {
+				return false;
+			}
+			for (auto &function : lookup_result) {
+				auto function_type = function.second;
+				// FIXME: what if there are two functions with the same name, from different extensions?
+				if (CompareCatalogTypes(type, function_type)) {
+					extension_name = function.first;
+					break;
+				}
+			}
 		} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
 		} else if (type == CatalogType::TYPE_ENTRY) {
@@ -533,7 +571,42 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 	string extension_name;
 	if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
 	    type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) {
-		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_FUNCTIONS);
+		auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
+		do {
+			if (lookup_result.empty()) {
+				break;
+			}
+			vector<string> other_types;
+			string extension_for_error;
+			for (auto &function : lookup_result) {
+				auto function_type = function.second;
+				if (CompareCatalogTypes(type, function_type)) {
+					extension_name = function.first;
+					break;
+				}
+				extension_for_error = function.first;
+				other_types.push_back(CatalogTypeToString(function_type));
+			}
+			if (!extension_name.empty()) {
+				break;
+			}
+			if (other_types.size() == 1) {
+				auto &function_type = other_types[0];
+				auto error =
+				    CatalogException("%s with name \"%s\" is not in the catalog, a function by this name exists "
+				                     "in the %s extension, but it's of a different type, namely %s",
+				                     CatalogTypeToString(type), entry_name, extension_for_error, function_type);
+				return error;
+			} else {
+				D_ASSERT(!other_types.empty());
+				auto list_of_types = StringUtil::Join(other_types, ", ");
+				auto error =
+				    CatalogException("%s with name \"%s\" is not in the catalog, functions with this name exist "
+				                     "in the %s extension, but they are of different types, namely %s",
+				                     CatalogTypeToString(type), entry_name, extension_for_error, list_of_types);
+				return error;
+			}
+		} while (false);
 	} else if (type == CatalogType::TYPE_ENTRY) {
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
 	} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
@@ -657,17 +730,28 @@ CatalogEntryLookup Catalog::TryLookupEntry(ClientContext &context, CatalogType t
                                            QueryErrorContext error_context) {
 	auto entries = GetCatalogEntries(context, catalog, schema);
 	vector<CatalogLookup> lookups;
+	vector<CatalogLookup> final_lookups;
 	lookups.reserve(entries.size());
 	for (auto &entry : entries) {
+		optional_ptr<Catalog> catalog_entry;
 		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-			auto catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog);
-			if (!catalog_entry) {
-				return {nullptr, nullptr, ErrorData()};
-			}
-			lookups.emplace_back(*catalog_entry, entry.schema);
+			catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog);
 		} else {
-			lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema);
+			catalog_entry = &Catalog::GetCatalog(context, entry.catalog);
+		}
+		if (!catalog_entry) {
+			return {nullptr, nullptr, ErrorData()};
 		}
+		D_ASSERT(catalog_entry);
+		auto lookup_behavior = catalog_entry->CatalogTypeLookupRule(type);
+		if (lookup_behavior == CatalogLookupBehavior::STANDARD) {
+			lookups.emplace_back(*catalog_entry, entry.schema);
+		} else if (lookup_behavior == CatalogLookupBehavior::LOWER_PRIORITY) {
+			final_lookups.emplace_back(*catalog_entry, entry.schema);
+		}
+	}
+	for (auto &lookup : final_lookups) {
+		lookups.emplace_back(std::move(lookup));
 	}
 	return Catalog::TryLookupEntry(context, lookups, type, name, if_not_found, error_context);
 }

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -22,6 +22,7 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/common/exception/transaction_exception.hpp"
+#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
 
 namespace duckdb {
 
@@ -160,6 +161,13 @@ unique_ptr<BaseStatistics> DuckTableEntry::GetStatistics(ClientContext &context,
 
 unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
+
+	// Column comments have a special alter type
+	if (info.type == AlterType::SET_COLUMN_COMMENT) {
+		auto &comment_on_column_info = info.Cast<SetColumnCommentInfo>();
+		return SetColumnComment(context, comment_on_column_info);
+	}
+
 	if (info.type != AlterType::ALTER_TABLE) {
 		throw CatalogException("Can only modify table with ALTER TABLE statement");
 	}
@@ -208,10 +216,6 @@ unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, Alte
 		auto &drop_not_null_info = table_info.Cast<DropNotNullInfo>();
 		return DropNotNull(context, drop_not_null_info);
 	}
-	case AlterTableType::SET_COLUMN_COMMENT: {
-		auto &column_comment_info = table_info.Cast<SetColumnCommentInfo>();
-		return SetColumnComment(context, column_comment_info);
-	}
 	default:
 		throw InternalException("Unrecognized alter table type!");
 	}
@@ -673,7 +677,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetColumnComment(ClientContext &context
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
 		if (default_idx == col.Logical()) {
-			copy.SetComment(info.comment);
+			copy.SetComment(info.comment_value);
 		}
 		create_info->columns.AddColumn(std::move(copy));
 	}

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -217,6 +217,7 @@ static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalP
 static bool TypeSupportsRegularUpdate(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::LIST:
+	case LogicalTypeId::ARRAY:
 	case LogicalTypeId::MAP:
 	case LogicalTypeId::UNION:
 		// lists and maps and unions don't support updates directly

package/src/duckdb/src/catalog/catalog_entry/ub_duckdb_catalog_entries.cpp

@@ -0,0 +1,16 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/copy_function_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/duck_index_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/pragma_function_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/column_dependency_manager.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp>
+#include </Users/carlo/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp>

package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp

@@ -2,8 +2,10 @@
 
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/exception/binder_exception.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
 #include "duckdb/common/limits.hpp"
 
 #include <algorithm>
@@ -19,6 +21,7 @@ void ViewCatalogEntry::Initialize(CreateViewInfo &info) {
 	this->sql = info.sql;
 	this->internal = info.internal;
 	this->comment = info.comment;
+	this->column_comments = info.column_comments;
 }
 
 ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info)
@@ -37,11 +40,36 @@ unique_ptr<CreateInfo> ViewCatalogEntry::GetInfo() const {
 	result->types = types;
 	result->temporary = temporary;
 	result->comment = comment;
+	result->column_comments = column_comments;
 	return std::move(result);
 }
 
 unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
+
+	// Column comments have a special alter type
+	if (info.type == AlterType::SET_COLUMN_COMMENT) {
+		auto &comment_on_column_info = info.Cast<SetColumnCommentInfo>();
+		auto copied_view = Copy(context);
+
+		for (idx_t i = 0; i < names.size(); i++) {
+			const auto &col_name = names[i];
+			if (col_name == comment_on_column_info.column_name) {
+				auto &copied_view_entry = copied_view->Cast<ViewCatalogEntry>();
+
+				// If vector is empty, we need to initialize it on setting here
+				if (copied_view_entry.column_comments.empty()) {
+					copied_view_entry.column_comments = vector<Value>(copied_view_entry.types.size());
+				}
+
+				copied_view_entry.column_comments[i] = comment_on_column_info.comment_value;
+				return copied_view;
+			}
+		}
+		throw BinderException("View \"%s\" does not have a column with name \"%s\"", name,
+		                      comment_on_column_info.column_name);
+	}
+
 	if (info.type != AlterType::ALTER_VIEW) {
 		throw CatalogException("Can only modify view with ALTER VIEW statement");
 	}

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