ClickHouse/dbms/src/Databases/DatabaseMemory.cpp

#include <common/logger_useful.h>
#include <DB/Databases/DatabaseMemory.h>
#include <DB/Databases/DatabasesCommon.h>


namespace DB
{

namespace ErrorCodes
{
	extern const int TABLE_ALREADY_EXISTS;
	extern const int UNKNOWN_TABLE;
	extern const int LOGICAL_ERROR;
}

void DatabaseMemory::loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag)
{
	log = &Logger::get("DatabaseMemory(" + name + ")");

	/// Nothing to load.
}

bool DatabaseMemory::isTableExist(const String & table_name) const
{
	std::lock_guard<std::mutex> lock(mutex);
	return tables.count(table_name);
}

StoragePtr DatabaseMemory::tryGetTable(const String & table_name)
{
	std::lock_guard<std::mutex> lock(mutex);
	auto it = tables.find(table_name);
	if (it == tables.end())
		return {};
	return it->second;
}

DatabaseIteratorPtr DatabaseMemory::getIterator()
{
	std::lock_guard<std::mutex> lock(mutex);
	return std::make_unique<DatabaseSnaphotIterator>(tables);
}

bool DatabaseMemory::empty() const
{
	std::lock_guard<std::mutex> lock(mutex);
	return tables.empty();
}

StoragePtr DatabaseMemory::detachTable(const String & table_name)
{
	StoragePtr res;
	{
		std::lock_guard<std::mutex> lock(mutex);
		auto it = tables.find(table_name);
		if (it == tables.end())
			throw Exception("Table " + name + "." + table_name + " doesn't exist.", ErrorCodes::TABLE_ALREADY_EXISTS);
		res = it->second;
		tables.erase(it);
	}

	return res;
}

void DatabaseMemory::attachTable(const String & table_name, const StoragePtr & table)
{
	std::lock_guard<std::mutex> lock(mutex);
	if (!tables.emplace(table_name, table).second)
		throw Exception("Table " + name + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
}

void DatabaseMemory::createTable(
	const String & table_name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings)
{
	attachTable(table_name, table);
}

void DatabaseMemory::removeTable(const String & table_name)
{
	detachTable(table_name);
}

void DatabaseMemory::renameTable(
	const Context & context, const String & table_name, IDatabase & to_database, const String & to_table_name, const Settings & settings)
{
	throw Exception("DatabaseMemory: renameTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
}

time_t DatabaseMemory::getTableMetadataModificationTime(const String & table_name)
{
	return static_cast<time_t>(0);
}

ASTPtr DatabaseMemory::getCreateQuery(const String & table_name) const
{
	throw Exception("DatabaseMemory: getCreateQuery() is not supported", ErrorCodes::NOT_IMPLEMENTED);
	return nullptr;
}

void DatabaseMemory::shutdown()
{
	/// You can not hold a lock during shutdown.
	/// Because inside `shutdown` function tables can work with database, and mutex is not recursive.

	for (auto iterator = getIterator(); iterator->isValid(); iterator->next())
		iterator->table()->shutdown();

	std::lock_guard<std::mutex> lock(mutex);
	tables.clear();
}

void DatabaseMemory::drop()
{
	/// Additional actions to delete database are not required.
}

void DatabaseMemory::alterTable(
	const Context & context,
	const String & name,
	const NamesAndTypesList & columns,
	const NamesAndTypesList & materialized_columns,
	const NamesAndTypesList & alias_columns,
	const ColumnDefaults & column_defaults,
	const ASTModifier & engine_modifier)
{
	throw Exception("DatabaseMemory: alterTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
}

}