aboutsummaryrefslogtreecommitdiffstats
path: root/yql/essentials/sql/v1/complete/analysis/global/use.cpp
blob: d9a430ec12b9b301ab01009e948c8775f40b4afd (plain) (blame)
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
#include "use.h"

#include "evaluate.h"
#include "narrowing_visitor.h"

namespace NSQLComplete {

    namespace {

        class TVisitor: public TSQLv1NarrowingVisitor {
        public:
            TVisitor(
                antlr4::TokenStream* tokens,
                size_t cursorPosition,
                const TEnvironment* env)
                : TSQLv1NarrowingVisitor(tokens, cursorPosition)
                , Env_(env)
            {
            }

            std::any visitSql_stmt_core(SQLv1::Sql_stmt_coreContext* ctx) override {
                if (ctx->use_stmt() || IsEnclosing(ctx)) {
                    return visitChildren(ctx);
                }
                return {};
            }

            std::any visitUse_stmt(SQLv1::Use_stmtContext* ctx) override {
                SQLv1::Cluster_exprContext* expr = ctx->cluster_expr();
                if (!expr) {
                    return {};
                }

                std::string provider;
                std::string cluster;

                if (SQLv1::An_idContext* ctx = expr->an_id()) {
                    provider = ctx->getText();
                }

                if (SQLv1::Pure_column_or_namedContext* ctx = expr->pure_column_or_named()) {
                    if (auto id = GetId(ctx)) {
                        cluster = std::move(*id);
                    }
                }

                if (cluster.empty()) {
                    return {};
                }

                return TUseContext{
                    .Provider = std::move(provider),
                    .Cluster = std::move(cluster),
                };
            }

        private:
            TMaybe<TString> GetId(SQLv1::Pure_column_or_namedContext* ctx) const {
                if (auto* x = ctx->bind_parameter()) {
                    return GetId(x);
                } else if (auto* x = ctx->an_id()) {
                    return x->getText();
                } else {
                    Y_ABORT("You should change implementation according grammar changes");
                }
            }

            TMaybe<TString> GetId(SQLv1::Bind_parameterContext* ctx) const {
                NYT::TNode node = Evaluate(ctx, *Env_);
                if (!node.HasValue() || !node.IsString()) {
                    return Nothing();
                }
                return node.AsString();
            }

            const TEnvironment* Env_;
        };

    } // namespace

    TMaybe<TUseContext> FindUseStatement(
        SQLv1::Sql_queryContext* ctx,
        antlr4::TokenStream* tokens,
        size_t cursorPosition,
        const TEnvironment& env) {
        std::any result = TVisitor(tokens, cursorPosition, &env).visit(ctx);
        if (!result.has_value()) {
            return Nothing();
        }
        return std::any_cast<TUseContext>(result);
    }

} // namespace NSQLComplete