ClickHouse/src/Parsers/ASTIdentifier.cpp

289 lines
7.7 KiB
C++
Raw Normal View History

#include <Parsers/ASTIdentifier.h>
#include <IO/WriteHelpers.h>
#include <Interpreters/IdentifierSemantic.h>
2020-03-13 10:30:55 +00:00
#include <Interpreters/StorageID.h>
#include <Parsers/queryToString.h>
2020-11-09 16:05:40 +00:00
#include <IO/Operators.h>
namespace DB
{
2019-08-08 20:02:30 +00:00
namespace ErrorCodes
{
extern const int UNEXPECTED_AST_STRUCTURE;
}
2020-11-02 10:03:52 +00:00
ASTIdentifier::ASTIdentifier(const String & short_name, ASTPtr && name_param)
: full_name(short_name), name_parts{short_name}, semantic(std::make_shared<IdentifierSemanticImpl>())
{
2021-04-15 07:33:15 +00:00
if (!name_param)
2020-11-02 10:03:52 +00:00
assert(!full_name.empty());
else
children.push_back(std::move(name_param));
}
2019-08-08 20:02:30 +00:00
2020-11-02 10:03:52 +00:00
ASTIdentifier::ASTIdentifier(std::vector<String> && name_parts_, bool special, std::vector<ASTPtr> && name_params)
: name_parts(name_parts_), semantic(std::make_shared<IdentifierSemanticImpl>())
{
assert(!name_parts.empty());
semantic->special = special;
semantic->legacy_compound = true;
2020-11-02 10:03:52 +00:00
if (!name_params.empty())
{
size_t params = 0;
for (const auto & part [[maybe_unused]] : name_parts)
{
if (part.empty())
++params;
}
assert(params == name_params.size());
children = std::move(name_params);
}
else
{
for (const auto & part [[maybe_unused]] : name_parts)
assert(!part.empty());
2020-11-02 10:03:52 +00:00
if (!special && name_parts.size() >= 2)
semantic->table = name_parts.end()[-2];
2020-11-02 10:03:52 +00:00
resetFullName();
}
}
ASTPtr ASTIdentifier::getParam() const
{
assert(full_name.empty() && children.size() == 1);
return children.front()->clone();
}
ASTPtr ASTIdentifier::clone() const
{
auto ret = std::make_shared<ASTIdentifier>(*this);
ret->semantic = std::make_shared<IdentifierSemanticImpl>(*ret->semantic);
return ret;
}
bool ASTIdentifier::supposedToBeCompound() const
{
return semantic->legacy_compound;
}
2019-02-12 15:08:21 +00:00
void ASTIdentifier::setShortName(const String & new_name)
{
assert(!new_name.empty());
full_name = new_name;
name_parts = {new_name};
2019-02-12 15:08:21 +00:00
bool special = semantic->special;
auto table = semantic->table;
*semantic = IdentifierSemanticImpl();
semantic->special = special;
semantic->table = table;
2019-02-12 15:08:21 +00:00
}
const String & ASTIdentifier::name() const
{
2020-11-02 10:03:52 +00:00
if (children.empty())
{
assert(!name_parts.empty());
assert(!full_name.empty());
}
return full_name;
}
2020-11-02 10:03:52 +00:00
void ASTIdentifier::formatImplWithoutAlias(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const
{
2018-08-26 02:19:18 +00:00
auto format_element = [&](const String & elem_name)
{
settings.ostr << (settings.hilite ? hilite_identifier : "");
settings.writeIdentifier(elem_name);
settings.ostr << (settings.hilite ? hilite_none : "");
};
2021-04-14 15:35:52 +00:00
if (compound())
{
2020-11-02 10:03:52 +00:00
for (size_t i = 0, j = 0, size = name_parts.size(); i < size; ++i)
{
if (i != 0)
settings.ostr << '.';
2021-06-08 17:39:42 +00:00
/// Some AST rewriting code, like IdentifierSemantic::setColumnLongName,
/// does not respect children of identifier.
2021-06-08 15:23:42 +00:00
/// Here we also ignore children if they are empty.
if (name_parts[i].empty() && j < children.size())
2021-06-08 17:40:33 +00:00
{
children[j]->formatImpl(settings, state, frame);
++j;
}
2020-11-02 10:03:52 +00:00
else
format_element(name_parts[i]);
}
}
else
{
2020-11-02 10:03:52 +00:00
const auto & name = shortName();
if (name.empty() && !children.empty())
2020-11-02 10:03:52 +00:00
children.front()->formatImpl(settings, state, frame);
else
format_element(name);
}
}
void ASTIdentifier::appendColumnNameImpl(WriteBuffer & ostr) const
{
writeString(name(), ostr);
}
void ASTIdentifier::restoreTable()
{
if (!compound())
{
name_parts.insert(name_parts.begin(), semantic->table);
resetFullName();
}
}
2020-11-13 14:13:27 +00:00
std::shared_ptr<ASTTableIdentifier> ASTIdentifier::createTable() const
{
if (name_parts.size() == 1) return std::make_shared<ASTTableIdentifier>(name_parts[0]);
if (name_parts.size() == 2) return std::make_shared<ASTTableIdentifier>(name_parts[0], name_parts[1]);
return nullptr;
}
2020-10-26 15:49:00 +00:00
void ASTIdentifier::resetFullName()
{
2020-10-26 15:49:00 +00:00
full_name = name_parts[0];
for (size_t i = 1; i < name_parts.size(); ++i)
full_name += '.' + name_parts[i];
}
2021-04-15 07:33:15 +00:00
ASTTableIdentifier::ASTTableIdentifier(const String & table_name, std::vector<ASTPtr> && name_params)
: ASTIdentifier({table_name}, true, std::move(name_params))
2020-08-20 02:01:40 +00:00
{
}
2021-04-15 07:33:15 +00:00
ASTTableIdentifier::ASTTableIdentifier(const StorageID & table_id, std::vector<ASTPtr> && name_params)
2020-10-26 15:49:00 +00:00
: ASTIdentifier(
table_id.database_name.empty() ? std::vector<String>{table_id.table_name}
: std::vector<String>{table_id.database_name, table_id.table_name},
2021-04-15 07:33:15 +00:00
true, std::move(name_params))
{
2020-10-26 15:49:00 +00:00
uuid = table_id.uuid;
}
2021-04-15 07:33:15 +00:00
ASTTableIdentifier::ASTTableIdentifier(const String & database_name, const String & table_name, std::vector<ASTPtr> && name_params)
: ASTIdentifier({database_name, table_name}, true, std::move(name_params))
2019-01-15 12:28:17 +00:00
{
2020-03-12 18:04:29 +00:00
}
2019-01-15 12:28:17 +00:00
2020-10-26 15:49:00 +00:00
ASTPtr ASTTableIdentifier::clone() const
2020-03-12 18:04:29 +00:00
{
2020-10-26 15:49:00 +00:00
auto ret = std::make_shared<ASTTableIdentifier>(*this);
ret->semantic = std::make_shared<IdentifierSemanticImpl>(*ret->semantic);
return ret;
}
StorageID ASTTableIdentifier::getTableId() const
{
if (name_parts.size() == 2) return {name_parts[0], name_parts[1], uuid};
else return {{}, name_parts[0], uuid};
}
2020-12-16 13:32:23 +00:00
String ASTTableIdentifier::getDatabaseName() const
{
if (name_parts.size() == 2) return name_parts[0];
else return {};
}
2021-10-12 18:10:07 +00:00
ASTPtr ASTTableIdentifier::getTable() const
{
if (name_parts.size() == 2)
{
if (!name_parts[1].empty())
return std::make_shared<ASTIdentifier>(name_parts[1]);
if (name_parts[0].empty())
return std::make_shared<ASTIdentifier>("", children[1]->clone());
else
return std::make_shared<ASTIdentifier>("", children[0]->clone());
}
else if (name_parts.size() == 1)
2021-10-12 18:10:07 +00:00
{
if (name_parts[0].empty())
return std::make_shared<ASTIdentifier>("", children[0]->clone());
else
return std::make_shared<ASTIdentifier>(name_parts[0]);
}
else return {};
2021-10-12 18:10:07 +00:00
}
ASTPtr ASTTableIdentifier::getDatabase() const
{
if (name_parts.size() == 2)
{
if (name_parts[0].empty())
return std::make_shared<ASTIdentifier>("", children[0]->clone());
else
return std::make_shared<ASTIdentifier>(name_parts[0]);
}
else return {};
}
2020-10-26 15:49:00 +00:00
void ASTTableIdentifier::resetTable(const String & database_name, const String & table_name)
{
auto identifier = std::make_shared<ASTTableIdentifier>(database_name, table_name);
full_name.swap(identifier->full_name);
name_parts.swap(identifier->name_parts);
uuid = identifier->uuid;
}
void ASTTableIdentifier::updateTreeHashImpl(SipHash & hash_state) const
{
hash_state.update(uuid);
IAST::updateTreeHashImpl(hash_state);
2019-01-15 12:28:17 +00:00
}
2019-08-08 20:02:30 +00:00
String getIdentifierName(const IAST * ast)
{
2019-08-08 20:02:30 +00:00
String res;
if (tryGetIdentifierNameInto(ast, res))
return res;
2019-08-08 20:26:42 +00:00
throw Exception(ast ? queryToString(*ast) + " is not an identifier" : "AST node is nullptr", ErrorCodes::UNEXPECTED_AST_STRUCTURE);
2019-08-08 20:02:30 +00:00
}
std::optional<String> tryGetIdentifierName(const IAST * ast)
{
String res;
if (tryGetIdentifierNameInto(ast, res))
return res;
return {};
}
2019-08-08 20:26:42 +00:00
bool tryGetIdentifierNameInto(const IAST * ast, String & name)
{
if (ast)
2019-08-08 20:02:30 +00:00
{
2020-11-13 14:34:47 +00:00
if (const auto * node = dynamic_cast<const ASTIdentifier *>(ast))
{
name = node->name();
return true;
}
2019-08-08 20:02:30 +00:00
}
return false;
}
void setIdentifierSpecial(ASTPtr & ast)
{
if (ast)
2019-03-11 13:22:51 +00:00
if (auto * id = ast->as<ASTIdentifier>())
id->semantic->special = true;
2019-01-16 17:26:14 +00:00
}
}