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

package/src/duckdb/src/function/built_in_functions.cpp

@@ -0,0 +1,88 @@
+#include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_collation_info.hpp"
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+
+namespace duckdb {
+
+BuiltinFunctions::BuiltinFunctions(CatalogTransaction transaction, Catalog &catalog)
+    : transaction(transaction), catalog(catalog) {
+}
+
+BuiltinFunctions::~BuiltinFunctions() {
+}
+
+void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool combinable,
+                                    bool not_required_for_equality) {
+	CreateCollationInfo info(move(name), move(function), combinable, not_required_for_equality);
+	info.internal = true;
+	catalog.CreateCollation(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
+	CreateAggregateFunctionInfo info(move(set));
+	info.internal = true;
+	catalog.CreateFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(AggregateFunction function) {
+	CreateAggregateFunctionInfo info(move(function));
+	info.internal = true;
+	catalog.CreateFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(PragmaFunction function) {
+	CreatePragmaFunctionInfo info(move(function));
+	info.internal = true;
+	catalog.CreatePragmaFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(const string &name, PragmaFunctionSet functions) {
+	CreatePragmaFunctionInfo info(name, move(functions));
+	info.internal = true;
+	catalog.CreatePragmaFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(ScalarFunction function) {
+	CreateScalarFunctionInfo info(move(function));
+	info.internal = true;
+	catalog.CreateFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
+	for (auto &name : names) {
+		function.name = name;
+		AddFunction(function);
+	}
+}
+
+void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
+	CreateScalarFunctionInfo info(move(set));
+	info.internal = true;
+	catalog.CreateFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(TableFunction function) {
+	CreateTableFunctionInfo info(move(function));
+	info.internal = true;
+	catalog.CreateTableFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(TableFunctionSet set) {
+	CreateTableFunctionInfo info(move(set));
+	info.internal = true;
+	catalog.CreateTableFunction(transaction, &info);
+}
+
+void BuiltinFunctions::AddFunction(CopyFunction function) {
+	CreateCopyFunctionInfo info(move(function));
+	info.internal = true;
+	catalog.CreateCopyFunction(transaction, &info);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/function.cpp

@@ -1,17 +1,9 @@
 #include "duckdb/function/function.hpp"
 
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/scalar_function.hpp"
-#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_collation_info.hpp"
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
@@ -124,77 +116,6 @@ void BuiltinFunctions::Initialize() {
 	AddCollation("nfc", NFCNormalizeFun::GetFunction());
 }
 
-BuiltinFunctions::BuiltinFunctions(ClientContext &context, Catalog &catalog) : context(context), catalog(catalog) {
-}
-
-void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool combinable,
-                                    bool not_required_for_equality) {
-	CreateCollationInfo info(move(name), move(function), combinable, not_required_for_equality);
-	info.internal = true;
-	catalog.CreateCollation(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
-	CreateAggregateFunctionInfo info(move(set));
-	info.internal = true;
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(AggregateFunction function) {
-	CreateAggregateFunctionInfo info(move(function));
-	info.internal = true;
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(PragmaFunction function) {
-	CreatePragmaFunctionInfo info(move(function));
-	info.internal = true;
-	catalog.CreatePragmaFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(const string &name, PragmaFunctionSet functions) {
-	CreatePragmaFunctionInfo info(name, move(functions));
-	info.internal = true;
-	catalog.CreatePragmaFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(ScalarFunction function) {
-	CreateScalarFunctionInfo info(move(function));
-	info.internal = true;
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
-	for (auto &name : names) {
-		function.name = name;
-		AddFunction(function);
-	}
-}
-
-void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
-	CreateScalarFunctionInfo info(move(set));
-	info.internal = true;
-	catalog.CreateFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(TableFunction function) {
-	CreateTableFunctionInfo info(move(function));
-	info.internal = true;
-	catalog.CreateTableFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(TableFunctionSet set) {
-	CreateTableFunctionInfo info(move(set));
-	info.internal = true;
-	catalog.CreateTableFunction(context, &info);
-}
-
-void BuiltinFunctions::AddFunction(CopyFunction function) {
-	CreateCopyFunctionInfo info(move(function));
-	info.internal = true;
-	catalog.CreateCopyFunction(context, &info);
-}
-
 hash_t BaseScalarFunction::Hash() const {
 	hash_t hash = return_type.Hash();
 	for (auto &arg : arguments) {

package/src/duckdb/src/function/function_binder.cpp

@@ -247,7 +247,8 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
                                                           vector<unique_ptr<Expression>> children, string &error,
                                                           bool is_operator, Binder *binder) {
 	// bind the function
-	auto function = Catalog::GetCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
+	auto function =
+	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
 	D_ASSERT(function && function->type == CatalogType::SCALAR_FUNCTION_ENTRY);
 	return BindScalarFunction((ScalarFunctionCatalogEntry &)*function, move(children), error, is_operator, binder);
 }

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -28,6 +28,10 @@ string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters
 	)";
 }
 
+string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
+	return "SELECT name FROM pragma_database_list() ORDER BY name;";
+}
+
 string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_last_profiling_output() JOIN pragma_detailed_profiling_output() ON "
 	       "(pragma_last_profiling_output.operator_id);";
@@ -42,7 +46,11 @@ string PragmaCollations(ClientContext &context, const FunctionParameters &parame
 }
 
 string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_functions() ORDER BY 1;";
+	return "SELECT function_name AS name, upper(function_type) AS type, parameter_types AS parameters, varargs, "
+	       "return_type, has_side_effects AS side_effects"
+	       " FROM duckdb_functions()"
+	       " WHERE function_type IN ('scalar', 'aggregate')"
+	       " ORDER BY 1;";
 }
 
 string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
@@ -94,6 +102,7 @@ void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaCall("storage_info", PragmaStorageInfo, {LogicalType::VARCHAR}));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_tables", PragmaShowTables));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_tables_expanded", PragmaShowTablesExpanded));
+	set.AddFunction(PragmaFunction::PragmaStatement("show_databases", PragmaShowDatabases));
 	set.AddFunction(PragmaFunction::PragmaStatement("database_list", PragmaDatabaseList));
 	set.AddFunction(PragmaFunction::PragmaStatement("collations", PragmaCollations));
 	set.AddFunction(PragmaFunction::PragmaCall("show", PragmaShow, {LogicalType::VARCHAR}));

package/src/duckdb/src/function/scalar/date/current.cpp

@@ -5,12 +5,12 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/main/client_context.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/meta_transaction.hpp"
 
 namespace duckdb {
 
 static timestamp_t GetTransactionTimestamp(ExpressionState &state) {
-	return state.GetContext().ActiveTransaction().start_timestamp;
+	return MetaTransaction::Get(state.GetContext()).start_timestamp;
 }
 
 static void CurrentTimeFunction(DataChunk &input, ExpressionState &state, Vector &result) {

package/src/duckdb/src/function/scalar/list/list_aggregates.cpp

@@ -417,8 +417,9 @@ static unique_ptr<FunctionData> ListAggregatesBind(ClientContext &context, Scala
 
 	// look up the aggregate function in the catalog
 	QueryErrorContext error_context(nullptr, 0);
-	auto func = (AggregateFunctionCatalogEntry *)Catalog::GetCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
-	    context, DEFAULT_SCHEMA, function_name, false, error_context);
+	auto func =
+	    (AggregateFunctionCatalogEntry *)Catalog::GetSystemCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
+	        context, DEFAULT_SCHEMA, function_name, false, error_context);
 	D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 	if (is_parameter) {

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/function/scalar/sequence_functions.hpp"
 
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -9,6 +10,7 @@
 #include "duckdb/transaction/transaction.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "duckdb/common/operator/add.hpp"
+#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
@@ -74,14 +76,12 @@ struct NextSequenceValueOperator {
 	}
 };
 
-struct NextValData {
-	NextValData(NextvalBindData &bind_data_p, Transaction &transaction_p)
-	    : bind_data(bind_data_p), transaction(transaction_p) {
-	}
-
-	NextvalBindData &bind_data;
-	Transaction &transaction;
-};
+SequenceCatalogEntry *BindSequence(ClientContext &context, const string &name) {
+	auto qname = QualifiedName::Parse(name);
+	// fetch the sequence from the catalog
+	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
+	return Catalog::GetEntry<SequenceCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
+}
 
 template <class OP>
 static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -90,8 +90,8 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 	auto &input = args.data[0];
 
 	auto &context = state.GetContext();
-	auto &transaction = Transaction::GetTransaction(context);
 	if (info.sequence) {
+		auto &transaction = Transaction::Get(context, *info.sequence->catalog);
 		// sequence to use is hard coded
 		// increment the sequence
 		result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -101,14 +101,12 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res
 			result_data[i] = OP::Operation(transaction, info.sequence);
 		}
 	} else {
-		NextValData next_val_input(info, transaction);
 		// sequence to use comes from the input
 		UnaryExecutor::Execute<string_t, int64_t>(input, result, args.size(), [&](string_t value) {
-			auto qname = QualifiedName::Parse(value.GetString());
 			// fetch the sequence from the catalog
-			auto sequence =
-			    Catalog::GetCatalog(context).GetEntry<SequenceCatalogEntry>(context, qname.schema, qname.name);
+			auto sequence = BindSequence(context, value.GetString());
 			// finally get the next value from the sequence
+			auto &transaction = Transaction::Get(context, *sequence->catalog);
 			return OP::Operation(transaction, sequence);
 		});
 	}
@@ -122,17 +120,16 @@ static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFuncti
 		// evaluate the constant and perform the catalog lookup already
 		auto seqname = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
 		if (!seqname.IsNull()) {
-			auto qname = QualifiedName::Parse(seqname.ToString());
-			sequence = Catalog::GetCatalog(context).GetEntry<SequenceCatalogEntry>(context, qname.schema, qname.name);
+			sequence = BindSequence(context, seqname.ToString());
 		}
 	}
 	return make_unique<NextvalBindData>(sequence);
 }
 
-static void NextValDependency(BoundFunctionExpression &expr, unordered_set<CatalogEntry *> &dependencies) {
+static void NextValDependency(BoundFunctionExpression &expr, DependencyList &dependencies) {
 	auto &info = (NextvalBindData &)*expr.bind_info;
 	if (info.sequence) {
-		dependencies.insert(info.sequence);
+		dependencies.AddDependency(info.sequence);
 	}
 }
 

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -199,8 +199,8 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	auto state_type = AggregateStateType::GetStateType(arg_return_type);
 
 	// now we can look up the function in the catalog again and bind it
-	auto func = Catalog::GetCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA,
-	                                                  state_type.function_name);
+	auto func = Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA,
+	                                                        state_type.function_name);
 	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
 		throw InternalException("Could not find aggregate %s", state_type.function_name);
 	}

package/src/duckdb/src/function/scalar/system/system_functions.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -17,7 +18,7 @@ static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vecto
 
 // current_schema
 static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	Value val(ClientData::Get(state.GetContext()).catalog_search_path->GetDefault());
+	Value val(ClientData::Get(state.GetContext()).catalog_search_path->GetDefault().schema);
 	result.Reference(val);
 }
 
@@ -34,9 +35,9 @@ static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vec
 	auto implicit_schemas = *ConstantVector::GetData<bool>(input.data[0]);
 	vector<Value> schema_list;
 	auto &catalog_search_path = ClientData::Get(state.GetContext()).catalog_search_path;
-	vector<string> search_path = implicit_schemas ? catalog_search_path->Get() : catalog_search_path->GetSetPaths();
+	auto &search_path = implicit_schemas ? catalog_search_path->Get() : catalog_search_path->GetSetPaths();
 	std::transform(search_path.begin(), search_path.end(), std::back_inserter(schema_list),
-	               [](const string &s) -> Value { return Value(s); });
+	               [](const CatalogSearchEntry &s) -> Value { return Value(s.schema); });
 
 	auto val = Value::LIST(LogicalType::VARCHAR, schema_list);
 	result.Reference(val);
