duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -9,6 +9,7 @@
 #include "duckdb/parser/constraint.hpp"
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 
 namespace duckdb {
 
@@ -75,11 +76,11 @@ unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, Ta
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	};
-	return move(result);
+	return std::move(result);
 }
 
 static bool TableHasPrimaryKey(TableCatalogEntry &table) {
-	for (auto &constraint : table.constraints) {
+	for (auto &constraint : table.GetConstraints()) {
 		if (constraint->type == ConstraintType::UNIQUE) {
 			auto &unique = (UniqueConstraint &)*constraint;
 			if (unique.is_primary_key) {
@@ -92,7 +93,7 @@ static bool TableHasPrimaryKey(TableCatalogEntry &table) {
 
 static idx_t CheckConstraintCount(TableCatalogEntry &table) {
 	idx_t check_count = 0;
-	for (auto &constraint : table.constraints) {
+	for (auto &constraint : table.GetConstraints()) {
 		if (constraint->type == ConstraintType::CHECK) {
 			check_count++;
 		}
@@ -116,6 +117,7 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 			continue;
 		}
 		auto &table = (TableCatalogEntry &)*entry;
+		auto storage_info = table.GetStorageInfo(context);
 		// return values:
 		idx_t col = 0;
 		// database_name, VARCHAR
@@ -137,11 +139,13 @@ 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
-		output.SetValue(col++, count, Value::BIGINT(table.storage->info->cardinality.load()));
+		Value card_val =
+		    storage_info.cardinality == DConstants::INVALID_INDEX ? Value() : Value::BIGINT(storage_info.cardinality);
+		output.SetValue(col++, count, card_val);
 		// column_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.columns.LogicalColumnCount()));
+		output.SetValue(col++, count, Value::BIGINT(table.GetColumns().LogicalColumnCount()));
 		// index_count, LogicalType::BIGINT
-		output.SetValue(col++, count, Value::BIGINT(table.storage->info->indexes.Count()));
+		output.SetValue(col++, count, Value::BIGINT(storage_info.index_info.size()));
 		// check_constraint_count, LogicalType::BIGINT
 		output.SetValue(col++, count, Value::BIGINT(CheckConstraintCount(table)));
 		// sql, LogicalType::VARCHAR

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

@@ -64,7 +64,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, Tab
 		schema->Scan(context, CatalogType::TYPE_ENTRY,
 		             [&](CatalogEntry *entry) { result->entries.push_back((TypeCatalogEntry *)entry); });
 	};
-	return move(result);
+	return std::move(result);
 }
 
 void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

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

@@ -55,12 +55,12 @@ static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, TableFun
 unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBViewsData>();
 
-	// scan all the schemas for tables and collect themand collect them
+	// scan all the schemas for tables and collect them and collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::VIEW_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	};
-	return move(result);
+	return std::move(result);
 }
 
 void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

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

@@ -31,7 +31,7 @@ unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, T
 		schema->Scan(context, CatalogType::COLLATION_ENTRY,
 		             [&](CatalogEntry *entry) { result->entries.push_back(entry->name); });
 	}
-	return move(result);
+	return std::move(result);
 }
 
 static void PragmaCollateFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

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

@@ -61,7 +61,7 @@ unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &conte
 	result->memory_limit =
 	    max_memory == (idx_t)-1 ? Value("Unlimited") : Value(StringUtil::BytesToHumanReadableString(max_memory));
 
-	return move(result);
+	return std::move(result);
 }
 
 void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
@@ -72,8 +72,7 @@ void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data
 		if (db->IsSystem() || db->IsTemporary()) {
 			continue;
 		}
-		auto &storage = db->GetStorageManager();
-		auto ds = storage.GetDatabaseSize();
+		auto ds = db->GetCatalog().GetDatabaseSize(context);
 		idx_t col = 0;
 		output.data[col++].SetValue(row, Value(db->GetName()));
 		output.data[col++].SetValue(row, Value(StringUtil::BytesToHumanReadableString(ds.bytes)));
@@ -81,7 +80,8 @@ void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data
 		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(StringUtil::BytesToHumanReadableString(ds.wal_size)));
+		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);
 		output.data[col++].SetValue(row, data.memory_limit);
 		row++;

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

@@ -10,6 +10,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 
 #include <algorithm>
 
@@ -20,7 +21,7 @@ struct PragmaStorageFunctionData : public TableFunctionData {
 	}
 
 	TableCatalogEntry *table_entry;
