aboutsummaryrefslogtreecommitdiffstats
path: root/yql/essentials/sql/v1/proto_parser/proto_parser.cpp
blob: 81df851a925e0ad5ced446a8dfaab5476533f3a3 (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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include "proto_parser.h"

#include <yql/essentials/utils/yql_panic.h>

#include <yql/essentials/parser/proto_ast/collect_issues/collect_issues.h>


#include <yql/essentials/sql/v1/proto_parser/antlr3/proto_parser.h>
#include <yql/essentials/sql/v1/proto_parser/antlr3_ansi/proto_parser.h>
#include <yql/essentials/sql/v1/proto_parser/antlr4/proto_parser.h>
#include <yql/essentials/sql/v1/proto_parser/antlr4_ansi/proto_parser.h>

#include <util/generic/algorithm.h>

#if defined(_tsan_enabled_)
#include <util/system/mutex.h>
#endif

using namespace NYql;

namespace NSQLTranslationV1 {


#if defined(_tsan_enabled_)
    TMutex SanitizerSQLTranslationMutex;
#endif

namespace {

void ReportError(NProtoAST::IErrorCollector& err, const TString& name) {
    err.Error(0, 0, TStringBuilder() << "Parser " << name << " is not supported");
}

}

google::protobuf::Message* SqlAST(const TParsers& parsers, const TString& query, const TString& queryName, TIssues& err,
    size_t maxErrors, bool ansiLexer, bool anlr4Parser, google::protobuf::Arena* arena) {
    NSQLTranslation::TErrorCollectorOverIssues collector(err, maxErrors, queryName);
    return SqlAST(parsers, query, queryName, collector, ansiLexer, anlr4Parser, arena);
}

google::protobuf::Message* SqlAST(const TParsers& parsers, const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err,
    bool ansiLexer, bool anlr4Parser, google::protobuf::Arena* arena) {
    YQL_ENSURE(arena);
#if defined(_tsan_enabled_)
    TGuard<TMutex> grd(SanitizerSQLTranslationMutex);
#endif
    if (ansiLexer && !anlr4Parser) {
        google::protobuf::Message* res = nullptr;
        if (parsers.Antlr3Ansi) {
            res = parsers.Antlr3Ansi->MakeParser()->Parse(query, queryName, err, arena);
            if (!res) {
                return res;
            }
        } else if (parsers.Antlr4Ansi) {
            res = parsers.Antlr4Ansi->MakeParser()->Parse(query, queryName, err, arena);
            if (!res) {
                return res;
            }
        } else {
            ReportError(err, "antlr3_ansi");
            return nullptr;
        }

        return res;
    } else if (!ansiLexer && !anlr4Parser) {
        google::protobuf::Message* res = nullptr;
        if (parsers.Antlr3) {
            res = parsers.Antlr3->MakeParser()->Parse(query, queryName, err, arena);
            if (!res) {
                return res;
            }
        } else if (parsers.Antlr4) {
            res = parsers.Antlr4->MakeParser()->Parse(query, queryName, err, arena);
            if (!res) {
                return res;
            }
        } else {
            ReportError(err, "antlr3");
            return nullptr;
        }

        return res;
    } else if (ansiLexer && anlr4Parser) {
        google::protobuf::Message* res = nullptr;
        if (parsers.Antlr4Ansi) {
            res = parsers.Antlr4Ansi->MakeParser()->Parse(query, queryName, err, arena);
            if (!res) {
                return res;
            }
        } else {
            ReportError(err, "antlr4_ansi");
            return nullptr;
        }

        return res;
    } else {
        google::protobuf::Message* res = nullptr;
        if (parsers.Antlr4) {
            res = parsers.Antlr4->MakeParser()->Parse(query, queryName, err, arena);
            if (!res) {
                return res;
            }
        } else {
            ReportError(err, "antlr4");
            return nullptr;
        }

        return res;
    }
}

google::protobuf::Message* SqlAST(const TString& query, const TString& queryName,
    NYql::TIssues& err, size_t maxErrors, bool ansiLexer, bool antlr4Parser, bool testAntlr4, google::protobuf::Arena* arena) {
    Y_UNUSED(testAntlr4);
    return SqlAST(MakeAllParsers(), query, queryName, err, maxErrors, ansiLexer, antlr4Parser, arena);
}

google::protobuf::Message* SqlAST(const TString& query, const TString& queryName,
    NProtoAST::IErrorCollector& err, bool ansiLexer, bool antlr4Parser, bool testAntlr4, google::protobuf::Arena* arena) {
    Y_UNUSED(testAntlr4);
    return SqlAST(MakeAllParsers(), query, queryName, err, ansiLexer, antlr4Parser, arena);
}

TParsers MakeAllParsers() {
    return TParsers {
        .Antlr3 = MakeAntlr3ParserFactory(),
        .Antlr3Ansi = MakeAntlr3AnsiParserFactory(),
        .Antlr4 = MakeAntlr4ParserFactory(),
        .Antlr4Ansi = MakeAntlr4AnsiParserFactory()
    };
}

} // namespace NSQLTranslationV1