@@ -44,7 +45,9 @@ static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vec
 
 // txid_current
 static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &transaction = Transaction::GetTransaction(state.GetContext());
+	auto &context = state.GetContext();
+	auto &catalog = Catalog::GetCatalog(context, DatabaseManager::GetDefaultDatabase(context));
+	auto &transaction = Transaction::Get(context, catalog);
 	auto val = Value::BIGINT(transaction.start_time);
 	result.Reference(val);
 }

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

@@ -2,26 +2,59 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
+struct CheckpointBindData : public FunctionData {
+	explicit CheckpointBindData(AttachedDatabase *db) : db(db) {
+	}
+
+	AttachedDatabase *db;
+
+public:
+	unique_ptr<FunctionData> Copy() const override {
+		return make_unique<CheckpointBindData>(db);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = (const CheckpointBindData &)other_p;
+		return db == other.db;
+	}
+};
+
 static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunctionBindInput &input,
                                                vector<LogicalType> &return_types, vector<string> &names) {
 	return_types.emplace_back(LogicalType::BOOLEAN);
 	names.emplace_back("Success");
-	return nullptr;
+
+	AttachedDatabase *db;
+	auto &db_manager = DatabaseManager::Get(context);
+	if (!input.inputs.empty()) {
+		db = db_manager.GetDatabase(context, StringValue::Get(input.inputs[0]));
+	} else {
+		db = db_manager.GetDatabase(context, DatabaseManager::GetDefaultDatabase(context));
+	}
+	return make_unique<CheckpointBindData>(db);
 }
 
 template <bool FORCE>
 static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &transaction_manager = TransactionManager::Get(context);