-	vector<vector<Value>> storage_info;
+	TableStorageInfo storage_info;
 };
 
 struct PragmaStorageOperatorData : public GlobalTableFunctionState {
@@ -79,8 +80,8 @@ static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, Ta
 	// look up the table name in the catalog
 	auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
 	auto result = make_unique<PragmaStorageFunctionData>(table_entry);
-	result->storage_info = table_entry->storage->GetStorageInfo();
-	return move(result);
+	result->storage_info = table_entry->GetStorageInfo(context);
+	return std::move(result);
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaStorageInfoInit(ClientContext &context, TableFunctionInitInput &input) {
@@ -91,23 +92,45 @@ static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput
 	auto &bind_data = (PragmaStorageFunctionData &)*data_p.bind_data;
 	auto &data = (PragmaStorageOperatorData &)*data_p.global_state;
 	idx_t count = 0;
-	auto &columns = bind_data.table_entry->columns;
-	while (data.offset < bind_data.storage_info.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = bind_data.storage_info[data.offset++];
-		D_ASSERT(entry.size() + 1 == output.ColumnCount());
-		idx_t result_idx = 0;
-		for (idx_t col_idx = 0; col_idx < entry.size(); col_idx++, result_idx++) {
-			if (col_idx == 1) {
-				// write the column name
-				auto storage_column_index = entry[col_idx].GetValue<int64_t>();
-				auto &col = columns.GetColumn(PhysicalIndex(storage_column_index));
-
-				output.SetValue(result_idx, count, Value(col.Name()));
-				result_idx++;
-			}
-			output.SetValue(result_idx, count, entry[col_idx]);
+	auto &columns = bind_data.table_entry->GetColumns();
+	while (data.offset < bind_data.storage_info.column_segments.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = bind_data.storage_info.column_segments[data.offset++];
+
+		idx_t col_idx = 0;
+		// row_group_id
+		output.SetValue(col_idx++, count, Value::BIGINT(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));
+		// column_path
+		output.SetValue(col_idx++, count, Value(entry.column_path));
+		// segment_id
+		output.SetValue(col_idx++, count, Value::BIGINT(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));
+		// count
+		output.SetValue(col_idx++, count, Value::BIGINT(entry.segment_count));
+		// compression
+		output.SetValue(col_idx++, count, Value(entry.compression_type));
+		// stats
+		output.SetValue(col_idx++, count, Value(entry.segment_stats));
+		// has_updates
+		output.SetValue(col_idx++, count, Value::BOOLEAN(entry.has_updates));
+		// persistent
+		output.SetValue(col_idx++, count, Value::BOOLEAN(entry.persistent));
+		// block_id
+		// 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));
+		} else {
+			output.SetValue(col_idx++, count, Value());
+			output.SetValue(col_idx++, count, Value());
 		}
-
 		count++;
 	}
 	output.SetCardinality(count);

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

@@ -4,8 +4,8 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
+#include "duckdb/parser/constraints/not_null_constraint.hpp"
+#include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/binder.hpp"
 
@@ -68,19 +68,25 @@ static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &c
 	out_pk = false;
 	// check all constraints
 	// FIXME: this is pretty inefficient, it probably doesn't matter
-	for (auto &constraint : table->bound_constraints) {
+	for (auto &constraint : table->GetConstraints()) {
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = (BoundNotNullConstraint &)*constraint;
-			if (not_null.index == column.Physical()) {
+			auto &not_null = (NotNullConstraint &)*constraint;
+			if (not_null.index == column.Logical()) {
 				out_not_null = true;
 			}
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &unique = (BoundUniqueConstraint &)*constraint;
-			if (unique.is_primary_key && unique.key_set.find(column.Logical()) != unique.key_set.end()) {
-				out_pk = true;
+			auto &unique = (UniqueConstraint &)*constraint;
+
+			if (unique.is_primary_key) {
+				if (unique.index == column.Logical()) {
+					out_pk = true;
+				}
+				if (std::find(unique.columns.begin(), unique.columns.end(), column.GetName()) != unique.columns.end()) {
+					out_pk = true;
+				}
 			}
 			break;
 		}
@@ -91,19 +97,19 @@ static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &c
 }
 
 static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry *table, DataChunk &output) {
-	if (data.offset >= table->columns.LogicalColumnCount()) {
+	if (data.offset >= table->GetColumns().LogicalColumnCount()) {
 		// finished returning values
 		return;
 	}
 	// start returning values
 	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table->columns.LogicalColumnCount());
+	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table->GetColumns().LogicalColumnCount());
 	output.SetCardinality(next - data.offset);
 
 	for (idx_t i = data.offset; i < next; i++) {
 		bool not_null, pk;
 		auto index = i - data.offset;
-		auto &column = table->columns.GetColumn(LogicalIndex(i));
+		auto &column = table->GetColumn(LogicalIndex(i));
 		D_ASSERT(column.Oid() < (idx_t)NumericLimits<int32_t>::Maximum());
 		CheckConstraints(table, column, not_null, pk);
 

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

@@ -1,7 +1,9 @@
-#include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/function/table/system_functions.hpp"
+
 #include <cmath>
 #include <limits>
 
@@ -56,12 +58,12 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	max_interval.micros = 999999999;
 	result.emplace_back(LogicalType::INTERVAL, "interval", Value::INTERVAL(min_interval),
 	                    Value::INTERVAL(max_interval));
-	// strings/blobs
+	// strings/blobs/bitstrings
 	result.emplace_back(LogicalType::VARCHAR, "varchar", Value("🦆🦆🦆🦆🦆🦆"),
 	                    Value(string("goo\x00se", 6)));
-	result.emplace_back(LogicalType::JSON, "json", Value("🦆🦆🦆🦆🦆🦆"), Value("goose"));
 	result.emplace_back(LogicalType::BLOB, "blob", Value::BLOB("thisisalongblob\\x00withnullbytes"),
 	                    Value::BLOB("\\x00\\x00\\x00a"));
+	result.emplace_back(LogicalType::BIT, "bit", Value::BIT("0010001001011100010101011010111"), Value::BIT("10101"));
 
 	// enums
 	Vector small_enum(LogicalType::VARCHAR, 2);
@@ -136,17 +138,17 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_type_list;
 	struct_type_list.push_back(make_pair("a", LogicalType::INTEGER));
 	struct_type_list.push_back(make_pair("b", LogicalType::VARCHAR));
-	auto struct_type = LogicalType::STRUCT(move(struct_type_list));
+	auto struct_type = LogicalType::STRUCT(std::move(struct_type_list));
 
 	child_list_t<Value> min_struct_list;
 	min_struct_list.push_back(make_pair("a", Value(LogicalType::INTEGER)));
 	min_struct_list.push_back(make_pair("b", Value(LogicalType::VARCHAR)));
-	auto min_struct_val = Value::STRUCT(move(min_struct_list));
+	auto min_struct_val = Value::STRUCT(std::move(min_struct_list));
 
 	child_list_t<Value> max_struct_list;
 	max_struct_list.push_back(make_pair("a", Value::INTEGER(42)));
 	max_struct_list.push_back(make_pair("b", Value("🦆🦆🦆🦆🦆🦆")));
-	auto max_struct_val = Value::STRUCT(move(max_struct_list));
+	auto max_struct_val = Value::STRUCT(std::move(max_struct_list));
 
 	result.emplace_back(struct_type, "struct", min_struct_val, max_struct_val);
 
@@ -154,26 +156,27 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_list_type_list;
 	struct_list_type_list.push_back(make_pair("a", int_list_type));
 	struct_list_type_list.push_back(make_pair("b", varchar_list_type));
-	auto struct_list_type = LogicalType::STRUCT(move(struct_list_type_list));
+	auto struct_list_type = LogicalType::STRUCT(std::move(struct_list_type_list));
 
 	child_list_t<Value> min_struct_vl_list;
 	min_struct_vl_list.push_back(make_pair("a", Value(int_list_type)));
 	min_struct_vl_list.push_back(make_pair("b", Value(varchar_list_type)));
-	auto min_struct_val_list = Value::STRUCT(move(min_struct_vl_list));
+	auto min_struct_val_list = Value::STRUCT(std::move(min_struct_vl_list));
 
 	child_list_t<Value> max_struct_vl_list;
 	max_struct_vl_list.push_back(make_pair("a", int_list));
 	max_struct_vl_list.push_back(make_pair("b", varchar_list));
-	auto max_struct_val_list = Value::STRUCT(move(max_struct_vl_list));
+	auto max_struct_val_list = Value::STRUCT(std::move(max_struct_vl_list));
 
-	result.emplace_back(struct_list_type, "struct_of_arrays", move(min_struct_val_list), move(max_struct_val_list));
+	result.emplace_back(struct_list_type, "struct_of_arrays", std::move(min_struct_val_list),
+	                    std::move(max_struct_val_list));
 
 	// array of structs
 	auto array_of_structs_type = LogicalType::LIST(struct_type);
 	auto min_array_of_struct_val = Value::EMPTYLIST(struct_type);
 	auto max_array_of_struct_val = Value::LIST({min_struct_val, max_struct_val, Value(struct_type)});
-	result.emplace_back(array_of_structs_type, "array_of_structs", move(min_array_of_struct_val),
-	                    move(max_array_of_struct_val));
+	result.emplace_back(array_of_structs_type, "array_of_structs", std::move(min_array_of_struct_val),
+	                    std::move(max_array_of_struct_val));
 
 	// map
 	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
@@ -191,7 +194,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	map_values.push_back(Value::STRUCT(map_struct2));
 
 	auto max_map_value = Value::MAP(ListType::GetChildType(map_type), map_values);
-	result.emplace_back(map_type, "map", move(min_map_value), move(max_map_value));
+	result.emplace_back(map_type, "map", std::move(min_map_value), std::move(max_map_value));
 
 	return result;
 }
@@ -200,8 +203,8 @@ static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFu
                                                  vector<LogicalType> &return_types, vector<string> &names) {
 	auto test_types = TestAllTypesFun::GetTestTypes();
 	for (auto &test_type : test_types) {
-		return_types.push_back(move(test_type.type));
-		names.push_back(move(test_type.name));
+		return_types.push_back(std::move(test_type.type));
+		names.push_back(std::move(test_type.name));
 	}
 	return nullptr;
 }
@@ -213,11 +216,11 @@ unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, Ta
 	result->entries.resize(3);
 	// initialize the values
 	for (auto &test_type : test_types) {
-		result->entries[0].push_back(move(test_type.min_value));
-		result->entries[1].push_back(move(test_type.max_value));
-		result->entries[2].emplace_back(move(test_type.type));
+		result->entries[0].push_back(std::move(test_type.min_value));
+		result->entries[1].push_back(std::move(test_type.max_value));
+		result->entries[2].emplace_back(std::move(test_type.type));
 	}
-	return move(result);
+	return std::move(result);
 }
 
 void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

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

@@ -44,11 +44,11 @@ struct TestVectorFlat {
 				auto child_values = GenerateValues(info, child_type.second);
 
 				for (idx_t i = 0; i < child_values.size(); i++) {
-					struct_children[i].push_back(make_pair(child_type.first, move(child_values[i])));
+					struct_children[i].push_back(make_pair(child_type.first, std::move(child_values[i])));
 				}
 			}
 			for (auto &struct_child : struct_children) {
-				result.push_back(Value::STRUCT(move(struct_child)));
+				result.push_back(Value::STRUCT(std::move(struct_child)));
 			}
 			break;
 		}
@@ -85,7 +85,7 @@ struct TestVectorFlat {
 				result->data[0].SetValue(i, result_values[cur_row + i]);
 			}
 			result->SetCardinality(cardinality);
-			info.entries.push_back(move(result));
+			info.entries.push_back(std::move(result));
 		}
 	}
 };
