duckdb 0.6.2-dev781.0 → 0.6.2-dev889.0

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

@@ -19,6 +19,12 @@ struct DuckDBViewsData : public GlobalTableFunctionState {
 
 static unique_ptr<FunctionData> DuckDBViewsBind(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);
 
@@ -50,14 +56,10 @@ unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, Tab
 	auto result = make_unique<DuckDBViewsData>();
 
 	// 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::VIEW_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	};
-
-	// check the temp schema as well
-	SchemaCatalogEntry::GetTemporaryObjects(context)->Scan(
-	    context, CatalogType::VIEW_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
 	return move(result);
 }
 
@@ -79,22 +81,27 @@ void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		auto &view = (ViewCatalogEntry &)*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(view.schema->name));
+		output.SetValue(col++, count, Value(view.schema->name));
 		// schema_oid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(view.schema->oid));
+		output.SetValue(col++, count, Value::BIGINT(view.schema->oid));
 		// view_name, LogicalType::VARCHAR
-		output.SetValue(2, count, Value(view.name));
+		output.SetValue(col++, count, Value(view.name));
 		// view_oid, LogicalType::BIGINT
-		output.SetValue(3, count, Value::BIGINT(view.oid));
+		output.SetValue(col++, count, Value::BIGINT(view.oid));
 		// internal, LogicalType::BOOLEAN
-		output.SetValue(4, count, Value::BOOLEAN(view.internal));
+		output.SetValue(col++, count, Value::BOOLEAN(view.internal));
 		// temporary, LogicalType::BOOLEAN
-		output.SetValue(5, count, Value::BOOLEAN(view.temporary));
+		output.SetValue(col++, count, Value::BOOLEAN(view.temporary));
 		// column_count, LogicalType::BIGINT
-		output.SetValue(6, count, Value::BIGINT(view.types.size()));
+		output.SetValue(col++, count, Value::BIGINT(view.types.size()));
 		// sql, LogicalType::VARCHAR
-		output.SetValue(7, count, Value(view.ToSQL()));
+		output.SetValue(col++, count, Value(view.ToSQL()));
 
 		count++;
 	}

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

@@ -26,12 +26,11 @@ static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, TableF
 unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<PragmaCollateData>();
 
-	Catalog::GetCatalog(context).schemas->Scan(context, [&](CatalogEntry *entry) {
-		auto schema = (SchemaCatalogEntry *)entry;
+	auto schemas = Catalog::GetAllSchemas(context);
+	for (auto schema : schemas) {
 		schema->Scan(context, CatalogType::COLLATION_ENTRY,
 		             [&](CatalogEntry *entry) { result->entries.push_back(entry->name); });
-	});
-
+	}
 	return move(result);
 }
 

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

