1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
#include <Access/IAccessStorage.h>
#include <Parsers/Access/ParserDropAccessEntityQuery.h>
#include <Parsers/Access/ASTDropAccessEntityQuery.h>
#include <Parsers/Access/ParserRowPolicyName.h>
#include <Parsers/Access/ASTRowPolicyName.h>
#include <Parsers/Access/parseUserName.h>
#include <Parsers/CommonParsers.h>
#include <Parsers/parseIdentifierOrStringLiteral.h>
#include <base/range.h>
namespace DB
{
namespace
{
bool parseEntityType(IParserBase::Pos & pos, Expected & expected, AccessEntityType & type)
{
for (auto i : collections::range(AccessEntityType::MAX))
{
const auto & type_info = AccessEntityTypeInfo::get(i);
if (ParserKeyword{type_info.name}.ignore(pos, expected)
|| (!type_info.alias.empty() && ParserKeyword{type_info.alias}.ignore(pos, expected)))
{
type = i;
return true;
}
}
return false;
}
bool parseOnCluster(IParserBase::Pos & pos, Expected & expected, String & cluster)
{
return IParserBase::wrapParseImpl(pos, [&]
{
return ParserKeyword{"ON"}.ignore(pos, expected) && ASTQueryWithOnCluster::parse(pos, cluster, expected);
});
}
}
bool ParserDropAccessEntityQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{
if (!ParserKeyword{"DROP"}.ignore(pos, expected))
return false;
AccessEntityType type;
if (!parseEntityType(pos, expected, type))
return false;
bool if_exists = false;
if (ParserKeyword{"IF EXISTS"}.ignore(pos, expected))
if_exists = true;
Strings names;
std::shared_ptr<ASTRowPolicyNames> row_policy_names;
String storage_name;
String cluster;
if ((type == AccessEntityType::USER) || (type == AccessEntityType::ROLE))
{
if (!parseUserNames(pos, expected, names))
return false;
}
else if (type == AccessEntityType::ROW_POLICY)
{
ParserRowPolicyNames parser;
ASTPtr ast;
parser.allowOnCluster();
if (!parser.parse(pos, ast, expected))
return false;
row_policy_names = typeid_cast<std::shared_ptr<ASTRowPolicyNames>>(ast);
cluster = std::exchange(row_policy_names->cluster, "");
}
else
{
if (!parseIdentifiersOrStringLiterals(pos, expected, names))
return false;
}
if (ParserKeyword{"FROM"}.ignore(pos, expected))
parseAccessStorageName(pos, expected, storage_name);
if (cluster.empty())
parseOnCluster(pos, expected, cluster);
auto query = std::make_shared<ASTDropAccessEntityQuery>();
node = query;
query->type = type;
query->if_exists = if_exists;
query->cluster = std::move(cluster);
query->names = std::move(names);
query->row_policy_names = std::move(row_policy_names);
query->storage_name = std::move(storage_name);
return true;
}
}
|
