duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -36,6 +36,10 @@ static unique_ptr<GlobalTableFunctionState> CSVSniffInitGlobal(ClientContext &co
 static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFunctionBindInput &input,
                                              vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_uniq<CSVSniffFunctionData>();
+	auto &config = DBConfig::GetConfig(context);
+	if (!config.options.enable_external_access) {
+		throw PermissionException("sniff_csv is disabled through configuration");
+	}
 	result->path = input.inputs[0].ToString();
 	auto it = input.named_parameters.find("auto_detect");
 	if (it != input.named_parameters.end()) {
@@ -45,7 +49,7 @@ static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFuncti
 		// otherwise remove it
 		input.named_parameters.erase("auto_detect");
 	}
-	result->options.FromNamedParameters(input.named_parameters, context, result->return_types_csv, result->names_csv);
+	result->options.FromNamedParameters(input.named_parameters, context);
 	// We want to return the whole CSV Configuration
 	// 1. Delimiter
 	return_types.emplace_back(LogicalType::VARCHAR);
@@ -59,27 +63,30 @@ static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFuncti
 	// 4. NewLine Delimiter
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("NewLineDelimiter");
-	// 5. Skip Rows
+	// 5. Comment
+	return_types.emplace_back(LogicalType::VARCHAR);
+	names.emplace_back("Comment");
+	// 6. Skip Rows
 	return_types.emplace_back(LogicalType::UINTEGER);
 	names.emplace_back("SkipRows");
-	// 6. Has Header
+	// 7. Has Header
 	return_types.emplace_back(LogicalType::BOOLEAN);
 	names.emplace_back("HasHeader");
-	// 7. List<Struct<Column-Name:Types>>
+	// 8. List<Struct<Column-Name:Types>>
 	child_list_t<LogicalType> struct_children {{"name", LogicalType::VARCHAR}, {"type", LogicalType::VARCHAR}};
 	auto list_child = LogicalType::STRUCT(struct_children);
 	return_types.emplace_back(LogicalType::LIST(list_child));
 	names.emplace_back("Columns");
-	// 8. Date Format
+	// 9. Date Format
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("DateFormat");
-	// 9. Timestamp Format
+	// 10. Timestamp Format
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("TimestampFormat");
-	// 10. CSV read function with all the options used
+	// 11. CSV read function with all the options used
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("UserArguments");
-	// 11. CSV read function with all the options used
+	// 12. CSV read function with all the options used
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("Prompt");
 	return std::move(result);
@@ -103,18 +110,20 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	const CSVSniffFunctionData &data = data_p.bind_data->Cast<CSVSniffFunctionData>();
 	auto &fs = duckdb::FileSystem::GetFileSystem(context);
 
-	if (data.path.rfind("http://", 0) != 0 && data.path.rfind("https://", 0) != 0 && fs.HasGlob(data.path)) {
-		throw NotImplementedException("sniff_csv does not operate on globs yet");
+	auto paths = fs.GlobFiles(data.path, context, FileGlobOptions::DISALLOW_EMPTY);
+	if (paths.size() > 1) {
+		throw NotImplementedException("sniff_csv does not operate on more than one file yet");
 	}
 
 	// We must run the sniffer.
 	auto sniffer_options = data.options;
-	sniffer_options.file_path = data.path;
+	sniffer_options.file_path = paths[0];
 
 	auto buffer_manager = make_shared_ptr<CSVBufferManager>(context, sniffer_options, sniffer_options.file_path, 0);
 	if (sniffer_options.name_list.empty()) {
 		sniffer_options.name_list = data.names_csv;
 	}
+
 	if (sniffer_options.sql_type_list.empty()) {
 		sniffer_options.sql_type_list = data.return_types_csv;
 	}
@@ -137,12 +146,15 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	// 4. NewLine Delimiter
 	auto new_line_identifier = sniffer_options.NewLineIdentifierToString();
 	output.SetValue(3, 0, new_line_identifier);
-	// 5. Skip Rows
-	output.SetValue(4, 0, Value::UINTEGER(NumericCast<uint32_t>(sniffer_options.dialect_options.skip_rows.GetValue())));
-	// 6. Has Header
+	// 5. Comment
+	str_opt = sniffer_options.dialect_options.state_machine_options.comment.GetValue();
+	output.SetValue(4, 0, str_opt);
+	// 6. Skip Rows
+	output.SetValue(5, 0, Value::UINTEGER(NumericCast<uint32_t>(sniffer_options.dialect_options.skip_rows.GetValue())));
+	// 7. Has Header
 	auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue()).ToString();
-	output.SetValue(5, 0, has_header);
-	// 7. List<Struct<Column-Name:Types>> {'col1': 'INTEGER', 'col2': 'VARCHAR'}
+	output.SetValue(6, 0, has_header);
+	// 8. List<Struct<Column-Name:Types>> {'col1': 'INTEGER', 'col2': 'VARCHAR'}
 	vector<Value> values;
 	std::ostringstream columns;
 	columns << "{";
@@ -156,45 +168,45 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 		}
 	}
 	columns << "}";
