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

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

@@ -26,6 +26,9 @@ static unique_ptr<FunctionData> DuckDBDatabasesBind(ClientContext &context, Tabl
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("internal");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -66,7 +69,7 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 		// database_name, VARCHAR
 		output.SetValue(col++, count, attached.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(attached.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(attached.oid)));
 		bool is_internal = attached.IsSystem() || attached.IsTemporary();
 		bool is_readonly = attached.IsReadOnly();
 		// path, VARCHAR
@@ -80,6 +83,8 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 		output.SetValue(col++, count, db_path);
 		// comment, VARCHAR
 		output.SetValue(col++, count, Value(attached.comment));
+		// tags, MAP
+		output.SetValue(col++, count, Value::MAP(attached.tags));
 		// internal, BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(is_internal));
 		// type, VARCHAR

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

@@ -85,13 +85,13 @@ void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data
 		// classid, LogicalType::BIGINT
 		output.SetValue(0, count, Value::BIGINT(0));
 		// objid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(entry.object.oid));
+		output.SetValue(1, count, Value::BIGINT(NumericCast<int64_t>(entry.object.oid)));
 		// objsubid, LogicalType::INTEGER
 		output.SetValue(2, count, Value::INTEGER(0));
 		// refclassid, LogicalType::BIGINT
 		output.SetValue(3, count, Value::BIGINT(0));
 		// refobjid, LogicalType::BIGINT
-		output.SetValue(4, count, Value::BIGINT(entry.dependent.oid));
+		output.SetValue(4, count, Value::BIGINT(NumericCast<int64_t>(entry.dependent.oid)));
 		// refobjsubid, LogicalType::INTEGER
 		output.SetValue(5, count, Value::INTEGER(0));
 		// deptype, LogicalType::VARCHAR

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

@@ -8,6 +8,10 @@
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/extension_helper.hpp"
 
+#include "duckdb/common/serializer/buffered_file_reader.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+
 namespace duckdb {
 
 struct ExtensionInformation {
@@ -15,6 +19,8 @@ struct ExtensionInformation {
 	bool loaded = false;
 	bool installed = false;
 	string file_path;
+	ExtensionInstallMode install_mode;
+	string installed_from;
 	string description;
 	vector<Value> aliases;
 	string extension_version;
@@ -51,6 +57,12 @@ static unique_ptr<FunctionData> DuckDBExtensionsBind(ClientContext &context, Tab
 	names.emplace_back("extension_version");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("install_mode");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("installed_from");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	return nullptr;
 }
 
@@ -60,6 +72,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 	auto &fs = FileSystem::GetFileSystem(context);
 	auto &db = DatabaseInstance::GetDatabase(context);
 
+	// Firstly, we go over all Default Extensions: duckdb_extensions always prints those, installed/loaded or not
 	map<string, ExtensionInformation> installed_extensions;
 	auto extension_count = ExtensionHelper::DefaultExtensionCount();
 	auto alias_count = ExtensionHelper::ExtensionAliasCount();
@@ -70,6 +83,8 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		info.installed = extension.statically_loaded;
 		info.loaded = false;
 		info.file_path = extension.statically_loaded ? "(BUILT-IN)" : string();
+		info.install_mode =
+		    extension.statically_loaded ? ExtensionInstallMode::STATICALLY_LINKED : ExtensionInstallMode::UNKNOWN;
 		info.description = extension.description;
 		for (idx_t k = 0; k < alias_count; k++) {
 			auto alias = ExtensionHelper::GetExtensionAlias(k);
@@ -79,8 +94,9 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		}
 		installed_extensions[info.name] = std::move(info);
 	}
+
+	// Secondly we scan all installed extensions and their install info
 #ifndef WASM_LOADABLE_EXTENSIONS
-	// scan the install directory for installed extensions
 	auto ext_directory = ExtensionHelper::ExtensionDirectory(context);
 	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
 		if (!StringUtil::EndsWith(path, ".duckdb_extension")) {
@@ -88,34 +104,56 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		}
 		ExtensionInformation info;
 		info.name = fs.ExtractBaseName(path);
+		info.installed = true;
 		info.loaded = false;
 		info.file_path = fs.JoinPath(ext_directory, path);
+
+		// Check the info file for its installation source
+		auto info_file_path = fs.JoinPath(ext_directory, path + ".info");
+
+		// Read the info file
+		auto extension_install_info = ExtensionInstallInfo::TryReadInfoFile(fs, info_file_path, info.name);
+		info.install_mode = extension_install_info->mode;
+		info.extension_version = extension_install_info->version;
+		if (extension_install_info->mode == ExtensionInstallMode::REPOSITORY) {
+			info.installed_from = ExtensionRepository::GetRepository(extension_install_info->repository_url);
+		} else {
+			info.installed_from = extension_install_info->full_path;
+		}
+
 		auto entry = installed_extensions.find(info.name);
 		if (entry == installed_extensions.end()) {
 			installed_extensions[info.name] = std::move(info);
 		} else {
 			if (!entry->second.loaded) {
 				entry->second.file_path = info.file_path;
+				entry->second.install_mode = info.install_mode;
+				entry->second.installed_from = info.installed_from;
+				entry->second.install_mode = info.install_mode;
+				entry->second.extension_version = info.extension_version;
 			}
 			entry->second.installed = true;
 		}
 	});
 #endif
-	// now check the list of currently loaded extensions
+
+	// Finally, we check the list of currently loaded extensions
 	auto &loaded_extensions = db.LoadedExtensionsData();
 	for (auto &e : loaded_extensions) {
 		auto &ext_name = e.first;
 		auto &ext_info = e.second;
 		auto entry = installed_extensions.find(ext_name);
-		if (entry == installed_extensions.end()) {
+		if (entry == installed_extensions.end() || !entry->second.installed) {
 			ExtensionInformation info;
 			info.name = ext_name;
 			info.loaded = true;
-			info.extension_version = ext_info.extension_version;
+			info.extension_version = ext_info.version;
+			info.installed = ext_info.mode == ExtensionInstallMode::STATICALLY_LINKED;
+			info.install_mode = ext_info.mode;
 			installed_extensions[ext_name] = std::move(info);
 		} else {
 			entry->second.loaded = true;
-			entry->second.extension_version = ext_info.extension_version;
+			entry->second.extension_version = ext_info.version;
 		}
 	}
 
@@ -144,7 +182,7 @@ void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p
 		// loaded LogicalType::BOOLEAN
 		output.SetValue(1, count, Value::BOOLEAN(entry.loaded));
 		// installed LogicalType::BOOLEAN
-		output.SetValue(2, count, !entry.installed && entry.loaded ? Value() : Value::BOOLEAN(entry.installed));
+		output.SetValue(2, count, Value::BOOLEAN(entry.installed));
 		// install_path LogicalType::VARCHAR
 		output.SetValue(3, count, Value(entry.file_path));
 		// description LogicalType::VARCHAR
@@ -153,6 +191,10 @@ void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p
 		output.SetValue(5, count, Value::LIST(LogicalType::VARCHAR, entry.aliases));
 		// extension version     LogicalType::LIST(LogicalType::VARCHAR)
 		output.SetValue(6, count, Value(entry.extension_version));
+		// installed_mode LogicalType::VARCHAR
+		output.SetValue(7, count, entry.installed ? Value(EnumUtil::ToString(entry.install_mode)) : Value());
+		// installed_source LogicalType::VARCHAR
+		output.SetValue(8, count, Value(entry.installed_from));
 
 		data.offset++;
 		count++;

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

@@ -49,6 +49,9 @@ static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, Tabl
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("return_type");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -453,7 +456,7 @@ bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &ou
 	output.SetValue(col++, output_offset, Value(function.schema.catalog.GetName()));
 
 	// database_oid, BIGINT
-	output.SetValue(col++, output_offset, Value::BIGINT(function.schema.catalog.GetOid()));
+	output.SetValue(col++, output_offset, Value::BIGINT(NumericCast<int64_t>(function.schema.catalog.GetOid())));
 
 	// schema_name, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, Value(function.schema.name));
@@ -470,6 +473,9 @@ bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &ou
 	// comment, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, entry.comment);
 
+	// tags, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)
+	output.SetValue(col++, output_offset, Value::MAP(entry.tags));
+
 	// return_type, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, OP::GetReturnType(function, function_idx));
 
@@ -497,7 +503,7 @@ bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &ou
 	output.SetValue(col++, output_offset, Value::BOOLEAN(function.internal));
 
 	// function_oid, LogicalType::BIGINT
-	output.SetValue(col++, output_offset, Value::BIGINT(function.oid));
+	output.SetValue(col++, output_offset, Value::BIGINT(NumericCast<int64_t>(function.oid)));
 
 	// example, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, entry.example.empty() ? Value() : entry.example);

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

@@ -45,6 +45,9 @@ static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, TableF
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("is_unique");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -91,24 +94,26 @@ void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, D
 		// database_name, VARCHAR
 		output.SetValue(col++, count, index.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(index.catalog.GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(index.catalog.GetOid())));
 		// schema_name, VARCHAR
 		output.SetValue(col++, count, Value(index.schema.name));
 		// schema_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(index.schema.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(index.schema.oid)));
 		// index_name, VARCHAR
 		output.SetValue(col++, count, Value(index.name));
 		// index_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(index.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(index.oid)));
 		// find the table in the catalog
 		auto &table_entry =
 		    index.schema.catalog.GetEntry<TableCatalogEntry>(context, index.GetSchemaName(), index.GetTableName());
 		// table_name, VARCHAR
 		output.SetValue(col++, count, Value(table_entry.name));
 		// table_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table_entry.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table_entry.oid)));
 		// comment, VARCHAR
 		output.SetValue(col++, count, Value(index.comment));
+		// tags, MAP
+		output.SetValue(col++, count, Value::MAP(index.tags));
 		// is_unique, BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(index.IsUnique()));
 		// is_primary, BOOLEAN

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

@@ -48,9 +48,9 @@ void DuckDBMemoryFunction(ClientContext &context, TableFunctionInput &data_p, Da
 		// tag, VARCHAR
 		output.SetValue(col++, count, EnumUtil::ToString(entry.tag));
 		// memory_usage_bytes, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry.size));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.size)));
 		// temporary_storage_bytes, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry.evicted_data));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.evicted_data)));
 		count++;
 	}
 	output.SetCardinality(count);

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

@@ -33,6 +33,9 @@ static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, TableF
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("internal");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -66,15 +69,17 @@ void DuckDBSchemasFunction(ClientContext &context, TableFunctionInput &data_p, D
 		// return values:
 		idx_t col = 0;
 		// "oid", PhysicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.oid)));
 		// database_name, VARCHAR
 		output.SetValue(col++, count, entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry.catalog.GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.catalog.GetOid())));
 		// "schema_name", PhysicalType::VARCHAR
 		output.SetValue(col++, count, Value(entry.name));
 		// "comment", PhysicalType::VARCHAR
 		output.SetValue(col++, count, Value(entry.comment));
+		// "tags", MAP(VARCHAR, VARCHAR)
+		output.SetValue(col++, count, Value::MAP(entry.tags));
 		// "internal", PhysicalType::BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(entry.internal));
 		// "sql", PhysicalType::VARCHAR

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

@@ -41,6 +41,9 @@ static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, Tabl
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("temporary");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -98,17 +101,19 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p,
 		// database_name, VARCHAR
 		output.SetValue(col++, count, seq.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq.catalog.GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(seq.catalog.GetOid())));
 		// schema_name, VARCHAR
 		output.SetValue(col++, count, Value(seq.schema.name));
 		// schema_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq.schema.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(seq.schema.oid)));
 		// sequence_name, VARCHAR
 		output.SetValue(col++, count, Value(seq.name));
 		// sequence_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(seq.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(seq.oid)));
 		// comment, VARCHAR
 		output.SetValue(col++, count, Value(seq.comment));
