duckdb 0.6.2-dev781.0 → 0.6.2-dev891.0

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

@@ -60,6 +60,12 @@ struct DuckDBConstraintsData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, TableFunctionBindInput &input,
                                                       vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("database_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -98,13 +104,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 	auto result = make_unique<DuckDBConstraintsData>();
 
 	// scan all the schemas for tables and collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
-
-	sort(schemas.begin(), schemas.end(), [&](CatalogEntry *x, CatalogEntry *y) { return (x->name < y->name); });
-
-	// check the temp schema as well
-	auto temp_schema = SchemaCatalogEntry::GetTemporaryObjects(context);
-	schemas.push_back(temp_schema);
+	auto schemas = Catalog::GetAllSchemas(context);
 
 	for (auto &schema : schemas) {
 		vector<CatalogEntry *> entries;
@@ -169,16 +169,20 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			default:
 				throw NotImplementedException("Unimplemented constraint for duckdb_constraints");
 			}
-			output.SetValue(5, count, Value(constraint_type));
 
+			idx_t col = 0;
+			// database_name, LogicalType::VARCHAR
+			output.SetValue(col++, count, Value(table.schema->catalog->GetName()));
+			// database_oid, LogicalType::BIGINT
+			output.SetValue(col++, count, Value::BIGINT(table.schema->catalog->GetOid()));
 			// schema_name, LogicalType::VARCHAR
-			output.SetValue(0, count, Value(table.schema->name));
+			output.SetValue(col++, count, Value(table.schema->name));
 			// schema_oid, LogicalType::BIGINT
-			output.SetValue(1, count, Value::BIGINT(table.schema->oid));
+			output.SetValue(col++, count, Value::BIGINT(table.schema->oid));
 			// table_name, LogicalType::VARCHAR
-			output.SetValue(2, count, Value(table.name));
+			output.SetValue(col++, count, Value(table.name));
 			// table_oid, LogicalType::BIGINT
-			output.SetValue(3, count, Value::BIGINT(table.oid));
+			output.SetValue(col++, count, Value::BIGINT(table.oid));
 
 			// constraint_index, BIGINT
 			auto &bound_constraint = (BoundConstraint &)*table.bound_constraints[data.constraint_offset];
@@ -193,9 +197,8 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
 				const auto &info = bound_foreign_key.info;
 				// find the other table
-				auto &catalog = Catalog::GetCatalog(context);
-				auto table_entry = (TableCatalogEntry *)catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info.schema,
-				                                                         info.table, true);
+				auto table_entry =
+				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info.schema, info.table, true);
 				if (!table_entry) {
 					throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
 					                        info.schema, info.table);
@@ -212,20 +215,21 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			}
 
 			if (uk_info.columns.empty()) {
-				output.SetValue(4, count, Value::BIGINT(data.unique_constraint_offset++));
+				output.SetValue(col++, count, Value::BIGINT(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(4, count, Value::BIGINT(data.unique_constraint_offset));
+					output.SetValue(col++, count, Value::BIGINT(data.unique_constraint_offset));
 					data.unique_constraint_offset++;
 				} else {
-					output.SetValue(4, count, Value::BIGINT(known_unique_constraint_offset->second));
+					output.SetValue(col++, count, Value::BIGINT(known_unique_constraint_offset->second));
 				}
 			}
+			output.SetValue(col++, count, Value(constraint_type));
 
 			// constraint_text, VARCHAR
-			output.SetValue(6, count, Value(constraint->ToString()));
+			output.SetValue(col++, count, Value(constraint->ToString()));
 
 			// expression, VARCHAR
 			Value expression_text;
@@ -233,7 +237,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				auto &check = (CheckConstraint &)*constraint;
 				expression_text = Value(check.expression->ToString());
 			}
-			output.SetValue(7, count, expression_text);
+			output.SetValue(col++, count, expression_text);
 
 			vector<LogicalIndex> column_index_list;
 			switch (bound_constraint.type) {
@@ -275,10 +279,10 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			}
 
 			// constraint_column_indexes, LIST
