ClickHouse/src/Functions/hasColumnInTable.cpp

159 lines
5.0 KiB
C++
Raw Normal View History

2021-05-17 07:30:42 +00:00
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnConst.h>
#include <DataTypes/DataTypesNumber.h>
#include <Storages/IStorage.h>
#include <Interpreters/Cluster.h>
#include <Interpreters/Context.h>
#include <Storages/getStructureOfRemoteTable.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
2020-06-24 16:37:04 +00:00
extern const int UNKNOWN_TABLE;
}
2020-09-07 18:00:37 +00:00
namespace
{
/** Usage:
* hasColumnInTable(['hostname'[, 'username'[, 'password']],] 'database', 'table', 'column')
*/
class FunctionHasColumnInTable : public IFunction, WithConstContext
{
public:
static constexpr auto name = "hasColumnInTable";
static FunctionPtr create(ContextConstPtr context_)
{
return std::make_shared<FunctionHasColumnInTable>(context_->getGlobalContext());
}
explicit FunctionHasColumnInTable(ContextConstPtr global_context_) : WithConstContext(global_context_)
{
}
bool isVariadic() const override
{
return true;
}
size_t getNumberOfArguments() const override
{
return 0;
}
String getName() const override
{
return name;
}
DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override;
bool isDeterministic() const override { return false; }
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override;
};
DataTypePtr FunctionHasColumnInTable::getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const
{
if (arguments.size() < 3 || arguments.size() > 6)
throw Exception{"Invalid number of arguments for function " + getName(),
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
static const std::string arg_pos_description[] = {"First", "Second", "Third", "Fourth", "Fifth", "Sixth"};
for (size_t i = 0; i < arguments.size(); ++i)
{
const ColumnWithTypeAndName & argument = arguments[i];
if (!checkColumnConst<ColumnString>(argument.column.get()))
{
throw Exception(arg_pos_description[i] + " argument for function " + getName() + " must be const String.",
ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
}
}
return std::make_shared<DataTypeUInt8>();
}
ColumnPtr FunctionHasColumnInTable::executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const
{
auto get_string_from_columns = [&](const ColumnWithTypeAndName & column) -> String
{
2020-10-19 13:42:14 +00:00
const ColumnConst * const_column = checkAndGetColumnConst<ColumnString>(column.column.get());
return const_column->getValue<String>();
};
size_t arg = 0;
String host_name;
String user_name;
String password;
if (arguments.size() > 3)
2020-10-14 14:04:50 +00:00
host_name = get_string_from_columns(arguments[arg++]);
if (arguments.size() > 4)
2020-10-14 14:04:50 +00:00
user_name = get_string_from_columns(arguments[arg++]);
if (arguments.size() > 5)
2020-10-14 14:04:50 +00:00
password = get_string_from_columns(arguments[arg++]);
2020-10-14 14:04:50 +00:00
String database_name = get_string_from_columns(arguments[arg++]);
String table_name = get_string_from_columns(arguments[arg++]);
String column_name = get_string_from_columns(arguments[arg++]);
2020-06-24 16:37:04 +00:00
if (table_name.empty())
throw Exception("Table name is empty", ErrorCodes::UNKNOWN_TABLE);
bool has_column;
if (host_name.empty())
{
// FIXME this (probably) needs a non-constant access to query context,
// because it might initialized a storage. Ideally, the tables required
// by the query should be initialized at an earlier stage.
const StoragePtr & table = DatabaseCatalog::instance().getTable(
{database_name, table_name},
const_pointer_cast<Context>(getContext()));
auto table_metadata = table->getInMemoryMetadataPtr();
has_column = table_metadata->getColumns().hasPhysical(column_name);
}
else
{
std::vector<std::vector<String>> host_names = {{ host_name }};
auto cluster = std::make_shared<Cluster>(
getContext()->getSettings(),
host_names,
!user_name.empty() ? user_name : "default",
password,
getContext()->getTCPPort(),
false);
// FIXME this (probably) needs a non-constant access to query context,
// because it might initialized a storage. Ideally, the tables required
// by the query should be initialized at an earlier stage.
auto remote_columns = getStructureOfRemoteTable(*cluster,
{database_name, table_name},
const_pointer_cast<Context>(getContext()));
has_column = remote_columns.hasPhysical(column_name);
}
2021-05-08 20:50:12 +00:00
return DataTypeUInt8().createColumnConst(input_rows_count, Field{UInt64(has_column)});
}
2020-09-07 18:00:37 +00:00
}
void registerFunctionHasColumnInTable(FunctionFactory & factory)
{
factory.registerFunction<FunctionHasColumnInTable>();
}
}