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
|
#include "sql_complete.h"
#include "sql_context.h"
#include "string_util.h"
// FIXME(YQL-19747): unwanted dependency on a lexer implementation
#include <yql/essentials/sql/v1/lexer/antlr4_pure/lexer.h>
#include <yql/essentials/sql/v1/lexer/antlr4_pure_ansi/lexer.h>
#include <util/generic/algorithm.h>
#include <util/charset/utf8.h>
namespace NSQLComplete {
class TSqlCompletionEngine: public ISqlCompletionEngine {
public:
explicit TSqlCompletionEngine(TLexerSupplier lexer)
: ContextInference(MakeSqlContextInference(lexer))
{
}
TCompletion Complete(TCompletionInput input) {
auto prefix = input.Text.Head(input.CursorPosition);
auto completedToken = GetCompletedToken(prefix);
auto context = ContextInference->Analyze(input);
TVector<TCandidate> candidates;
EnrichWithKeywords(candidates, context.Keywords);
FilterByContent(candidates, completedToken.Content);
RankingSort(candidates);
return {
.CompletedToken = std::move(completedToken),
.Candidates = std::move(candidates),
};
}
private:
TCompletedToken GetCompletedToken(TStringBuf prefix) {
return {
.Content = LastWord(prefix),
.SourcePosition = LastWordIndex(prefix),
};
}
void EnrichWithKeywords(TVector<TCandidate>& candidates, TVector<TString> keywords) {
for (auto keyword : keywords) {
candidates.push_back({
.Kind = ECandidateKind::Keyword,
.Content = std::move(keyword),
});
}
}
void FilterByContent(TVector<TCandidate>& candidates, TStringBuf prefix) {
const auto lowerPrefix = ToLowerUTF8(prefix);
auto removed = std::ranges::remove_if(candidates, [&](const auto& candidate) {
return !ToLowerUTF8(candidate.Content).StartsWith(lowerPrefix);
});
candidates.erase(std::begin(removed), std::end(removed));
}
void RankingSort(TVector<TCandidate>& candidates) {
Sort(candidates, [](const TCandidate& lhs, const TCandidate& rhs) {
return std::tie(lhs.Kind, lhs.Content) < std::tie(rhs.Kind, rhs.Content);
});
}
ISqlContextInference::TPtr ContextInference;
};
// FIXME(YQL-19747): unwanted dependency on a lexer implementation
ISqlCompletionEngine::TPtr MakeSqlCompletionEngine() {
NSQLTranslationV1::TLexers lexers;
lexers.Antlr4Pure = NSQLTranslationV1::MakeAntlr4PureLexerFactory();
lexers.Antlr4PureAnsi = NSQLTranslationV1::MakeAntlr4PureAnsiLexerFactory();
return MakeSqlCompletionEngine([lexers = std::move(lexers)](bool ansi) {
return NSQLTranslationV1::MakeLexer(lexers, ansi, /* antlr4 = */ true, /* pure = */ true);
});
}
ISqlCompletionEngine::TPtr MakeSqlCompletionEngine(TLexerSupplier lexer) {
return ISqlCompletionEngine::TPtr(new TSqlCompletionEngine(lexer));
}
} // namespace NSQLComplete
template <>
void Out<NSQLComplete::ECandidateKind>(IOutputStream& out, NSQLComplete::ECandidateKind kind) {
switch (kind) {
case NSQLComplete::ECandidateKind::Keyword:
out << "Keyword";
break;
}
}
template <>
void Out<NSQLComplete::TCandidate>(IOutputStream& out, const NSQLComplete::TCandidate& candidate) {
out << "(" << candidate.Kind << ": " << candidate.Content << ")";
}
|