+		// tags, MAP(VARCHAR, VARCHAR)
+		output.SetValue(col++, count, Value::MAP(seq.tags));
 		// temporary, BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(seq.temporary));
 		// start_value, BIGINT

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

@@ -44,6 +44,9 @@ static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, TableFu
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("internal");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -127,17 +130,19 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 		// database_name, VARCHAR
 		output.SetValue(col++, count, table.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.catalog.GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.catalog.GetOid())));
 		// schema_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(table.schema.name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.schema.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.schema.oid)));
 		// table_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(table.name));
 		// table_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.oid)));
 		// comment, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(table.comment));
+		// tags, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)
+		output.SetValue(col++, count, Value::MAP(table.tags));
 		// internal, LogicalType::BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(table.internal));
 		// temporary, LogicalType::BOOLEAN
@@ -145,18 +150,21 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 		// has_primary_key, LogicalType::BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(TableHasPrimaryKey(table)));
 		// estimated_size, LogicalType::BIGINT
-		Value card_val =
-		    !storage_info.cardinality.IsValid() ? Value() : Value::BIGINT(storage_info.cardinality.GetIndex());
+
+		Value card_val = !storage_info.cardinality.IsValid()
+		                     ? Value()
+		                     : Value::BIGINT(NumericCast<int64_t>(storage_info.cardinality.GetIndex()));
 		output.SetValue(col++, count, card_val);
 		// column_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.GetColumns().LogicalColumnCount()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.GetColumns().LogicalColumnCount())));
 		// index_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(storage_info.index_info.size()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(storage_info.index_info.size())));
 		// check_constraint_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(CheckConstraintCount(table)));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(CheckConstraintCount(table))));
 		// sql, LogicalType::VARCHAR
