thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-09-20 00:30:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename ExternalDictionaries to ExternalDictionariesLoader

Browse Source
This commit is contained in:
alesapin 2019-09-26 13:41:33 +03:00
parent 5668f55ab7
commit 4fdb5a61e5
12 changed files with 90 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dbms/programs/server/Server.cpp
View File

@ -36,7 +36,7 @@
#include <IO/UseSSL.h>
#include <Interpreters/AsynchronousMetrics.h>
#include <Interpreters/DDLWorker.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Interpreters/ProcessList.h>
#include <Interpreters/loadMetadata.h>
#include <Interpreters/DNSCacheUpdater.h>
@ -918,7 +918,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
if (!config().getBool("dictionaries_lazy_load", true))
{
global_context->tryCreateEmbeddedDictionaries();
global_context->getExternalDictionaries().enableAlwaysLoadEverything(true);
global_context->getExternalDictionariesLoader().enableAlwaysLoadEverything(true);
}
}
catch (...)

14
dbms/src/Databases/DatabaseDictionary.cpp
View File

@ -1,6 +1,6 @@
#include <Databases/DatabaseDictionary.h>
#include <Interpreters/Context.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Storages/StorageDictionary.h>
#include <common/logger_useful.h>
#include <IO/WriteBufferFromString.h>
@ -38,12 +38,12 @@ Tables DatabaseDictionary::listTables(const Context & context, const FilterByNam
if (filter_by_name)
{
/// If `filter_by_name` is set, we iterate through all dictionaries with such names. That's why we need to load all of them.
loadables = context.getExternalDictionaries().loadAndGet(filter_by_name);
loadables = context.getExternalDictionariesLoader().loadAndGet(filter_by_name);
}
else
{
/// If `filter_by_name` isn't set, we iterate through only already loaded dictionaries. We don't try to load all dictionaries in this case.
loadables = context.getExternalDictionaries().getCurrentlyLoadedObjects();
loadables = context.getExternalDictionariesLoader().getCurrentlyLoadedObjects();
}
for (const auto & loadable : loadables)
@ -61,14 +61,14 @@ bool DatabaseDictionary::isTableExist(
const Context & context,
const String & table_name) const
{
return context.getExternalDictionaries().getCurrentStatus(table_name) != ExternalLoader::Status::NOT_EXIST;
return context.getExternalDictionariesLoader().getCurrentStatus(table_name) != ExternalLoader::Status::NOT_EXIST;
}
StoragePtr DatabaseDictionary::tryGetTable(
const Context & context,
const String & table_name) const
{
auto dict_ptr = context.getExternalDictionaries().tryGetDictionary(table_name);
auto dict_ptr = context.getExternalDictionariesLoader().tryGetDictionary(table_name);
if (dict_ptr)
{
const DictionaryStructure & dictionary_structure = dict_ptr->getStructure();
@ -86,7 +86,7 @@ DatabaseIteratorPtr DatabaseDictionary::getIterator(const Context & context, con
bool DatabaseDictionary::empty(const Context & context) const
{
return !context.getExternalDictionaries().hasCurrentlyLoadedObjects();
return !context.getExternalDictionariesLoader().hasCurrentlyLoadedObjects();
}
StoragePtr DatabaseDictionary::detachTable(const String & /*table_name*/)
@ -129,7 +129,7 @@ ASTPtr DatabaseDictionary::getCreateTableQueryImpl(const Context & context,
{
WriteBufferFromString buffer(query);
const auto & dictionaries = context.getExternalDictionaries();
const auto & dictionaries = context.getExternalDictionariesLoader();
auto dictionary = throw_on_error ? dictionaries.getDictionary(table_name)
: dictionaries.tryGetDictionary(table_name);

112
dbms/src/Functions/FunctionsExternalDictionaries.h
View File

@ -19,7 +19,7 @@
#include <Columns/ColumnTuple.h>
#include <Interpreters/Context.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Functions/IFunction.h>
#include <Functions/FunctionHelpers.h>
@ -51,7 +51,7 @@ namespace ErrorCodes
extern const int DICTIONARY_ACCESS_DENIED;
}
/** Functions that use plug-ins (external) dictionaries.
/** Functions that use plug-ins (external) dictionaries_loader.
*
* Get the value of the attribute of the specified type.
* dictGetType(dictionary, attribute, id),
@ -73,11 +73,11 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictHas>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictHas>(context.getExternalDictionariesLoader(), context);
}
FunctionDictHas(const ExternalDictionaries & dictionaries_, const Context & context_)
: dictionaries(dictionaries_)
FunctionDictHas(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_)
: dictionaries_loader(dictionaries_loader_)
, context(context_) {}
String getName() const override { return name; }
@ -124,7 +124,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -191,12 +191,12 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
};
static bool isDictGetFunctionInjective(const ExternalDictionaries & dictionaries, const Block & sample_block)
static bool isDictGetFunctionInjective(const ExternalDictionariesLoader & dictionaries_loader, const Block & sample_block)
{
if (sample_block.columns() != 3 && sample_block.columns() != 4)
throw Exception{"Function dictGet... takes 3 or 4 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
@ -209,7 +209,7 @@ static bool isDictGetFunctionInjective(const ExternalDictionaries & dictionaries
if (!attr_name_col)
throw Exception{"Second argument of function dictGet... must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
return dictionaries.getDictionary(dict_name_col->getValue<String>())->isInjective(attr_name_col->getValue<String>());
return dictionaries_loader.getDictionary(dict_name_col->getValue<String>())->isInjective(attr_name_col->getValue<String>());
}
@ -227,11 +227,11 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictGetString>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictGetString>(context.getExternalDictionariesLoader(), context);
}
FunctionDictGetString(const ExternalDictionaries & dictionaries_, const Context & context_)
: dictionaries(dictionaries_)
FunctionDictGetString(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_)
: dictionaries_loader(dictionaries_loader_)
, context(context_) {}
String getName() const override { return name; }
@ -245,7 +245,7 @@ private:
bool isInjective(const Block & sample_block) override
{
return isDictGetFunctionInjective(dictionaries, sample_block);
return isDictGetFunctionInjective(dictionaries_loader, sample_block);
}
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
@ -273,7 +273,7 @@ private:
+ ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
}
/// This is for the case of range dictionaries.
/// This is for the case of range dictionaries_loader.
if (arguments.size() == 4 && !arguments[3]->isValueRepresentedByInteger())
{
throw Exception{"Illegal type " + arguments[3]->getName() +
@ -299,7 +299,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -368,7 +368,7 @@ private:
String attr_name = attr_name_col->getValue<String>();
const ColumnWithTypeAndName & key_col_with_type = block.getByPosition(arguments[2]);
/// Functions in external dictionaries only support full-value (not constant) columns with keys.
/// Functions in external dictionaries_loader only support full-value (not constant) columns with keys.
ColumnPtr key_col = key_col_with_type.column->convertToFullColumnIfConst();
if (checkColumn<ColumnTuple>(key_col.get()))
@ -419,7 +419,7 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
};
@ -431,11 +431,11 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictGetStringOrDefault>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictGetStringOrDefault>(context.getExternalDictionariesLoader(), context);
}
FunctionDictGetStringOrDefault(const ExternalDictionaries & dictionaries_, const Context & context_)
: dictionaries(dictionaries_)
FunctionDictGetStringOrDefault(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_)
: dictionaries_loader(dictionaries_loader_)
, context(context_) {}
String getName() const override { return name; }
@ -485,7 +485,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -606,7 +606,7 @@ private:
String attr_name = attr_name_col->getValue<String>();
const ColumnWithTypeAndName & key_col_with_type = block.getByPosition(arguments[2]);
/// Functions in external dictionaries only support full-value (not constant) columns with keys.
/// Functions in external dictionaries_loader only support full-value (not constant) columns with keys.
ColumnPtr key_col = key_col_with_type.column->convertToFullColumnIfConst();
const auto & key_columns = typeid_cast<const ColumnTuple &>(*key_col).getColumnsCopy();
@ -631,7 +631,7 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
};
@ -755,11 +755,11 @@ public:
static FunctionPtr create(const Context & context, UInt32 dec_scale = 0)
{
return std::make_shared<FunctionDictGet>(context.getExternalDictionaries(), context, dec_scale);
return std::make_shared<FunctionDictGet>(context.getExternalDictionariesLoader(), context, dec_scale);
}
FunctionDictGet(const ExternalDictionaries & dictionaries_, const Context & context_, UInt32 dec_scale = 0)
: dictionaries(dictionaries_)
FunctionDictGet(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_, UInt32 dec_scale = 0)
: dictionaries_loader(dictionaries_loader_)
, context(context_)
, decimal_scale(dec_scale)
{}
@ -775,7 +775,7 @@ private:
bool isInjective(const Block & sample_block) override
{
return isDictGetFunctionInjective(dictionaries, sample_block);
return isDictGetFunctionInjective(dictionaries_loader, sample_block);
}
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
@ -827,7 +827,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -922,7 +922,7 @@ private:
const ColumnWithTypeAndName & key_col_with_type = block.getByPosition(arguments[2]);
/// Functions in external dictionaries only support full-value (not constant) columns with keys.
/// Functions in external dictionaries_loader only support full-value (not constant) columns with keys.
ColumnPtr key_col = key_col_with_type.column->convertToFullColumnIfConst();
if (checkColumn<ColumnTuple>(key_col.get()))
@ -983,7 +983,7 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
UInt32 decimal_scale;
};
@ -1034,11 +1034,11 @@ public:
static FunctionPtr create(const Context & context, UInt32 dec_scale = 0)
{
return std::make_shared<FunctionDictGetOrDefault>(context.getExternalDictionaries(), context, dec_scale);
return std::make_shared<FunctionDictGetOrDefault>(context.getExternalDictionariesLoader(), context, dec_scale);
}
FunctionDictGetOrDefault(const ExternalDictionaries & dictionaries_, const Context & context_, UInt32 dec_scale = 0)
: dictionaries(dictionaries_)
FunctionDictGetOrDefault(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_, UInt32 dec_scale = 0)
: dictionaries_loader(dictionaries_loader_)
, context(context_)
, decimal_scale(dec_scale)
{}
@ -1091,7 +1091,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -1248,7 +1248,7 @@ private:
const ColumnWithTypeAndName & key_col_with_type = block.getByPosition(arguments[2]);
/// Functions in external dictionaries only support full-value (not constant) columns with keys.
/// Functions in external dictionaries_loader only support full-value (not constant) columns with keys.
ColumnPtr key_col = key_col_with_type.column->convertToFullColumnIfConst();
const auto & key_columns = typeid_cast<const ColumnTuple &>(*key_col).getColumnsCopy();
@ -1284,7 +1284,7 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
UInt32 decimal_scale;
};
@ -1332,10 +1332,10 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictGetNoType>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictGetNoType>(context.getExternalDictionariesLoader(), context);
}
FunctionDictGetNoType(const ExternalDictionaries & dictionaries_, const Context & context_) : dictionaries(dictionaries_), context(context_) {}
FunctionDictGetNoType(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_) : dictionaries_loader(dictionaries_loader_), context(context_) {}
String getName() const override { return name; }
@ -1348,7 +1348,7 @@ private:
bool isInjective(const Block & sample_block) override
{
return isDictGetFunctionInjective(dictionaries, sample_block);
return isDictGetFunctionInjective(dictionaries_loader, sample_block);
}
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
@ -1388,7 +1388,7 @@ private:
+ ", must be convertible to " + TypeName<Int64>::get() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
}
auto dict = dictionaries.getDictionary(dict_name);
auto dict = dictionaries_loader.getDictionary(dict_name);
const DictionaryStructure & structure = dict->getStructure();
for (const auto idx : ext::range(0, structure.attributes.size()))
@ -1468,7 +1468,7 @@ private:
}
private:
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
mutable FunctionPtr impl; // underlying function used by dictGet function without explicit type info
};
@ -1481,10 +1481,10 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictGetNoTypeOrDefault>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictGetNoTypeOrDefault>(context.getExternalDictionariesLoader(), context);
}
FunctionDictGetNoTypeOrDefault(const ExternalDictionaries & dictionaries_, const Context & context_) : dictionaries(dictionaries_), context(context_) {}
FunctionDictGetNoTypeOrDefault(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_) : dictionaries_loader(dictionaries_loader_), context(context_) {}
String getName() const override { return name; }
@ -1496,7 +1496,7 @@ private:
bool isInjective(const Block & sample_block) override
{
return isDictGetFunctionInjective(dictionaries, sample_block);
return isDictGetFunctionInjective(dictionaries_loader, sample_block);
}
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
@ -1524,7 +1524,7 @@ private:
throw Exception{"Illegal type " + arguments[2].type->getName() + " of third argument of function " + getName()
+ ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
auto dict = dictionaries.getDictionary(dict_name);
auto dict = dictionaries_loader.getDictionary(dict_name);
const DictionaryStructure & structure = dict->getStructure();
for (const auto idx : ext::range(0, structure.attributes.size()))
@ -1610,7 +1610,7 @@ private:
}
private:
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
mutable FunctionPtr impl; // underlying function used by dictGet function without explicit type info
};
@ -1624,11 +1624,11 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictGetHierarchy>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictGetHierarchy>(context.getExternalDictionariesLoader(), context);
}
FunctionDictGetHierarchy(const ExternalDictionaries & dictionaries_, const Context & context_)
: dictionaries(dictionaries_)
FunctionDictGetHierarchy(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_)
: dictionaries_loader(dictionaries_loader_)
, context(context_) {}
String getName() const override { return name; }
@ -1668,7 +1668,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -1778,7 +1778,7 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
};
@ -1790,11 +1790,11 @@ public:
static FunctionPtr create(const Context & context)
{
return std::make_shared<FunctionDictIsIn>(context.getExternalDictionaries(), context);
return std::make_shared<FunctionDictIsIn>(context.getExternalDictionariesLoader(), context);
}
FunctionDictIsIn(const ExternalDictionaries & dictionaries_, const Context & context_)
: dictionaries(dictionaries_)
FunctionDictIsIn(const ExternalDictionariesLoader & dictionaries_loader_, const Context & context_)
: dictionaries_loader(dictionaries_loader_)
, context(context_) {}
String getName() const override { return name; }
@ -1837,7 +1837,7 @@ private:
return;
}
auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
auto dict = dictionaries_loader.getDictionary(dict_name_col->getValue<String>());
const auto dict_ptr = dict.get();
if (!context.hasDictionaryAccessRights(dict_ptr->getName()))
@ -1949,7 +1949,7 @@ private:
return true;
}
const ExternalDictionaries & dictionaries;
const ExternalDictionariesLoader & dictionaries_loader;
const Context & context;
};

22
dbms/src/Interpreters/Context.cpp
View File

@ -29,7 +29,7 @@
#include <Interpreters/IUsersManager.h>
#include <Interpreters/Quota.h>
#include <Interpreters/EmbeddedDictionaries.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Interpreters/ExternalModelsLoader.h>
#include <Interpreters/ExpressionActions.h>
#include <Interpreters/ProcessList.h>
@ -124,7 +124,7 @@ struct ContextShared
Databases databases; /// List of databases and tables in them.
mutable std::optional<EmbeddedDictionaries> embedded_dictionaries; /// Metrica's dictionaries. Have lazy initialization.
mutable std::optional<ExternalDictionaries> external_dictionaries;
mutable std::optional<ExternalDictionariesLoader> external_dictionaries_loader;
mutable std::optional<ExternalModelsLoader> external_models_loader;
String default_profile_name; /// Default profile name used for default values.
String system_profile_name; /// Profile used by system processes
@ -282,7 +282,7 @@ struct ContextShared
system_logs.reset();
embedded_dictionaries.reset();
external_dictionaries.reset();
external_dictionaries_loader.reset();
external_models_loader.reset();
background_pool.reset();
schedule_pool.reset();
@ -1312,30 +1312,30 @@ EmbeddedDictionaries & Context::getEmbeddedDictionaries()
}
const ExternalDictionaries & Context::getExternalDictionaries() const
const ExternalDictionariesLoader & Context::getExternalDictionariesLoader() const
{
{
std::lock_guard lock(shared->external_dictionaries_mutex);
if (shared->external_dictionaries)
return *shared->external_dictionaries;
if (shared->external_dictionaries_loader)
return *shared->external_dictionaries_loader;
}
const auto & config = getConfigRef();
std::lock_guard lock(shared->external_dictionaries_mutex);
if (!shared->external_dictionaries)
if (!shared->external_dictionaries_loader)
{
if (!this->global_context)
throw Exception("Logical error: there is no global context", ErrorCodes::LOGICAL_ERROR);
auto config_repository = shared->runtime_components_factory->createExternalDictionariesConfigRepository();
shared->external_dictionaries.emplace(std::move(config_repository), config, *this->global_context);
shared->external_dictionaries_loader.emplace(std::move(config_repository), config, *this->global_context);
}
return *shared->external_dictionaries;
return *shared->external_dictionaries_loader;
}
ExternalDictionaries & Context::getExternalDictionaries()
ExternalDictionariesLoader & Context::getExternalDictionariesLoader()
{
return const_cast<ExternalDictionaries &>(const_cast<const Context *>(this)->getExternalDictionaries());
return const_cast<ExternalDictionariesLoader &>(const_cast<const Context *>(this)->getExternalDictionariesLoader());
}

6
dbms/src/Interpreters/Context.h
View File

@ -46,7 +46,7 @@ class Context;
class RuntimeComponentsFactory;
class QuotaForIntervals;
class EmbeddedDictionaries;
class ExternalDictionaries;
class ExternalDictionariesLoader;
class ExternalModelsLoader;
class InterserverIOHandler;
class BackgroundProcessingPool;
@ -321,10 +321,10 @@ public:
void checkSettingsConstraints(const SettingsChanges & changes);
const EmbeddedDictionaries & getEmbeddedDictionaries() const;
const ExternalDictionaries & getExternalDictionaries() const;
const ExternalDictionariesLoader & getExternalDictionariesLoader() const;
const ExternalModelsLoader & getExternalModelsLoader() const;
EmbeddedDictionaries & getEmbeddedDictionaries();
ExternalDictionaries & getExternalDictionaries();
ExternalDictionariesLoader & getExternalDictionariesLoader();
ExternalModelsLoader & getExternalModelsLoader();
void tryCreateEmbeddedDictionaries() const;

2
dbms/src/Interpreters/ExpressionAnalyzer.cpp
View File

@ -27,7 +27,7 @@
#include <Interpreters/InJoinSubqueriesPreprocessor.h>
#include <Interpreters/LogicalExpressionsOptimizer.h>
#include <Interpreters/PredicateExpressionsOptimizer.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Interpreters/Set.h>
#include <Interpreters/AnalyzedJoin.h>
#include <Interpreters/Join.h>

30
dbms/src/Interpreters/ExternalDictionaries.cpp
View File

@ -1,30 +0,0 @@
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/Context.h>
#include <Dictionaries/DictionaryFactory.h>
namespace DB
{
/// Must not acquire Context lock in constructor to avoid possibility of deadlocks.
ExternalDictionaries::ExternalDictionaries(
std::unique_ptr<IExternalLoaderConfigRepository> config_repository,
const Poco::Util::AbstractConfiguration & config,
Context & context_)
: ExternalLoader(config,
"external dictionary",
&Logger::get("ExternalDictionaries")),
context(context_)
{
addConfigRepository(std::move(config_repository), {"dictionary", "name", "dictionaries_config"});
enableAsyncLoading(true);
enablePeriodicUpdates(true);
}
ExternalLoader::LoadablePtr ExternalDictionaries::create(
const std::string & name, const Poco::Util::AbstractConfiguration & config, const std::string & key_in_config) const
{
return DictionaryFactory::instance().create(name, config, key_in_config, context);
}
}

48
dbms/src/Interpreters/ExternalDictionaries.h
View File

@ -1,48 +0,0 @@
#pragma once
#include <Dictionaries/IDictionary.h>
#include <Interpreters/ExternalLoader.h>
#include <common/logger_useful.h>
#include <memory>
namespace DB
{
class Context;
/// Manages user-defined dictionaries.
class ExternalDictionaries : public ExternalLoader
{
public:
using DictPtr = std::shared_ptr<const IDictionaryBase>;
/// Dictionaries will be loaded immediately and then will be updated in separate thread, each 'reload_period' seconds.
ExternalDictionaries(
std::unique_ptr<IExternalLoaderConfigRepository> config_repository,
const Poco::Util::AbstractConfiguration & config,
Context & context_);
DictPtr getDictionary(const std::string & name) const
{
return std::static_pointer_cast<const IDictionaryBase>(getLoadable(name));
}
DictPtr tryGetDictionary(const std::string & name) const
{
return std::static_pointer_cast<const IDictionaryBase>(tryGetLoadable(name));
}
protected:
LoadablePtr create(const std::string & name, const Poco::Util::AbstractConfiguration & config,
const std::string & key_in_config) const override;
friend class StorageSystemDictionaries;
friend class DatabaseDictionary;
private:
Context & context;
};
}

6
dbms/src/Interpreters/InterpreterSystemQuery.cpp
View File

@ -6,7 +6,7 @@
#include <Common/getNumberOfPhysicalCPUCores.h>
#include <Common/ThreadPool.h>
#include <Interpreters/Context.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Interpreters/EmbeddedDictionaries.h>
#include <Interpreters/ActionLocksManager.h>
#include <Interpreters/InterpreterDropQuery.h>
@ -165,11 +165,11 @@ BlockIO InterpreterSystemQuery::execute()
break;
#endif
case Type::RELOAD_DICTIONARY:
system_context.getExternalDictionaries().reload(query.target_dictionary, true /* load the dictionary even if it wasn't loading before */);
system_context.getExternalDictionariesLoader().reload(query.target_dictionary, true /* load the dictionary even if it wasn't loading before */);
break;
case Type::RELOAD_DICTIONARIES:
executeCommandsAndThrowIfError(
[&] () { system_context.getExternalDictionaries().reload(); },
[&] () { system_context.getExternalDictionariesLoader().reload(); },
[&] () { system_context.getEmbeddedDictionaries().reload(); }
);
break;

4
dbms/src/Interpreters/SyntaxAnalyzer.cpp
View File

@ -13,7 +13,7 @@
#include <Interpreters/ExecuteScalarSubqueriesVisitor.h>
#include <Interpreters/PredicateExpressionsOptimizer.h>
#include <Interpreters/CollectJoinOnKeysVisitor.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Interpreters/OptimizeIfWithConstantConditionVisitor.h>
#include <Interpreters/RequiredSourceColumnsVisitor.h>
#include <Interpreters/GetAggregatesVisitor.h>
@ -315,7 +315,7 @@ void optimizeGroupBy(ASTSelectQuery * select_query, const NameSet & source_colum
}
const auto & dict_name = function->arguments->children[0]->as<ASTLiteral &>().value.safeGet<String>();
const auto & dict_ptr = context.getExternalDictionaries().getDictionary(dict_name);
const auto & dict_ptr = context.getExternalDictionariesLoader().getDictionary(dict_name);
const auto & attr_name = function->arguments->children[1]->as<ASTLiteral &>().value.safeGet<String>();
if (!dict_ptr->isInjective(attr_name))

6
dbms/src/Storages/StorageDictionary.cpp
View File

@ -7,7 +7,7 @@
#include <Storages/StorageFactory.h>
#include <Interpreters/Context.h>
#include <Interpreters/evaluateConstantExpression.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Parsers/ASTLiteral.h>
#include <common/logger_useful.h>
#include <Common/typeid_cast.h>
@ -39,7 +39,7 @@ StorageDictionary::StorageDictionary(
if (!attach)
{
const auto & dictionary = context.getExternalDictionaries().getDictionary(dictionary_name);
const auto & dictionary = context.getExternalDictionariesLoader().getDictionary(dictionary_name);
const DictionaryStructure & dictionary_structure = dictionary->getStructure();
checkNamesAndTypesCompatibleWithDictionary(dictionary_structure);
}
@ -53,7 +53,7 @@ BlockInputStreams StorageDictionary::read(
const size_t max_block_size,
const unsigned /*threads*/)
{
auto dictionary = context.getExternalDictionaries().getDictionary(dictionary_name);
auto dictionary = context.getExternalDictionariesLoader().getDictionary(dictionary_name);
return BlockInputStreams{dictionary->getBlockInputStream(column_names, max_block_size)};
}

4
dbms/src/Storages/System/StorageSystemDictionaries.cpp
View File

@ -7,7 +7,7 @@
#include <Dictionaries/IDictionarySource.h>
#include <Dictionaries/DictionaryStructure.h>
#include <Interpreters/Context.h>
#include <Interpreters/ExternalDictionaries.h>
#include <Interpreters/ExternalDictionariesLoader.h>
#include <Storages/System/StorageSystemDictionaries.h>
#include <ext/map.h>
@ -41,7 +41,7 @@ NamesAndTypesList StorageSystemDictionaries::getNamesAndTypes()
void StorageSystemDictionaries::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
const auto & external_dictionaries = context.getExternalDictionaries();
const auto & external_dictionaries = context.getExternalDictionariesLoader();
for (const auto & [dict_name, load_result] : external_dictionaries.getCurrentLoadResults())
{
size_t i = 0;