-	output.SetValue(6, 0, Value::LIST(values));
-	// 8. Date Format
+	output.SetValue(7, 0, Value::LIST(values));
+	// 9. Date Format
 	auto date_format = sniffer_options.dialect_options.date_format[LogicalType::DATE].GetValue();
 	if (!date_format.Empty()) {
-		output.SetValue(7, 0, date_format.format_specifier);
+		output.SetValue(8, 0, date_format.format_specifier);
 	} else {
 		bool has_date = false;
 		for (auto &c_type : sniffer_result.return_types) {
 			// Must be ISO 8601
 			if (c_type.id() == LogicalTypeId::DATE) {
-				output.SetValue(7, 0, Value("%Y-%m-%d"));
+				output.SetValue(8, 0, Value("%Y-%m-%d"));
 				has_date = true;
 			}
 		}
 		if (!has_date) {
-			output.SetValue(7, 0, Value(nullptr));
+			output.SetValue(8, 0, Value(nullptr));
 		}
 	}
 
-	// 9. Timestamp Format
+	// 10. Timestamp Format
 	auto timestamp_format = sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue();
 	if (!timestamp_format.Empty()) {
-		output.SetValue(8, 0, timestamp_format.format_specifier);
+		output.SetValue(9, 0, timestamp_format.format_specifier);
 	} else {
-		output.SetValue(8, 0, Value(nullptr));
+		output.SetValue(9, 0, Value(nullptr));
 	}
 
-	// 10. The Extra User Arguments
+	// 11. The Extra User Arguments
 	if (data.options.user_defined_parameters.empty()) {
-		output.SetValue(9, 0, Value());
+		output.SetValue(10, 0, Value());
 	} else {
-		output.SetValue(9, 0, Value(data.options.user_defined_parameters));
+		output.SetValue(10, 0, Value(data.options.user_defined_parameters));
 	}
 
-	// 11. csv_read string
+	// 12. csv_read string
 	std::ostringstream csv_read;
 
 	// Base, Path and auto_detect=false