+	auto &bind_data = (CheckpointBindData &)*data_p.bind_data;
+	auto &transaction_manager = TransactionManager::Get(*bind_data.db);
 	transaction_manager.Checkpoint(context, FORCE);
 }
 
 void CheckpointFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction checkpoint("checkpoint", {}, TemplatedCheckpointFunction<false>, CheckpointBind);
+	TableFunctionSet checkpoint("checkpoint");
+	checkpoint.AddFunction(TableFunction({}, TemplatedCheckpointFunction<false>, CheckpointBind));
+	checkpoint.AddFunction(TableFunction({LogicalType::VARCHAR}, TemplatedCheckpointFunction<false>, CheckpointBind));
 	set.AddFunction(checkpoint);
-	TableFunction force_checkpoint("force_checkpoint", {}, TemplatedCheckpointFunction<true>, CheckpointBind);
+
+	TableFunctionSet force_checkpoint("force_checkpoint");
+	force_checkpoint.AddFunction(TableFunction({}, TemplatedCheckpointFunction<true>, CheckpointBind));
+	force_checkpoint.AddFunction(
+	    TableFunction({LogicalType::VARCHAR}, TemplatedCheckpointFunction<true>, CheckpointBind));
 	set.AddFunction(force_checkpoint);
 }
 

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

