dt-sql-parser
Version:
SQL Parsers for BigData, built with antlr4
162 lines (161 loc) • 7.85 kB
JavaScript
import { processTokenCandidates } from '../common/tokenUtils';
import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
import { EntityContextType, } from '../common/types';
import { BasicSQL } from '../common/basicSQL';
import { FlinkEntityCollector } from './flinkEntityCollector';
import { FlinkErrorListener } from './flinkErrorListener';
import { FlinkSqlSplitListener } from './flinkSplitListener';
import { FlinkSemanticContextCollector } from './flinkSemanticContextCollector';
export { FlinkEntityCollector, FlinkSqlSplitListener };
export class FlinkSQL extends BasicSQL {
constructor() {
super(...arguments);
/**
* The rules that keywords you don't want to be suggested.
*/
this.excludeKeywordRules = new Set([
FlinkSqlParser.RULE_nonReservedKeywords,
FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncName,
FlinkSqlParser.RULE_reservedKeywordsFollowParamsUsedAsFuncName,
FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName,
FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncParam,
]);
this.preferredRules = new Set([
FlinkSqlParser.RULE_catalogPath, // catalog name
FlinkSqlParser.RULE_databasePath, // database name
FlinkSqlParser.RULE_databasePathCreate, // database name that will be created
FlinkSqlParser.RULE_tablePath, // table name
FlinkSqlParser.RULE_tablePathCreate, // table name that will be created
FlinkSqlParser.RULE_viewPath, // view name path
FlinkSqlParser.RULE_viewPathCreate, // viewName that will be created
FlinkSqlParser.RULE_functionName, // functionName
FlinkSqlParser.RULE_functionNameWithParams, // functionName
FlinkSqlParser.RULE_reservedKeywordsFollowParamsUsedAsFuncName, // functionName
FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName, // functionName
FlinkSqlParser.RULE_functionNameCreate, // functionName that will be created
FlinkSqlParser.RULE_columnName,
FlinkSqlParser.RULE_columnNamePath,
FlinkSqlParser.RULE_columnNameCreate,
FlinkSqlParser.RULE_tablePropertyKey,
FlinkSqlParser.RULE_tablePropertyValue,
...this.excludeKeywordRules,
]);
}
createLexerFromCharStream(charStreams) {
return new FlinkSqlLexer(charStreams);
}
createParserFromTokenStream(tokenStream) {
return new FlinkSqlParser(tokenStream);
}
get splitListener() {
return new FlinkSqlSplitListener();
}
createErrorListener(_errorListener) {
const parserContext = this;
return new FlinkErrorListener(_errorListener, parserContext, this.preferredRules);
}
createEntityCollector(input, allTokens, caretTokenIndex) {
return new FlinkEntityCollector(input, allTokens, caretTokenIndex);
}
createSemanticContextCollector(input, caretPosition, allTokens, options) {
return new FlinkSemanticContextCollector(input, caretPosition, allTokens, options);
}
processCandidates(candidates, allTokens, caretTokenIndex) {
const originalSyntaxSuggestions = [];
const keywords = [];
for (let candidate of candidates.rules) {
const [ruleType, candidateRule] = candidate;
const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
let syntaxContextType = void 0;
switch (ruleType) {
case FlinkSqlParser.RULE_catalogPath: {
syntaxContextType = EntityContextType.CATALOG;
break;
}
case FlinkSqlParser.RULE_databasePath: {
syntaxContextType = EntityContextType.DATABASE;
break;
}
case FlinkSqlParser.RULE_databasePathCreate: {
syntaxContextType = EntityContextType.DATABASE_CREATE;
break;
}
case FlinkSqlParser.RULE_tablePath: {
syntaxContextType = EntityContextType.TABLE;
break;
}
case FlinkSqlParser.RULE_tablePathCreate: {
syntaxContextType = EntityContextType.TABLE_CREATE;
break;
}
case FlinkSqlParser.RULE_viewPath: {
syntaxContextType = EntityContextType.VIEW;
break;
}
case FlinkSqlParser.RULE_viewPathCreate: {
syntaxContextType = EntityContextType.VIEW_CREATE;
break;
}
case FlinkSqlParser.RULE_functionName:
case FlinkSqlParser.RULE_functionNameWithParams:
case FlinkSqlParser.RULE_reservedKeywordsFollowParamsUsedAsFuncName:
case FlinkSqlParser.RULE_reservedKeywordsNoParamsUsedAsFuncName: {
syntaxContextType = EntityContextType.FUNCTION;
break;
}
case FlinkSqlParser.RULE_functionNameCreate: {
syntaxContextType = EntityContextType.FUNCTION_CREATE;
break;
}
case FlinkSqlParser.RULE_columnName: {
syntaxContextType = EntityContextType.COLUMN;
break;
}
case FlinkSqlParser.RULE_columnNameCreate: {
syntaxContextType = EntityContextType.COLUMN_CREATE;
break;
}
case FlinkSqlParser.RULE_columnNamePath: {
if (candidateRule.ruleList.includes(FlinkSqlParser.RULE_selectClause) ||
candidateRule.ruleList.includes(FlinkSqlParser.RULE_whereClause) ||
candidateRule.ruleList.includes(FlinkSqlParser.RULE_groupByClause) ||
candidateRule.ruleList.includes(FlinkSqlParser.RULE_limitClause) ||
candidateRule.ruleList.includes(FlinkSqlParser.RULE_whenClause) ||
candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause)) {
syntaxContextType = EntityContextType.COLUMN;
}
break;
}
case FlinkSqlParser.RULE_tablePropertyKey: {
syntaxContextType = EntityContextType.TABLE_PROPERTY_KEY;
break;
}
case FlinkSqlParser.RULE_tablePropertyValue: {
syntaxContextType = EntityContextType.TABLE_PROPERTY_VALUE;
break;
}
default:
break;
}
if (syntaxContextType &&
!originalSyntaxSuggestions.some((syn) => {
var _a, _b;
return syn.syntaxContextType === syntaxContextType &&
((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
})) {
originalSyntaxSuggestions.push({
syntaxContextType,
wordRanges: tokenRanges,
});
}
}
const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
keywords.push(...processedKeywords);
return {
syntax: originalSyntaxSuggestions,
keywords,
};
}
}