-	csv_read << "FROM read_csv('" << data.path << "'" << separator << "auto_detect=false" << separator;
+	csv_read << "FROM read_csv('" << paths[0] << "'" << separator << "auto_detect=false" << separator;
 	// 10.1. Delimiter
 	if (!sniffer_options.dialect_options.state_machine_options.delimiter.IsSetByUser()) {
 		csv_read << "delim="
@@ -224,13 +236,21 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	if (!sniffer_options.dialect_options.skip_rows.IsSetByUser()) {
 		csv_read << "skip=" << sniffer_options.dialect_options.skip_rows.GetValue() << separator;
 	}
-	// 11.6. Has Header
+
+	// 11.6. Comment
+	if (!sniffer_options.dialect_options.state_machine_options.comment.IsSetByUser()) {
+		csv_read << "comment="
+		         << "'" << FormatOptions(sniffer_options.dialect_options.state_machine_options.comment.GetValue())
+		         << "'" << separator;
+	}
+
+	// 11.7. Has Header
 	if (!sniffer_options.dialect_options.header.IsSetByUser()) {
 		csv_read << "header=" << has_header << separator;
 	}
-	// 11.7. column={'col1': 'INTEGER', 'col2': 'VARCHAR'}
+	// 11.8. column={'col1': 'INTEGER', 'col2': 'VARCHAR'}
 	csv_read << "columns=" << columns.str();
-	// 11.8. Date Format
+	// 11.9. Date Format
 	if (!sniffer_options.dialect_options.date_format[LogicalType::DATE].IsSetByUser()) {
 		if (!sniffer_options.dialect_options.date_format[LogicalType::DATE].GetValue().format_specifier.empty()) {
 			csv_read << separator << "dateformat="
@@ -248,7 +268,7 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 			}
 		}
 	}
-	// 11.9. Timestamp Format
+	// 11.10. Timestamp Format
 	if (!sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].IsSetByUser()) {
 		if (!sniffer_options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue().format_specifier.empty()) {
 			csv_read << separator << "timestampformat="
@@ -257,12 +277,12 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 			         << "'";
 		}
 	}
-	// 11.10 User Arguments
+	// 11.11 User Arguments
 	if (!data.options.user_defined_parameters.empty()) {
 		csv_read << separator << data.options.user_defined_parameters;
 	}
 	csv_read << ");";
-	output.SetValue(10, 0, csv_read.str());
+	output.SetValue(11, 0, csv_read.str());
 	global_state.done = true;
 }
 

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

@@ -1,52 +1,19 @@
-#include "duckdb/function/table/system_functions.hpp"
-
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/parser/constraint.hpp"
 #include "duckdb/parser/constraints/check_constraint.hpp"
+#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
+#include "duckdb/parser/constraints/not_null_constraint.hpp"
 #include "duckdb/parser/constraints/unique_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-#include "duckdb/planner/constraints/bound_check_constraint.hpp"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/planner/binder.hpp"
-
-namespace duckdb {
-
-struct UniqueKeyInfo {
-	string schema;
-	string table;
-	vector<LogicalIndex> columns;
-
-	bool operator==(const UniqueKeyInfo &other) const {
-		return (schema == other.schema) && (table == other.table) && (columns == other.columns);
-	}
-};
-
-} // namespace duckdb
-
-namespace std {
-
-template <>
-struct hash<duckdb::UniqueKeyInfo> {
-	template <class X>
-	static size_t ComputeHash(const X &x) {
-		return hash<X>()(x);
-	}
-
-	size_t operator()(const duckdb::UniqueKeyInfo &j) const {
-		D_ASSERT(j.columns.size() > 0);
-		return ComputeHash(j.schema) + ComputeHash(j.table) + ComputeHash(j.columns[0].index);
-	}
-};
-
-} // namespace std
+#include "duckdb/planner/constraints/bound_check_constraint.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 namespace duckdb {
 
@@ -71,7 +38,7 @@ struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	idx_t offset;
 	idx_t constraint_offset;
 	idx_t unique_constraint_offset;
-	unordered_map<UniqueKeyInfo, idx_t> known_fk_unique_constraint_offsets;
+	case_insensitive_set_t constraint_names;
 };
 
 static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, TableFunctionBindInput &input,
@@ -113,6 +80,16 @@ static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, Ta
 	names.emplace_back("constraint_column_names");
 	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
 
+	names.emplace_back("constraint_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	// FOREIGN KEY
+	names.emplace_back("referenced_table");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("referenced_column_names");
+	return_types.push_back(LogicalType::LIST(LogicalType::VARCHAR));
+
 	return nullptr;
 }
 
@@ -140,6 +117,97 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 	return std::move(result);
 }
 