-		output.SetValue(col++, count, Value(table.ToSQL()));
-
+		auto table_info = table.GetInfo();
+		table_info->catalog.clear();
+		output.SetValue(col++, count, Value(table_info->ToString()));
 		count++;
 	}
 	output.SetCardinality(count);

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

@@ -45,7 +45,7 @@ void DuckDBTemporaryFilesFunction(ClientContext &context, TableFunctionInput &da
 		// database_name, VARCHAR
 		output.SetValue(col++, count, entry.path);
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(entry.size));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(entry.size)));
 		count++;
 	}
 	output.SetCardinality(count);

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

@@ -52,6 +52,9 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFun
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("internal");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -89,17 +92,17 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		// database_name, VARCHAR
 		output.SetValue(col++, count, type_entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(type_entry.catalog.GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(type_entry.catalog.GetOid())));
 		// schema_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(type_entry.schema.name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(type_entry.schema.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(type_entry.schema.oid)));
 		// type_oid, BIGINT
 		int64_t oid;
 		if (type_entry.internal) {
-			oid = int64_t(type.id());
+			oid = NumericCast<int64_t>(type.id());
 		} else {
-			oid = type_entry.oid;
+			oid = NumericCast<int64_t>(type_entry.oid);
 		}
 		Value oid_val;
 		if (data.oids.find(oid) == data.oids.end()) {
@@ -114,7 +117,9 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		// type_size, BIGINT
 		auto internal_type = type.InternalType();
 		output.SetValue(col++, count,
-		                internal_type == PhysicalType::INVALID ? Value() : Value::BIGINT(GetTypeIdSize(internal_type)));
+		                internal_type == PhysicalType::INVALID
+		                    ? Value()
+		                    : Value::BIGINT(NumericCast<int64_t>(GetTypeIdSize(internal_type))));
 		// logical_type, VARCHAR
 		output.SetValue(col++, count, Value(EnumUtil::ToString(type.id())));
 		// type_category, VARCHAR