@@ -101,7 +101,7 @@ struct TestVectorConstant {
 			result->data[0].SetVectorType(VectorType::CONSTANT_VECTOR);
 			result->SetCardinality(cardinality);
 
-			info.entries.push_back(move(result));
+			info.entries.push_back(std::move(result));
 		}
 	}
 };
@@ -164,7 +164,7 @@ struct TestVectorSequence {
 
 		GenerateVector(info, info.type, result->data[0]);
 		result->SetCardinality(3);
-		info.entries.push_back(move(result));
+		info.entries.push_back(std::move(result));
 #endif
 	}
 };
@@ -200,7 +200,7 @@ static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, Tabl
 
 	return_types.push_back(result->type);
 	names.emplace_back("test_vector");
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context, TableFunctionInitInput &input) {
@@ -212,7 +212,7 @@ unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context,
 
 	map<LogicalTypeId, TestType> test_type_map;
 	for (auto &test_type : test_types) {
-		test_type_map.insert(make_pair(test_type.type.id(), move(test_type)));
+		test_type_map.insert(make_pair(test_type.type.id(), std::move(test_type)));
 	}
 
 	TestVectorInfo info(bind_data.type, test_type_map, result->entries);
@@ -229,7 +229,7 @@ unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context,
 			entry->Verify();
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {

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

@@ -14,12 +14,12 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaTableInfo::RegisterFunction(*this);
 	PragmaStorageInfo::RegisterFunction(*this);
 	PragmaDatabaseSize::RegisterFunction(*this);
-	PragmaDatabaseList::RegisterFunction(*this);
 	PragmaLastProfilingOutput::RegisterFunction(*this);
 	PragmaDetailedProfilingOutput::RegisterFunction(*this);
 
 	DuckDBColumnsFun::RegisterFunction(*this);
 	DuckDBConstraintsFun::RegisterFunction(*this);
+	DuckDBDatabasesFun::RegisterFunction(*this);
 	DuckDBFunctionsFun::RegisterFunction(*this);
 	DuckDBKeywordsFun::RegisterFunction(*this);
 	DuckDBIndexesFun::RegisterFunction(*this);