duckdb 0.10.3-dev3.0 → 0.10.3-dev6.0

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

@@ -0,0 +1,64 @@
+#include "duckdb/catalog/catalog_entry_retriever.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/parser/query_error_context.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+
+namespace duckdb {
+
+LogicalType CatalogEntryRetriever::GetType(Catalog &catalog, const string &schema, const string &name,
+                                           OnEntryNotFound on_entry_not_found) {
+	QueryErrorContext error_context;
+	auto result = GetEntry(CatalogType::TYPE_ENTRY, catalog, schema, name, on_entry_not_found, error_context);
+	if (!result) {
+		return LogicalType::INVALID;
+	}
+	auto &type_entry = result->Cast<TypeCatalogEntry>();
+	return type_entry.user_type;
+}
+
+LogicalType CatalogEntryRetriever::GetType(const string &catalog, const string &schema, const string &name,
+                                           OnEntryNotFound on_entry_not_found) {
+	QueryErrorContext error_context;
+	auto result = GetEntry(CatalogType::TYPE_ENTRY, catalog, schema, name, on_entry_not_found, error_context);
+	if (!result) {
+		return LogicalType::INVALID;
+	}
+	auto &type_entry = result->Cast<TypeCatalogEntry>();
+	return type_entry.user_type;
+}
+
+optional_ptr<CatalogEntry> CatalogEntryRetriever::GetEntry(CatalogType type, const string &catalog,
+                                                           const string &schema, const string &name,
+                                                           OnEntryNotFound on_entry_not_found,
+                                                           QueryErrorContext error_context) {
+	return GetEntryInternal(
+	    [&]() { return Catalog::GetEntry(context, type, catalog, schema, name, on_entry_not_found, error_context); });
+}
+
+optional_ptr<SchemaCatalogEntry> CatalogEntryRetriever::GetSchema(const string &catalog, const string &name,
+                                                                  OnEntryNotFound on_entry_not_found,
+                                                                  QueryErrorContext error_context) {
+	auto result = Catalog::GetSchema(context, catalog, name, on_entry_not_found, error_context);
+	if (!result) {
+		return result;
+	}
+	if (callback) {
+		// Call the callback if it's set
+		callback(*result);
+	}
+	return result;
+}
+
+optional_ptr<CatalogEntry> CatalogEntryRetriever::GetEntry(CatalogType type, Catalog &catalog, const string &schema,
+                                                           const string &name, OnEntryNotFound on_entry_not_found,
+                                                           QueryErrorContext error_context) {
+	return GetEntryInternal(
+	    [&]() { return catalog.GetEntry(context, type, schema, name, on_entry_not_found, error_context); });
+}
+
+} // namespace duckdb

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

@@ -14,6 +14,7 @@
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/common/exception/transaction_exception.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -245,10 +246,22 @@ bool CatalogSet::AlterOwnership(CatalogTransaction transaction, ChangeOwnershipI
 	if (!entry) {
 		return false;
 	}
-
-	auto &owner_entry = catalog.GetEntry(transaction.GetContext(), info.owner_schema, info.owner_name);
+	optional_ptr<CatalogEntry> owner_entry;
+	auto schema = catalog.GetSchema(transaction, info.owner_schema, OnEntryNotFound::RETURN_NULL);
+	if (schema) {
+		vector<CatalogType> entry_types {CatalogType::TABLE_ENTRY, CatalogType::SEQUENCE_ENTRY};
+		for (auto entry_type : entry_types) {
+			owner_entry = schema->GetEntry(transaction, entry_type, info.owner_name);
+			if (owner_entry) {
+				break;
+			}
+		}
+	}
+	if (!owner_entry) {
+		throw CatalogException("CatalogElement \"%s.%s\" does not exist!", info.owner_schema, info.owner_name);
+	}
 	write_lock.unlock();
-	catalog.GetDependencyManager().AddOwnership(transaction, owner_entry, *entry);
+	catalog.GetDependencyManager().AddOwnership(transaction, *owner_entry, *entry);
 	return true;
 }
 