-			output.SetValue(8, count, Value::LIST(move(index_list)));
+			output.SetValue(col++, count, Value::LIST(move(index_list)));
 
 			// constraint_column_names, LIST
-			output.SetValue(9, count, Value::LIST(move(column_name_list)));
+			output.SetValue(col++, count, Value::LIST(move(column_name_list)));
 
 			count++;
 		}

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

@@ -51,7 +51,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &conte
 	auto result = make_unique<DuckDBDependenciesData>();
 
 	// scan all the schemas and collect them
-	auto &catalog = Catalog::GetCatalog(context);
+	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 	auto &dependency_manager = catalog.GetDependencyManager();
 	dependency_manager.Scan([&](CatalogEntry *obj, CatalogEntry *dependent, DependencyType type) {
 		DependencyInformation info;

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

@@ -69,7 +69,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		info.description = extension.description;
 		for (idx_t k = 0; k < alias_count; k++) {
 			auto alias = ExtensionHelper::GetExtensionAlias(k);
-			if (alias.extension == extension.name) {
+			if (info.name == alias.extension) {
 				info.aliases.emplace_back(alias.alias);
 			}
 		}

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

@@ -28,6 +28,9 @@ struct DuckDBFunctionsData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, TableFunctionBindInput &input,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -81,11 +84,10 @@ unique_ptr<GlobalTableFunctionState> DuckDBFunctionsInit(ClientContext &context,
 	auto result = make_unique<DuckDBFunctionsData>();
 
 	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
 		ExtractFunctionsFromSchema(context, *schema, *result);
 	};
-	ExtractFunctionsFromSchema(context, *SchemaCatalogEntry::GetTemporaryObjects(context), *result);
 
 	std::sort(result->entries.begin(), result->entries.end(),
 	          [&](CatalogEntry *a, CatalogEntry *b) { return (int)a->type < (int)b->type; });
@@ -420,41 +422,46 @@ struct PragmaFunctionExtractor {
 template <class T, class OP>
 bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
 	auto &function = (T &)*entry;
+	idx_t col = 0;
+
+	// database_name, LogicalType::VARCHAR
+	output.SetValue(col++, output_offset, Value(entry->schema->catalog->GetName()));
+
 	// schema_name, LogicalType::VARCHAR
-	output.SetValue(0, output_offset, Value(entry->schema->name));
+	output.SetValue(col++, output_offset, Value(entry->schema->name));
 
 	// function_name, LogicalType::VARCHAR
-	output.SetValue(1, output_offset, Value(entry->name));
+	output.SetValue(col++, output_offset, Value(entry->name));
 
 	// function_type, LogicalType::VARCHAR
-	output.SetValue(2, output_offset, Value(OP::GetFunctionType()));
+	output.SetValue(col++, output_offset, Value(OP::GetFunctionType()));
 
 	// function_description, LogicalType::VARCHAR
-	output.SetValue(3, output_offset, OP::GetFunctionDescription(function, function_idx));
+	output.SetValue(col++, output_offset, OP::GetFunctionDescription(function, function_idx));
 
 	// return_type, LogicalType::VARCHAR
-	output.SetValue(4, output_offset, OP::GetReturnType(function, function_idx));
+	output.SetValue(col++, output_offset, OP::GetReturnType(function, function_idx));
 
 	// parameters, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(5, output_offset, OP::GetParameters(function, function_idx));
+	output.SetValue(col++, output_offset, OP::GetParameters(function, function_idx));
 
 	// parameter_types, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(6, output_offset, OP::GetParameterTypes(function, function_idx));
+	output.SetValue(col++, output_offset, OP::GetParameterTypes(function, function_idx));
 
 	// varargs, LogicalType::VARCHAR
-	output.SetValue(7, output_offset, OP::GetVarArgs(function, function_idx));
+	output.SetValue(col++, output_offset, OP::GetVarArgs(function, function_idx));
 
 	// macro_definition, LogicalType::VARCHAR
-	output.SetValue(8, output_offset, OP::GetMacroDefinition(function, function_idx));
+	output.SetValue(col++, output_offset, OP::GetMacroDefinition(function, function_idx));
 
 	// has_side_effects, LogicalType::BOOLEAN
-	output.SetValue(9, output_offset, OP::HasSideEffects(function, function_idx));
+	output.SetValue(col++, output_offset, OP::HasSideEffects(function, function_idx));
 
 	// internal, LogicalType::BOOLEAN
-	output.SetValue(10, output_offset, Value::BOOLEAN(entry->internal));
+	output.SetValue(col++, output_offset, Value::BOOLEAN(entry->internal));
 
 	// function_oid, LogicalType::BIGINT
-	output.SetValue(11, output_offset, Value::BIGINT(entry->oid));
+	output.SetValue(col++, output_offset, Value::BIGINT(entry->oid));
 
 	return function_idx + 1 == OP::FunctionCount(function);
 }
@@ -471,7 +478,7 @@ void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p,
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset];
 		auto standard_entry = (StandardEntry *)entry;
-		bool finished = false;
+		bool finished;
 
 		switch (entry->type) {
 		case CatalogType::SCALAR_FUNCTION_ENTRY:

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

@@ -20,6 +20,12 @@ struct DuckDBIndexesData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, TableFunctionBindInput &input,
                                                   vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("database_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -56,15 +62,11 @@ static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, TableF
 unique_ptr<GlobalTableFunctionState> DuckDBIndexesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBIndexesData>();
 
-	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+	// 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::INDEX_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	};
-
-	// check the temp schema as well
-	SchemaCatalogEntry::GetTemporaryObjects(context)->Scan(
-	    context, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	return move(result);
 }
 
@@ -83,29 +85,34 @@ void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, D
 		auto &index = (IndexCatalogEntry &)*entry;
 		// return values:
 
+		idx_t col = 0;
+		// database_name, VARCHAR
+		output.SetValue(col++, count, index.catalog->GetName());
+		// database_oid, BIGINT
+		output.SetValue(col++, count, Value::BIGINT(index.catalog->GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(0, count, Value(index.schema->name));
+		output.SetValue(col++, count, Value(index.schema->name));
 		// schema_oid, BIGINT
-		output.SetValue(1, count, Value::BIGINT(index.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(index.schema->oid));
 		// index_name, VARCHAR
-		output.SetValue(2, count, Value(index.name));
+		output.SetValue(col++, count, Value(index.name));
 		// index_oid, BIGINT
-		output.SetValue(3, count, Value::BIGINT(index.oid));
+		output.SetValue(col++, count, Value::BIGINT(index.oid));
 		// table_name, VARCHAR
-		output.SetValue(4, count, Value(index.info->table));
+		output.SetValue(col++, count, Value(index.info->table));
 		// table_oid, BIGINT
 		// find the table in the catalog
-		auto &catalog = Catalog::GetCatalog(context);
-		auto table_entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, index.info->schema, index.info->table);
-		output.SetValue(5, count, Value::BIGINT(table_entry->oid));
+		auto table_entry =
+		    index.schema->catalog->GetEntry<TableCatalogEntry>(context, index.info->schema, index.info->table);
+		output.SetValue(col++, count, Value::BIGINT(table_entry->oid));
 		// is_unique, BOOLEAN
-		output.SetValue(6, count, Value::BOOLEAN(index.index->IsUnique()));
+		output.SetValue(col++, count, Value::BOOLEAN(index.index->IsUnique()));
 		// is_primary, BOOLEAN
-		output.SetValue(7, count, Value::BOOLEAN(index.index->IsPrimary()));
+		output.SetValue(col++, count, Value::BOOLEAN(index.index->IsPrimary()));
 		// expressions, VARCHAR
-		output.SetValue(8, count, Value());
+		output.SetValue(col++, count, Value());
 		// sql, VARCHAR
-		output.SetValue(9, count, Value(index.ToSQL()));
+		output.SetValue(col++, count, Value(index.ToSQL()));
 
 		count++;
 	}

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

@@ -21,6 +21,12 @@ static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, TableF
 	names.emplace_back("oid");
 	return_types.emplace_back(LogicalType::BIGINT);
 
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("database_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -37,10 +43,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBSchemasInit(ClientContext &context, T
 	auto result = make_unique<DuckDBSchemasData>();
 
 	// scan all the schemas and collect them
-	Catalog::GetCatalog(context).ScanSchemas(
-	    context, [&](CatalogEntry *entry) { result->entries.push_back((SchemaCatalogEntry *)entry); });
-	// get the temp schema as well
-	result->entries.push_back(SchemaCatalogEntry::GetTemporaryObjects(context));
+	result->entries = Catalog::GetAllSchemas(context);
 
 	return move(result);
 }
@@ -58,14 +61,19 @@ void DuckDBSchemasFunction(ClientContext &context, TableFunctionInput &data_p, D
 		auto &entry = data.entries[data.offset];
 
 		// return values:
+		idx_t col = 0;
 		// "oid", PhysicalType::BIGINT
-		output.SetValue(0, count, Value::BIGINT(entry->oid));
+		output.SetValue(col++, count, Value::BIGINT(entry->oid));
+		// database_name, VARCHAR
+		output.SetValue(col++, count, entry->catalog->GetName());
+		// database_oid, BIGINT
+		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
 		// "schema_name", PhysicalType::VARCHAR
-		output.SetValue(1, count, Value(entry->name));
+		output.SetValue(col++, count, Value(entry->name));
 		// "internal", PhysicalType::BOOLEAN
-		output.SetValue(2, count, Value::BOOLEAN(entry->internal));
+		output.SetValue(col++, count, Value::BOOLEAN(entry->internal));
 		// "sql", PhysicalType::VARCHAR
-		output.SetValue(3, count, Value());
+		output.SetValue(col++, count, Value());
 
 		data.offset++;
 		count++;

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

@@ -13,12 +13,18 @@ struct DuckDBSequencesData : public GlobalTableFunctionState {
 	DuckDBSequencesData() : offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<SequenceCatalogEntry *> entries;
 	idx_t offset;
 };
 
 static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, TableFunctionBindInput &input,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("database_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -62,15 +68,11 @@ unique_ptr<GlobalTableFunctionState> DuckDBSequencesInit(ClientContext &context,
 	auto result = make_unique<DuckDBSequencesData>();
 
 	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::SEQUENCE_ENTRY,
-		             [&](CatalogEntry *entry) { result->entries.push_back(entry); });
+		             [&](CatalogEntry *entry) { result->entries.push_back((SequenceCatalogEntry *)entry); });
 	};
-
-	// check the temp schema as well
-	SchemaCatalogEntry::GetTemporaryObjects(context)->Scan(
-	    context, CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	return move(result);
 }
 
@@ -88,30 +90,35 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p,
 
 		auto &seq = (SequenceCatalogEntry &)*entry;
 		// return values:
+		idx_t col = 0;
+		// database_name, VARCHAR
+		output.SetValue(col++, count, entry->catalog->GetName());
+		// database_oid, BIGINT
+		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(0, count, Value(seq.schema->name));
+		output.SetValue(col++, count, Value(seq.schema->name));
 		// schema_oid, BIGINT
-		output.SetValue(1, count, Value::BIGINT(seq.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(seq.schema->oid));
 		// sequence_name, VARCHAR
-		output.SetValue(2, count, Value(seq.name));
+		output.SetValue(col++, count, Value(seq.name));
 		// sequence_oid, BIGINT
-		output.SetValue(3, count, Value::BIGINT(seq.oid));
+		output.SetValue(col++, count, Value::BIGINT(seq.oid));
 		// temporary, BOOLEAN
-		output.SetValue(4, count, Value::BOOLEAN(seq.temporary));
+		output.SetValue(col++, count, Value::BOOLEAN(seq.temporary));
 		// start_value, BIGINT
-		output.SetValue(5, count, Value::BIGINT(seq.start_value));
+		output.SetValue(col++, count, Value::BIGINT(seq.start_value));
 		// min_value, BIGINT
-		output.SetValue(6, count, Value::BIGINT(seq.min_value));
+		output.SetValue(col++, count, Value::BIGINT(seq.min_value));
 		// max_value, BIGINT
-		output.SetValue(7, count, Value::BIGINT(seq.max_value));
+		output.SetValue(col++, count, Value::BIGINT(seq.max_value));
 		// increment_by, BIGINT
-		output.SetValue(8, count, Value::BIGINT(seq.increment));
+		output.SetValue(col++, count, Value::BIGINT(seq.increment));
 		// cycle, BOOLEAN
-		output.SetValue(9, count, Value::BOOLEAN(seq.cycle));
+		output.SetValue(col++, count, Value::BOOLEAN(seq.cycle));
 		// last_value, BIGINT
-		output.SetValue(10, count, seq.usage_count == 0 ? Value() : Value::BOOLEAN(seq.last_value));
+		output.SetValue(col++, count, seq.usage_count == 0 ? Value() : Value::BOOLEAN(seq.last_value));
 		// sql, LogicalType::VARCHAR
-		output.SetValue(11, count, Value(seq.ToSQL()));
+		output.SetValue(col++, count, Value(seq.ToSQL()));
 
 		count++;
 	}

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

@@ -22,6 +22,12 @@ struct DuckDBTablesData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, TableFunctionBindInput &input,
                                                  vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("database_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -65,14 +71,10 @@ unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, Ta
 	auto result = make_unique<DuckDBTablesData>();
 
 	// scan all the schemas for tables and collect themand collect them
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	};
-
-	// check the temp schema as well
-	SchemaCatalogEntry::GetTemporaryObjects(context)->Scan(
-	    context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	return move(result);
 }
 
@@ -115,30 +117,35 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 		}
 		auto &table = (TableCatalogEntry &)*entry;
 		// return values:
+		idx_t col = 0;
+		// database_name, VARCHAR
+		output.SetValue(col++, count, entry->catalog->GetName());
+		// database_oid, BIGINT
+		output.SetValue(col++, count, Value::BIGINT(entry->catalog->GetOid()));
 		// schema_name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(table.schema->name));
+		output.SetValue(col++, count, Value(table.schema->name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(table.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(table.schema->oid));
 		// table_name, LogicalType::VARCHAR
-		output.SetValue(2, count, Value(table.name));
+		output.SetValue(col++, count, Value(table.name));
 		// table_oid, LogicalType::BIGINT
-		output.SetValue(3, count, Value::BIGINT(table.oid));
+		output.SetValue(col++, count, Value::BIGINT(table.oid));
 		// internal, LogicalType::BOOLEAN
-		output.SetValue(4, count, Value::BOOLEAN(table.internal));
+		output.SetValue(col++, count, Value::BOOLEAN(table.internal));
 		// temporary, LogicalType::BOOLEAN
-		output.SetValue(5, count, Value::BOOLEAN(table.temporary));
+		output.SetValue(col++, count, Value::BOOLEAN(table.temporary));
 		// has_primary_key, LogicalType::BOOLEAN
-		output.SetValue(6, count, Value::BOOLEAN(TableHasPrimaryKey(table)));
+		output.SetValue(col++, count, Value::BOOLEAN(TableHasPrimaryKey(table)));
 		// estimated_size, LogicalType::BIGINT
-		output.SetValue(7, count, Value::BIGINT(table.storage->info->cardinality.load()));
+		output.SetValue(col++, count, Value::BIGINT(table.storage->info->cardinality.load()));
 		// column_count, LogicalType::BIGINT
-		output.SetValue(8, count, Value::BIGINT(table.columns.LogicalColumnCount()));
+		output.SetValue(col++, count, Value::BIGINT(table.columns.LogicalColumnCount()));
 		// index_count, LogicalType::BIGINT
-		output.SetValue(9, count, Value::BIGINT(table.storage->info->indexes.Count()));
+		output.SetValue(col++, count, Value::BIGINT(table.storage->info->indexes.Count()));
 		// check_constraint_count, LogicalType::BIGINT
-		output.SetValue(10, count, Value::BIGINT(CheckConstraintCount(table)));
+		output.SetValue(col++, count, Value::BIGINT(CheckConstraintCount(table)));
 		// sql, LogicalType::VARCHAR
-		output.SetValue(11, count, Value(table.ToSQL()));
+		output.SetValue(col++, count, Value(table.ToSQL()));
 
 		count++;
 	}

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

@@ -20,6 +20,12 @@ struct DuckDBTypesData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFunctionBindInput &input,
                                                 vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("database_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("database_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("schema_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -53,16 +59,11 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFun
 
 unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBTypesData>();
-	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
+	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::TYPE_ENTRY,
 		             [&](CatalogEntry *entry) { result->entries.push_back((TypeCatalogEntry *)entry); });
 	};
-
-	// check the temp schema as well
-	SchemaCatalogEntry::GetTemporaryObjects(context)->Scan(context, CatalogType::TYPE_ENTRY, [&](CatalogEntry *entry) {
-		result->entries.push_back((TypeCatalogEntry *)entry);
-	});
 	return move(result);
 }
 
@@ -80,10 +81,15 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		auto &type = type_entry->user_type;
 
 		// return values:
+		idx_t col = 0;
+		// database_name, VARCHAR
+		output.SetValue(col++, count, type_entry->catalog->GetName());
+		// database_oid, BIGINT
+		output.SetValue(col++, count, Value::BIGINT(type_entry->catalog->GetOid()));
 		// schema_name, LogicalType::VARCHAR
-		output.SetValue(0, count, Value(type_entry->schema->name));
+		output.SetValue(col++, count, Value(type_entry->schema->name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(type_entry->schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(type_entry->schema->oid));
 		// type_oid, BIGINT
 		int64_t oid;
 		if (type_entry->internal) {
@@ -98,15 +104,15 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		} else {
 			oid_val = Value();
 		}
-		output.SetValue(2, count, oid_val);
+		output.SetValue(col++, count, oid_val);
 		// type_name, VARCHAR
-		output.SetValue(3, count, Value(type_entry->name));
+		output.SetValue(col++, count, Value(type_entry->name));
 		// type_size, BIGINT
 		auto internal_type = type.InternalType();
-		output.SetValue(4, count,
+		output.SetValue(col++, count,
 		                internal_type == PhysicalType::INVALID ? Value() : Value::BIGINT(GetTypeIdSize(internal_type)));
 		// logical_type, VARCHAR
-		output.SetValue(5, count, Value(LogicalTypeIdToString(type.id())));
+		output.SetValue(col++, count, Value(LogicalTypeIdToString(type.id())));
 		// type_category, VARCHAR
 		string category;
 		switch (type.id()) {
@@ -151,9 +157,9 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		default:
 			break;
 		}
-		output.SetValue(6, count, category.empty() ? Value() : Value(category));
+		output.SetValue(col++, count, category.empty() ? Value() : Value(category));
 		// internal, BOOLEAN
-		output.SetValue(7, count, Value::BOOLEAN(type_entry->internal));
+		output.SetValue(col++, count, Value::BOOLEAN(type_entry->internal));
 		// labels, VARCHAR[]
 		if (type.id() == LogicalTypeId::ENUM && type.AuxInfo()) {
 			auto data = FlatVector::GetData<string_t>(EnumType::GetValuesInsertOrder(type));
@@ -164,9 +170,9 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 				labels.emplace_back(data[i]);
 			}
 
-			output.SetValue(8, count, Value::LIST(labels));
+			output.SetValue(col++, count, Value::LIST(labels));
 		} else {
-			output.SetValue(8, count, Value());
+			output.SetValue(col++, count, Value());
 		}
 
 		count++;