@@ -165,6 +170,8 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		output.SetValue(col++, count, category.empty() ? Value() : Value(category));
 		// comment, VARCHAR
 		output.SetValue(col++, count, Value(type_entry.comment));
+		// tags, MAP
+		output.SetValue(col++, count, Value::MAP(type_entry.tags));
 		// internal, BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(type_entry.internal));
 		// labels, VARCHAR[]

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

@@ -40,6 +40,9 @@ static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, TableFun
 	names.emplace_back("comment");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("tags");
+	return_types.emplace_back(LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR));
+
 	names.emplace_back("internal");
 	return_types.emplace_back(LogicalType::BOOLEAN);
 
@@ -89,23 +92,25 @@ void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		// database_name, VARCHAR
 		output.SetValue(col++, count, view.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, count, Value::BIGINT(view.catalog.GetOid()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.catalog.GetOid())));
 		// schema_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(view.schema.name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(view.schema.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.schema.oid)));
 		// view_name, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(view.name));
 		// view_oid, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(view.oid));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.oid)));
 		// comment, LogicalType::VARCHARs
 		output.SetValue(col++, count, Value(view.comment));
+		// tags, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)
+		output.SetValue(col++, count, Value::MAP(view.tags));
 		// internal, LogicalType::BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(view.internal));
 		// temporary, LogicalType::BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(view.temporary));
 		// column_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(view.types.size()));
+		output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(view.types.size())));
 		// sql, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(view.ToSQL()));
 

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