+struct ExtraConstraintInfo {
+	vector<LogicalIndex> column_indexes;
+	vector<string> column_names;
+	string referenced_table;
+	vector<string> referenced_columns;
+};
+
+void ExtractReferencedColumns(const ParsedExpression &expr, vector<string> &result) {
+	if (expr.GetExpressionClass() == ExpressionClass::COLUMN_REF) {
+		auto &colref = expr.Cast<ColumnRefExpression>();
+		result.push_back(colref.GetColumnName());
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](const ParsedExpression &child) { ExtractReferencedColumns(child, result); });
+}
+
+ExtraConstraintInfo GetExtraConstraintInfo(const TableCatalogEntry &table, const Constraint &constraint) {
+	ExtraConstraintInfo result;
+	switch (constraint.type) {
+	case ConstraintType::CHECK: {
+		auto &check_constraint = constraint.Cast<CheckConstraint>();
+		ExtractReferencedColumns(*check_constraint.expression, result.column_names);
+		break;
+	}
+	case ConstraintType::NOT_NULL: {
+		auto &not_null_constraint = constraint.Cast<NotNullConstraint>();
+		result.column_indexes.push_back(not_null_constraint.index);
+		break;
+	}
+	case ConstraintType::UNIQUE: {
+		auto &unique = constraint.Cast<UniqueConstraint>();
+		if (unique.HasIndex()) {
+			result.column_indexes.push_back(unique.GetIndex());
+		} else {
+			result.column_names = unique.GetColumnNames();
+		}
+		break;
+	}
+	case ConstraintType::FOREIGN_KEY: {
+		auto &fk = constraint.Cast<ForeignKeyConstraint>();
+		result.referenced_columns = fk.pk_columns;
+		result.referenced_table = fk.info.table;
+		result.column_names = fk.fk_columns;
+		break;
+	}
+	default:
+		throw InternalException("Unsupported type for constraint name");
+	}
+	if (result.column_indexes.empty()) {
+		// generate column indexes from names
+		for (auto &name : result.column_names) {
+			result.column_indexes.push_back(table.GetColumnIndex(name));
+		}
+	} else {
+		// generate names from column indexes
+		for (auto &index : result.column_indexes) {
+			result.column_names.push_back(table.GetColumn(index).GetName());
+		}
+	}
+	return result;
+}
+
+string GetConstraintName(const TableCatalogEntry &table, Constraint &constraint, const ExtraConstraintInfo &info) {
+	string result = table.name + "_";
+	for (auto &col : info.column_names) {
+		result += StringUtil::Lower(col) + "_";
+	}
+	for (auto &col : info.referenced_columns) {
+		result += StringUtil::Lower(col) + "_";
+	}
+	switch (constraint.type) {
+	case ConstraintType::CHECK:
+		result += "check";
+		break;
+	case ConstraintType::NOT_NULL:
+		result += "not_null";
+		break;
+	case ConstraintType::UNIQUE: {
+		auto &unique = constraint.Cast<UniqueConstraint>();
+		result += unique.IsPrimaryKey() ? "pkey" : "key";
+		break;
+	}
+	case ConstraintType::FOREIGN_KEY:
+		result += "fkey";
+		break;
+	default:
+		throw InternalException("Unsupported type for constraint name");
+	}
+	return result;
+}
+
 void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &data = data_p.global_state->Cast<DuckDBConstraintsData>();
 	if (data.offset >= data.entries.size()) {
@@ -154,7 +222,6 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 
 		auto &table = entry.table;
 		auto &constraints = table.GetConstraints();
-		bool is_duck_table = table.IsDuckTable();
 		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {
 			auto &constraint = constraints[data.constraint_offset];
 			// return values:
@@ -174,12 +241,8 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				constraint_type = "NOT NULL";
 				break;
 			case ConstraintType::FOREIGN_KEY: {
-				if (!is_duck_table) {
-					continue;
-				}
-				auto &bound_constraints = entry.bound_constraints;
-				auto &bound_foreign_key = bound_constraints[data.constraint_offset]->Cast<BoundForeignKeyConstraint>();
-				if (bound_foreign_key.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
+				auto &fk = constraint->Cast<ForeignKeyConstraint>();
+				if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
 					// Those are already covered by PRIMARY KEY and UNIQUE entries
 					continue;
 				}
@@ -204,52 +267,21 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			// table_oid, LogicalType::BIGINT
 			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.oid)));
 