@@ -899,7 +899,7 @@ unique_ptr<TableFunctionRef> ReadCSVReplacement(ClientContext &context, const st
 void BuiltinFunctions::RegisterReadFunctions() {
 	CSVCopyFunction::RegisterFunction(*this);
 	ReadCSVTableFunction::RegisterFunction(*this);
-	auto &config = DBConfig::GetConfig(context);
+	auto &config = DBConfig::GetConfig(*transaction.db);
 	config.replacement_scans.emplace_back(ReadCSVReplacement);
 }
 

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

@@ -23,18 +23,24 @@ struct DuckDBColumnsData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, TableFunctionBindInput &input,
                                                   vector<LogicalType> &return_types, vector<string> &names) {
-	names.emplace_back("schema_oid");
+	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);
 
-	names.emplace_back("table_oid");
+	names.emplace_back("schema_oid");
 	return_types.emplace_back(LogicalType::BIGINT);
 
 	names.emplace_back("table_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("table_oid");
+	return_types.emplace_back(LogicalType::BIGINT);
+
 	names.emplace_back("column_name");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -75,14 +81,10 @@ unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, T
 	auto result = make_unique<DuckDBColumnsData>();
 
 	// scan all the schemas for tables and views and 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);
 }
 
@@ -186,36 +188,41 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 		auto index = start_index + (i - start_col);
 		auto &entry = *Entry();
 