@@ -1,14 +1,17 @@
 #include "duckdb/function/table/system_functions.hpp"
 
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
 struct PragmaDatabaseListData : public GlobalTableFunctionState {
-	PragmaDatabaseListData() : finished(false) {
+	PragmaDatabaseListData() : index(0) {
 	}
 
-	bool finished;
+	vector<AttachedDatabase *> databases;
+	idx_t index;
 };
 
 static unique_ptr<FunctionData> PragmaDatabaseListBind(ClientContext &context, TableFunctionBindInput &input,
@@ -26,21 +29,26 @@ static unique_ptr<FunctionData> PragmaDatabaseListBind(ClientContext &context, T
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaDatabaseListInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaDatabaseListData>();
+	auto result = make_unique<PragmaDatabaseListData>();
+	auto &db_manager = DatabaseManager::Get(context);
+	result->databases = db_manager.GetDatabases(context);
+	return move(result);
 }
 
 void PragmaDatabaseListFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &data = (PragmaDatabaseListData &)*data_p.global_state;
-	if (data.finished) {
-		return;
-	}
-
-	output.SetCardinality(1);
-	output.data[0].SetValue(0, Value::INTEGER(0));
-	output.data[1].SetValue(0, Value("main"));
-	output.data[2].SetValue(0, Value(StorageManager::GetStorageManager(context).GetDBPath()));
 
-	data.finished = true;
+	idx_t count = 0;
+	for (; count < STANDARD_VECTOR_SIZE && data.index < data.databases.size(); data.index++, count++) {
+		output.data[0].SetValue(count, Value::INTEGER(data.index));
+		output.data[1].SetValue(count, Value(data.databases[data.index]->GetName()));
+		Value file_name;
+		if (!data.databases[data.index]->IsSystem()) {
+			file_name = Value(data.databases[data.index]->GetStorageManager().GetDBPath());
+		}
+		output.data[2].SetValue(count, file_name);
+	}
+	output.SetCardinality(count);
 }
 
 void PragmaDatabaseList::RegisterFunction(BuiltinFunctions &set) {

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

@@ -5,18 +5,26 @@
 #include "duckdb/storage/storage_info.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
 struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
-	PragmaDatabaseSizeData() : finished(false) {
+	PragmaDatabaseSizeData() : index(0) {
 	}
 
-	bool finished;
+	idx_t index;
+	vector<AttachedDatabase *> databases;
+	Value memory_usage;
+	Value memory_limit;
 };
 
 static unique_ptr<FunctionData> PragmaDatabaseSizeBind(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_size");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
@@ -45,33 +53,40 @@ static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, T
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaDatabaseSizeData>();
+	auto result = make_unique<PragmaDatabaseSizeData>();
+	result->databases = DatabaseManager::Get(context).GetDatabases(context);
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	result->memory_usage = Value(StringUtil::BytesToHumanReadableString(buffer_manager.GetUsedMemory()));
+	auto max_memory = buffer_manager.GetMaxMemory();
+	result->memory_limit =
+	    max_memory == (idx_t)-1 ? Value("Unlimited") : Value(StringUtil::BytesToHumanReadableString(max_memory));
+
+	return move(result);
 }
 
 void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &data = (PragmaDatabaseSizeData &)*data_p.global_state;
-	if (data.finished) {
-		return;
+	idx_t row = 0;
+	for (; data.index < data.databases.size() && row < STANDARD_VECTOR_SIZE; data.index++) {
+		auto db = data.databases[data.index];
+		if (db->IsSystem() || db->IsTemporary()) {
+			continue;
+		}
+		auto &storage = db->GetStorageManager();
+		auto ds = storage.GetDatabaseSize();
+		idx_t col = 0;
+		output.data[col++].SetValue(row, Value(db->GetName()));
+		output.data[col++].SetValue(row, Value(StringUtil::BytesToHumanReadableString(ds.bytes)));
+		output.data[col++].SetValue(row, Value::BIGINT(ds.block_size));
+		output.data[col++].SetValue(row, Value::BIGINT(ds.total_blocks));
+		output.data[col++].SetValue(row, Value::BIGINT(ds.used_blocks));
+		output.data[col++].SetValue(row, Value::BIGINT(ds.free_blocks));
+		output.data[col++].SetValue(row, Value(StringUtil::BytesToHumanReadableString(ds.wal_size)));
+		output.data[col++].SetValue(row, data.memory_usage);
+		output.data[col++].SetValue(row, data.memory_limit);
+		row++;
 	}
-	auto &storage = StorageManager::GetStorageManager(context);
-	auto &buffer_manager = BufferManager::GetBufferManager(context);
-
-	auto ds = storage.GetDatabaseSize();
-
-	output.SetCardinality(1);
-	output.data[0].SetValue(0, Value(StringUtil::BytesToHumanReadableString(ds.bytes)));
-	output.data[1].SetValue(0, Value::BIGINT(ds.block_size));
-	output.data[2].SetValue(0, Value::BIGINT(ds.total_blocks));
-	output.data[3].SetValue(0, Value::BIGINT(ds.used_blocks));
-	output.data[4].SetValue(0, Value::BIGINT(ds.free_blocks));
-	output.data[5].SetValue(0, Value(StringUtil::BytesToHumanReadableString(ds.wal_size)));
-
-	output.data[6].SetValue(0, Value(StringUtil::BytesToHumanReadableString(buffer_manager.GetUsedMemory())));
-	auto max_memory = buffer_manager.GetMaxMemory();
-	output.data[7].SetValue(0, max_memory == (idx_t)-1 ? Value("Unlimited")
-	                                                   : Value(StringUtil::BytesToHumanReadableString(max_memory)));
-
-	data.finished = true;
+	output.SetCardinality(row);
 }
 
 void PragmaDatabaseSize::RegisterFunction(BuiltinFunctions &set) {

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

@@ -77,13 +77,7 @@ static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, Ta
 	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
 
 	// look up the table name in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, qname.schema, qname.name);
-	if (entry->type != CatalogType::TABLE_ENTRY) {
-		throw Exception("storage_info requires a table as parameter");
-	}
-	auto table_entry = (TableCatalogEntry *)entry;
-
+	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);

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

@@ -7,6 +7,7 @@
 #include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
 #include "duckdb/planner/constraints/bound_unique_constraint.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
+#include "duckdb/planner/binder.hpp"
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/limits.hpp"
@@ -52,8 +53,8 @@ static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, Tabl
 	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
 
 	// look up the table name in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, qname.schema, qname.name);
+	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
+	auto entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
 	return make_unique<PragmaTableFunctionData>(entry);
 }
 

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

@@ -10,7 +10,6 @@ namespace duckdb {
 
 void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaVersion::RegisterFunction(*this);
-	PragmaFunctionPragma::RegisterFunction(*this);
 	PragmaCollations::RegisterFunction(*this);
 	PragmaTableInfo::RegisterFunction(*this);
 	PragmaStorageInfo::RegisterFunction(*this);

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

@@ -12,6 +12,8 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/transaction/local_storage.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 namespace duckdb {
 
@@ -102,7 +104,7 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p,
                                                       column_t column_id) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
 	if (local_storage.Find(bind_data.table->storage.get())) {
 		// we don't emit any statistics for tables that have outstanding transaction-local data
 		return nullptr;
@@ -114,7 +116,7 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 	auto &bind_data = (TableScanBindData &)*data_p.bind_data;
 	auto &gstate = (TableScanGlobalState &)*data_p.global_state;
 	auto &state = (TableScanLocalState &)*data_p.local_state;
-	auto &transaction = Transaction::GetTransaction(context);
+	auto &transaction = Transaction::Get(context, *bind_data.table->catalog);
 	do {
 		if (bind_data.is_create_index) {
 			bind_data.table->storage->CreateIndexScan(
@@ -180,14 +182,14 @@ BindInfo TableScanGetBindInfo(const FunctionData *bind_data) {
 	return BindInfo(ScanType::TABLE);
 }
 
-void TableScanDependency(unordered_set<CatalogEntry *> &entries, const FunctionData *bind_data_p) {
+void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_p) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	entries.insert(bind_data.table);
+	entries.AddDependency(bind_data.table);
 }
 
 unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
 	idx_t estimated_cardinality =
 	    bind_data.table->storage->info->cardinality + local_storage.AddedRows(bind_data.table->storage.get());
 	return make_unique<NodeStatistics>(bind_data.table->storage->info->cardinality, estimated_cardinality);
@@ -214,7 +216,7 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
 	}
 	auto result = make_unique<IndexScanGlobalState>(row_id_data);
-	auto &local_storage = LocalStorage::Get(context);
+	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
 	result->column_ids = input.column_ids;
 	result->local_storage_state.Initialize(input.column_ids, input.filters);
 	local_storage.InitializeScan(bind_data.table->storage.get(), result->local_storage_state.local_state,
@@ -227,7 +229,7 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (const TableScanBindData &)*data_p.bind_data;
 	auto &state = (IndexScanGlobalState &)*data_p.global_state;
-	auto &transaction = Transaction::GetTransaction(context);
+	auto &transaction = Transaction::Get(context, *bind_data.table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
 
 	if (!state.finished) {
@@ -363,7 +365,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		}
 		if (!equal_value.IsNull() || !low_value.IsNull() || !high_value.IsNull()) {
 			// we can scan this index using this predicate: try a scan
-			auto &transaction = Transaction::GetTransaction(context);
+			auto &transaction = Transaction::Get(context, *bind_data.table->catalog);
 			unique_ptr<IndexScanState> index_state;
 			if (!equal_value.IsNull()) {
 				// equality predicate
@@ -407,6 +409,7 @@ static void TableScanSerialize(FieldWriter &writer, const FunctionData *bind_dat
 	writer.WriteField<bool>(bind_data.is_index_scan);
 	writer.WriteField<bool>(bind_data.is_create_index);
 	writer.WriteList<row_t>(bind_data.result_ids);
+	writer.WriteString(bind_data.table->schema->catalog->GetName());
 }
 
 static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, FieldReader &reader,
@@ -416,9 +419,9 @@ static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, Fie
 	auto is_index_scan = reader.ReadRequired<bool>();
 	auto is_create_index = reader.ReadRequired<bool>();
 	auto result_ids = reader.ReadRequiredList<row_t>();
+	auto catalog_name = reader.ReadField<string>(INVALID_CATALOG);
 
-	auto &catalog = Catalog::GetCatalog(context);
-	auto catalog_entry = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, schema_name, table_name);
+	auto catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, catalog_name, schema_name, table_name);
 	if (!catalog_entry || catalog_entry->type != CatalogType::TABLE_ENTRY) {
 		throw SerializationException("Cant find table for %s.%s", schema_name, table_name);
 	}

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev781"
+#define DUCKDB_VERSION "0.6.2-dev889"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "c9893aabda"
+#define DUCKDB_SOURCE_ID "062fc98c51"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"