@@ -292,39 +305,41 @@ bool CatalogSet::RenameEntryInternal(CatalogTransaction transaction, CatalogEntr
 }
 
 bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info) {
-	// lock the catalog for writing
-	unique_lock<mutex> write_lock(catalog.GetWriteLock());
-	// lock this catalog set to disallow reading
-	unique_lock<mutex> read_lock(catalog_lock);
-
 	// If the entry does not exist, we error
-	auto entry = GetEntryInternal(transaction, name);
+	auto entry = GetEntry(transaction, name);
 	if (!entry) {
 		return false;
 	}
 	if (!alter_info.allow_internal && entry->internal) {
 		throw CatalogException("Cannot alter entry \"%s\" because it is an internal system entry", entry->name);
 	}
-	if (!transaction.context) {
-		throw InternalException("Cannot AlterEntry without client context");
-	}
-
-	auto &context = *transaction.context;
 
 	unique_ptr<CatalogEntry> value;
 	if (alter_info.type == AlterType::SET_COMMENT) {
 		// Copy the existing entry; we are only changing metadata here
-		value = entry->Copy(context);
+		if (!transaction.context) {
+			throw InternalException("Cannot AlterEntry::SET_COMMENT without client context");
+		}
+		value = entry->Copy(*transaction.context);
 		value->comment = alter_info.Cast<SetCommentInfo>().comment_value;
 	} else {
 		// Use the existing entry to create the altered entry
-		value = entry->AlterEntry(context, alter_info);
+		value = entry->AlterEntry(transaction, alter_info);
 		if (!value) {
 			// alter failed, but did not result in an error
 			return true;
 		}
 	}
 
+	// lock the catalog for writing
+	unique_lock<mutex> write_lock(catalog.GetWriteLock());
+	// lock this catalog set to disallow reading
+	unique_lock<mutex> read_lock(catalog_lock);
+
+	// fetch the entry again before doing the modification
+	// this will catch any write-write conflicts between transactions
+	entry = GetEntryInternal(transaction, name);
+
 	// Mark this entry as being created by this transaction
 	value->timestamp = transaction.transaction_id;
 	value->set = this;
@@ -355,7 +370,7 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	write_lock.unlock();
 
 	// Check the dependency manager to verify that there are no conflicting dependencies with this alter
-	catalog.GetDependencyManager().AlterObject(transaction, *entry, *new_entry);
+	catalog.GetDependencyManager().AlterObject(transaction, *entry, *new_entry, alter_info);
 
 	return true;
 }

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