-			// constraint_index, BIGINT
-			UniqueKeyInfo uk_info;
-
-			if (is_duck_table) {
-				auto &bound_constraint = *entry.bound_constraints[data.constraint_offset];
-				switch (bound_constraint.type) {
-				case ConstraintType::UNIQUE: {
-					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
-					uk_info = {table.schema.name, table.name, bound_unique.keys};
-					break;
-				}
-				case ConstraintType::FOREIGN_KEY: {
-					const auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
-					const auto &info = bound_foreign_key.info;
-					// find the other table
-					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(
-					    context, table.catalog.GetName(), info.schema, info.table, OnEntryNotFound::RETURN_NULL);
-					if (!table_entry) {
-						throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
-						                        info.schema, info.table);
-					}
-					vector<LogicalIndex> index;
-					for (auto &key : info.pk_keys) {
-						index.push_back(table_entry->GetColumns().PhysicalToLogical(key));
-					}
-					uk_info = {table_entry->schema.name, table_entry->name, index};
-					break;
-				}
-				default:
-					break;
+			auto info = GetExtraConstraintInfo(table, *constraint);
+			auto constraint_name = GetConstraintName(table, *constraint, info);
+			if (data.constraint_names.find(constraint_name) != data.constraint_names.end()) {
+				// duplicate constraint name
+				idx_t index = 2;
+				while (data.constraint_names.find(constraint_name + "_" + to_string(index)) !=
+				       data.constraint_names.end()) {
+					index++;
 				}
+				constraint_name += "_" + to_string(index);
 			}
+			// constraint_index, BIGINT
+			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(data.unique_constraint_offset++)));
 
-			if (uk_info.columns.empty()) {
-				output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(data.unique_constraint_offset++)));
-			} else {
-				auto known_unique_constraint_offset = data.known_fk_unique_constraint_offsets.find(uk_info);
-				if (known_unique_constraint_offset == data.known_fk_unique_constraint_offsets.end()) {
-					data.known_fk_unique_constraint_offsets.insert(make_pair(uk_info, data.unique_constraint_offset));
-					output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(data.unique_constraint_offset)));
-					data.unique_constraint_offset++;
-				} else {
-					output.SetValue(col++, count,
-					                Value::BIGINT(NumericCast<int64_t>(known_unique_constraint_offset->second)));
-				}
-			}
+			// constraint_type, VARCHAR
 			output.SetValue(col++, count, Value(constraint_type));
 
 			// constraint_text, VARCHAR
@@ -263,54 +295,34 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			}
 			output.SetValue(col++, count, expression_text);
 
-			vector<LogicalIndex> column_index_list;
-			if (is_duck_table) {
-				auto &bound_constraint = *entry.bound_constraints[data.constraint_offset];
-				switch (bound_constraint.type) {
-				case ConstraintType::CHECK: {
-					auto &bound_check = bound_constraint.Cast<BoundCheckConstraint>();
-					for (auto &col_idx : bound_check.bound_columns) {
-						column_index_list.push_back(table.GetColumns().PhysicalToLogical(col_idx));
-					}
-					break;
-				}
-				case ConstraintType::UNIQUE: {
-					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
-					for (auto &col_idx : bound_unique.keys) {
-						column_index_list.push_back(col_idx);
-					}
-					break;
-				}
-				case ConstraintType::NOT_NULL: {
-					auto &bound_not_null = bound_constraint.Cast<BoundNotNullConstraint>();
-					column_index_list.push_back(table.GetColumns().PhysicalToLogical(bound_not_null.index));
-					break;
-				}
-				case ConstraintType::FOREIGN_KEY: {
-					auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
-					for (auto &col_idx : bound_foreign_key.info.fk_keys) {
-						column_index_list.push_back(table.GetColumns().PhysicalToLogical(col_idx));
-					}
-					break;
-				}
-				default:
-					throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
-				}
-			}
-
-			vector<Value> index_list;
+			vector<Value> column_index_list;
 			vector<Value> column_name_list;