-		// schema_oid, BIGINT
-		output.SetValue(0, index, Value::BIGINT(entry.schema->oid));
+		idx_t col = 0;
+		// database_name, VARCHAR
+		output.SetValue(col++, index, entry.catalog->GetName());
+		// database_oid, BIGINT
+		output.SetValue(col++, index, Value::BIGINT(entry.catalog->GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(1, index, entry.schema->name);
-		// table_oid, BIGINT
-		output.SetValue(2, index, Value::BIGINT(entry.oid));
+		output.SetValue(col++, index, entry.schema->name);
+		// schema_oid, BIGINT
+		output.SetValue(col++, index, Value::BIGINT(entry.schema->oid));
 		// table_name, VARCHAR
-		output.SetValue(3, index, entry.name);
+		output.SetValue(col++, index, entry.name);
+		// table_oid, BIGINT
+		output.SetValue(col++, index, Value::BIGINT(entry.oid));
 		// column_name, VARCHAR
-		output.SetValue(4, index, Value(ColumnName(i)));
+		output.SetValue(col++, index, Value(ColumnName(i)));
 		// column_index, INTEGER
-		output.SetValue(5, index, Value::INTEGER(i + 1));
+		output.SetValue(col++, index, Value::INTEGER(i + 1));
 		// internal, BOOLEAN
-		output.SetValue(6, index, Value::BOOLEAN(entry.internal));
+		output.SetValue(col++, index, Value::BOOLEAN(entry.internal));
 		// column_default, VARCHAR
-		output.SetValue(7, index, Value(ColumnDefault(i)));
+		output.SetValue(col++, index, Value(ColumnDefault(i)));
 		// is_nullable, BOOLEAN
-		output.SetValue(8, index, Value::BOOLEAN(IsNullable(i)));
+		output.SetValue(col++, index, Value::BOOLEAN(IsNullable(i)));
 		// data_type, VARCHAR
 		const LogicalType &type = ColumnType(i);
-		output.SetValue(9, index, Value(type.ToString()));
+		output.SetValue(col++, index, Value(type.ToString()));
 		// data_type_id, BIGINT
-		output.SetValue(10, index, Value::BIGINT(int(type.id())));
+		output.SetValue(col++, index, Value::BIGINT(int(type.id())));
 		if (type == LogicalType::VARCHAR) {
 			// FIXME: need check constraints in place to set this correctly
 			// character_maximum_length, INTEGER
-			output.SetValue(11, index, Value());
+			output.SetValue(col++, index, Value());
 		} else {
 			// "character_maximum_length", PhysicalType::INTEGER
-			output.SetValue(11, index, Value());
+			output.SetValue(col++, index, Value());
 		}
 
 		Value numeric_precision, numeric_scale, numeric_precision_radix;
@@ -268,11 +275,11 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 		}
 
 		// numeric_precision, INTEGER
-		output.SetValue(12, index, numeric_precision);
+		output.SetValue(col++, index, numeric_precision);
 		// numeric_precision_radix, INTEGER
-		output.SetValue(13, index, numeric_precision_radix);
+		output.SetValue(col++, index, numeric_precision_radix);
 		// numeric_scale, INTEGER
-		output.SetValue(14, index, numeric_scale);
+		output.SetValue(col++, index, numeric_scale);
 	}
 }