@@ -0,0 +1,75 @@
+#include "duckdb/function/table/system_functions.hpp"
+
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/multi_file_reader.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/main/extension_helper.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
+
+namespace duckdb {
+
+struct DuckDBWhichSecretData : public GlobalTableFunctionState {
+	DuckDBWhichSecretData() : finished(false) {
+	}
+	bool finished;
+};
+
+struct DuckDBWhichSecretBindData : public TableFunctionData {
+	explicit DuckDBWhichSecretBindData(TableFunctionBindInput &tf_input) : inputs(tf_input.inputs) {};
+
+	duckdb::vector<duckdb::Value> inputs;
+};
+
+static unique_ptr<FunctionData> DuckDBWhichSecretBind(ClientContext &context, TableFunctionBindInput &input,
+                                                      vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("persistent");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("storage");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	return make_uniq<DuckDBWhichSecretBindData>(input);
+}
+
+unique_ptr<GlobalTableFunctionState> DuckDBWhichSecretInit(ClientContext &context, TableFunctionInitInput &input) {
+	return make_uniq<DuckDBWhichSecretData>();
+}
+
+void DuckDBWhichSecretFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = data_p.global_state->Cast<DuckDBWhichSecretData>();
+	if (data.finished) {
+		// finished returning values
+		return;
+	}
+	auto &bind_data = data_p.bind_data->Cast<DuckDBWhichSecretBindData>();
+
+	auto &secret_manager = SecretManager::Get(context);
+	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
+
+	auto &inputs = bind_data.inputs;
+	auto path = inputs[0].ToString();
+	auto type = inputs[1].ToString();
+	auto secret_match = secret_manager.LookupSecret(transaction, path, type);
+	if (secret_match.HasMatch()) {
+		auto &secret_entry = *secret_match.secret_entry;
+		output.SetCardinality(1);
+		output.SetValue(0, 0, secret_entry.secret->GetName());
+		output.SetValue(1, 0, EnumUtil::ToString(secret_entry.persist_type));
+		output.SetValue(2, 0, secret_entry.storage_mode);
+	}
+	data.finished = true;
+}
+
+void DuckDBWhichSecretFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(TableFunction("which_secret", {duckdb::LogicalType::VARCHAR, duckdb::LogicalType::VARCHAR},
+	                              DuckDBWhichSecretFunction, DuckDBWhichSecretBind, DuckDBWhichSecretInit));
+}
+
+} // namespace duckdb

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

@@ -76,10 +76,10 @@ void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data
 		idx_t col = 0;
 		output.data[col++].SetValue(row, Value(db.GetName()));
 		output.data[col++].SetValue(row, Value(StringUtil::BytesToHumanReadableString(ds.bytes)));
-		output.data[col++].SetValue(row, Value::BIGINT(ds.block_size));
-		output.data[col++].SetValue(row, Value::BIGINT(ds.total_blocks));
-		output.data[col++].SetValue(row, Value::BIGINT(ds.used_blocks));
-		output.data[col++].SetValue(row, Value::BIGINT(ds.free_blocks));
+		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.block_size)));
+		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.total_blocks)));
+		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.used_blocks)));
+		output.data[col++].SetValue(row, Value::BIGINT(NumericCast<int64_t>(ds.free_blocks)));
 		output.data[col++].SetValue(
 		    row, ds.wal_size == idx_t(-1) ? Value() : Value(StringUtil::BytesToHumanReadableString(ds.wal_size)));
 		output.data[col++].SetValue(row, data.memory_usage);

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

@@ -64,13 +64,13 @@ static void PragmaMetadataInfoFunction(ClientContext &context, TableFunctionInpu
 		// block_id
 		output.SetValue(col_idx++, count, Value::BIGINT(entry.block_id));
 		// total_blocks
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.total_blocks));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.total_blocks)));
 		// free_blocks
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.free_list.size()));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.free_list.size())));
 		// free_list
 		vector<Value> list_values;
 		for (auto &free_id : entry.free_list) {
-			list_values.push_back(Value::BIGINT(free_id));
+			list_values.push_back(Value::BIGINT(NumericCast<int64_t>(free_id)));
 		}
 		output.SetValue(col_idx++, count, Value::LIST(LogicalType::BIGINT, std::move(list_values)));
 		count++;

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

@@ -103,22 +103,22 @@ static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput
 
 		idx_t col_idx = 0;
 		// row_group_id
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.row_group_index));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.row_group_index)));
 		// column_name
 		auto &col = columns.GetColumn(PhysicalIndex(entry.column_id));
 		output.SetValue(col_idx++, count, Value(col.Name()));
 		// column_id
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.column_id));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.column_id)));
 		// column_path
 		output.SetValue(col_idx++, count, Value(entry.column_path));
 		// segment_id
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.segment_idx));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.segment_idx)));
 		// segment_type
 		output.SetValue(col_idx++, count, Value(entry.segment_type));
 		// start
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.segment_start));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.segment_start)));
 		// count
-		output.SetValue(col_idx++, count, Value::BIGINT(entry.segment_count));
+		output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.segment_count)));
 		// compression
 		output.SetValue(col_idx++, count, Value(entry.compression_type));
 		// stats
@@ -131,7 +131,7 @@ static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput
 		// block_offset
 		if (entry.persistent) {
 			output.SetValue(col_idx++, count, Value::BIGINT(entry.block_id));
-			output.SetValue(col_idx++, count, Value::BIGINT(entry.block_offset));
+			output.SetValue(col_idx++, count, Value::BIGINT(NumericCast<int64_t>(entry.block_offset)));
 		} else {
 			output.SetValue(col_idx++, count, Value());
 			output.SetValue(col_idx++, count, Value());