-			for (auto column_index : column_index_list) {
-				index_list.push_back(Value::BIGINT(NumericCast<int64_t>(column_index.index)));
-				column_name_list.emplace_back(table.GetColumn(column_index).Name());
+			vector<Value> referenced_column_name_list;
+			for (auto &col_index : info.column_indexes) {
+				column_index_list.push_back(Value::UBIGINT(col_index.index));
+			}
+			for (auto &name : info.column_names) {
+				column_name_list.push_back(Value(std::move(name)));
+			}
+			for (auto &name : info.referenced_columns) {
+				referenced_column_name_list.push_back(Value(std::move(name)));
 			}
 
 			// constraint_column_indexes, LIST
-			output.SetValue(col++, count, Value::LIST(LogicalType::BIGINT, std::move(index_list)));
+			output.SetValue(col++, count, Value::LIST(LogicalType::BIGINT, std::move(column_index_list)));
 
 			// constraint_column_names, LIST
 			output.SetValue(col++, count, Value::LIST(LogicalType::VARCHAR, std::move(column_name_list)));
 
+			// constraint_name, VARCHAR
+			output.SetValue(col++, count, Value(std::move(constraint_name)));
+
+			// referenced_table, VARCHAR
+			output.SetValue(col++, count,
+			                info.referenced_table.empty() ? Value() : Value(std::move(info.referenced_table)));
+
+			// referenced_column_names, LIST
+			output.SetValue(col++, count, Value::LIST(LogicalType::VARCHAR, std::move(referenced_column_name_list)));
 			count++;
 		}
 		if (data.constraint_offset >= constraints.size()) {

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

@@ -138,21 +138,32 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 #endif
 
 	// Finally, we check the list of currently loaded extensions
-	auto &loaded_extensions = db.LoadedExtensionsData();
-	for (auto &e : loaded_extensions) {
+	auto &extensions = db.GetExtensions();
+	for (auto &e : extensions) {
+		if (!e.second.is_loaded) {
+			continue;
+		}
 		auto &ext_name = e.first;
-		auto &ext_info = e.second;
-		auto entry = installed_extensions.find(ext_name);
-		if (entry == installed_extensions.end() || !entry->second.installed) {
-			ExtensionInformation &info = installed_extensions[ext_name];
-			info.name = ext_name;
-			info.loaded = true;
-			info.extension_version = ext_info.version;
-			info.installed = ext_info.mode == ExtensionInstallMode::STATICALLY_LINKED;
-			info.install_mode = ext_info.mode;
-		} else {
-			entry->second.loaded = true;
-			entry->second.extension_version = ext_info.version;
+		auto &ext_data = e.second;
+		if (auto &ext_install_info = ext_data.install_info) {
+			auto entry = installed_extensions.find(ext_name);
+			if (entry == installed_extensions.end() || !entry->second.installed) {
+				ExtensionInformation &info = installed_extensions[ext_name];
+				info.name = ext_name;
+				info.loaded = true;
+				info.extension_version = ext_install_info->version;
+				info.installed = ext_install_info->mode == ExtensionInstallMode::STATICALLY_LINKED;
+				info.install_mode = ext_install_info->mode;
+			} else {
+				entry->second.loaded = true;
+				entry->second.extension_version = ext_install_info->version;
+			}
+		}
+		if (auto &ext_load_info = ext_data.load_info) {
+			auto entry = installed_extensions.find(ext_name);
+			if (entry != installed_extensions.end()) {
+				entry->second.description = ext_load_info->description;
+			}
 		}
 	}