@@ -60,8 +60,9 @@ static const DefaultMacro internal_macros[] = {
 	{"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
 	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid//1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
 	{"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, "pg_node_tree"},
-	{"pg_catalog", "format_pg_type", {"logical_type", "type_name", nullptr}, "case when logical_type='FLOAT' then 'real' when logical_type='DOUBLE' then 'double precision' when logical_type='DECIMAL' then 'numeric' when logical_type='ENUM' then lower(type_name) when logical_type='VARCHAR' then 'character varying' when logical_type='BLOB' then 'bytea' when logical_type='TIMESTAMP' then 'timestamp without time zone' when logical_type='TIME' then 'time without time zone' else lower(logical_type) end"},
+	{"pg_catalog", "format_pg_type", {"logical_type", "type_name", nullptr}, "case upper(logical_type) when 'FLOAT' then 'float4' when 'DOUBLE' then 'float8' when 'DECIMAL' then 'numeric' when 'ENUM' then lower(type_name) when 'VARCHAR' then 'varchar' when 'BLOB' then 'bytea' when 'TIMESTAMP' then 'timestamp' when 'TIME' then 'time' when 'TIMESTAMP WITH TIME ZONE' then 'timestamptz' when 'TIME WITH TIME ZONE' then 'timetz' when 'SMALLINT' then 'int2' when 'INTEGER' then 'int4' when 'BIGINT' then 'int8' when 'BOOLEAN' then 'bool' else lower(logical_type) end"},
 	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(logical_type, type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
+	{"pg_catalog", "map_to_pg_oid", {"type_name", nullptr}, "case type_name when 'bool' then 16 when 'int16' then 21 when 'int' then 23 when 'bigint' then 20 when 'date' then 1082 when 'time' then 1083 when 'datetime' then 1114 when 'dec' then 1700 when 'float' then 700 when 'double' then 701 when 'bpchar' then 1043 when 'binary' then 17 when 'interval' then 1186 when 'timestamptz' then 1184 when 'timetz' then 1266 when 'bit' then 1560 when 'guid' then 2950 else null end"}, // map duckdb_oid to pg_oid. If no corresponding type, return null 
 
 	{"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for role
 	{"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for role

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

@@ -44,7 +44,7 @@ static const DefaultView internal_views[] = {
 	{"pg_catalog", "pg_settings", "SELECT name, value setting, description short_desc, CASE WHEN input_type = 'VARCHAR' THEN 'string' WHEN input_type = 'BOOLEAN' THEN 'bool' WHEN input_type IN ('BIGINT', 'UBIGINT') THEN 'integer' ELSE input_type END vartype FROM duckdb_settings()"},
     {"pg_catalog", "pg_tables", "SELECT schema_name schemaname, table_name tablename, 'duckdb' tableowner, NULL \"tablespace\", index_count > 0 hasindexes, false hasrules, false hastriggers FROM duckdb_tables()"},
     {"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(logical_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_type", "SELECT CASE WHEN type_oid IS NULL THEN NULL WHEN logical_type = 'ENUM' AND type_name <> 'enum' THEN type_oid ELSE map_to_pg_oid(type_name) END oid, format_pg_type(logical_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_oid 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::INT character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL::INT datetime_precision, NULL::VARCHAR interval_type, NULL::INT interval_precision, NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, NULL::VARCHAR character_set_name, NULL::VARCHAR collation_catalog, NULL::VARCHAR collation_schema, NULL::VARCHAR collation_name, NULL::VARCHAR domain_catalog, NULL::VARCHAR domain_schema, NULL::VARCHAR domain_name, NULL::VARCHAR udt_catalog, NULL::VARCHAR udt_schema, NULL::VARCHAR udt_name, NULL::VARCHAR scope_catalog, NULL::VARCHAR scope_schema, NULL::VARCHAR scope_name, NULL::BIGINT maximum_cardinality, NULL::VARCHAR dtd_identifier, NULL::BOOL is_self_referencing, NULL::BOOL is_identity, NULL::VARCHAR identity_generation, NULL::VARCHAR identity_start, NULL::VARCHAR identity_increment, NULL::VARCHAR identity_maximum, NULL::VARCHAR identity_minimum, NULL::BOOL identity_cycle, NULL::VARCHAR is_generated, NULL::VARCHAR generation_expression, NULL::BOOL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"},
     {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL::VARCHAR default_character_set_catalog, NULL::VARCHAR default_character_set_schema, NULL::VARCHAR default_character_set_name, sql sql_path FROM duckdb_schemas()"},

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

@@ -349,6 +349,90 @@ void DependencyManager::CleanupDependencies(CatalogTransaction transaction, Cata
 	}
 }
 
+static string EntryToString(CatalogEntryInfo &info) {
+	auto type = info.type;
+	switch (type) {
+	case CatalogType::TABLE_ENTRY: {
+		return StringUtil::Format("table \"%s\"", info.name);
+	}
+	case CatalogType::SCHEMA_ENTRY: {
+		return StringUtil::Format("schema \"%s\"", info.name);
+	}
+	case CatalogType::VIEW_ENTRY: {
+		return StringUtil::Format("view \"%s\"", info.name);
+	}
+	case CatalogType::INDEX_ENTRY: {
+		return StringUtil::Format("index \"%s\"", info.name);
+	}
+	case CatalogType::SEQUENCE_ENTRY: {
+		return StringUtil::Format("index \"%s\"", info.name);
+	}
+	case CatalogType::COLLATION_ENTRY: {
+		return StringUtil::Format("collation \"%s\"", info.name);
+	}
+	case CatalogType::TYPE_ENTRY: {
+		return StringUtil::Format("type \"%s\"", info.name);
+	}
+	case CatalogType::TABLE_FUNCTION_ENTRY: {
+		return StringUtil::Format("table function \"%s\"", info.name);
+	}
+	case CatalogType::SCALAR_FUNCTION_ENTRY: {
+		return StringUtil::Format("scalar function \"%s\"", info.name);
+	}
+	case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
+		return StringUtil::Format("aggregate function \"%s\"", info.name);
+	}
+	case CatalogType::PRAGMA_FUNCTION_ENTRY: {
+		return StringUtil::Format("pragma function \"%s\"", info.name);
+	}
+	case CatalogType::COPY_FUNCTION_ENTRY: {
+		return StringUtil::Format("copy function \"%s\"", info.name);
+	}
+	case CatalogType::MACRO_ENTRY: {
+		return StringUtil::Format("macro function \"%s\"", info.name);
+	}
+	case CatalogType::TABLE_MACRO_ENTRY: {
+		return StringUtil::Format("table macro function \"%s\"", info.name);
+	}
+	case CatalogType::SECRET_ENTRY: {
+		return StringUtil::Format("secret \"%s\"", info.name);
+	}
+	case CatalogType::SECRET_TYPE_ENTRY: {
+		return StringUtil::Format("secret type \"%s\"", info.name);
+	}
+	case CatalogType::SECRET_FUNCTION_ENTRY: {
+		return StringUtil::Format("secret function \"%s\"", info.name);
+	}
+	default:
+		throw InternalException("CatalogType not handled in EntryToString (DependencyManager) for %s",
+		                        CatalogTypeToString(type));
+	};
+}
+
+string DependencyManager::CollectDependents(CatalogTransaction transaction, catalog_entry_set_t &entries,
+                                            CatalogEntryInfo &info) {
+	string result;
+	for (auto &entry : entries) {
+		D_ASSERT(!IsSystemEntry(entry.get()));
+		auto other_info = GetLookupProperties(entry);
+		result += StringUtil::Format("%s depends on %s.\n", EntryToString(other_info), EntryToString(info));
+		catalog_entry_set_t entry_dependents;
+		ScanDependents(transaction, other_info, [&](DependencyEntry &dep) {
+			auto child = LookupEntry(transaction, dep);
+			if (!child) {
+				return;
+			}
+			if (!CascadeDrop(false, dep.Dependent().flags)) {
+				entry_dependents.insert(*child);
+			}
+		});
+		if (!entry_dependents.empty()) {
+			result += CollectDependents(transaction, entry_dependents, other_info);
+		}
+	}
+	return result;
+}
+
 void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade) {
 	if (IsSystemEntry(object)) {
 		// Don't do anything for this
@@ -358,6 +442,8 @@ void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry
 	auto info = GetLookupProperties(object);
 	// Check if there are any entries that block the DROP because they still depend on the object
 	catalog_entry_set_t to_drop;
+
+	catalog_entry_set_t blocking_dependents;
 	ScanDependents(transaction, info, [&](DependencyEntry &dep) {
 		// It makes no sense to have a schema depend on anything
 		D_ASSERT(dep.EntryInfo().type != CatalogType::SCHEMA_ENTRY);
@@ -368,12 +454,19 @@ void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry
 
 		if (!CascadeDrop(cascade, dep.Dependent().flags)) {
 			// no cascade and there are objects that depend on this object: throw error
-			throw DependencyException("Cannot drop entry \"%s\" because there are entries that "
-			                          "depend on it. Use DROP...CASCADE to drop all dependents.",
-			                          object.name);
+			blocking_dependents.insert(*entry);
+		} else {
+			to_drop.insert(*entry);
 		}
-		to_drop.insert(*entry);
 	});
+	if (!blocking_dependents.empty()) {
+		string error_string =
+		    StringUtil::Format("Cannot drop entry \"%s\" because there are entries that depend on it.\n", object.name);
+		error_string += CollectDependents(transaction, blocking_dependents, info);
+		error_string += "Use DROP...CASCADE to drop all dependents.";
+		throw DependencyException(error_string);
+	}
+
 	ScanSubjects(transaction, info, [&](DependencyEntry &dep) {
 		auto flags = dep.Subject().flags;
 		if (flags.IsOwnership()) {
@@ -392,7 +485,8 @@ void DependencyManager::DropObject(CatalogTransaction transaction, CatalogEntry
 	}
 }
 
-void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj) {
+void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj,
+                                    AlterInfo &alter_info) {
 	if (IsSystemEntry(new_obj)) {
 		D_ASSERT(IsSystemEntry(old_obj));
 		// Don't do anything for this
@@ -408,9 +502,35 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 		// It makes no sense to have a schema depend on anything
 		D_ASSERT(dep.EntryInfo().type != CatalogType::SCHEMA_ENTRY);
 
-		throw DependencyException("Cannot alter entry \"%s\" because there are entries that "
-		                          "depend on it.",
-		                          old_obj.name);
+		bool disallow_alter = true;
+		switch (alter_info.type) {
+		case AlterType::ALTER_TABLE: {
+			auto &alter_table = alter_info.Cast<AlterTableInfo>();
+			switch (alter_table.alter_table_type) {
+			case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
+				// These alters are made as part of a CREATE or DROP table statement when a foreign key column is
+				// present either adding or removing a reference to the referenced primary key table
+				disallow_alter = false;
+				break;
+			}
+			default:
+				break;
+			}
+			break;
+		}
+		case AlterType::SET_COLUMN_COMMENT:
+		case AlterType::SET_COMMENT: {
+			disallow_alter = false;
+			break;
+		}
+		default:
+			break;
+		}
+		if (disallow_alter) {
+			throw DependencyException("Cannot alter entry \"%s\" because there are entries that "
+			                          "depend on it.",
+			                          old_obj.name);
+		}
 
 		auto dep_info = DependencyInfo::FromDependent(dep);
 		dep_info.subject.entry = new_info;
@@ -447,8 +567,8 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 void DependencyManager::Scan(
     ClientContext &context,
     const std::function<void(CatalogEntry &, CatalogEntry &, const DependencyDependentFlags &)> &callback) {
-	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	auto transaction = catalog.GetCatalogTransaction(context);
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 
 	// All the objects registered in the dependency manager
 	catalog_entry_set_t entries;

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

@@ -7,6 +7,7 @@
 #include "duckdb/catalog/default/default_schemas.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/transaction/duck_transaction_manager.hpp"
 #ifndef DISABLE_CORE_FUNCTIONS_EXTENSION
 #include "duckdb/core_functions/core_functions.hpp"
 #endif
@@ -129,10 +130,14 @@ optional_ptr<SchemaCatalogEntry> DuckCatalog::GetSchema(CatalogTransaction trans
 }
 
 DatabaseSize DuckCatalog::GetDatabaseSize(ClientContext &context) {
+	auto &transaction = DuckTransactionManager::Get(db);
+	auto lock = transaction.SharedCheckpointLock();
 	return db.GetStorageManager().GetDatabaseSize();
 }
 
 vector<MetadataBlockInfo> DuckCatalog::GetMetadataInfo(ClientContext &context) {
+	auto &transaction = DuckTransactionManager::Get(db);
+	auto lock = transaction.SharedCheckpointLock();
 	return db.GetStorageManager().GetMetadataInfo();
 }
 

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

@@ -23,11 +23,11 @@
 namespace duckdb_nanoarrow {
 
 void *ArrowMalloc(int64_t size) {
-	return malloc(size);
+	return malloc(size_t(size));
 }
 
 void *ArrowRealloc(void *ptr, int64_t size) {
-	return realloc(ptr, size);
+	return realloc(ptr, size_t(size));
 }
 
 void ArrowFree(void *ptr) {

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

@@ -78,7 +78,7 @@ int64_t ArrowMetadataSizeOf(const char *metadata) {
 
 	int64_t size = sizeof(int32_t);
 	while (ArrowMetadataReaderRead(&reader, &key, &value) == NANOARROW_OK) {
-		size += sizeof(int32_t) + key.n_bytes + sizeof(int32_t) + value.n_bytes;
+		size += sizeof(int32_t) + uint64_t(key.n_bytes) + sizeof(int32_t) + uint64_t(value.n_bytes);
 	}
 
 	return size;
@@ -89,7 +89,7 @@ ArrowErrorCode ArrowMetadataGetValue(const char *metadata, const char *key, cons
 	struct ArrowStringView target_key_view = {key, static_cast<int64_t>(strlen(key))};
 	value_out->data = default_value;
 	if (default_value != NULL) {
-		value_out->n_bytes = strlen(default_value);
+		value_out->n_bytes = int64_t(strlen(default_value));
 	} else {
 		value_out->n_bytes = 0;
 	}
@@ -101,7 +101,7 @@ ArrowErrorCode ArrowMetadataGetValue(const char *metadata, const char *key, cons
 
 	while (ArrowMetadataReaderRead(&reader, &key_view, &value) == NANOARROW_OK) {
 		int key_equal = target_key_view.n_bytes == key_view.n_bytes &&
-		                strncmp(target_key_view.data, key_view.data, key_view.n_bytes) == 0;
+		                strncmp(target_key_view.data, key_view.data, size_t(key_view.n_bytes)) == 0;
 		if (key_equal) {
 			value_out->data = value.data;
 			value_out->n_bytes = value.n_bytes;

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

@@ -318,7 +318,7 @@ ArrowErrorCode ArrowSchemaSetFormat(struct ArrowSchema *schema, const char *form
 
 	if (format != NULL) {
 		size_t format_size = strlen(format) + 1;
-		schema->format = (const char *)ArrowMalloc(format_size);
+		schema->format = (const char *)ArrowMalloc(int64_t(format_size));
 		if (schema->format == NULL) {
 			return ENOMEM;
 		}
@@ -338,7 +338,7 @@ ArrowErrorCode ArrowSchemaSetName(struct ArrowSchema *schema, const char *name)
 
 	if (name != NULL) {
 		size_t name_size = strlen(name) + 1;
-		schema->name = (const char *)ArrowMalloc(name_size);
+		schema->name = (const char *)ArrowMalloc(int64_t(name_size));
 		if (schema->name == NULL) {
 			return ENOMEM;
 		}
@@ -357,13 +357,13 @@ ArrowErrorCode ArrowSchemaSetMetadata(struct ArrowSchema *schema, const char *me
 	}
 
 	if (metadata != NULL) {
-		size_t metadata_size = ArrowMetadataSizeOf(metadata);
+		auto metadata_size = ArrowMetadataSizeOf(metadata);
 		schema->metadata = (const char *)ArrowMalloc(metadata_size);
 		if (schema->metadata == NULL) {
 			return ENOMEM;
 		}
 
-		memcpy((void *)schema->metadata, metadata, metadata_size);
+		memcpy((void *)schema->metadata, metadata, size_t(metadata_size));
 	} else {
 		schema->metadata = NULL;
 	}
@@ -377,7 +377,8 @@ ArrowErrorCode ArrowSchemaAllocateChildren(struct ArrowSchema *schema, int64_t n
 	}
 
 	if (n_children > 0) {
-		schema->children = (struct ArrowSchema **)ArrowMalloc(n_children * sizeof(struct ArrowSchema *));
+		schema->children =
+		    (struct ArrowSchema **)ArrowMalloc(int64_t(uint64_t(n_children) * sizeof(struct ArrowSchema *)));
 
 		if (schema->children == NULL) {
 			return ENOMEM;
@@ -385,7 +386,7 @@ ArrowErrorCode ArrowSchemaAllocateChildren(struct ArrowSchema *schema, int64_t n
 
 		schema->n_children = n_children;
 
-		memset(schema->children, 0, n_children * sizeof(struct ArrowSchema *));
+		memset(schema->children, 0, uint64_t(n_children) * sizeof(struct ArrowSchema *));
 
 		for (int64_t i = 0; i < n_children; i++) {
 			schema->children[i] = (struct ArrowSchema *)ArrowMalloc(sizeof(struct ArrowSchema));

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

@@ -173,7 +173,11 @@ data_ptr_t Allocator::DefaultAllocate(PrivateAllocatorData *private_data, idx_t
 #ifdef USE_JEMALLOC
 	return JemallocExtension::Allocate(private_data, size);
 #else
-	return data_ptr_cast(malloc(size));
+	auto default_allocate_result = malloc(size);
+	if (!default_allocate_result) {
+		throw std::bad_alloc();
+	}
+	return data_ptr_cast(default_allocate_result);
 #endif
 }
 
@@ -195,7 +199,7 @@ data_ptr_t Allocator::DefaultReallocate(PrivateAllocatorData *private_data, data
 }
 
 shared_ptr<Allocator> &Allocator::DefaultAllocatorReference() {
-	static shared_ptr<Allocator> DEFAULT_ALLOCATOR = make_shared<Allocator>();
+	static shared_ptr<Allocator> DEFAULT_ALLOCATOR = make_shared_ptr<Allocator>();
 	return DEFAULT_ALLOCATOR;
 }
 

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

@@ -6,6 +6,7 @@ namespace duckdb {
 void ArrowBoolData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
 	auto byte_count = (capacity + 7) / 8;
 	result.main_buffer.reserve(byte_count);
+	(void)AppendValidity; // silence a compiler warning about unused static function
 }
 
 void ArrowBoolData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {

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

@@ -35,7 +35,7 @@ void ArrowStructData::Finalize(ArrowAppendData &append_data, const LogicalType &
 	auto &child_types = StructType::GetChildTypes(type);
 	ArrowAppender::AddChildren(append_data, child_types.size());
 	result->children = append_data.child_pointers.data();
-	result->n_children = child_types.size();
+	result->n_children = NumericCast<int64_t>(child_types.size());
 	for (idx_t i = 0; i < child_types.size(); i++) {
 		auto &child_type = child_types[i].second;
 		append_data.child_arrays[i] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[i]));

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

@@ -14,6 +14,7 @@ void ArrowUnionData::Initialize(ArrowAppendData &result, const LogicalType &type
 		auto child_buffer = ArrowAppender::InitializeChild(child.second, capacity, result.options);
 		result.child_data.push_back(std::move(child_buffer));
 	}
+	(void)AppendValidity; // silence a compiler warning about unused static functiondep
 }
 
 void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
@@ -61,7 +62,7 @@ void ArrowUnionData::Finalize(ArrowAppendData &append_data, const LogicalType &t
 	auto &child_types = UnionType::CopyMemberTypes(type);
 	ArrowAppender::AddChildren(append_data, child_types.size());
 	result->children = append_data.child_pointers.data();
-	result->n_children = child_types.size();
+	result->n_children = NumericCast<int64_t>(child_types.size());
 	for (idx_t i = 0; i < child_types.size(); i++) {
 		auto &child_type = child_types[i].second;
 		append_data.child_arrays[i] = *ArrowAppender::FinalizeChild(child_type, std::move(append_data.child_data[i]));

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

@@ -70,8 +70,8 @@ ArrowArray *ArrowAppender::FinalizeChild(const LogicalType &type, unique_ptr<Arr
 	result->offset = 0;
 	result->dictionary = nullptr;
 	result->buffers = append_data.buffers.data();
-	result->null_count = append_data.null_count;
-	result->length = append_data.row_count;
+	result->null_count = NumericCast<int64_t>(append_data.null_count);
+	result->length = NumericCast<int64_t>(append_data.row_count);
 	result->buffers[0] = append_data.validity.data();
 
 	if (append_data.finalize) {
@@ -90,10 +90,10 @@ ArrowArray ArrowAppender::Finalize() {
 	ArrowArray result;
 	AddChildren(*root_holder, types.size());
 	result.children = root_holder->child_pointers.data();
-	result.n_children = types.size();
+	result.n_children = NumericCast<int64_t>(types.size());
 
 	// Configure root array
-	result.length = row_count;
+	result.length = NumericCast<int64_t>(row_count);
 	result.n_buffers = 1;
 	result.buffers = root_holder->buffers.data(); // there is no actual buffer there since we don't have NULLs
 	result.offset = 0;
@@ -138,13 +138,15 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::INTEGER:
 		InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
 		break;
+	case LogicalTypeId::TIME_TZ:
+		InitializeAppenderForType<ArrowScalarData<int64_t, dtime_tz_t, ArrowTimeTzConverter>>(append_data);
+		break;
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::BIGINT:
 		InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
 		break;

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

@@ -138,9 +138,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 	case LogicalTypeId::DATE:
 		child.format = "tdD";
 		break;
-#ifdef DUCKDB_WASM
 	case LogicalTypeId::TIME_TZ:
-#endif
 	case LogicalTypeId::TIME:
 		child.format = "ttu";
 		break;
@@ -206,7 +204,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 	case LogicalTypeId::STRUCT: {
 		child.format = "+s";
 		auto &child_types = StructType::GetChildTypes(type);
-		child.n_children = child_types.size();
+		child.n_children = NumericCast<int64_t>(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();
@@ -251,7 +249,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		std::string format = "+us:";
 
 		auto &child_types = UnionType::CopyMemberTypes(type);
-		child.n_children = child_types.size();
+		child.n_children = NumericCast<int64_t>(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();
@@ -323,7 +321,7 @@ void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vector<Logical
 		root_holder->children_ptrs[i] = &root_holder->children[i];
 	}
 	out_schema->children = root_holder->children_ptrs.data();
-	out_schema->n_children = column_count;
+	out_schema->n_children = NumericCast<int64_t>(column_count);
 
 	// Store the schema
 	out_schema->format = "+s"; // struct apparently

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

@@ -50,7 +50,7 @@ void ArrowArrayStreamWrapper::GetSchema(ArrowSchemaWrapper &schema) {
 }
 
 shared_ptr<ArrowArrayWrapper> ArrowArrayStreamWrapper::GetNextChunk() {
-	auto current_chunk = make_shared<ArrowArrayWrapper>();
+	auto current_chunk = make_shared_ptr<ArrowArrayWrapper>();
 	if (arrow_array_stream.get_next(&arrow_array_stream, &current_chunk->arrow_array)) { // LCOV_EXCL_START
 		throw InvalidInputException("arrow_scan: get_next failed(): %s", string(GetError()));
 	} // LCOV_EXCL_STOP