9277 lines
1.7 MiB
JavaScript
9277 lines
1.7 MiB
JavaScript
|
// Licensed to Cloudera, Inc. under one
|
||
|
|
// or more contributor license agreements. See the NOTICE file
|
||
|
|
// distributed with this work for additional information
|
||
|
|
// regarding copyright ownership. Cloudera, Inc. licenses this file
|
||
|
|
// to you under the Apache License, Version 2.0 (the
|
||
|
|
// "License"); you may not use this file except in compliance
|
||
|
|
// with the License. You may obtain a copy of the License at
|
||
|
|
//
|
||
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
//
|
||
|
|
// Unless required by applicable law or agreed to in writing, software
|
||
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
// See the License for the specific language governing permissions and
|
||
|
|
// limitations under the License.
|
||
|
|
|
||
|
|
var SqlParseSupport = (function () {
|
||
|
|
|
||
|
|
// endsWith polyfill from hue_utils.js, needed as workers live in their own js environment
|
||
|
|
if (!String.prototype.endsWith) {
|
||
|
|
String.prototype.endsWith = function (searchString, position) {
|
||
|
|
var subjectString = this.toString();
|
||
|
|
if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
|
||
|
|
position = subjectString.length;
|
||
|
|
}
|
||
|
|
position -= searchString.length;
|
||
|
|
var lastIndex = subjectString.lastIndexOf(searchString, position);
|
||
|
|
return lastIndex !== -1 && lastIndex === position;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Calculates the Optimal String Alignment distance between two strings. Returns 0 when the strings are equal and the
|
||
|
|
* distance when not, distances is less than or equal to the length of the longest string.
|
||
|
|
*
|
||
|
|
* @param strA
|
||
|
|
* @param strB
|
||
|
|
* @param [ignoreCase]
|
||
|
|
* @returns {number} The similarity
|
||
|
|
*/
|
||
|
|
var stringDistance = function (strA, strB, ignoreCase) {
|
||
|
|
if (ignoreCase) {
|
||
|
|
strA = strA.toLowerCase();
|
||
|
|
strB = strB.toLowerCase();
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO: Consider other algorithms for performance
|
||
|
|
var strALength = strA.length;
|
||
|
|
var strBLength = strB.length;
|
||
|
|
if (strALength === 0) {
|
||
|
|
return strBLength;
|
||
|
|
}
|
||
|
|
if (strBLength === 0) {
|
||
|
|
return strALength;
|
||
|
|
}
|
||
|
|
|
||
|
|
var distances = new Array(strALength);
|
||
|
|
|
||
|
|
var cost, deletion, insertion, substitution, transposition;
|
||
|
|
for (var i = 0; i <= strALength; i++) {
|
||
|
|
distances[i] = new Array(strBLength);
|
||
|
|
distances[i][0] = i;
|
||
|
|
for (var j = 1; j <= strBLength; j++) {
|
||
|
|
if (!i){
|
||
|
|
distances[0][j] = j;
|
||
|
|
} else {
|
||
|
|
cost = strA[i-1] === strB[j-1] ? 0 : 1;
|
||
|
|
deletion = distances[i - 1][j] + 1;
|
||
|
|
insertion = distances[i][j - 1] + 1;
|
||
|
|
substitution = distances[i - 1][j - 1] + cost;
|
||
|
|
if (deletion <= insertion && deletion <= substitution) {
|
||
|
|
distances[i][j] = deletion;
|
||
|
|
} else if (insertion <= deletion && insertion <= substitution) {
|
||
|
|
distances[i][j] = insertion;
|
||
|
|
} else {
|
||
|
|
distances[i][j] = substitution;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i > 1 && j > 1 && strA[i] === strB[j - 1] && strA[i - 1] === strB[j]) {
|
||
|
|
transposition = distances[i - 2][j - 2] + cost;
|
||
|
|
if (transposition < distances[i][j]) {
|
||
|
|
distances[i][j] = transposition;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return distances[strALength][strBLength];
|
||
|
|
};
|
||
|
|
|
||
|
|
var equalIgnoreCase = function (a, b) {
|
||
|
|
return a && b && a.toLowerCase() === b.toLowerCase();
|
||
|
|
};
|
||
|
|
|
||
|
|
var initSqlParser = function (parser) {
|
||
|
|
|
||
|
|
var SIMPLE_TABLE_REF_SUGGESTIONS = ['suggestJoinConditions', 'suggestAggregateFunctions', 'suggestFilters', 'suggestGroupBys', 'suggestOrderBys'];
|
||
|
|
|
||
|
|
parser.prepareNewStatement = function () {
|
||
|
|
linkTablePrimaries();
|
||
|
|
parser.commitLocations();
|
||
|
|
|
||
|
|
delete parser.yy.lateralViews;
|
||
|
|
delete parser.yy.latestCommonTableExpressions;
|
||
|
|
delete parser.yy.correlatedSubQuery;
|
||
|
|
parser.yy.subQueries = [];
|
||
|
|
parser.yy.selectListAliases = [];
|
||
|
|
parser.yy.latestTablePrimaries = [];
|
||
|
|
|
||
|
|
prioritizeSuggestions();
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.yy.parseError = function (message, error) {
|
||
|
|
parser.yy.errors.push(error);
|
||
|
|
return message;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addCommonTableExpressions = function (identifiers) {
|
||
|
|
parser.yy.result.commonTableExpressions = identifiers;
|
||
|
|
parser.yy.latestCommonTableExpressions = identifiers;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.isInSubquery = function () {
|
||
|
|
return !!parser.yy.primariesStack.length
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.pushQueryState = function () {
|
||
|
|
parser.yy.resultStack.push(parser.yy.result);
|
||
|
|
parser.yy.locationsStack.push(parser.yy.locations);
|
||
|
|
parser.yy.lateralViewsStack.push(parser.yy.lateralViews);
|
||
|
|
parser.yy.selectListAliasesStack.push(parser.yy.selectListAliases);
|
||
|
|
parser.yy.primariesStack.push(parser.yy.latestTablePrimaries);
|
||
|
|
parser.yy.subQueriesStack.push(parser.yy.subQueries);
|
||
|
|
|
||
|
|
parser.yy.result = {};
|
||
|
|
parser.yy.locations = [];
|
||
|
|
parser.yy.selectListAliases = []; // Not allowed in correlated sub-queries
|
||
|
|
parser.yy.lateralViews = []; // Not allowed in correlated sub-queries
|
||
|
|
|
||
|
|
if (parser.yy.correlatedSubQuery) {
|
||
|
|
parser.yy.latestTablePrimaries = parser.yy.latestTablePrimaries.concat();
|
||
|
|
parser.yy.subQueries = parser.yy.subQueries.concat();
|
||
|
|
} else {
|
||
|
|
parser.yy.latestTablePrimaries = [];
|
||
|
|
parser.yy.subQueries = [];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.popQueryState = function (subQuery) {
|
||
|
|
linkTablePrimaries();
|
||
|
|
parser.commitLocations();
|
||
|
|
|
||
|
|
if (Object.keys(parser.yy.result).length === 0) {
|
||
|
|
parser.yy.result = parser.yy.resultStack.pop();
|
||
|
|
} else {
|
||
|
|
parser.yy.resultStack.pop();
|
||
|
|
}
|
||
|
|
var oldSubQueries = parser.yy.subQueries;
|
||
|
|
parser.yy.subQueries = parser.yy.subQueriesStack.pop();
|
||
|
|
if (subQuery) {
|
||
|
|
if (oldSubQueries.length > 0) {
|
||
|
|
subQuery.subQueries = oldSubQueries;
|
||
|
|
}
|
||
|
|
parser.yy.subQueries.push(subQuery);
|
||
|
|
}
|
||
|
|
|
||
|
|
parser.yy.lateralViews = parser.yy.lateralViewsStack.pop();
|
||
|
|
parser.yy.latestTablePrimaries = parser.yy.primariesStack.pop();
|
||
|
|
parser.yy.locations = parser.yy.locationsStack.pop();
|
||
|
|
parser.yy.selectListAliases = parser.yy.selectListAliasesStack.pop();
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestSelectListAliases = function () {
|
||
|
|
if (parser.yy.selectListAliases && parser.yy.selectListAliases.length > 0 && parser.yy.result.suggestColumns
|
||
|
|
&& (typeof parser.yy.result.suggestColumns.identifierChain === 'undefined' || parser.yy.result.suggestColumns.identifierChain.length === 0)) {
|
||
|
|
parser.yy.result.suggestColumnAliases = parser.yy.selectListAliases;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.isHive = function () {
|
||
|
|
return parser.yy.activeDialect === 'hive';
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.isImpala = function () {
|
||
|
|
return parser.yy.activeDialect === 'impala';
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.mergeSuggestKeywords = function () {
|
||
|
|
var result = [];
|
||
|
|
Array.prototype.slice.call(arguments).forEach(function (suggestion) {
|
||
|
|
if (typeof suggestion !== 'undefined' && typeof suggestion.suggestKeywords !== 'undefined') {
|
||
|
|
result = result.concat(suggestion.suggestKeywords);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (result.length > 0) {
|
||
|
|
return {suggestKeywords: result};
|
||
|
|
}
|
||
|
|
return {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords = function (valueExpression, extras) {
|
||
|
|
var expressionKeywords = parser.getValueExpressionKeywords(valueExpression, extras);
|
||
|
|
parser.suggestKeywords(expressionKeywords.suggestKeywords);
|
||
|
|
if (expressionKeywords.suggestColRefKeywords) {
|
||
|
|
parser.suggestColRefKeywords(expressionKeywords.suggestColRefKeywords);
|
||
|
|
}
|
||
|
|
if (valueExpression.lastType) {
|
||
|
|
parser.addColRefIfExists(valueExpression.lastType);
|
||
|
|
} else {
|
||
|
|
parser.addColRefIfExists(valueExpression);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getSelectListKeywords = function (excludeAsterisk) {
|
||
|
|
var keywords = [{ value: 'CASE', weight: 450 }, 'FALSE', 'TRUE', 'NULL'];
|
||
|
|
if (!excludeAsterisk) {
|
||
|
|
keywords.push({ value: '*', weight: 10000 });
|
||
|
|
}
|
||
|
|
if (parser.isHive()) {
|
||
|
|
keywords = keywords.concat(['EXISTS', 'NOT']);
|
||
|
|
}
|
||
|
|
return keywords;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getValueExpressionKeywords = function (valueExpression, extras) {
|
||
|
|
var types = valueExpression.lastType ? valueExpression.lastType.types : valueExpression.types;
|
||
|
|
// We could have valueExpression.columnReference to suggest based on column type
|
||
|
|
var keywords = ['<', '<=', '<=>', '<>', '=', '>', '>=', 'BETWEEN', 'IN', 'IS NOT NULL', 'IS NULL', 'IS NOT TRUE', 'IS TRUE', 'IS NOT FALSE', 'IS FALSE', 'NOT BETWEEN', 'NOT IN'];
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat(['IS DISTINCT FROM', 'IS NOT DISTINCT FROM', 'IS NOT UNKNOWN', 'IS UNKNOWN']);
|
||
|
|
}
|
||
|
|
if (extras) {
|
||
|
|
keywords = keywords.concat(extras);
|
||
|
|
}
|
||
|
|
if (valueExpression.suggestKeywords) {
|
||
|
|
keywords = keywords.concat(valueExpression.suggestKeywords);
|
||
|
|
}
|
||
|
|
if (types.length === 1 && types[0] === 'COLREF') {
|
||
|
|
return {
|
||
|
|
suggestKeywords: keywords,
|
||
|
|
suggestColRefKeywords: {
|
||
|
|
BOOLEAN: ['AND', 'OR'],
|
||
|
|
NUMBER: ['+', '-', '*', '/', '%', 'DIV'],
|
||
|
|
STRING: parser.isImpala() ? ['ILIKE', 'IREGEXP', 'LIKE', 'NOT LIKE', 'REGEXP', 'RLIKE'] : ['LIKE', 'NOT LIKE', 'REGEXP', 'RLIKE']
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (typeof SqlFunctions === 'undefined' || SqlFunctions.matchesType(parser.yy.activeDialect, ['BOOLEAN'], types)) {
|
||
|
|
keywords = keywords.concat(['AND', 'OR']);
|
||
|
|
}
|
||
|
|
if (typeof SqlFunctions === 'undefined' || SqlFunctions.matchesType(parser.yy.activeDialect, ['NUMBER'], types)) {
|
||
|
|
keywords = keywords.concat(['+', '-', '*', '/', '%', 'DIV']);
|
||
|
|
}
|
||
|
|
if (typeof SqlFunctions === 'undefined' || SqlFunctions.matchesType(parser.yy.activeDialect, ['STRING'], types)) {
|
||
|
|
keywords = keywords.concat(parser.isImpala() ? ['ILIKE', 'IREGEXP', 'LIKE', 'NOT LIKE', 'REGEXP', 'RLIKE'] : ['LIKE', 'NOT LIKE', 'REGEXP', 'RLIKE']);
|
||
|
|
}
|
||
|
|
return { suggestKeywords: keywords };
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getTypeKeywords = function () {
|
||
|
|
if (parser.isHive()) {
|
||
|
|
return ['BIGINT', 'BINARY', 'BOOLEAN', 'CHAR', 'DATE', 'DECIMAL', 'DOUBLE', 'DOUBLE PRECISION', 'FLOAT', 'INT', 'SMALLINT', 'TIMESTAMP', 'STRING', 'TINYINT', 'VARCHAR'];
|
||
|
|
}
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
return ['BIGINT', 'BOOLEAN', 'CHAR', 'DECIMAL', 'DOUBLE', 'FLOAT', 'INT', 'REAL', 'SMALLINT', 'TIMESTAMP', 'STRING', 'TINYINT', 'VARCHAR'];
|
||
|
|
}
|
||
|
|
return ['BIGINT', 'BOOLEAN', 'CHAR', 'DECIMAL', 'DOUBLE', 'FLOAT', 'INT', 'SMALLINT', 'TIMESTAMP', 'STRING', 'TINYINT', 'VARCHAR'];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getColumnDataTypeKeywords = function () {
|
||
|
|
if (parser.isHive()) {
|
||
|
|
return parser.getTypeKeywords().concat(['ARRAY<>', 'MAP<>', 'STRUCT<>', 'UNIONTYPE<>']);
|
||
|
|
}
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
return parser.getTypeKeywords().concat(['ARRAY<>', 'MAP<>', 'STRUCT<>']);
|
||
|
|
}
|
||
|
|
return parser.getTypeKeywords();
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addColRefIfExists = function (valueExpression) {
|
||
|
|
if (valueExpression.columnReference) {
|
||
|
|
parser.yy.result.colRef = {identifierChain: valueExpression.columnReference};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.selectListNoTableSuggest = function (selectListEdit, hasDistinctOrAll) {
|
||
|
|
if (selectListEdit.cursorAtStart) {
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!hasDistinctOrAll) {
|
||
|
|
keywords = keywords.concat([{ value: 'ALL', weight: 2 }, { value: 'DISTINCT', weight: 2 }]);
|
||
|
|
}
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push('STRAIGHT_JOIN');
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
} else {
|
||
|
|
parser.checkForKeywords(selectListEdit);
|
||
|
|
}
|
||
|
|
if (selectListEdit.suggestFunctions) {
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
if (selectListEdit.suggestColumns) {
|
||
|
|
parser.suggestColumns();
|
||
|
|
}
|
||
|
|
if (selectListEdit.suggestAggregateFunctions && (!hasDistinctOrAll || hasDistinctOrAll === 'ALL')) {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestJoinConditions = function (details) {
|
||
|
|
parser.yy.result.suggestJoinConditions = details || {};
|
||
|
|
if (parser.yy.latestTablePrimaries && !parser.yy.result.suggestJoinConditions.tablePrimaries) {
|
||
|
|
parser.yy.result.suggestJoinConditions.tablePrimaries = parser.yy.latestTablePrimaries.concat();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestJoins = function (details) {
|
||
|
|
parser.yy.result.suggestJoins = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest = function (oppositeValueExpression, operator) {
|
||
|
|
if (oppositeValueExpression && oppositeValueExpression.columnReference) {
|
||
|
|
parser.suggestValues();
|
||
|
|
parser.yy.result.colRef = {identifierChain: oppositeValueExpression.columnReference};
|
||
|
|
}
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
var keywords = [{ value: 'CASE', weight: 450 }, { value: 'FALSE', weight: 450 }, { value: 'NULL', weight: 450 }, { value: 'TRUE', weight: 450 }];
|
||
|
|
if (parser.isHive() || typeof oppositeValueExpression === 'undefined' || typeof operator === 'undefined') {
|
||
|
|
keywords = keywords.concat(['EXISTS', 'NOT']);
|
||
|
|
}
|
||
|
|
if (oppositeValueExpression && oppositeValueExpression.types[0] === 'NUMBER') {
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
} else if (parser.isImpala() && (typeof operator === 'undefined' || operator === '-' || operator === '+')) {
|
||
|
|
keywords.push('INTERVAL');
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.applyTypeToSuggestions = function (types) {
|
||
|
|
if (types[0] === 'BOOLEAN') {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) {
|
||
|
|
parser.yy.result.suggestFunctions.types = types;
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestColumns && !parser.yy.result.suggestColumns.types) {
|
||
|
|
parser.yy.result.suggestColumns.types = types;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.findCaseType = function (whenThenList) {
|
||
|
|
var types = {};
|
||
|
|
whenThenList.caseTypes.forEach(function (valueExpression) {
|
||
|
|
valueExpression.types.forEach(function (type) {
|
||
|
|
types[type] = true;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
if (Object.keys(types).length === 1) {
|
||
|
|
return {types: [Object.keys(types)[0]]};
|
||
|
|
}
|
||
|
|
return {types: ['T']};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.findReturnTypes = function (functionName) {
|
||
|
|
return typeof SqlFunctions === 'undefined' ? ['T'] : SqlFunctions.getReturnTypes(parser.yy.activeDialect, functionName.toLowerCase());
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.applyArgumentTypesToSuggestions = function (functionName, position) {
|
||
|
|
var foundArguments = typeof SqlFunctions === 'undefined' ? ['T'] : SqlFunctions.getArgumentTypes(parser.yy.activeDialect, functionName.toLowerCase(), position);
|
||
|
|
if (foundArguments.length == 0 && parser.yy.result.suggestColumns) {
|
||
|
|
delete parser.yy.result.suggestColumns;
|
||
|
|
delete parser.yy.result.suggestKeyValues;
|
||
|
|
delete parser.yy.result.suggestValues;
|
||
|
|
delete parser.yy.result.suggestFunctions;
|
||
|
|
delete parser.yy.result.suggestIdentifiers;
|
||
|
|
delete parser.yy.result.suggestKeywords;
|
||
|
|
} else {
|
||
|
|
parser.applyTypeToSuggestions(foundArguments);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var getCleanImpalaPrimaries = function (primaries) {
|
||
|
|
var cleanPrimaries = [];
|
||
|
|
for (var i = primaries.length - 1; i >= 0; i--) {
|
||
|
|
var cleanPrimary = primaries[i];
|
||
|
|
if (cleanPrimary.identifierChain && cleanPrimary.identifierChain.length > 0) {
|
||
|
|
for (var j = i - 1; j >=0; j--) {
|
||
|
|
var parentPrimary = primaries[j];
|
||
|
|
if (parentPrimary.alias && cleanPrimary.identifierChain[0].name === parentPrimary.alias) {
|
||
|
|
var restOfChain = cleanPrimary.identifierChain.concat();
|
||
|
|
restOfChain.shift();
|
||
|
|
if (cleanPrimary.alias) {
|
||
|
|
cleanPrimary = { identifierChain: parentPrimary.identifierChain.concat(restOfChain), alias: cleanPrimary.alias, impalaComplex: true };
|
||
|
|
} else {
|
||
|
|
cleanPrimary = { identifierChain: parentPrimary.identifierChain.concat(restOfChain), impalaComplex: true };
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cleanPrimaries.push(cleanPrimary);
|
||
|
|
}
|
||
|
|
return cleanPrimaries;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.commitLocations = function () {
|
||
|
|
if (parser.yy.locations.length === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var tablePrimaries = parser.yy.latestTablePrimaries;
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
tablePrimaries = [];
|
||
|
|
getCleanImpalaPrimaries(parser.yy.latestTablePrimaries).forEach(function (primary) {
|
||
|
|
var cleanPrimary = primary;
|
||
|
|
if (primary.identifierChain && primary.identifierChain.length > 0) {
|
||
|
|
for (var j = parser.yy.primariesStack.length - 1; j >= 0; j--) {
|
||
|
|
getCleanImpalaPrimaries(parser.yy.primariesStack[j]).every(function (parentPrimary) {
|
||
|
|
if (parentPrimary.alias && parentPrimary.alias === primary.identifierChain[0].name) {
|
||
|
|
var identifierChain = primary.identifierChain.concat();
|
||
|
|
identifierChain.shift();
|
||
|
|
cleanPrimary = { identifierChain: parentPrimary.identifierChain.concat(identifierChain) };
|
||
|
|
if (primary.alias) {
|
||
|
|
cleanPrimary.alias = primary.alias;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
tablePrimaries.unshift(cleanPrimary);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
var i = parser.yy.locations.length;
|
||
|
|
|
||
|
|
while (i--) {
|
||
|
|
var location = parser.yy.locations[i];
|
||
|
|
if (location.type === 'variable' && location.colRef) {
|
||
|
|
parser.expandIdentifierChain({ wrapper: location.colRef, tablePrimaries: tablePrimaries, isColumnWrapper: true });
|
||
|
|
delete location.colRef.linked;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Impala can have references to previous tables after FROM, i.e. FROM testTable t, t.testArray
|
||
|
|
// In this testArray would be marked a type table so we need to switch it to column.
|
||
|
|
if (location.type === 'table' && typeof location.identifierChain !== 'undefined' && location.identifierChain.length > 1 && tablePrimaries) {
|
||
|
|
var allPrimaries = tablePrimaries;
|
||
|
|
parser.yy.primariesStack.forEach(function (parentPrimaries) {
|
||
|
|
allPrimaries = getCleanImpalaPrimaries(parentPrimaries).concat(allPrimaries);
|
||
|
|
});
|
||
|
|
var found = allPrimaries.filter(function (primary) {
|
||
|
|
return equalIgnoreCase(primary.alias, location.identifierChain[0].name);
|
||
|
|
});
|
||
|
|
if (found.length > 0) {
|
||
|
|
location.type = 'column';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'database' && typeof location.identifierChain !== 'undefined' && location.identifierChain.length > 0 && tablePrimaries) {
|
||
|
|
var allPrimaries = tablePrimaries;
|
||
|
|
parser.yy.primariesStack.forEach(function (parentPrimaries) {
|
||
|
|
allPrimaries = getCleanImpalaPrimaries(parentPrimaries).concat(allPrimaries);
|
||
|
|
});
|
||
|
|
var foundAlias = allPrimaries.filter(function (primary) {
|
||
|
|
return equalIgnoreCase(primary.alias, location.identifierChain[0].name);
|
||
|
|
});
|
||
|
|
if (foundAlias.length > 0 && parser.isImpala()) {
|
||
|
|
// Impala complex reference in FROM clause, i.e. FROM testTable t, t.testMap tm
|
||
|
|
location.type = 'table';
|
||
|
|
parser.expandIdentifierChain({ tablePrimaries: allPrimaries, wrapper: location, anyOwner: true });
|
||
|
|
location.type = location.identifierChain.length === 1 ? 'table' : 'complex';
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'unknown') {
|
||
|
|
if (typeof location.identifierChain !== 'undefined' && location.identifierChain.length > 0 && location.identifierChain.length <= 2 && tablePrimaries) {
|
||
|
|
var found = tablePrimaries.filter(function (primary) {
|
||
|
|
return equalIgnoreCase(primary.alias, location.identifierChain[0].name) || (primary.identifierChain && equalIgnoreCase(primary.identifierChain[0].name, location.identifierChain[0].name));
|
||
|
|
});
|
||
|
|
if (!found.length && location.firstInChain) {
|
||
|
|
found = tablePrimaries.filter(function (primary) {
|
||
|
|
return !primary.alias && primary.identifierChain && equalIgnoreCase(primary.identifierChain[primary.identifierChain.length - 1].name, location.identifierChain[0].name);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (found.length) {
|
||
|
|
if (found[0].identifierChain.length > 1 && location.identifierChain.length === 1 && equalIgnoreCase(found[0].identifierChain[0].name, location.identifierChain[0].name)) {
|
||
|
|
location.type = 'database';
|
||
|
|
} else if (found[0].alias && equalIgnoreCase(location.identifierChain[0].name, found[0].alias) && location.identifierChain.length > 1) {
|
||
|
|
location.type = 'column';
|
||
|
|
parser.expandIdentifierChain({ tablePrimaries: tablePrimaries, wrapper: location, anyOwner: true });
|
||
|
|
} else if (!found[0].alias && found[0].identifierChain && equalIgnoreCase(location.identifierChain[0].name, found[0].identifierChain[found[0].identifierChain.length - 1].name) && location.identifierChain.length > 1) {
|
||
|
|
location.type = 'column';
|
||
|
|
parser.expandIdentifierChain({ tablePrimaries: tablePrimaries, wrapper: location, anyOwner: true });
|
||
|
|
} else {
|
||
|
|
location.type = found[0].impalaComplex ? 'column' : 'table';
|
||
|
|
parser.expandIdentifierChain({ tablePrimaries: tablePrimaries, wrapper: location, anyOwner: true });
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (parser.yy.subQueries) {
|
||
|
|
found = parser.yy.subQueries.filter(function (subQuery) {
|
||
|
|
return equalIgnoreCase(subQuery.alias, location.identifierChain[0].name);
|
||
|
|
});
|
||
|
|
if (found.length > 0) {
|
||
|
|
location.type = 'subQuery';
|
||
|
|
location.identifierChain = [{subQuery: found[0].alias}];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'asterisk' && !location.linked) {
|
||
|
|
|
||
|
|
if (tablePrimaries && tablePrimaries.length > 0) {
|
||
|
|
location.tables = [];
|
||
|
|
location.linked = false;
|
||
|
|
if (!location.identifierChain) {
|
||
|
|
location.identifierChain = [{ asterisk: true }];
|
||
|
|
}
|
||
|
|
parser.expandIdentifierChain({ tablePrimaries: tablePrimaries, wrapper: location, anyOwner: false });
|
||
|
|
if (location.tables.length === 0) {
|
||
|
|
parser.yy.locations.splice(i, 1);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
parser.yy.locations.splice(i, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'table' && typeof location.identifierChain !== 'undefined' && location.identifierChain.length === 1 && location.identifierChain[0].name) {
|
||
|
|
// Could be a cte reference
|
||
|
|
parser.yy.locations.some(function (otherLocation) {
|
||
|
|
if (otherLocation.type === 'alias' && otherLocation.source === 'cte' && SqlUtils.identifierEquals(otherLocation.alias, location.identifierChain[0].name)) {
|
||
|
|
// TODO: Possibly add the other location if we want to show the link in the future.
|
||
|
|
// i.e. highlight select definition on hover over alias, also for subquery references.
|
||
|
|
location.type = 'alias';
|
||
|
|
location.target = 'cte';
|
||
|
|
location.alias = location.identifierChain[0].name;
|
||
|
|
delete location.identifierChain;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'table' && (typeof location.identifierChain === 'undefined' || location.identifierChain.length === 0)) {
|
||
|
|
parser.yy.locations.splice(i, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'unknown') {
|
||
|
|
location.type = 'column';
|
||
|
|
}
|
||
|
|
|
||
|
|
// A column location might refer to a previously defined alias, i.e. last 'foo' in "SELECT cast(id AS int) foo FROM tbl ORDER BY foo;"
|
||
|
|
if (location.type === 'column') {
|
||
|
|
for (var j = i - 1; j >= 0; j--) {
|
||
|
|
var otherLocation = parser.yy.locations[j];
|
||
|
|
if (otherLocation.type === 'alias' && otherLocation.source === 'column' && location.identifierChain && location.identifierChain.length === 1 && location.identifierChain[0].name && otherLocation.alias && location.identifierChain[0].name.toLowerCase() === otherLocation.alias.toLowerCase()) {
|
||
|
|
location.type = 'alias';
|
||
|
|
location.source = 'column';
|
||
|
|
location.alias = location.identifierChain[0].name;
|
||
|
|
delete location.identifierChain;
|
||
|
|
location.parentLocation = otherLocation.parentLocation;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (location.type === 'column') {
|
||
|
|
if (parser.isHive() && !location.linked) {
|
||
|
|
location.identifierChain = parser.expandLateralViews(parser.yy.lateralViews, location.identifierChain);
|
||
|
|
}
|
||
|
|
|
||
|
|
var initialIdentifierChain = location.identifierChain ? location.identifierChain.concat() : undefined;
|
||
|
|
|
||
|
|
parser.expandIdentifierChain({ tablePrimaries: tablePrimaries, wrapper: location, anyOwner: true, isColumnWrapper: true, isColumnLocation: true });
|
||
|
|
|
||
|
|
if (typeof location.identifierChain === 'undefined') {
|
||
|
|
parser.yy.locations.splice(i, 1);
|
||
|
|
} else if (location.identifierChain.length === 0 && initialIdentifierChain && initialIdentifierChain.length === 1) {
|
||
|
|
// This is for the case "SELECT tblOrColName FROM db.tblOrColName";
|
||
|
|
location.identifierChain = initialIdentifierChain;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (location.type === 'column' && location.identifierChain) {
|
||
|
|
if (location.identifierChain.length > 1 && location.tables && location.tables.length > 0) {
|
||
|
|
location.type = 'complex';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
delete location.firstInChain;
|
||
|
|
if (location.type !== 'column' && location.type !== 'complex') {
|
||
|
|
delete location.qualified;
|
||
|
|
} else if (typeof location.qualified === 'undefined') {
|
||
|
|
location.qualified = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parser.yy.locations.length > 0) {
|
||
|
|
parser.yy.allLocations = parser.yy.allLocations.concat(parser.yy.locations);
|
||
|
|
parser.yy.locations = [];
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var prioritizeSuggestions = function () {
|
||
|
|
parser.yy.result.lowerCase = parser.yy.lowerCase || false;
|
||
|
|
|
||
|
|
var cteIndex = {};
|
||
|
|
|
||
|
|
if (typeof parser.yy.latestCommonTableExpressions !== 'undefined') {
|
||
|
|
parser.yy.latestCommonTableExpressions.forEach(function (cte) {
|
||
|
|
cteIndex[cte.alias.toLowerCase()] = cte;
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
SIMPLE_TABLE_REF_SUGGESTIONS.forEach(function (suggestionType) {
|
||
|
|
if (suggestionType !== 'suggestAggregateFunctions' && typeof parser.yy.result[suggestionType] !== 'undefined' && parser.yy.result[suggestionType].tables.length === 0) {
|
||
|
|
delete parser.yy.result[suggestionType];
|
||
|
|
} else if (typeof parser.yy.result[suggestionType] !== 'undefined' && typeof parser.yy.result[suggestionType].tables !== 'undefined') {
|
||
|
|
for (var i = parser.yy.result[suggestionType].tables.length - 1; i >= 0; i--) {
|
||
|
|
var table = parser.yy.result[suggestionType].tables[i];
|
||
|
|
if (table.identifierChain.length === 1 && typeof table.identifierChain[0].name !== 'undefined' && typeof cteIndex[table.identifierChain[0].name.toLowerCase()] !== 'undefined') {
|
||
|
|
parser.yy.result[suggestionType].tables.splice(i, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.colRef !== 'undefined') {
|
||
|
|
if (!parser.yy.result.colRef.linked || typeof parser.yy.result.colRef.identifierChain === 'undefined' || parser.yy.result.colRef.identifierChain.length === 0) {
|
||
|
|
delete parser.yy.result.colRef;
|
||
|
|
if (typeof parser.yy.result.suggestColRefKeywords !== 'undefined') {
|
||
|
|
Object.keys(parser.yy.result.suggestColRefKeywords).forEach(function (type) {
|
||
|
|
parser.yy.result.suggestKeywords = parser.yy.result.suggestKeywords.concat(parser.createWeightedKeywords(parser.yy.result.suggestColRefKeywords[type], -1));
|
||
|
|
});
|
||
|
|
delete parser.yy.result.suggestColRefKeywords;
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestColumns && parser.yy.result.suggestColumns.types.length === 1 && parser.yy.result.suggestColumns.types[0] === 'COLREF') {
|
||
|
|
parser.yy.result.suggestColumns.types = ['T'];
|
||
|
|
}
|
||
|
|
delete parser.yy.result.suggestValues;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.colRef !== 'undefined') {
|
||
|
|
if (!parser.yy.result.suggestValues && !parser.yy.result.suggestColRefKeywords &&
|
||
|
|
(!parser.yy.result.suggestColumns ||
|
||
|
|
parser.yy.result.suggestColumns.types[0] !== 'COLREF')) {
|
||
|
|
delete parser.yy.result.colRef;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (typeof parser.yy.result.suggestIdentifiers !== 'undefined' && parser.yy.result.suggestIdentifiers.length > 0) {
|
||
|
|
delete parser.yy.result.suggestTables;
|
||
|
|
delete parser.yy.result.suggestDatabases;
|
||
|
|
}
|
||
|
|
if (typeof parser.yy.result.suggestColumns !== 'undefined') {
|
||
|
|
var suggestColumns = parser.yy.result.suggestColumns;
|
||
|
|
if (typeof suggestColumns.tables === 'undefined' || suggestColumns.tables.length === 0) {
|
||
|
|
// Impala supports statements like SELECT * FROM tbl1, tbl2 WHERE db.tbl1.col = tbl2.bla
|
||
|
|
if (parser.yy.result.suggestColumns.linked && parser.isImpala() && typeof suggestColumns.identifierChain !== 'undefined' && suggestColumns.identifierChain.length > 0) {
|
||
|
|
if (suggestColumns.identifierChain.length === 1) {
|
||
|
|
parser.yy.result.suggestTables = suggestColumns;
|
||
|
|
delete parser.yy.result.suggestColumns
|
||
|
|
} else {
|
||
|
|
suggestColumns.tables = [{identifierChain: suggestColumns.identifierChain}];
|
||
|
|
delete suggestColumns.identifierChain;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
delete parser.yy.result.suggestColumns;
|
||
|
|
delete parser.yy.result.subQueries;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
delete parser.yy.result.suggestTables;
|
||
|
|
delete parser.yy.result.suggestDatabases;
|
||
|
|
|
||
|
|
suggestColumns.tables.forEach(function (table) {
|
||
|
|
if (typeof table.identifierChain !== 'undefined' && table.identifierChain.length === 1 && typeof table.identifierChain[0].name !== 'undefined') {
|
||
|
|
var cte = cteIndex[table.identifierChain[0].name.toLowerCase()];
|
||
|
|
if (typeof cte !== 'undefined') {
|
||
|
|
delete table.identifierChain[0].name;
|
||
|
|
table.identifierChain[0].cte = cte.alias;
|
||
|
|
}
|
||
|
|
} else if (typeof table.identifierChain === 'undefined' && table.subQuery) {
|
||
|
|
table.identifierChain = [{ subQuery: table.subQuery }];
|
||
|
|
delete table.subQuery;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (typeof suggestColumns.identifierChain !== 'undefined' && suggestColumns.identifierChain.length === 0) {
|
||
|
|
delete suggestColumns.identifierChain;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
delete parser.yy.result.subQueries;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.suggestJoinConditions !== 'undefined') {
|
||
|
|
if (typeof parser.yy.result.suggestJoinConditions.tables === 'undefined' || parser.yy.result.suggestJoinConditions.tables.length === 0) {
|
||
|
|
delete parser.yy.result.suggestJoinConditions;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.suggestTables !== 'undefined' && typeof parser.yy.latestCommonTableExpressions !== 'undefined') {
|
||
|
|
var ctes = [];
|
||
|
|
parser.yy.latestCommonTableExpressions.forEach(function (cte) {
|
||
|
|
var suggestion = {name: cte.alias};
|
||
|
|
if (parser.yy.result.suggestTables.prependFrom) {
|
||
|
|
suggestion.prependFrom = true
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestTables.prependQuestionMark) {
|
||
|
|
suggestion.prependQuestionMark = true;
|
||
|
|
}
|
||
|
|
ctes.push(suggestion);
|
||
|
|
});
|
||
|
|
if (ctes.length > 0) {
|
||
|
|
parser.yy.result.suggestCommonTableExpressions = ctes;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Impala supports referencing maps and arrays in the the table reference list i.e.
|
||
|
|
*
|
||
|
|
* SELECT m['foo'].bar.| FROM someDb.someTable t, t.someMap m;
|
||
|
|
*
|
||
|
|
* From this the tablePrimaries would look like:
|
||
|
|
*
|
||
|
|
* [ { alias: 't', identifierChain: [ { name: 'someDb' }, { name: 'someTable' } ] },
|
||
|
|
* { alias: 'm', identifierChain: [ { name: 't' }, { name: 'someMap' } ] } ]
|
||
|
|
*
|
||
|
|
* with an identifierChain from the select list:
|
||
|
|
*
|
||
|
|
* [ { name: 'm', keySet: true }, { name: 'bar' } ]
|
||
|
|
*
|
||
|
|
* Calling this would return an expanded identifierChain, given the above it would be:
|
||
|
|
*
|
||
|
|
* [ { name: 't' }, { name: 'someMap', keySet: true }, { name: 'bar' } ]
|
||
|
|
*/
|
||
|
|
parser.expandImpalaIdentifierChain = function (tablePrimaries, identifierChain) {
|
||
|
|
var expandedChain = identifierChain.concat(); // Clone in case it's called multiple times.
|
||
|
|
if (typeof expandedChain === 'undefined' || expandedChain.length === 0) {
|
||
|
|
return identifierChain;
|
||
|
|
}
|
||
|
|
var expand = function (identifier, expandedChain) {
|
||
|
|
var foundPrimary = tablePrimaries.filter(function (tablePrimary) {
|
||
|
|
var primaryIdentifier = tablePrimary.alias;
|
||
|
|
if (!primaryIdentifier && tablePrimary.identifierChain && tablePrimary.identifierChain.length > 0) {
|
||
|
|
primaryIdentifier = tablePrimary.identifierChain[tablePrimary.identifierChain.length - 1].name;
|
||
|
|
}
|
||
|
|
return equalIgnoreCase(primaryIdentifier, identifier);
|
||
|
|
});
|
||
|
|
|
||
|
|
if (foundPrimary.length === 1 && foundPrimary[0].identifierChain) {
|
||
|
|
var parentPrimary = tablePrimaries.filter(function (tablePrimary) {
|
||
|
|
return equalIgnoreCase(tablePrimary.alias, foundPrimary[0].identifierChain[0].name);
|
||
|
|
});
|
||
|
|
if (parentPrimary.length === 1) {
|
||
|
|
var keySet = expandedChain[0].keySet;
|
||
|
|
var secondPart = expandedChain.slice(1);
|
||
|
|
var firstPart = [];
|
||
|
|
// Clone to make sure we don't add keySet to the primaries
|
||
|
|
foundPrimary[0].identifierChain.forEach(function (identifier) {
|
||
|
|
firstPart.push({name: identifier.name});
|
||
|
|
});
|
||
|
|
if (keySet && firstPart.length > 0) {
|
||
|
|
firstPart[firstPart.length - 1].keySet = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (firstPart.length === 0 || typeof secondPart === 'undefined' || secondPart.length === 0) {
|
||
|
|
return firstPart;
|
||
|
|
}
|
||
|
|
var result = firstPart.concat(secondPart);
|
||
|
|
if (result.length > 0) {
|
||
|
|
return expand(firstPart[0].name, result);
|
||
|
|
} else {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return expandedChain;
|
||
|
|
};
|
||
|
|
return expand(expandedChain[0].name, expandedChain);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.identifyPartials = function (beforeCursor, afterCursor) {
|
||
|
|
var beforeMatch = beforeCursor.match(/[0-9a-zA-Z_]*$/);
|
||
|
|
var afterMatch = afterCursor.match(/^[0-9a-zA-Z_]*(?:\((?:[^)]*\))?)?/);
|
||
|
|
return {left: beforeMatch ? beforeMatch[0].length : 0, right: afterMatch ? afterMatch[0].length : 0};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.expandLateralViews = function (lateralViews, originalIdentifierChain, columnSuggestion) {
|
||
|
|
var identifierChain = originalIdentifierChain.concat(); // Clone in case it's re-used
|
||
|
|
var firstIdentifier = identifierChain[0];
|
||
|
|
if (typeof lateralViews !== 'undefined') {
|
||
|
|
lateralViews.concat().reverse().forEach(function (lateralView) {
|
||
|
|
if (!lateralView.udtf.expression.columnReference) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (equalIgnoreCase(firstIdentifier.name, lateralView.tableAlias) && identifierChain.length > 1) {
|
||
|
|
identifierChain.shift();
|
||
|
|
firstIdentifier = identifierChain[0];
|
||
|
|
if (columnSuggestion) {
|
||
|
|
delete parser.yy.result.suggestKeywords;
|
||
|
|
}
|
||
|
|
} else if (equalIgnoreCase(firstIdentifier.name, lateralView.tableAlias) && identifierChain.length === 1 && typeof parser.yy.result.suggestColumns !== 'undefined') {
|
||
|
|
if (columnSuggestion) {
|
||
|
|
if (typeof parser.yy.result.suggestIdentifiers === 'undefined') {
|
||
|
|
parser.yy.result.suggestIdentifiers = [];
|
||
|
|
}
|
||
|
|
lateralView.columnAliases.forEach(function (columnAlias) {
|
||
|
|
parser.yy.result.suggestIdentifiers.push({name: columnAlias, type: 'alias'});
|
||
|
|
});
|
||
|
|
delete parser.yy.result.suggestColumns;
|
||
|
|
delete parser.yy.result.suggestKeywords;
|
||
|
|
}
|
||
|
|
return identifierChain;
|
||
|
|
}
|
||
|
|
if (lateralView.columnAliases.indexOf(firstIdentifier.name) !== -1) {
|
||
|
|
if (lateralView.columnAliases.length === 2 && lateralView.udtf.function.toLowerCase() === 'explode' && equalIgnoreCase(firstIdentifier.name, lateralView.columnAliases[0])) {
|
||
|
|
identifierChain[0] = {name: 'key'};
|
||
|
|
} else if (lateralView.columnAliases.length === 2 && lateralView.udtf.function.toLowerCase() === 'explode' && equalIgnoreCase(firstIdentifier.name, lateralView.columnAliases[1])) {
|
||
|
|
identifierChain[0] = {name: 'value'};
|
||
|
|
} else {
|
||
|
|
identifierChain[0] = {name: 'item'};
|
||
|
|
}
|
||
|
|
identifierChain = lateralView.udtf.expression.columnReference.concat(identifierChain);
|
||
|
|
firstIdentifier = identifierChain[0];
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return identifierChain;
|
||
|
|
};
|
||
|
|
|
||
|
|
var addCleanTablePrimary = function (tables, tablePrimary) {
|
||
|
|
if (tablePrimary.alias) {
|
||
|
|
tables.push({alias: tablePrimary.alias, identifierChain: tablePrimary.identifierChain});
|
||
|
|
} else {
|
||
|
|
tables.push({identifierChain: tablePrimary.identifierChain});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.expandIdentifierChain = function (options) {
|
||
|
|
var wrapper = options.wrapper;
|
||
|
|
var anyOwner = options.anyOwner;
|
||
|
|
var isColumnWrapper = options.isColumnWrapper;
|
||
|
|
var isColumnLocation = options.isColumnLocation;
|
||
|
|
var tablePrimaries = options.tablePrimaries || parser.yy.latestTablePrimaries;
|
||
|
|
|
||
|
|
if (typeof wrapper.identifierChain === 'undefined' || typeof tablePrimaries === 'undefined') {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var identifierChain = wrapper.identifierChain.concat();
|
||
|
|
|
||
|
|
if (tablePrimaries.length === 0) {
|
||
|
|
delete wrapper.identifierChain;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!anyOwner) {
|
||
|
|
tablePrimaries = filterTablePrimariesForOwner(tablePrimaries, wrapper.owner);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (identifierChain.length > 0 && identifierChain[identifierChain.length - 1].asterisk) {
|
||
|
|
var tables = [];
|
||
|
|
tablePrimaries.forEach(function (tablePrimary) {
|
||
|
|
if (identifierChain.length > 1 && !tablePrimary.subQueryAlias) {
|
||
|
|
if (identifierChain.length === 2 && equalIgnoreCase(tablePrimary.alias, identifierChain[0].name)) {
|
||
|
|
addCleanTablePrimary(tables, tablePrimary);
|
||
|
|
} else if (identifierChain.length === 2 && equalIgnoreCase(tablePrimary.identifierChain[0].name, identifierChain[0].name)) {
|
||
|
|
addCleanTablePrimary(tables, tablePrimary);
|
||
|
|
} else if (identifierChain.length === 3 && tablePrimary.identifierChain.length > 1 &&
|
||
|
|
equalIgnoreCase(tablePrimary.identifierChain[0].name, identifierChain[0].name) &&
|
||
|
|
equalIgnoreCase(tablePrimary.identifierChain[1].name, identifierChain[1].name)) {
|
||
|
|
addCleanTablePrimary(tables, tablePrimary);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (tablePrimary.subQueryAlias) {
|
||
|
|
tables.push({identifierChain: [{subQuery: tablePrimary.subQueryAlias}]});
|
||
|
|
} else {
|
||
|
|
addCleanTablePrimary(tables, tablePrimary);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
// Possible Joins
|
||
|
|
if (tables.length > 0) {
|
||
|
|
wrapper.tables = tables;
|
||
|
|
delete wrapper.identifierChain;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Impala can have references to maps or array, i.e. FROM table t, t.map m
|
||
|
|
// We need to replace those in the identifierChain
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
var lengthBefore = identifierChain.length;
|
||
|
|
identifierChain = parser.expandImpalaIdentifierChain(tablePrimaries, identifierChain);
|
||
|
|
// Change type of any locations marked as table
|
||
|
|
if (wrapper.type === 'table' && identifierChain.length > lengthBefore) {
|
||
|
|
wrapper.type = 'column';
|
||
|
|
}
|
||
|
|
wrapper.identifierChain = identifierChain;
|
||
|
|
}
|
||
|
|
// Expand exploded views in the identifier chain
|
||
|
|
if (parser.isHive() && identifierChain.length > 0) {
|
||
|
|
identifierChain = parser.expandLateralViews(parser.yy.lateralViews, identifierChain);
|
||
|
|
wrapper.identifierChain = identifierChain;
|
||
|
|
}
|
||
|
|
|
||
|
|
// IdentifierChain contains a possibly started identifier or empty, example: a.b.c = ['a', 'b', 'c']
|
||
|
|
// Reduce the tablePrimaries to the one that matches the first identifier if found
|
||
|
|
var foundPrimary;
|
||
|
|
var doubleMatch = false;
|
||
|
|
var aliasMatch = false;
|
||
|
|
if (identifierChain.length > 0) {
|
||
|
|
for (var i = 0; i < tablePrimaries.length; i++) {
|
||
|
|
if (tablePrimaries[i].subQueryAlias) {
|
||
|
|
if (equalIgnoreCase(tablePrimaries[i].subQueryAlias, identifierChain[0].name)) {
|
||
|
|
foundPrimary = tablePrimaries[i];
|
||
|
|
}
|
||
|
|
} else if (equalIgnoreCase(tablePrimaries[i].alias, identifierChain[0].name)) {
|
||
|
|
foundPrimary = tablePrimaries[i];
|
||
|
|
aliasMatch = true;
|
||
|
|
break;
|
||
|
|
} else if (tablePrimaries[i].identifierChain.length > 1 && identifierChain.length > 1 &&
|
||
|
|
equalIgnoreCase(tablePrimaries[i].identifierChain[0].name, identifierChain[0].name) &&
|
||
|
|
equalIgnoreCase(tablePrimaries[i].identifierChain[1].name, identifierChain[1].name)) {
|
||
|
|
foundPrimary = tablePrimaries[i];
|
||
|
|
doubleMatch = true;
|
||
|
|
break;
|
||
|
|
} else if (!foundPrimary && equalIgnoreCase(tablePrimaries[i].identifierChain[0].name, identifierChain[0].name) && identifierChain.length > (isColumnLocation ? 1 : 0)) {
|
||
|
|
foundPrimary = tablePrimaries[i];
|
||
|
|
// No break as first two can still match.
|
||
|
|
} else if (!foundPrimary && tablePrimaries[i].identifierChain.length > 1 && !tablePrimaries[i].alias
|
||
|
|
&& equalIgnoreCase(tablePrimaries[i].identifierChain[tablePrimaries[i].identifierChain.length - 1].name, identifierChain[0].name)) {
|
||
|
|
// This is for the case SELECT baa. FROM bla.baa, blo.boo;
|
||
|
|
foundPrimary = tablePrimaries[i];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (foundPrimary) {
|
||
|
|
if (foundPrimary.impalaComplex && wrapper.type === 'column') {
|
||
|
|
wrapper.type = 'complex';
|
||
|
|
}
|
||
|
|
identifierChain.shift();
|
||
|
|
if (doubleMatch) {
|
||
|
|
identifierChain.shift();
|
||
|
|
}
|
||
|
|
} else if (tablePrimaries.length === 1 && !isColumnWrapper) {
|
||
|
|
foundPrimary = tablePrimaries[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (foundPrimary) {
|
||
|
|
if (isColumnWrapper) {
|
||
|
|
wrapper.identifierChain = identifierChain;
|
||
|
|
if (foundPrimary.subQueryAlias) {
|
||
|
|
wrapper.tables = [{ subQuery: foundPrimary.subQueryAlias }];
|
||
|
|
} else if (foundPrimary.alias) {
|
||
|
|
if (!isColumnLocation && isColumnWrapper && aliasMatch) {
|
||
|
|
// TODO: add alias on table in suggestColumns (needs support in sqlAutocomplete3.js)
|
||
|
|
// the case is: SELECT cu.| FROM customers cu;
|
||
|
|
// This prevents alias from being added automatically in sqlAutocompleter3.js
|
||
|
|
wrapper.tables = [{ identifierChain: foundPrimary.identifierChain }];
|
||
|
|
} else {
|
||
|
|
wrapper.tables = [{ identifierChain: foundPrimary.identifierChain, alias: foundPrimary.alias }];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
wrapper.tables = [{ identifierChain: foundPrimary.identifierChain }];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (foundPrimary.subQueryAlias) {
|
||
|
|
identifierChain.unshift({ subQuery: foundPrimary.subQueryAlias });
|
||
|
|
} else {
|
||
|
|
identifierChain = foundPrimary.identifierChain.concat(identifierChain);
|
||
|
|
}
|
||
|
|
if (wrapper.tables) {
|
||
|
|
wrapper.tables.push({identifierChain: identifierChain});
|
||
|
|
delete wrapper.identifierChain;
|
||
|
|
} else {
|
||
|
|
wrapper.identifierChain = identifierChain;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (isColumnWrapper) {
|
||
|
|
wrapper.tables = [];
|
||
|
|
}
|
||
|
|
tablePrimaries.forEach(function (tablePrimary) {
|
||
|
|
var targetTable = tablePrimary.subQueryAlias ? { subQuery: tablePrimary.subQueryAlias } : { identifierChain: tablePrimary.identifierChain } ;
|
||
|
|
if (tablePrimary.alias) {
|
||
|
|
targetTable.alias = tablePrimary.alias;
|
||
|
|
}
|
||
|
|
if (wrapper.tables) {
|
||
|
|
wrapper.tables.push(targetTable)
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
delete wrapper.owner;
|
||
|
|
wrapper.linked = true;
|
||
|
|
};
|
||
|
|
|
||
|
|
var suggestLateralViewAliasesAsIdentifiers = function () {
|
||
|
|
if (typeof parser.yy.lateralViews === 'undefined' || parser.yy.lateralViews.length === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (typeof parser.yy.result.suggestIdentifiers === 'undefined') {
|
||
|
|
parser.yy.result.suggestIdentifiers = [];
|
||
|
|
}
|
||
|
|
parser.yy.lateralViews.forEach(function (lateralView) {
|
||
|
|
if (typeof lateralView.tableAlias !== 'undefined') {
|
||
|
|
parser.yy.result.suggestIdentifiers.push({name: lateralView.tableAlias + '.', type: 'alias'});
|
||
|
|
}
|
||
|
|
lateralView.columnAliases.forEach(function (columnAlias) {
|
||
|
|
parser.yy.result.suggestIdentifiers.push({name: columnAlias, type: 'alias'});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
if (parser.yy.result.suggestIdentifiers.length === 0) {
|
||
|
|
delete parser.yy.result.suggestIdentifiers;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var filterTablePrimariesForOwner = function (tablePrimaries, owner) {
|
||
|
|
var result = [];
|
||
|
|
tablePrimaries.forEach(function (primary) {
|
||
|
|
if (typeof owner === 'undefined' && typeof primary.owner === 'undefined') {
|
||
|
|
result.push(primary);
|
||
|
|
} else if (owner === primary.owner) {
|
||
|
|
result.push(primary);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
var convertTablePrimariesToSuggestions = function (tablePrimaries) {
|
||
|
|
var tables = [];
|
||
|
|
var identifiers = [];
|
||
|
|
tablePrimaries.forEach(function (tablePrimary) {
|
||
|
|
if (tablePrimary.identifierChain && tablePrimary.identifierChain.length > 0) {
|
||
|
|
var table = {identifierChain: tablePrimary.identifierChain};
|
||
|
|
if (tablePrimary.alias) {
|
||
|
|
table.alias = tablePrimary.alias;
|
||
|
|
identifiers.push({name: table.alias + '.', type: 'alias'});
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
var testForImpalaAlias = [{name: table.alias}];
|
||
|
|
var result = parser.expandImpalaIdentifierChain(tablePrimaries, testForImpalaAlias);
|
||
|
|
if (result.length > 1) {
|
||
|
|
// Continue if it's a reference to a complex type
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var lastIdentifier = tablePrimary.identifierChain[tablePrimary.identifierChain.length - 1];
|
||
|
|
if (typeof lastIdentifier.name !== 'undefined') {
|
||
|
|
identifiers.push({name: lastIdentifier.name + '.', type: 'table'});
|
||
|
|
} else if (typeof lastIdentifier.subQuery !== 'undefined') {
|
||
|
|
identifiers.push({name: lastIdentifier.subQuery + '.', type: 'sub-query'});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
tables.push(table);
|
||
|
|
} else if (tablePrimary.subQueryAlias) {
|
||
|
|
identifiers.push({name: tablePrimary.subQueryAlias + '.', type: 'sub-query'});
|
||
|
|
tables.push({identifierChain: [{subQuery: tablePrimary.subQueryAlias}]});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (identifiers.length > 0) {
|
||
|
|
if (typeof parser.yy.result.suggestIdentifiers === 'undefined') {
|
||
|
|
parser.yy.result.suggestIdentifiers = identifiers;
|
||
|
|
} else {
|
||
|
|
parser.yy.result.suggestIdentifiers = identifiers.concat(parser.yy.result.suggestIdentifiers);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.yy.result.suggestColumns.tables = tables;
|
||
|
|
if (parser.yy.result.suggestColumns.identifierChain && parser.yy.result.suggestColumns.identifierChain.length === 0) {
|
||
|
|
delete parser.yy.result.suggestColumns.identifierChain;
|
||
|
|
}
|
||
|
|
parser.yy.result.suggestColumns.linked = true;
|
||
|
|
};
|
||
|
|
|
||
|
|
var linkTablePrimaries = function () {
|
||
|
|
if (!parser.yy.cursorFound || typeof parser.yy.latestTablePrimaries === 'undefined') {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
SIMPLE_TABLE_REF_SUGGESTIONS.forEach(function (suggestionType) {
|
||
|
|
if (typeof parser.yy.result[suggestionType] !== 'undefined' && parser.yy.result[suggestionType].tablePrimaries && !parser.yy.result[suggestionType].linked) {
|
||
|
|
parser.yy.result[suggestionType].tables = [];
|
||
|
|
parser.yy.result[suggestionType].tablePrimaries.forEach(function (tablePrimary) {
|
||
|
|
if (!tablePrimary.subQueryAlias) {
|
||
|
|
parser.yy.result[suggestionType].tables.push(tablePrimary.alias ? {
|
||
|
|
identifierChain: tablePrimary.identifierChain.concat(),
|
||
|
|
alias: tablePrimary.alias
|
||
|
|
} : {identifierChain: tablePrimary.identifierChain.concat()});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
delete parser.yy.result[suggestionType].tablePrimaries;
|
||
|
|
parser.yy.result[suggestionType].linked = true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.suggestColumns !== 'undefined' && !parser.yy.result.suggestColumns.linked) {
|
||
|
|
var tablePrimaries = filterTablePrimariesForOwner(parser.yy.latestTablePrimaries, parser.yy.result.suggestColumns.owner);
|
||
|
|
if (!parser.yy.result.suggestColumns.tables) {
|
||
|
|
parser.yy.result.suggestColumns.tables = [];
|
||
|
|
}
|
||
|
|
if (parser.yy.subQueries.length > 0) {
|
||
|
|
parser.yy.result.subQueries = parser.yy.subQueries;
|
||
|
|
}
|
||
|
|
if (typeof parser.yy.result.suggestColumns.identifierChain === 'undefined' || parser.yy.result.suggestColumns.identifierChain.length === 0) {
|
||
|
|
if (tablePrimaries.length > 1) {
|
||
|
|
convertTablePrimariesToSuggestions(tablePrimaries);
|
||
|
|
} else {
|
||
|
|
suggestLateralViewAliasesAsIdentifiers();
|
||
|
|
if (tablePrimaries.length === 1 && (tablePrimaries[0].alias || tablePrimaries[0].subQueryAlias)) {
|
||
|
|
convertTablePrimariesToSuggestions(tablePrimaries);
|
||
|
|
}
|
||
|
|
parser.expandIdentifierChain({ wrapper: parser.yy.result.suggestColumns, anyOwner: false, isColumnWrapper: true });
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Expand exploded views in the identifier chain
|
||
|
|
if (parser.isHive() && !parser.yy.result.suggestColumns.linked) {
|
||
|
|
var originalLength = parser.yy.result.suggestColumns.identifierChain.length;
|
||
|
|
parser.yy.result.suggestColumns.identifierChain = parser.expandLateralViews(parser.yy.lateralViews, parser.yy.result.suggestColumns.identifierChain, true);
|
||
|
|
// Drop '*' keyword for lateral views
|
||
|
|
if (typeof parser.yy.result.suggestColumns !== 'undefined') {
|
||
|
|
if (parser.yy.result.suggestColumns.identifierChain.length > originalLength &&
|
||
|
|
typeof parser.yy.result.suggestKeywords !== 'undefined' &&
|
||
|
|
parser.yy.result.suggestKeywords.length === 1 &&
|
||
|
|
parser.yy.result.suggestKeywords[0].value === '*') {
|
||
|
|
delete parser.yy.result.suggestKeywords;
|
||
|
|
}
|
||
|
|
parser.expandIdentifierChain({ wrapper: parser.yy.result.suggestColumns, anyOwner: false, isColumnWrapper: true });
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
parser.expandIdentifierChain({ wrapper: parser.yy.result.suggestColumns, anyOwner: false, isColumnWrapper: true });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.colRef !== 'undefined' && !parser.yy.result.colRef.linked) {
|
||
|
|
parser.expandIdentifierChain({ wrapper: parser.yy.result.colRef });
|
||
|
|
|
||
|
|
var primaries = filterTablePrimariesForOwner(parser.yy.latestTablePrimaries);
|
||
|
|
if (primaries.length === 0 || (primaries.length > 1 && parser.yy.result.colRef.identifierChain.length === 1)) {
|
||
|
|
parser.yy.result.colRef.identifierChain = [];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (typeof parser.yy.result.suggestKeyValues !== 'undefined' && !parser.yy.result.suggestKeyValues.linked) {
|
||
|
|
parser.expandIdentifierChain({ wrapper: parser.yy.result.suggestKeyValues });
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getSubQuery = function (cols) {
|
||
|
|
var columns = [];
|
||
|
|
cols.selectList.forEach(function (col) {
|
||
|
|
var result = {};
|
||
|
|
if (col.alias) {
|
||
|
|
result.alias = col.alias;
|
||
|
|
}
|
||
|
|
if (col.valueExpression && col.valueExpression.columnReference) {
|
||
|
|
result.identifierChain = col.valueExpression.columnReference
|
||
|
|
} else if (col.asterisk) {
|
||
|
|
result.identifierChain = [{asterisk: true}];
|
||
|
|
}
|
||
|
|
if (col.valueExpression && col.valueExpression.types && col.valueExpression.types.length === 1) {
|
||
|
|
result.type = col.valueExpression.types[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
columns.push(result);
|
||
|
|
});
|
||
|
|
|
||
|
|
return {
|
||
|
|
columns: columns
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addTablePrimary = function (ref) {
|
||
|
|
if (typeof parser.yy.latestTablePrimaries === 'undefined') {
|
||
|
|
parser.yy.latestTablePrimaries = [];
|
||
|
|
}
|
||
|
|
parser.yy.latestTablePrimaries.push(ref);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestFileFormats = function () {
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['AVRO', 'INPUTFORMAT', 'ORC', 'PARQUET', 'RCFILE', 'SEQUENCEFILE', 'TEXTFILE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['AVRO', 'KUDU', 'ORC', 'PARQUET', 'RCFILE', 'SEQUENCEFILE', 'TEXTFILE']);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getKeywordsForOptionalsLR = function (optionals, keywords, override) {
|
||
|
|
var result = [];
|
||
|
|
|
||
|
|
for (var i = 0; i < optionals.length; i++) {
|
||
|
|
if (!optionals[i] && (typeof override === 'undefined' || override[i])) {
|
||
|
|
if (keywords[i] instanceof Array) {
|
||
|
|
result = result.concat(keywords[i]);
|
||
|
|
} else {
|
||
|
|
result.push(keywords[i]);
|
||
|
|
}
|
||
|
|
} else if (optionals[i]) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestDdlAndDmlKeywords = function (extraKeywords) {
|
||
|
|
var keywords = ['ALTER', 'CREATE', 'DESCRIBE', 'DROP', 'GRANT', 'INSERT', 'REVOKE', 'SELECT', 'SET', 'SHOW', 'TRUNCATE', 'UPDATE', 'USE', 'WITH'];
|
||
|
|
|
||
|
|
if (extraKeywords) {
|
||
|
|
keywords = keywords.concat(extraKeywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
keywords = keywords.concat(['ABORT', 'ANALYZE TABLE', 'DELETE', 'EXPORT', 'IMPORT', 'LOAD', 'MERGE', 'MSCK', 'RELOAD FUNCTION', 'RESET']);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat(['COMMENT ON', 'COMPUTE', 'DELETE', 'INVALIDATE METADATA', 'LOAD', 'REFRESH', 'UPSERT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.checkForSelectListKeywords = function (selectList) {
|
||
|
|
if (selectList.length === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var last = selectList[selectList.length - 1];
|
||
|
|
if (!last || !last.valueExpression) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var valueExpressionKeywords = parser.getValueExpressionKeywords(last.valueExpression);
|
||
|
|
var keywords = [];
|
||
|
|
if (last.suggestKeywords) {
|
||
|
|
keywords = keywords.concat(last.suggestKeywords);
|
||
|
|
}
|
||
|
|
if (valueExpressionKeywords.suggestKeywords) {
|
||
|
|
keywords = keywords.concat(valueExpressionKeywords.suggestKeywords);
|
||
|
|
}
|
||
|
|
if (valueExpressionKeywords.suggestColRefKeywords) {
|
||
|
|
parser.suggestColRefKeywords(valueExpressionKeywords.suggestColRefKeywords);
|
||
|
|
parser.addColRefIfExists(last.valueExpression);
|
||
|
|
}
|
||
|
|
if (!last.alias) {
|
||
|
|
keywords.push('AS');
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.checkForKeywords = function (expression) {
|
||
|
|
if (expression) {
|
||
|
|
if (expression.suggestKeywords && expression.suggestKeywords.length > 0) {
|
||
|
|
parser.suggestKeywords(expression.suggestKeywords);
|
||
|
|
}
|
||
|
|
if (expression.suggestColRefKeywords) {
|
||
|
|
parser.suggestColRefKeywords(expression.suggestColRefKeywords);
|
||
|
|
parser.addColRefIfExists(expression);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.createWeightedKeywords = function (keywords, weight) {
|
||
|
|
var result = [];
|
||
|
|
keywords.forEach(function (keyword) {
|
||
|
|
if (typeof keyword.weight !== 'undefined') {
|
||
|
|
keyword.weight = weight + (keyword.weight / 10);
|
||
|
|
result.push(keyword);
|
||
|
|
} else {
|
||
|
|
result.push({value: keyword, weight: weight});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestKeywords = function (keywords) {
|
||
|
|
var weightedKeywords = [];
|
||
|
|
if (keywords.length == 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
keywords.forEach(function (keyword) {
|
||
|
|
if (typeof keyword.weight !== 'undefined') {
|
||
|
|
weightedKeywords.push(keyword);
|
||
|
|
} else {
|
||
|
|
weightedKeywords.push({value: keyword, weight: -1})
|
||
|
|
}
|
||
|
|
});
|
||
|
|
weightedKeywords.sort(function (a, b) {
|
||
|
|
if (a.weight !== b.weight) {
|
||
|
|
return b.weight - a.weight;
|
||
|
|
}
|
||
|
|
return a.value.localeCompare(b.value);
|
||
|
|
});
|
||
|
|
parser.yy.result.suggestKeywords = weightedKeywords;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestColRefKeywords = function (colRefKeywords) {
|
||
|
|
parser.yy.result.suggestColRefKeywords = colRefKeywords;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestTablesOrColumns = function (identifier) {
|
||
|
|
if (typeof parser.yy.latestTablePrimaries == 'undefined') {
|
||
|
|
parser.suggestTables({identifierChain: [{name: identifier}]});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var tableRef = parser.yy.latestTablePrimaries.filter(function (tablePrimary) {
|
||
|
|
return equalIgnoreCase(tablePrimary.alias, identifier);
|
||
|
|
});
|
||
|
|
if (tableRef.length > 0) {
|
||
|
|
parser.suggestColumns({identifierChain: [{name: identifier}]});
|
||
|
|
} else {
|
||
|
|
parser.suggestTables({identifierChain: [{name: identifier}]});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestFunctions = function (details) {
|
||
|
|
parser.yy.result.suggestFunctions = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestAggregateFunctions = function () {
|
||
|
|
var primaries = [];
|
||
|
|
var aliases = {};
|
||
|
|
parser.yy.latestTablePrimaries.forEach(function (primary) {
|
||
|
|
if (typeof primary.alias !== 'undefined') {
|
||
|
|
aliases[primary.alias] = true;
|
||
|
|
}
|
||
|
|
// Drop if the first one refers to a table alias (...FROM tbl t, t.map tm ...)
|
||
|
|
if (typeof primary.identifierChain !== 'undefined' && !aliases[primary.identifierChain[0].name] && typeof primary.owner === 'undefined') {
|
||
|
|
primaries.push(primary);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
parser.yy.result.suggestAggregateFunctions = {tablePrimaries: primaries};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestAnalyticFunctions = function () {
|
||
|
|
parser.yy.result.suggestAnalyticFunctions = true;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestSetOptions = function () {
|
||
|
|
parser.yy.result.suggestSetOptions = true;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestIdentifiers = function (identifiers) {
|
||
|
|
parser.yy.result.suggestIdentifiers = identifiers;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestColumns = function (details) {
|
||
|
|
if (typeof details === 'undefined') {
|
||
|
|
details = {identifierChain: []};
|
||
|
|
} else if (typeof details.identifierChain === 'undefined') {
|
||
|
|
details.identifierChain = [];
|
||
|
|
}
|
||
|
|
parser.yy.result.suggestColumns = details;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestGroupBys = function (details) {
|
||
|
|
parser.yy.result.suggestGroupBys = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestOrderBys = function (details) {
|
||
|
|
parser.yy.result.suggestOrderBys = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestFilters = function (details) {
|
||
|
|
parser.yy.result.suggestFilters = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestKeyValues = function (details) {
|
||
|
|
parser.yy.result.suggestKeyValues = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestTables = function (details) {
|
||
|
|
parser.yy.result.suggestTables = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
var adjustLocationForCursor = function (location) {
|
||
|
|
// columns are 0-based and lines not, so add 1 to cols
|
||
|
|
var newLocation = {
|
||
|
|
first_line: location.first_line,
|
||
|
|
last_line: location.last_line,
|
||
|
|
first_column: location.first_column + 1,
|
||
|
|
last_column: location.last_column + 1
|
||
|
|
};
|
||
|
|
if (parser.yy.cursorFound) {
|
||
|
|
if (parser.yy.cursorFound.first_line === newLocation.first_line && parser.yy.cursorFound.last_column <= newLocation.first_column) {
|
||
|
|
var additionalSpace = parser.yy.partialLengths.left + parser.yy.partialLengths.right;
|
||
|
|
additionalSpace -= parser.yy.partialCursor ? 1 : 3; // For some reason the normal cursor eats 3 positions.
|
||
|
|
newLocation.first_column = newLocation.first_column + additionalSpace;
|
||
|
|
newLocation.last_column = newLocation.last_column + additionalSpace;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return newLocation;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addFunctionLocation = function (location, functionName) {
|
||
|
|
// Remove trailing '(' from location
|
||
|
|
var adjustedLocation = {
|
||
|
|
first_line: location.first_line,
|
||
|
|
last_line: location.last_line,
|
||
|
|
first_column: location.first_column,
|
||
|
|
last_column: location.last_column - 1
|
||
|
|
};
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'function',
|
||
|
|
location: adjustLocationForCursor(adjustedLocation),
|
||
|
|
function: functionName.toLowerCase()
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addStatementLocation = function (location) {
|
||
|
|
// Don't report lonely cursor as a statement
|
||
|
|
if (location.first_line === location.last_line && Math.abs(location.last_column - location.first_column) === 1) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var adjustedLocation;
|
||
|
|
if (parser.yy.cursorFound && parser.yy.cursorFound.last_line === location.last_line &&
|
||
|
|
parser.yy.cursorFound.first_column >= location.first_column && parser.yy.cursorFound.last_column <= location.last_column) {
|
||
|
|
var additionalSpace = parser.yy.partialLengths.left + parser.yy.partialLengths.right;
|
||
|
|
adjustedLocation = {
|
||
|
|
first_line: location.first_line,
|
||
|
|
last_line: location.last_line,
|
||
|
|
first_column: location.first_column + 1,
|
||
|
|
last_column: location.last_column + additionalSpace - (parser.yy.partialCursor ? 0 : 2)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
adjustedLocation = {
|
||
|
|
first_line: location.first_line,
|
||
|
|
last_line: location.last_line,
|
||
|
|
first_column: location.first_column + 1,
|
||
|
|
last_column: location.last_column + 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'statement',
|
||
|
|
location: adjustedLocation
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.firstDefined = function () {
|
||
|
|
for (var i = 0; i + 1 < arguments.length; i += 2) {
|
||
|
|
if (arguments[i]) {
|
||
|
|
return arguments[i + 1];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addClauseLocation = function (type, precedingLocation, locationIfPresent, isCursor) {
|
||
|
|
var location;
|
||
|
|
if (isCursor) {
|
||
|
|
if (parser.yy.partialLengths.left === 0 && parser.yy.partialLengths.right === 0) {
|
||
|
|
location = {
|
||
|
|
type: type,
|
||
|
|
missing: true,
|
||
|
|
location: adjustLocationForCursor({
|
||
|
|
first_line: precedingLocation.last_line,
|
||
|
|
first_column: precedingLocation.last_column,
|
||
|
|
last_line: precedingLocation.last_line,
|
||
|
|
last_column: precedingLocation.last_column
|
||
|
|
})
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
location = {
|
||
|
|
type: type,
|
||
|
|
missing: false,
|
||
|
|
location: {
|
||
|
|
first_line: locationIfPresent.last_line,
|
||
|
|
first_column: locationIfPresent.last_column - 1,
|
||
|
|
last_line: locationIfPresent.last_line,
|
||
|
|
last_column: locationIfPresent.last_column - 1 + parser.yy.partialLengths.right + parser.yy.partialLengths.left
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
location = {
|
||
|
|
type: type,
|
||
|
|
missing: !locationIfPresent,
|
||
|
|
location: adjustLocationForCursor(locationIfPresent || {
|
||
|
|
first_line: precedingLocation.last_line,
|
||
|
|
first_column: precedingLocation.last_column,
|
||
|
|
last_line: precedingLocation.last_line,
|
||
|
|
last_column: precedingLocation.last_column
|
||
|
|
})
|
||
|
|
};
|
||
|
|
}
|
||
|
|
if (parser.isInSubquery()) {
|
||
|
|
location.subquery = true;
|
||
|
|
}
|
||
|
|
parser.yy.locations.push(location)
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addStatementTypeLocation = function (identifier, location, additionalText) {
|
||
|
|
if (!parser.isImpala()) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var loc = {
|
||
|
|
type: 'statementType',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifier: identifier
|
||
|
|
};
|
||
|
|
if (typeof additionalText !== 'undefined') {
|
||
|
|
switch (identifier) {
|
||
|
|
case 'ALTER':
|
||
|
|
if (/ALTER\s+VIEW/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'ALTER VIEW';
|
||
|
|
} else {
|
||
|
|
loc.identifier = 'ALTER TABLE';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 'COMPUTE':
|
||
|
|
loc.identifier = 'COMPUTE STATS';
|
||
|
|
break;
|
||
|
|
case 'CREATE':
|
||
|
|
if (/CREATE\s+VIEW/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'CREATE VIEW';
|
||
|
|
} else if (/CREATE\s+TABLE/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'CREATE TABLE';
|
||
|
|
} else if (/CREATE\s+DATABASE/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'CREATE DATABASE';
|
||
|
|
} else if (/CREATE\s+ROLE/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'CREATE ROLE';
|
||
|
|
} else if (/CREATE\s+FUNCTION/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'CREATE FUNCTION';
|
||
|
|
} else {
|
||
|
|
loc.identifier = 'CREATE TABLE';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 'DROP':
|
||
|
|
if (/DROP\s+VIEW/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'DROP VIEW';
|
||
|
|
} else if (/DROP\s+TABLE/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'DROP TABLE';
|
||
|
|
} else if (/DROP\s+DATABASE/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'DROP DATABASE';
|
||
|
|
} else if (/DROP\s+ROLE/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'DROP ROLE';
|
||
|
|
} else if (/DROP\s+STATS/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'DROP STATS';
|
||
|
|
} else if (/DROP\s+FUNCTION/i.test(additionalText)) {
|
||
|
|
loc.identifier = 'DROP FUNCTION';
|
||
|
|
} else {
|
||
|
|
loc.identifier = 'DROP TABLE';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 'INVALIDATE':
|
||
|
|
loc.identifier = 'INVALIDATE METADATA';
|
||
|
|
break;
|
||
|
|
case 'LOAD':
|
||
|
|
loc.identifier = 'LOAD DATA';
|
||
|
|
break;
|
||
|
|
case 'TRUNCATE':
|
||
|
|
loc.identifier = 'TRUNCATE TABLE';
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.yy.locations.push(loc);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addFileLocation = function (location, path) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'file',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
path: path
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addDatabaseLocation = function (location, identifierChain) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'database',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifierChain: identifierChain
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addTableLocation = function (location, identifierChain) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'table',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifierChain: identifierChain
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addColumnAliasLocation = function (location, alias, parentLocation) {
|
||
|
|
var aliasLocation = {
|
||
|
|
type: 'alias',
|
||
|
|
source: 'column',
|
||
|
|
alias: alias,
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
parentLocation: adjustLocationForCursor(parentLocation)
|
||
|
|
};
|
||
|
|
if (parser.yy.locations.length && parser.yy.locations[parser.yy.locations.length - 1].type === 'column') {
|
||
|
|
var closestColumn = parser.yy.locations[parser.yy.locations.length - 1];
|
||
|
|
if (closestColumn.location.first_line === aliasLocation.parentLocation.first_line &&
|
||
|
|
closestColumn.location.last_line === aliasLocation.parentLocation.last_line &&
|
||
|
|
closestColumn.location.first_column === aliasLocation.parentLocation.first_column &&
|
||
|
|
closestColumn.location.last_column === aliasLocation.parentLocation.last_column) {
|
||
|
|
parser.yy.locations[parser.yy.locations.length - 1].alias = alias;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.yy.locations.push(aliasLocation);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addTableAliasLocation = function (location, alias, identifierChain) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'alias',
|
||
|
|
source: 'table',
|
||
|
|
alias: alias,
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifierChain: identifierChain
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addSubqueryAliasLocation = function (location, alias) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'alias',
|
||
|
|
source: 'subquery',
|
||
|
|
alias: alias,
|
||
|
|
location: adjustLocationForCursor(location)
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addAsteriskLocation = function (location, identifierChain) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'asterisk',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifierChain: identifierChain
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addVariableLocation = function (location, value) {
|
||
|
|
if (/\$\{[^}]*\}/.test(value)) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'variable',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
value: value
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addColumnLocation = function (location, identifierChain) {
|
||
|
|
var isVariable = identifierChain.length && /\$\{[^}]*\}/.test(identifierChain[identifierChain.length - 1].name);
|
||
|
|
if (isVariable) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'variable',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
value: identifierChain[identifierChain.length - 1].name
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'column',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifierChain: identifierChain,
|
||
|
|
qualified: identifierChain.length > 1
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addCteAliasLocation = function (location, alias) {
|
||
|
|
parser.yy.locations.push({
|
||
|
|
type: 'alias',
|
||
|
|
source: 'cte',
|
||
|
|
alias: alias,
|
||
|
|
location: adjustLocationForCursor(location)
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addUnknownLocation = function (location, identifierChain) {
|
||
|
|
var isVariable = identifierChain.length && /\$\{[^}]*\}/.test(identifierChain[identifierChain.length - 1].name);
|
||
|
|
var loc;
|
||
|
|
if (isVariable) {
|
||
|
|
loc = {
|
||
|
|
type: 'variable',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
value: identifierChain[identifierChain.length - 1].name
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
loc = {
|
||
|
|
type: 'unknown',
|
||
|
|
location: adjustLocationForCursor(location),
|
||
|
|
identifierChain: identifierChain,
|
||
|
|
qualified: identifierChain.length > 1
|
||
|
|
};
|
||
|
|
}
|
||
|
|
parser.yy.locations.push(loc);
|
||
|
|
return loc;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.addColRefToVariableIfExists = function (left, right) {
|
||
|
|
if (left && left.columnReference && left.columnReference.length && right && right.columnReference && right.columnReference.length && parser.yy.locations.length > 1) {
|
||
|
|
var addColRefToVariableLocation = function (variableValue, colRef) {
|
||
|
|
// See if colref is actually an alias
|
||
|
|
if (colRef.length === 1 && colRef[0].name) {
|
||
|
|
parser.yy.locations.some(function (location) {
|
||
|
|
if (location.type === 'column' && location.alias === colRef[0].name) {
|
||
|
|
colRef = location.identifierChain;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
for (var i = parser.yy.locations.length - 1; i > 0; i--) {
|
||
|
|
var location = parser.yy.locations[i];
|
||
|
|
if (location.type === 'variable' && location.value === variableValue) {
|
||
|
|
location.colRef = { identifierChain: colRef };
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
if (/\$\{[^}]*\}/.test(left.columnReference[0].name)) {
|
||
|
|
// left is variable
|
||
|
|
addColRefToVariableLocation(left.columnReference[0].name, right.columnReference);
|
||
|
|
} else if (/\$\{[^}]*\}/.test(right.columnReference[0].name)) {
|
||
|
|
// right is variable
|
||
|
|
addColRefToVariableLocation(right.columnReference[0].name, left.columnReference);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestDatabases = function (details) {
|
||
|
|
parser.yy.result.suggestDatabases = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestHdfs = function (details) {
|
||
|
|
parser.yy.result.suggestHdfs = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.suggestValues = function (details) {
|
||
|
|
parser.yy.result.suggestValues = details || {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.determineCase = function (text) {
|
||
|
|
if (!parser.yy.caseDetermined) {
|
||
|
|
parser.yy.lowerCase = text.toLowerCase() === text;
|
||
|
|
parser.yy.caseDetermined = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.handleQuotedValueWithCursor = function (lexer, yytext, yylloc, quoteChar) {
|
||
|
|
if (yytext.indexOf('\u2020') !== -1 || yytext.indexOf('\u2021') !== -1) {
|
||
|
|
parser.yy.partialCursor = yytext.indexOf('\u2021') !== -1;
|
||
|
|
var cursorIndex = parser.yy.partialCursor ? yytext.indexOf('\u2021') : yytext.indexOf('\u2020');
|
||
|
|
parser.yy.cursorFound = {
|
||
|
|
first_line: yylloc.first_line,
|
||
|
|
last_line: yylloc.last_line,
|
||
|
|
first_column: yylloc.first_column + cursorIndex,
|
||
|
|
last_column: yylloc.first_column + cursorIndex + 1
|
||
|
|
};
|
||
|
|
var remainder = yytext.substring(cursorIndex + 1);
|
||
|
|
var remainingQuotes = (lexer.upcomingInput().match(new RegExp(quoteChar, 'g')) || []).length;
|
||
|
|
if (remainingQuotes > 0 && remainingQuotes & 1 != 0) {
|
||
|
|
parser.yy.missingEndQuote = false;
|
||
|
|
lexer.input();
|
||
|
|
} else {
|
||
|
|
parser.yy.missingEndQuote = true;
|
||
|
|
lexer.unput(remainder);
|
||
|
|
}
|
||
|
|
lexer.popState();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
|
||
|
|
var lexerModified = false;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Main parser function
|
||
|
|
*/
|
||
|
|
parser.parseSql = function (beforeCursor, afterCursor, dialect, debug) {
|
||
|
|
// Jison counts CRLF as two lines in the locations
|
||
|
|
beforeCursor = beforeCursor.replace(/\r\n|\n\r/gm, '\n');
|
||
|
|
afterCursor = afterCursor.replace(/\r\n|\n\r/gm, '\n');
|
||
|
|
parser.yy.result = {locations: []};
|
||
|
|
parser.yy.lowerCase = false;
|
||
|
|
parser.yy.locations = [];
|
||
|
|
parser.yy.allLocations = [];
|
||
|
|
parser.yy.subQueries = [];
|
||
|
|
parser.yy.errors = [];
|
||
|
|
parser.yy.selectListAliases = [];
|
||
|
|
|
||
|
|
parser.yy.locationsStack = [];
|
||
|
|
parser.yy.primariesStack = [];
|
||
|
|
parser.yy.lateralViewsStack = [];
|
||
|
|
parser.yy.subQueriesStack = [];
|
||
|
|
parser.yy.resultStack = [];
|
||
|
|
parser.yy.selectListAliasesStack = [];
|
||
|
|
|
||
|
|
delete parser.yy.caseDetermined;
|
||
|
|
delete parser.yy.cursorFound;
|
||
|
|
delete parser.yy.partialCursor;
|
||
|
|
|
||
|
|
parser.prepareNewStatement();
|
||
|
|
|
||
|
|
var REASONABLE_SURROUNDING_LENGTH = 150000; // About 3000 lines before and after
|
||
|
|
|
||
|
|
if (beforeCursor.length > REASONABLE_SURROUNDING_LENGTH) {
|
||
|
|
if ((beforeCursor.length - beforeCursor.lastIndexOf(';')) > REASONABLE_SURROUNDING_LENGTH) {
|
||
|
|
// Bail out if the last complete statement is more than 150000 chars before
|
||
|
|
return {};
|
||
|
|
}
|
||
|
|
// Cut it at the first statement found within 150000 chars before
|
||
|
|
var lastReasonableChunk = beforeCursor.substring(beforeCursor.length - REASONABLE_SURROUNDING_LENGTH);
|
||
|
|
beforeCursor = lastReasonableChunk.substring(lastReasonableChunk.indexOf(';') + 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (afterCursor.length > REASONABLE_SURROUNDING_LENGTH) {
|
||
|
|
if ((afterCursor.length - afterCursor.indexOf(';')) > REASONABLE_SURROUNDING_LENGTH) {
|
||
|
|
// No need to bail out for what's comes after, we can still get keyword completion
|
||
|
|
afterCursor = '';
|
||
|
|
} else {
|
||
|
|
// Cut it at the last statement found within 150000 chars after
|
||
|
|
var firstReasonableChunk = afterCursor.substring(0, REASONABLE_SURROUNDING_LENGTH);
|
||
|
|
afterCursor = firstReasonableChunk.substring(0, firstReasonableChunk.lastIndexOf(';'));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
parser.yy.partialLengths = parser.identifyPartials(beforeCursor, afterCursor);
|
||
|
|
|
||
|
|
if (parser.yy.partialLengths.left > 0) {
|
||
|
|
beforeCursor = beforeCursor.substring(0, beforeCursor.length - parser.yy.partialLengths.left);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parser.yy.partialLengths.right > 0) {
|
||
|
|
afterCursor = afterCursor.substring(parser.yy.partialLengths.right);
|
||
|
|
}
|
||
|
|
|
||
|
|
parser.yy.activeDialect = (dialect !== 'hive' && dialect !== 'impala') ? undefined : dialect;
|
||
|
|
|
||
|
|
// Hack to set the inital state of the lexer without first having to hit a token
|
||
|
|
// has to be done as the first token found can be dependant on dialect
|
||
|
|
if (!lexerModified) {
|
||
|
|
var originalSetInput = parser.lexer.setInput;
|
||
|
|
parser.lexer.setInput = function (input, yy) {
|
||
|
|
var lexer = originalSetInput.bind(parser.lexer)(input, yy);
|
||
|
|
if (typeof parser.yy.activeDialect !== 'undefined') {
|
||
|
|
lexer.begin(parser.yy.activeDialect);
|
||
|
|
}
|
||
|
|
return lexer;
|
||
|
|
};
|
||
|
|
lexerModified = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
var result;
|
||
|
|
try {
|
||
|
|
// Add |CURSOR| or |PARTIAL_CURSOR| to represent the different cursor states in the lexer
|
||
|
|
result = parser.parse(beforeCursor + (beforeCursor.length == 0 || /[\s\(]$$/.test(beforeCursor) ? ' \u2020 ' : '\u2021') + afterCursor);
|
||
|
|
} catch (err) {
|
||
|
|
// On any error try to at least return any existing result
|
||
|
|
if (typeof parser.yy.result === 'undefined') {
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
if (debug) {
|
||
|
|
console.log(err);
|
||
|
|
console.error(err.stack);
|
||
|
|
}
|
||
|
|
result = parser.yy.result;
|
||
|
|
}
|
||
|
|
if (parser.yy.errors.length > 0) {
|
||
|
|
parser.yy.result.errors = parser.yy.errors;
|
||
|
|
if (debug) {
|
||
|
|
console.log(parser.yy.errors);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
linkTablePrimaries();
|
||
|
|
parser.commitLocations();
|
||
|
|
// Clean up and prioritize
|
||
|
|
prioritizeSuggestions();
|
||
|
|
} catch (err) {
|
||
|
|
if (debug) {
|
||
|
|
console.log(err);
|
||
|
|
console.error(err.stack);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
parser.yy.allLocations.sort(function (a, b) {
|
||
|
|
if (a.location.first_line !== b.location.first_line) {
|
||
|
|
return a.location.first_line - b.location.first_line;
|
||
|
|
}
|
||
|
|
if (a.location.first_column !== b.location.first_column) {
|
||
|
|
return a.location.first_column - b.location.first_column;
|
||
|
|
}
|
||
|
|
if (a.location.last_column !== b.location.last_column) {
|
||
|
|
return b.location.last_column - a.location.last_column;
|
||
|
|
}
|
||
|
|
return b.type.localeCompare(a.type);
|
||
|
|
});
|
||
|
|
parser.yy.result.locations = parser.yy.allLocations;
|
||
|
|
|
||
|
|
parser.yy.result.locations.forEach(function (location) {
|
||
|
|
delete location.linked;
|
||
|
|
});
|
||
|
|
if (typeof parser.yy.result.suggestColumns !== 'undefined') {
|
||
|
|
delete parser.yy.result.suggestColumns.linked;
|
||
|
|
}
|
||
|
|
|
||
|
|
SIMPLE_TABLE_REF_SUGGESTIONS.forEach(function (suggestionType) {
|
||
|
|
if (typeof parser.yy.result[suggestionType] !== 'undefined') {
|
||
|
|
delete parser.yy.result[suggestionType].linked;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (typeof parser.yy.result.colRef !== 'undefined') {
|
||
|
|
delete parser.yy.result.colRef.linked;
|
||
|
|
}
|
||
|
|
if (typeof parser.yy.result.suggestKeyValues !== 'undefined') {
|
||
|
|
delete parser.yy.result.suggestKeyValues.linked;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof result.error !== 'undefined' && typeof result.error.expected !== 'undefined') {
|
||
|
|
// Remove any expected tokens from other dialects, jison doesn't remove tokens from other lexer states.
|
||
|
|
var actualExpected = {};
|
||
|
|
result.error.expected.forEach(function (expected) {
|
||
|
|
var match = expected.match(/\<([a-z]+)\>(.*)/);
|
||
|
|
if (match !== null) {
|
||
|
|
if (typeof parser.yy.activeDialect !== 'undefined' && parser.yy.activeDialect === match[1]) {
|
||
|
|
actualExpected[("'" + match[2])] = true;
|
||
|
|
}
|
||
|
|
} else if (expected.indexOf('CURSOR') == -1) {
|
||
|
|
actualExpected[expected] = true;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
result.error.expected = Object.keys(actualExpected);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof result.error !== 'undefined' && result.error.recoverable) {
|
||
|
|
delete result.error;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Adjust all the statement locations to include white space surrounding them
|
||
|
|
var lastStatementLocation = null;
|
||
|
|
result.locations.forEach(function (location) {
|
||
|
|
if (location.type === 'statement') {
|
||
|
|
if (lastStatementLocation === null) {
|
||
|
|
location.location.first_line = 1;
|
||
|
|
location.location.first_column = 1;
|
||
|
|
} else {
|
||
|
|
location.location.first_line = lastStatementLocation.location.last_line;
|
||
|
|
location.location.first_column = lastStatementLocation.location.last_column + 1;
|
||
|
|
}
|
||
|
|
lastStatementLocation = location;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
var SYNTAX_PARSER_NOOP_FUNCTIONS = ['prepareNewStatement', 'addCommonTableExpressions', 'pushQueryState', 'popQueryState', 'suggestSelectListAliases',
|
||
|
|
'suggestValueExpressionKeywords', 'getSelectListKeywords', 'getValueExpressionKeywords', 'addColRefIfExists', 'selectListNoTableSuggest', 'suggestJoinConditions',
|
||
|
|
'suggestJoins', 'valueExpressionSuggest', 'applyTypeToSuggestions', 'applyArgumentTypesToSuggestions', 'commitLocations', 'identifyPartials',
|
||
|
|
'getSubQuery', 'addTablePrimary', 'suggestFileFormats', 'suggestDdlAndDmlKeywords', 'checkForSelectListKeywords', 'checkForKeywords',
|
||
|
|
'suggestKeywords', 'suggestColRefKeywords', 'suggestTablesOrColumns', 'suggestFunctions', 'suggestAggregateFunctions', 'suggestAnalyticFunctions',
|
||
|
|
'suggestColumns', 'suggestGroupBys', 'suggestIdentifiers', 'suggestOrderBys', 'suggestFilters', 'suggestKeyValues', 'suggestTables', 'addFunctionLocation',
|
||
|
|
'addStatementLocation', 'firstDefined', 'addClauseLocation', 'addStatementTypeLocation', 'addFileLocation', 'addDatabaseLocation', 'addColumnAliasLocation',
|
||
|
|
'addTableAliasLocation', 'addSubqueryAliasLocation', 'addTableLocation', 'addAsteriskLocation', 'addVariableLocation', 'addColumnLocation', 'addCteAliasLocation',
|
||
|
|
'addUnknownLocation', 'addColRefToVariableIfExists', 'suggestDatabases', 'suggestHdfs', 'suggestValues'];
|
||
|
|
|
||
|
|
var SYNTAX_PARSER_NOOP = function () {};
|
||
|
|
|
||
|
|
var initSyntaxParser = function (parser) {
|
||
|
|
|
||
|
|
// Noop functions for compatibility with the autocomplete parser as the grammar is shared
|
||
|
|
SYNTAX_PARSER_NOOP_FUNCTIONS.forEach(function (noopFn) {
|
||
|
|
parser[noopFn] = SYNTAX_PARSER_NOOP
|
||
|
|
});
|
||
|
|
|
||
|
|
parser.yy.locations = [{}];
|
||
|
|
|
||
|
|
parser.determineCase = function (text) {
|
||
|
|
if (!parser.yy.caseDetermined) {
|
||
|
|
parser.yy.lowerCase = text.toLowerCase() === text;
|
||
|
|
parser.yy.caseDetermined = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getKeywordsForOptionalsLR = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.mergeSuggestKeywords = function () {
|
||
|
|
return {};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getTypeKeywords = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.getColumnDataTypeKeywords = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.findCaseType = function () {
|
||
|
|
return {types: ['T']};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.findReturnTypes = function (functionName) {
|
||
|
|
return ['T'];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.isHive = function () {
|
||
|
|
return parser.yy.activeDialect === 'hive';
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.isImpala = function () {
|
||
|
|
return parser.yy.activeDialect === 'impala';
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.expandImpalaIdentifierChain = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.expandIdentifierChain = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.expandLateralViews = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.createWeightedKeywords = function () {
|
||
|
|
return [];
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.handleQuotedValueWithCursor = function (lexer, yytext, yylloc, quoteChar) {
|
||
|
|
if (yytext.indexOf('\u2020') !== -1 || yytext.indexOf('\u2021') !== -1) {
|
||
|
|
parser.yy.partialCursor = yytext.indexOf('\u2021') !== -1;
|
||
|
|
var cursorIndex = parser.yy.partialCursor ? yytext.indexOf('\u2021') : yytext.indexOf('\u2020');
|
||
|
|
parser.yy.cursorFound = {
|
||
|
|
first_line: yylloc.first_line,
|
||
|
|
last_line: yylloc.last_line,
|
||
|
|
first_column: yylloc.first_column + cursorIndex,
|
||
|
|
last_column: yylloc.first_column + cursorIndex + 1
|
||
|
|
};
|
||
|
|
var remainder = yytext.substring(cursorIndex + 1);
|
||
|
|
var remainingQuotes = (lexer.upcomingInput().match(new RegExp(quoteChar, 'g')) || []).length;
|
||
|
|
if (remainingQuotes > 0 && remainingQuotes & 1 != 0) {
|
||
|
|
parser.yy.missingEndQuote = false;
|
||
|
|
lexer.input();
|
||
|
|
} else {
|
||
|
|
parser.yy.missingEndQuote = true;
|
||
|
|
lexer.unput(remainder);
|
||
|
|
}
|
||
|
|
lexer.popState();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
|
||
|
|
var lexerModified = false;
|
||
|
|
|
||
|
|
parser.yy.parseError = function (str, hash) {
|
||
|
|
parser.yy.error = hash;
|
||
|
|
};
|
||
|
|
|
||
|
|
var IGNORED_EXPECTED = {
|
||
|
|
';': true,
|
||
|
|
'.': true,
|
||
|
|
'EOF': true,
|
||
|
|
'UNSIGNED_INTEGER': true,
|
||
|
|
'UNSIGNED_INTEGER_E': true,
|
||
|
|
'REGULAR_IDENTIFIER': true, // TODO: Indicate that an identifier was expected
|
||
|
|
'CURSOR': true,
|
||
|
|
'PARTIAL_CURSOR': true,
|
||
|
|
'HDFS_START_QUOTE': true,
|
||
|
|
'HDFS_PATH': true,
|
||
|
|
'HDFS_END_QUOTE' : true,
|
||
|
|
'COMPARISON_OPERATOR': true, // TODO: Expand in results when found
|
||
|
|
'ARITHMETIC_OPERATOR' : true, // TODO: Expand in results when found
|
||
|
|
'VARIABLE_REFERENCE': true,
|
||
|
|
'BACKTICK': true,
|
||
|
|
'VALUE': true,
|
||
|
|
'PARTIAL_VALUE': true,
|
||
|
|
'SINGLE_QUOTE': true,
|
||
|
|
'DOUBLE_QUOTE': true
|
||
|
|
};
|
||
|
|
|
||
|
|
var CLEAN_EXPECTED = {
|
||
|
|
'BETWEEN_AND': 'AND',
|
||
|
|
'OVERWRITE_DIRECTORY' : 'OVERWRITE',
|
||
|
|
'STORED_AS_DIRECTORIES' : 'STORED',
|
||
|
|
'LIKE_PARQUET' : 'LIKE',
|
||
|
|
'PARTITION_VALUE' : 'PARTITION'
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.parseSyntax = function (beforeCursor, afterCursor, dialect, debug) {
|
||
|
|
parser.yy.caseDetermined = false;
|
||
|
|
parser.yy.error = undefined;
|
||
|
|
|
||
|
|
parser.yy.latestTablePrimaries = [];
|
||
|
|
parser.yy.subQueries = [];
|
||
|
|
parser.yy.selectListAliases = [];
|
||
|
|
parser.yy.latestTablePrimaries = [];
|
||
|
|
|
||
|
|
parser.yy.activeDialect = (dialect !== 'hive' && dialect !== 'impala') ? undefined : dialect;
|
||
|
|
|
||
|
|
// Hack to set the inital state of the lexer without first having to hit a token
|
||
|
|
// has to be done as the first token found can be dependant on dialect
|
||
|
|
if (!lexerModified) {
|
||
|
|
var originalSetInput = parser.lexer.setInput;
|
||
|
|
parser.lexer.setInput = function (input, yy) {
|
||
|
|
var lexer = originalSetInput.bind(parser.lexer)(input, yy);
|
||
|
|
if (typeof parser.yy.activeDialect !== 'undefined') {
|
||
|
|
lexer.begin(parser.yy.activeDialect);
|
||
|
|
}
|
||
|
|
return lexer;
|
||
|
|
};
|
||
|
|
lexerModified = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO: Find a way around throwing an exception when the parser finds a syntax error
|
||
|
|
try {
|
||
|
|
parser.yy.error = false;
|
||
|
|
parser.parse(beforeCursor + afterCursor);
|
||
|
|
} catch (err) {
|
||
|
|
if (debug) {
|
||
|
|
console.log(err);
|
||
|
|
console.error(err.stack);
|
||
|
|
console.log(parser.yy.error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (parser.yy.error && (parser.yy.error.loc.last_column < beforeCursor.length || !beforeCursor.endsWith(parser.yy.error.text))) {
|
||
|
|
var weightedExpected = [];
|
||
|
|
|
||
|
|
var addedExpected = {};
|
||
|
|
|
||
|
|
var isLowerCase = parser.yy.caseDetermined && parser.yy.lowerCase || parser.yy.error.text.toLowerCase() === parser.yy.error.text;
|
||
|
|
|
||
|
|
if (parser.yy.error.expected.length == 2 && parser.yy.error.expected.indexOf('\';\'') !== -1 && parser.yy.error.expected.indexOf('\'EOF\'') !== -1) {
|
||
|
|
parser.yy.error.expected = [];
|
||
|
|
parser.yy.error.expectedStatementEnd = true;
|
||
|
|
return parser.yy.error;
|
||
|
|
}
|
||
|
|
for (var i = 0; i < parser.yy.error.expected.length; i++) {
|
||
|
|
var expected = parser.yy.error.expected[i];
|
||
|
|
// Strip away the surrounding ' chars
|
||
|
|
expected = expected.substring(1, expected.length - 1);
|
||
|
|
// TODO: Only suggest alphanumeric?
|
||
|
|
if (!IGNORED_EXPECTED[expected] && /[a-z_]+/i.test(expected)) {
|
||
|
|
if (dialect && expected.indexOf('<' + dialect + '>') == 0) {
|
||
|
|
expected = expected.substring(dialect.length + 2);
|
||
|
|
} else if (/^<[a-z]+>/.test(expected)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
expected = CLEAN_EXPECTED[expected] || expected;
|
||
|
|
if (expected === parser.yy.error.text.toUpperCase()) {
|
||
|
|
// Can happen when the lexer entry for a rule contains multiple words like 'stored' in 'stored as parquet'
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var text = isLowerCase ? expected.toLowerCase() : expected;
|
||
|
|
if (text && !addedExpected[text]) {
|
||
|
|
addedExpected[text] = true;
|
||
|
|
weightedExpected.push({
|
||
|
|
text: text,
|
||
|
|
distance: stringDistance(parser.yy.error.text, text, true)
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (weightedExpected.length === 0) {
|
||
|
|
parser.yy.error.expected = [];
|
||
|
|
parser.yy.error.incompleteStatement = true;
|
||
|
|
return parser.yy.error;
|
||
|
|
}
|
||
|
|
weightedExpected.sort(function (a, b) {
|
||
|
|
if (a.distance === b.distance) {
|
||
|
|
return a.text.localeCompare(b.text);
|
||
|
|
}
|
||
|
|
return a.distance - b.distance
|
||
|
|
});
|
||
|
|
parser.yy.error.expected = weightedExpected;
|
||
|
|
parser.yy.error.incompleteStatement = true;
|
||
|
|
return parser.yy.error;
|
||
|
|
} else if (parser.yy.error) {
|
||
|
|
parser.yy.error.expected = [];
|
||
|
|
parser.yy.error.incompleteStatement = true;
|
||
|
|
return parser.yy.error;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var initGlobalSearchParser = function (parser) {
|
||
|
|
|
||
|
|
parser.identifyPartials = function (beforeCursor, afterCursor) {
|
||
|
|
var beforeMatch = beforeCursor.match(/[0-9a-zA-Z_]*$/);
|
||
|
|
var afterMatch = afterCursor.match(/^[0-9a-zA-Z_]*(?:\((?:[^)]*\))?)?/);
|
||
|
|
return {left: beforeMatch ? beforeMatch[0].length : 0, right: afterMatch ? afterMatch[0].length : 0};
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.mergeFacets = function (a, b) {
|
||
|
|
if (!a.facets) {
|
||
|
|
a.facets = {};
|
||
|
|
}
|
||
|
|
if (!b.facets) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
Object.keys(b.facets).forEach(function (key) {
|
||
|
|
if (a.facets[key]) {
|
||
|
|
Object.keys(b.facets[key]).forEach(function (val) {
|
||
|
|
a.facets[key][val.toLowerCase()] = true;
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
a.facets[key] = b.facets[key];
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.mergeText = function (a, b) {
|
||
|
|
if (!a.text) {
|
||
|
|
a.text = [];
|
||
|
|
}
|
||
|
|
if (!b.text) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
a.text = a.text.concat(b.text);
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.handleQuotedValueWithCursor = function (lexer, yytext, yylloc, quoteChar) {
|
||
|
|
if (yytext.indexOf('\u2020') !== -1 || yytext.indexOf('\u2021') !== -1) {
|
||
|
|
var cursorIndex = yytext.indexOf('\u2020');
|
||
|
|
parser.yy.cursorFound = {
|
||
|
|
first_line: yylloc.first_line,
|
||
|
|
last_line: yylloc.last_line,
|
||
|
|
first_column: yylloc.first_column + cursorIndex,
|
||
|
|
last_column: yylloc.first_column + cursorIndex + 1
|
||
|
|
};
|
||
|
|
var remainder = yytext.substring(cursorIndex + 1);
|
||
|
|
var remainingQuotes = (lexer.upcomingInput().match(new RegExp(quoteChar, 'g')) || []).length;
|
||
|
|
if (remainingQuotes > 0 && remainingQuotes & 1 != 0) {
|
||
|
|
parser.yy.missingEndQuote = false;
|
||
|
|
lexer.input();
|
||
|
|
} else {
|
||
|
|
parser.yy.missingEndQuote = true;
|
||
|
|
lexer.unput(remainder);
|
||
|
|
}
|
||
|
|
lexer.popState();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
};
|
||
|
|
|
||
|
|
parser.parseGlobalSearch = function (beforeCursor, afterCursor, debug) {
|
||
|
|
delete parser.yy.cursorFound;
|
||
|
|
|
||
|
|
var result;
|
||
|
|
try {
|
||
|
|
result = parser.parse(beforeCursor + '\u2020' + afterCursor);
|
||
|
|
} catch (err) {
|
||
|
|
if (debug) {
|
||
|
|
console.log(err);
|
||
|
|
console.error(err.stack);
|
||
|
|
console.log(parser.yy.error);
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
facets: {},
|
||
|
|
text: []
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
return {
|
||
|
|
initSqlParser: initSqlParser,
|
||
|
|
initSyntaxParser: initSyntaxParser,
|
||
|
|
stringDistance: stringDistance,
|
||
|
|
initGlobalSearchParser: initGlobalSearchParser
|
||
|
|
};
|
||
|
|
})();
|
||
|
|
/* parser generated by jison 0.4.18 */
|
||
|
|
/*
|
||
|
|
Returns a Parser object of the following structure:
|
||
|
|
|
||
|
|
Parser: {
|
||
|
|
yy: {}
|
||
|
|
}
|
||
|
|
|
||
|
|
Parser.prototype: {
|
||
|
|
yy: {},
|
||
|
|
trace: function(),
|
||
|
|
symbols_: {associative list: name ==> number},
|
||
|
|
terminals_: {associative list: number ==> name},
|
||
|
|
productions_: [...],
|
||
|
|
performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
|
||
|
|
table: [...],
|
||
|
|
defaultActions: {...},
|
||
|
|
parseError: function(str, hash),
|
||
|
|
parse: function(input),
|
||
|
|
|
||
|
|
lexer: {
|
||
|
|
EOF: 1,
|
||
|
|
parseError: function(str, hash),
|
||
|
|
setInput: function(input),
|
||
|
|
input: function(),
|
||
|
|
unput: function(str),
|
||
|
|
more: function(),
|
||
|
|
less: function(n),
|
||
|
|
pastInput: function(),
|
||
|
|
upcomingInput: function(),
|
||
|
|
showPosition: function(),
|
||
|
|
test_match: function(regex_match_array, rule_index),
|
||
|
|
next: function(),
|
||
|
|
lex: function(),
|
||
|
|
begin: function(condition),
|
||
|
|
popState: function(),
|
||
|
|
_currentRules: function(),
|
||
|
|
topState: function(),
|
||
|
|
pushState: function(condition),
|
||
|
|
|
||
|
|
options: {
|
||
|
|
ranges: boolean (optional: true ==> token location info will include a .range[] member)
|
||
|
|
flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
|
||
|
|
backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
|
||
|
|
},
|
||
|
|
|
||
|
|
performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
|
||
|
|
rules: [...],
|
||
|
|
conditions: {associative list: name ==> set},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
token location info (@$, _$, etc.): {
|
||
|
|
first_line: n,
|
||
|
|
last_line: n,
|
||
|
|
first_column: n,
|
||
|
|
last_column: n,
|
||
|
|
range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based)
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
the parseError function receives a 'hash' object with these members for lexer and parser errors: {
|
||
|
|
text: (matched text)
|
||
|
|
token: (the produced terminal token, if any)
|
||
|
|
line: (yylineno)
|
||
|
|
}
|
||
|
|
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
|
||
|
|
loc: (yylloc)
|
||
|
|
expected: (string describing the set of expected tokens)
|
||
|
|
recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
var sqlAutocompleteParser = (function(){
|
||
|
|
var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[2,6,10,19,24,26,28,30,32,33,34,37,38,39,40,42,43,45,46,47,48,49,50,51,52,54,56,58,59,60,61,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,85,86,87,88,89,90,91,92,93,95,96,97,98,99,100,101,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,128,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,156,157,158,160,161,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,439,440,441,442,453,569,570,576,762,824,866,928,929,931,1164,1188,1189,1190,1191,1193,1211,1226,1251,1252,1277,1313],$V1=[2,4],$V2=[6,10],$V3=[2,5],$V4=[1,6],$V5=[1,386],$V6=[1,360],$V7=[1,443],$V8=[1,13],$V9=[1,423],$Va=[1,17],$Vb=[1,19],$Vc=[1,20],$Vd=[1,23],$Ve=[1,24],$Vf=[1,78],$Vg=[1,79],$Vh=[1,80],$Vi=[1,25],$Vj=[1,81],$Vk=[1,82],$Vl=[1,30],$Vm=[1,32],$Vn=[1,83],$Vo=[1,33],$Vp=[1,34],$Vq=[1,35],$Vr=[1,38],$Vs=[1,39],$Vt=[1,384],$Vu=[1,474],$Vv=[1,42],$Vw=[1,43],$Vx=[1,46],$Vy=[1,86],$Vz=[1,89],$VA=[1,90],$VB=[1,92],$VC=[1,50],$VD=[1,91],$VE=[1,51],$VF=[1,93],$VG=[1,94],$VH=[1,546],$VI=[1,95],$VJ=[1,96],$VK=[1,56],$VL=[1,97],$VM=[1,563],$VN=[1,532],$VO=[1,99],$VP=[1,58],$VQ=[1,101],$VR=[1,103],$VS=[1,59],$VT=[1,60],$VU=[1,104],$VV=[1,105],$VW=[1,106],$VX=[1,62],$VY=[1,63],$VZ=[1,107],$V_=[1,65],$V$=[1,533],$V01=[1,67],$V11=[1,57],$V21=[1,68],$V31=[1,69],$V41=[1,108],$V51=[1,109],$V61=[1,111],$V71=[1,112],$V81=[1,113],$V91=[1,114],$Va1=[1,71],$Vb1=[1,560],$Vc1=[1,115],$Vd1=[1,116],$Ve1=[1,72],$Vf1=[1,117],$Vg1=[1,119],$Vh1=[1,279],$Vi1=[1,120],$Vj1=[1,122],$Vk1=[1,123],$Vl1=[1,124],$Vm1=[1,125],$Vn1=[1,75],$Vo1=[1,126],$Vp1=[1,127],$Vq1=[1,128],$Vr1=[1,543],$Vs1=[1,76],$Vt1=[1,130],$Vu1=[1,132],$Vv1=[1,308],$Vw1=[1,311],$Vx1=[1,312],$Vy1=[1,313],$Vz1=[1,317],$VA1=[1,318],$VB1=[1,319],$VC1=[1,320],$VD1=[1,197],$VE1=[1,199],$VF1=[1,200],$VG1=[1,180],$VH1=[1,205],$VI1=[1,206],$VJ1=[1,195],$VK1=[1,187],$VL1=[1,167],$VM1=[1,291],$VN1=[1,261],$VO1=[1,331],$VP1=[1,350],$VQ1=[1,385],$VR1=[1,16],$VS1=[1,40],$VT1=[1,14],$VU1=[1,15],$VV1=[1,18],$VW1=[1,21],$VX1=[1,22],$VY1=[1,26],$VZ1=[1,27],$V_1=[1,28],$V$1=[1,29],$V02=[1,31],$V12=[1,36],$V22=[1,37],$V32=[1,41],$V42=[1,44],$V52=[1,45],$V62=[1,47],$V72=[1,48],$V82=[1,49],$V92=[1,52],$Va2=[1,53],$Vb2=[1,54],$Vc2=[1,55],$Vd2=[1,61],$Ve2=[1,64],$Vf2=[1,66],$Vg2=[1,70],$Vh2=[1,73],$Vi2=[1,74],$Vj2=[1,77],$Vk2=[1,84],$Vl2=[1,85],$Vm2=[1,87],$Vn2=[1,88],$Vo2=[1,98],$Vp2=[1,100],$Vq2=[1,102],$Vr2=[1,110],$Vs2=[1,118],$Vt2=[1,121],$Vu2=[1,129],$Vv2=[1,131],$Vw2=[1,133],$Vx2=[1,134],$Vy2=[1,135],$Vz2=[1,136],$VA2=[1,137],$VB2=[1,138],$VC2=[1,139],$VD2=[1,140],$VE2=[1,141],$VF2=[1,142],$VG2=[1,143],$VH2=[1,144],$VI2=[1,145],$VJ2=[1,146],$VK2=[1,147],$VL2=[1,148],$VM2=[1,149],$VN2=[1,150],$VO2=[1,151],$VP2=[1,152],$VQ2=[1,153],$VR2=[1,154],$VS2=[1,155],$VT2=[1,156],$VU2=[1,157],$VV2=[1,158],$VW2=[1,159],$VX2=[1,160],$VY2=[1,161],$VZ2=[1,162],$V_2=[1,163],$V$2=[1,164],$V03=[1,165],$V13=[1,166],$V23=[1,168],$V33=[1,169],$V43=[1,170],$V53=[1,171],$V63=[1,172],$V73=[1,173],$V83=[1,174],$V93=[1,175],$Va3=[1,176],$Vb3=[1,177],$Vc3=[1,178],$Vd3=[1,179],$Ve3=[1,181],$Vf3=[1,182],$Vg3=
|
||
|
|
var parser = {trace: function trace() { },
|
||
|
|
yy: {},
|
||
|
|
symbols_: {"error":2,"SqlSyntax":3,"NewStatement":4,"SqlStatements":5,"EOF":6,"SqlAutocomplete":7,"SqlStatements_EDIT":8,"SqlStatement":9,";":10,"NonStartingToken":11,"SqlStatement_EDIT":12,"DataDefinition":13,"DataManipulation":14,"QuerySpecification":15,"ExplainClause":16,"AnyCursor":17,"CommonTableExpression":18,"CURSOR":19,"ExplainClause_EDIT":20,"DataDefinition_EDIT":21,"DataManipulation_EDIT":22,"QuerySpecification_EDIT":23,"SetSpecification_EDIT":24,"NonReservedKeyword":25,"<hive>ABORT":26,"<hive>ADD":27,"<hive>ADMIN":28,"<hive>AFTER":29,"<hive>ANALYZE":30,"<hive>ARCHIVE":31,"<hive>AVRO":32,"<hive>BUCKET":33,"<hive>BUCKETS":34,"<hive>CASCADE":35,"<hive>CHANGE":36,"<hive>CLUSTERED":37,"<hive>COLLECTION":38,"<hive>COLUMNS":39,"<hive>COMMENT":40,"<hive>COMPACT":41,"<hive>COMPACTIONS":42,"<hive>COMPUTE":43,"<hive>CONCATENATE":44,"<hive>DATA":45,"<hive>DATABASES":46,"<hive>DBPROPERTIES":47,"<hive>DEFERRED":48,"<hive>DEFINED":49,"<hive>DELIMITED":50,"<hive>DEPENDENCY":51,"<hive>DIRECTORY":52,"<hive>DISABLE":53,"<hive>DOUBLE_PRECISION":54,"<hive>ENABLE":55,"<hive>ESCAPED":56,"<hive>EXCHANGE":57,"<hive>EXPLAIN":58,"<hive>EXPORT":59,"<hive>FIELDS":60,"<hive>FILE":61,"<hive>FILEFORMAT":62,"<hive>FIRST":63,"<hive>FORMAT":64,"<hive>FUNCTIONS":65,"<hive>INPATH":66,"<hive>INPUTFORMAT":67,"<hive>JAR":68,"<hive>IDXPROPERTIES":69,"<hive>ITEMS":70,"<hive>KEY":71,"<hive>KEYS":72,"<hive>LINES":73,"<hive>LOAD":74,"<hive>LOCATION":75,"<hive>LOCKS":76,"<hive>MATCHED":77,"<hive>METADATA":78,"<hive>MERGE":79,"<hive>MSCK":80,"<hive>NOSCAN":81,"<hive>NOVALIDATE":82,"<hive>NO_DROP":83,"<hive>OFFLINE":84,"<hive>ORC":85,"<hive>OUTPUTFORMAT":86,"<hive>OVERWRITE":87,"<hive>OWNER":88,"<hive>PARQUET":89,"<hive>PARTITIONED":90,"<hive>PARTITIONS":91,"<hive>PERCENT":92,"<hive>PRIVILEGES":93,"<hive>PURGE":94,"<hive>RCFILE":95,"<hive>REBUILD":96,"<hive>RELOAD":97,"<hive>RELY":98,"<hive>NORELY":99,"<hive>REPAIR":100,"<hive>REPLICATION":101,"<hive>RECOVER":102,"<hive>RENAME":103,"<hive>REPLACE":104,"<hive>RESTRICT":105,"<hive>ROLE":106,"<hive>ROLES":107,"<hive>SCHEMAS":108,"<hive>SEQUENCEFILE":109,"<hive>SERDE":110,"<hive>SERDEPROPERTIES":111,"<hive>SETS":112,"<hive>SHOW":113,"<hive>SKEWED":114,"<hive>SORTED":115,"<hive>STATISTICS":116,"<hive>STORED":117,"<hive>STRING":118,"STRUCT":119,"<hive>TABLES":120,"<hive>TBLPROPERTIES":121,"<hive>TEMPORARY":122,"<hive>TERMINATED":123,"<hive>TEXTFILE":124,"<hive>TIMESTAMP":125,"<hive>TINYINT":126,"<hive>TOUCH":127,"<hive>TRANSACTIONS":128,"<hive>UNARCHIVE":129,"<hive>UNIONTYPE":130,"<hive>USE":131,"<hive>USER":132,"<hive>VIEW":133,"<hive>WAIT":134,"<hive>DAY":135,"<hive>HOUR":136,"<hive>MINUTE":137,"<hive>MONTH":138,"<hive>QUARTER":139,"<hive>SECOND":140,"<hive>WEEK":141,"<hive>YEAR":142,"<impala>ANALYTIC":143,"<impala>CURRENT":144,"<impala>GRANT":145,"<impala>RECOVER":146,"<impala>ROLE":147,"<impala>ROLES":148,"<impala>URI":149,"<impala>SERVER":150,"<impala>UNKNOWN":151,"<impala>BLOCK_SIZE":152,"<impala>COMPRESSION":153,"<impala>DEFAULT":154,"<impala>ENCODING":155,"<impala>KEY":156,"ROLE":157,"OPTION":158,"RegularIdentifier":159,"REGULAR_IDENTIFIER":160,"VARIABLE_REFERENCE":161,"OptionalHiveExplainTypes":162,"<impala>EXPLAIN":163,"<hive>AUTHORIZATION":164,"<hive>EXTENDED":165,"<hive>ALL":166,"<hive>AS":167,"<hive>BINARY":168,"<hive>CACHE":169,"<hive>CLUSTER":170,"<hive>CONF":171,"<hive>CONSTRAINT":172,"<hive>CUBE":173,"<hive>CURRENT":174,"<hive>DATE":175,"<hive>DISTRIBUTE":176,"<hive>DISTRIBUTED":177,"<hive>EXTERNAL":178,"<hive>FOR":179,"<hive>FOREIGN":180,"<hive>FUNCTION":181,"<hive>GRANT":182,"<hive>GROUPING":183,"<hive>LATERAL":184,"<hive>LOCAL":185,"<hive>LOCK":186,"<hive>MACRO":187,"<hive>PARTITION":188,"<hive>PRIMARY":189,"<hive>REFERENCES":190,"<hive>ROLLUP":191,"<hive>SHOW_DATABASE":192,"<hive>TABLE":193,"<hive>ASC":194,"<hive>DESC":195,"<hive>FORMATTED":196,"<hive>INDEX":197,"<hive>INDEXES":198,"<hive>NONE":199,"<hive>OF":200,"<hive>OUT":201,"<hive>SCHEMA":202,"<hive>STORED_AS_DIRECTORIES":203,"<hive>TABLESAMPLE":204,"<hive>USING":205,"<hive>VIEWS":206,"<hive>WINDOW":207,"<hive>.":208,"<hive>[":209,"<hiv
|
||
|
|
terminals_: {2:"error",6:"EOF",10:";",19:"CURSOR",24:"SetSpecification_EDIT",26:"<hive>ABORT",27:"<hive>ADD",28:"<hive>ADMIN",29:"<hive>AFTER",30:"<hive>ANALYZE",31:"<hive>ARCHIVE",32:"<hive>AVRO",33:"<hive>BUCKET",34:"<hive>BUCKETS",35:"<hive>CASCADE",36:"<hive>CHANGE",37:"<hive>CLUSTERED",38:"<hive>COLLECTION",39:"<hive>COLUMNS",40:"<hive>COMMENT",41:"<hive>COMPACT",42:"<hive>COMPACTIONS",43:"<hive>COMPUTE",44:"<hive>CONCATENATE",45:"<hive>DATA",46:"<hive>DATABASES",47:"<hive>DBPROPERTIES",48:"<hive>DEFERRED",49:"<hive>DEFINED",50:"<hive>DELIMITED",51:"<hive>DEPENDENCY",52:"<hive>DIRECTORY",53:"<hive>DISABLE",54:"<hive>DOUBLE_PRECISION",55:"<hive>ENABLE",56:"<hive>ESCAPED",57:"<hive>EXCHANGE",58:"<hive>EXPLAIN",59:"<hive>EXPORT",60:"<hive>FIELDS",61:"<hive>FILE",62:"<hive>FILEFORMAT",63:"<hive>FIRST",64:"<hive>FORMAT",65:"<hive>FUNCTIONS",66:"<hive>INPATH",67:"<hive>INPUTFORMAT",68:"<hive>JAR",69:"<hive>IDXPROPERTIES",70:"<hive>ITEMS",71:"<hive>KEY",72:"<hive>KEYS",73:"<hive>LINES",74:"<hive>LOAD",75:"<hive>LOCATION",76:"<hive>LOCKS",77:"<hive>MATCHED",78:"<hive>METADATA",79:"<hive>MERGE",80:"<hive>MSCK",81:"<hive>NOSCAN",82:"<hive>NOVALIDATE",83:"<hive>NO_DROP",84:"<hive>OFFLINE",85:"<hive>ORC",86:"<hive>OUTPUTFORMAT",87:"<hive>OVERWRITE",88:"<hive>OWNER",89:"<hive>PARQUET",90:"<hive>PARTITIONED",91:"<hive>PARTITIONS",92:"<hive>PERCENT",93:"<hive>PRIVILEGES",94:"<hive>PURGE",95:"<hive>RCFILE",96:"<hive>REBUILD",97:"<hive>RELOAD",98:"<hive>RELY",99:"<hive>NORELY",100:"<hive>REPAIR",101:"<hive>REPLICATION",102:"<hive>RECOVER",103:"<hive>RENAME",104:"<hive>REPLACE",105:"<hive>RESTRICT",106:"<hive>ROLE",107:"<hive>ROLES",108:"<hive>SCHEMAS",109:"<hive>SEQUENCEFILE",110:"<hive>SERDE",111:"<hive>SERDEPROPERTIES",112:"<hive>SETS",113:"<hive>SHOW",114:"<hive>SKEWED",115:"<hive>SORTED",116:"<hive>STATISTICS",117:"<hive>STORED",118:"<hive>STRING",119:"STRUCT",120:"<hive>TABLES",121:"<hive>TBLPROPERTIES",122:"<hive>TEMPORARY",123:"<hive>TERMINATED",124:"<hive>TEXTFILE",125:"<hive>TIMESTAMP",126:"<hive>TINYINT",127:"<hive>TOUCH",128:"<hive>TRANSACTIONS",129:"<hive>UNARCHIVE",130:"<hive>UNIONTYPE",131:"<hive>USE",132:"<hive>USER",133:"<hive>VIEW",134:"<hive>WAIT",135:"<hive>DAY",136:"<hive>HOUR",137:"<hive>MINUTE",138:"<hive>MONTH",139:"<hive>QUARTER",140:"<hive>SECOND",141:"<hive>WEEK",142:"<hive>YEAR",143:"<impala>ANALYTIC",144:"<impala>CURRENT",145:"<impala>GRANT",146:"<impala>RECOVER",147:"<impala>ROLE",148:"<impala>ROLES",149:"<impala>URI",150:"<impala>SERVER",151:"<impala>UNKNOWN",152:"<impala>BLOCK_SIZE",153:"<impala>COMPRESSION",154:"<impala>DEFAULT",155:"<impala>ENCODING",156:"<impala>KEY",157:"ROLE",158:"OPTION",160:"REGULAR_IDENTIFIER",161:"VARIABLE_REFERENCE",163:"<impala>EXPLAIN",164:"<hive>AUTHORIZATION",165:"<hive>EXTENDED",166:"<hive>ALL",167:"<hive>AS",168:"<hive>BINARY",169:"<hive>CACHE",170:"<hive>CLUSTER",171:"<hive>CONF",172:"<hive>CONSTRAINT",173:"<hive>CUBE",174:"<hive>CURRENT",175:"<hive>DATE",176:"<hive>DISTRIBUTE",177:"<hive>DISTRIBUTED",178:"<hive>EXTERNAL",179:"<hive>FOR",180:"<hive>FOREIGN",181:"<hive>FUNCTION",182:"<hive>GRANT",183:"<hive>GROUPING",184:"<hive>LATERAL",185:"<hive>LOCAL",186:"<hive>LOCK",187:"<hive>MACRO",188:"<hive>PARTITION",189:"<hive>PRIMARY",190:"<hive>REFERENCES",191:"<hive>ROLLUP",192:"<hive>SHOW_DATABASE",193:"<hive>TABLE",194:"<hive>ASC",195:"<hive>DESC",196:"<hive>FORMATTED",197:"<hive>INDEX",198:"<hive>INDEXES",199:"<hive>NONE",200:"<hive>OF",201:"<hive>OUT",202:"<hive>SCHEMA",203:"<hive>STORED_AS_DIRECTORIES",204:"<hive>TABLESAMPLE",205:"<hive>USING",206:"<hive>VIEWS",207:"<hive>WINDOW",208:"<hive>.",209:"<hive>[",210:"<hive>]",211:"<impala>AGGREGATE",212:"<impala>AVRO",213:"<impala>CACHED",214:"<impala>CASCADE",215:"<impala>CLOSE_FN",216:"<impala>COLUMN",217:"<impala>DATA",218:"<impala>DATABASES",219:"<impala>DELETE",220:"<impala>DELIMITED",221:"<impala>ESCAPED",222:"<impala>EXTENDED",223:"<impala>EXTERNAL",224:"<impala>FIELDS",225:"<impala>FILES",226:"<impala>FINALIZE_FN",227:"<impala>FIRST",228:"<impala>FORMAT",229:"<impala>FORMATTED",230:"<impala>FUNCTION",231:"<impala>
|
||
|
|
productions_: [0,[3,3],[7,3],[7,3],[4,0],[5,0],[5,1],[5,4],[5,1],[5,2],[8,1],[8,4],[8,4],[8,7],[9,1],[9,1],[9,1],[9,2],[9,2],[9,2],[12,1],[12,2],[12,1],[12,1],[12,1],[12,1],[12,1],[12,2],[12,2],[12,2],[12,2],[12,2],[12,2],[12,2],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[25,1],[159,1],[159,1],[159,1],[16,2],[16,1],[20,3],[20,2],[162,0],[162,1],[162,1],[162,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[11,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,1],[21,2],[21,1],[21,1],[435,1],[435,1],[436,1],[436,2],[437,1],[437,1],[438,1],[438,1],[438,1],[17,1],[17,1],[443,1],[443,1],[443,1],[444,1],[444,1],[445,1],[445,1],[445,1],[447,1],[447,1],[448,1],[448,1],[448,1],[449,1],[449,1],[449,1],[450,1],[450,1],[451,1],[451,1],[452,1],
|
||
|
|
performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
|
||
|
|
/* this == yyval */
|
||
|
|
|
||
|
|
var $0 = $$.length - 1;
|
||
|
|
switch (yystate) {
|
||
|
|
case 2: case 3:
|
||
|
|
|
||
|
|
return parser.yy.result;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 4:
|
||
|
|
|
||
|
|
parser.prepareNewStatement();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 6: case 10: case 12:
|
||
|
|
|
||
|
|
parser.addStatementLocation(_$[$0]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 11: case 13:
|
||
|
|
|
||
|
|
parser.addStatementLocation(_$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 20: case 33:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestDdlAndDmlKeywords(['EXPLAIN', 'FROM']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestDdlAndDmlKeywords(['EXPLAIN']);
|
||
|
|
} else {
|
||
|
|
parser.suggestDdlAndDmlKeywords();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 21:
|
||
|
|
|
||
|
|
if (parser.isHive() || parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['INSERT', 'SELECT']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 172:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestDdlAndDmlKeywords([{ value: 'AUTHORIZATION', weight: 2 }, { value: 'DEPENDENCY', weight: 2 }, { value: 'EXTENDED', weight: 2 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestDdlAndDmlKeywords();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 173:
|
||
|
|
|
||
|
|
parser.suggestDdlAndDmlKeywords();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 546:
|
||
|
|
|
||
|
|
parser.suggestSetOptions();
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['ROLE']);
|
||
|
|
}
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['ALL']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 614: case 617: case 722: case 763: case 855: case 1097: case 1280: case 1392: case 1449: case 2586: case 2588: case 3088:
|
||
|
|
this.$ = $$[$0-1];
|
||
|
|
break;
|
||
|
|
case 615: case 618: case 764:
|
||
|
|
this.$ = '';
|
||
|
|
break;
|
||
|
|
case 639:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['INDEX', 'INDEXES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 640:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FORMATTED']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 657: case 660:
|
||
|
|
|
||
|
|
parser.yy.correlatedSubQuery = false;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 658: case 662:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['EXISTS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 661:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['NOT EXISTS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 672: case 674: case 675: case 677:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['<', '<=', '<>', '=', '>', '>=']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 673: case 676: case 3115:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 700: case 704: case 708: case 744: case 745: case 790: case 793: case 999: case 1068: case 1839: case 1937: case 1956: case 2002: case 2004: case 2369: case 2626: case 3403:
|
||
|
|
|
||
|
|
parser.suggestColumns();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 712: case 765:
|
||
|
|
|
||
|
|
parser.addTableLocation(_$[$0], [ { name: $$[$0] } ]);
|
||
|
|
this.$ = { identifierChain: [ { name: $$[$0] } ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 713: case 766:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]);
|
||
|
|
parser.addTableLocation(_$[$0], [ { name: $$[$0-2] }, { name: $$[$0] } ]);
|
||
|
|
this.$ = { identifierChain: [ { name: $$[$0-2] }, { name: $$[$0] } ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 714:
|
||
|
|
|
||
|
|
// This is a special case for Impala expression like "SELECT | FROM db.table.col"
|
||
|
|
this.$ = { identifierChain: [ { name: $$[$0-3] }, { name: $$[$0-1] } ].concat($$[$0]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 715: case 1743: case 1909: case 2076: case 2082: case 2091: case 2277: case 2599: case 2623: case 2726: case 2731: case 2749: case 2772: case 2779: case 2836: case 2844: case 3122: case 3153: case 3156: case 3162: case 3389: case 3409:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 716: case 730:
|
||
|
|
|
||
|
|
parser.suggestDatabases();
|
||
|
|
this.$ = { identifierChain: [{ name: $$[$0-2] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 717:
|
||
|
|
|
||
|
|
// In Impala you can have statements like 'SELECT ... FROM testTable t, t.|'
|
||
|
|
parser.suggestTablesOrColumns($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 718:
|
||
|
|
|
||
|
|
// TODO: switch to suggestColumns, it's currently handled in sqlAutocompleter2.js
|
||
|
|
// Issue is that suggestColumns is deleted if no tables are defined and this is
|
||
|
|
// Impala only cases like "SELECT | FROM db.table.col"
|
||
|
|
parser.suggestTables({ identifierChain: [{ name: $$[$0-3] }, { name: $$[$0-1] }].concat($$[$0]) });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 719: case 897:
|
||
|
|
this.$ = [$$[$0]];
|
||
|
|
break;
|
||
|
|
case 720:
|
||
|
|
|
||
|
|
$$[$0-1].push($$[$0]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 721: case 724:
|
||
|
|
this.$ = [];
|
||
|
|
break;
|
||
|
|
case 723: case 857: case 1282:
|
||
|
|
this.$ = $$[$0-2];
|
||
|
|
break;
|
||
|
|
case 725:
|
||
|
|
this.$ = { name: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 729: case 1794: case 2021:
|
||
|
|
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 733: case 2035: case 2072: case 2835: case 2843: case 3243: case 3303: case 3317: case 3375: case 3376: case 3414:
|
||
|
|
|
||
|
|
parser.suggestDatabases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 743: case 1004: case 1005: case 1011: case 1012: case 1388: case 1476: case 3073: case 3109:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 751: case 754:
|
||
|
|
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['WITH REPLICATION ='] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 756: case 3261:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['IN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 760:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['REPLICATION =']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 761: case 1777: case 1934: case 2330:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['=']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 767: case 3366:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ prependDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 768:
|
||
|
|
|
||
|
|
parser.suggestTablesOrColumns($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 770:
|
||
|
|
this.$ = { identifierChain: $$[$0-1].identifierChain, alias: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 773:
|
||
|
|
|
||
|
|
parser.yy.locations[parser.yy.locations.length - 1].type = 'column';
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 774: case 1233:
|
||
|
|
|
||
|
|
parser.addAsteriskLocation(_$[$0], $$[$0-2].concat({ asterisk: true }));
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 776:
|
||
|
|
|
||
|
|
this.$ = [ $$[$0].identifier ];
|
||
|
|
parser.yy.firstChainLocation = parser.addUnknownLocation($$[$0].location, [ $$[$0].identifier ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 777:
|
||
|
|
|
||
|
|
if (parser.yy.firstChainLocation) {
|
||
|
|
parser.yy.firstChainLocation.firstInChain = true;
|
||
|
|
delete parser.yy.firstChainLocation;
|
||
|
|
}
|
||
|
|
$$[$0-2].push($$[$0].identifier);
|
||
|
|
parser.addUnknownLocation($$[$0].location, $$[$0-2].concat());
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 778: case 786:
|
||
|
|
|
||
|
|
if ($$[$0].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: [ $$[$0].identifier ] });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 779: case 787:
|
||
|
|
|
||
|
|
if ($$[$0].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: $$[$0-2].concat([ $$[$0].identifier ]) });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 782:
|
||
|
|
|
||
|
|
parser.suggestColumns({
|
||
|
|
identifierChain: $$[$0-2]
|
||
|
|
});
|
||
|
|
this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 783:
|
||
|
|
|
||
|
|
parser.suggestColumns({
|
||
|
|
identifierChain: $$[$0-4]
|
||
|
|
});
|
||
|
|
this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 784:
|
||
|
|
this.$ = [ $$[$0].identifier ];
|
||
|
|
break;
|
||
|
|
case 785:
|
||
|
|
|
||
|
|
$$[$0-2].push($$[$0].identifier);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 788:
|
||
|
|
|
||
|
|
if ($$[$0-2].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: $$[$0-4].concat([ $$[$0-2].identifier ]) });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 789:
|
||
|
|
|
||
|
|
if ($$[$0-2].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: [ $$[$0-2].identifier ] });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 791:
|
||
|
|
|
||
|
|
parser.suggestColumns({ identifierChain: $$[$0-2] });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 792:
|
||
|
|
|
||
|
|
parser.suggestColumns({ identifierChain: $$[$0-4] });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 794:
|
||
|
|
this.$ = { identifier: { name: $$[$0] }, location: _$[$0] };;
|
||
|
|
break;
|
||
|
|
case 795:
|
||
|
|
this.$ = { identifier: { name: $$[$0-3], keySet: true }, location: _$[$0-3] };
|
||
|
|
break;
|
||
|
|
case 796:
|
||
|
|
this.$ = { identifier: { name: $$[$0-2], keySet: true }, location: _$[$0-2] };
|
||
|
|
break;
|
||
|
|
case 797:
|
||
|
|
this.$ = { identifier: { name: $$[$0-3] }, insideKey: true };
|
||
|
|
break;
|
||
|
|
case 798:
|
||
|
|
this.$ = { identifier: { name: $$[$0-3] }};;
|
||
|
|
break;
|
||
|
|
case 831:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
parser.addColumnLocation(_$[$0-1], $$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 832: case 1745: case 2044: case 2066: case 2080: case 2094: case 2279: case 2725: case 2735: case 2736: case 2761: case 2767: case 2770: case 2775: case 3116: case 3125: case 3126: case 3155: case 3165: case 3260: case 3306: case 3307: case 3319: case 3321:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 833: case 849: case 2067:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0], [{ name: $$[$0] }]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 836: case 1741: case 2079: case 2086: case 2087: case 3308:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 837:
|
||
|
|
|
||
|
|
if (!$$[$0-4]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 838:
|
||
|
|
|
||
|
|
if (!$$[$0-3]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 839:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
parser.suggestColumns();
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 840:
|
||
|
|
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 843:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'EXTENDED', 'FORMATTED', 'FUNCTION', 'SCHEMA']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 844: case 846:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 845: case 847:
|
||
|
|
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 848: case 1939: case 2022: case 2025: case 2074: case 2595: case 2724: case 2745: case 2755: case 2759: case 2833: case 2834: case 2840: case 3089: case 3158: case 3230: case 3246: case 3305: case 3318: case 3320: case 3363: case 3392:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 850:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'DATABASE', weight: 2 }, { value: 'EXTENDED', weight: 1 }, { value: 'FORMATTED', weight: 1 }]);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 852:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords([{ value: 'DATABASE', weight: 2 }, { value: 'EXTENDED', weight: 1 }, { value: 'FORMATTED', weight: 1 }]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 853:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 854:
|
||
|
|
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
parser.addDatabaseLocation(_$[$0], [{ name: $$[$0] }]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 860:
|
||
|
|
|
||
|
|
parser.addCommonTableExpressions($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 861: case 862: case 900:
|
||
|
|
|
||
|
|
parser.addCommonTableExpressions($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 866:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0]);
|
||
|
|
this.$ = { selectList: $$[$0] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 867:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-1]);
|
||
|
|
this.$ = { selectList: $$[$0-1], tableExpression: $$[$0] }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 880:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'DISTINCT', 'SELECT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 881:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'DISTINCT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 883:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0]);
|
||
|
|
if ($$[$0].cursorAtStart) {
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!$$[$0-1] && !$$[$0-2]) {
|
||
|
|
keywords.push({ value: 'ALL', weight: 2 });
|
||
|
|
keywords.push({ value: 'DISTINCT', weight: 2 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'STRAIGHT_JOIN', weight: 1 });
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
} else {
|
||
|
|
parser.checkForSelectListKeywords($$[$0]);
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestFunctions) {
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestColumns) {
|
||
|
|
parser.suggestColumns({ identifierChain: [], source: 'select' });
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestTables) {
|
||
|
|
parser.suggestTables({ prependQuestionMark: true, prependFrom: true });
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestDatabases) {
|
||
|
|
parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true });
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestAggregateFunctions && (!$$[$0-2] || $$[$0-2] === 'ALL')) {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 884:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0], true);
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!$$[$0-2] || $$[$0-2] === 'ALL') {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
}
|
||
|
|
if (!$$[$0-1] && !$$[$0-2]) {
|
||
|
|
keywords.push({ value: 'ALL', weight: 2 });
|
||
|
|
keywords.push({ value: 'DISTINCT', weight: 2 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'STRAIGHT_JOIN', weight: 1 });
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns({ identifierChain: [], source: 'select' });
|
||
|
|
parser.suggestTables({ prependQuestionMark: true, prependFrom: true });
|
||
|
|
parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 885:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 886:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-1]);
|
||
|
|
parser.selectListNoTableSuggest($$[$0-1], $$[$0-3]);
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'select';
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 887:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-1], true);
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!$$[$0-3] || $$[$0-3] === 'ALL') {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
}
|
||
|
|
if (!$$[$0-2] && !$$[$0-3]) {
|
||
|
|
keywords.push({ value: 'ALL', weight: 2 });
|
||
|
|
keywords.push({ value: 'DISTINCT', weight: 2 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0-2]) {
|
||
|
|
keywords.push({ value: 'STRAIGHT_JOIN', weight: 1 });
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns({ identifierChain: [], source: 'select' });
|
||
|
|
parser.suggestTables({ prependQuestionMark: true, prependFrom: true });
|
||
|
|
parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 888:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5]), _$[$0-2]);
|
||
|
|
parser.checkForSelectListKeywords($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 889:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5], $$[$0-6], _$[$0-6]), _$[$0-3]);
|
||
|
|
parser.checkForSelectListKeywords($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 890:
|
||
|
|
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-1]);
|
||
|
|
parser.checkForSelectListKeywords($$[$0-1]);
|
||
|
|
var keywords = ['FROM'];
|
||
|
|
if (parser.yy.result.suggestKeywords) {
|
||
|
|
keywords = parser.yy.result.suggestKeywords.concat(keywords);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
parser.suggestTables({ prependFrom: true });
|
||
|
|
parser.suggestDatabases({ prependFrom: true, appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 891:
|
||
|
|
|
||
|
|
parser.selectListNoTableSuggest($$[$0-1], $$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 895: case 971: case 1002: case 1015: case 1019: case 1057: case 1061: case 1089: case 1115: case 1116: case 1197: case 1199: case 1267: case 1277: case 1284: case 1296: case 1474: case 1674: case 1675: case 1700: case 1701: case 1702: case 1985: case 2150: case 2167: case 3108: case 3408:
|
||
|
|
this.$ = $$[$0];
|
||
|
|
break;
|
||
|
|
case 898:
|
||
|
|
this.$ = $$[$0-2].concat([$$[$0]]);;
|
||
|
|
break;
|
||
|
|
case 902:
|
||
|
|
|
||
|
|
parser.addCommonTableExpressions($$[$0-4]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 903:
|
||
|
|
|
||
|
|
parser.addCteAliasLocation(_$[$0-4], $$[$0-4]);
|
||
|
|
$$[$0-1].alias = $$[$0-4];
|
||
|
|
this.$ = $$[$0-1];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 904: case 1529: case 2389: case 2448: case 2525: case 2529: case 2602:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['AS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 905: case 1395: case 2018: case 2462: case 2471: case 3090:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 911: case 912:
|
||
|
|
|
||
|
|
parser.addClauseLocation('whereClause', _$[$0-1], $$[$0].whereClauseLocation);
|
||
|
|
parser.addClauseLocation('limitClause', $$[$0].limitClausePreceding || _$[$0-1], $$[$0].limitClauseLocation);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 913:
|
||
|
|
|
||
|
|
var keywords = [];
|
||
|
|
|
||
|
|
parser.addClauseLocation('whereClause', _$[$0-3], $$[$0-1].whereClauseLocation);
|
||
|
|
parser.addClauseLocation('limitClause', $$[$0-2].limitClausePreceding || _$[$0-3], $$[$0-2].limitClauseLocation);
|
||
|
|
|
||
|
|
if ($$[$0-3]) {
|
||
|
|
if (!$$[$0-3].hasLateralViews && typeof $$[$0-3].tableReferenceList.hasJoinCondition !== 'undefined' && !$$[$0-3].tableReferenceList.hasJoinCondition) {
|
||
|
|
keywords.push({ value: 'ON', weight: 3 });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push({ value: 'USING', weight: 3 });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ($$[$0-3].suggestKeywords) {
|
||
|
|
keywords = parser.createWeightedKeywords($$[$0-3].suggestKeywords, 3);
|
||
|
|
}
|
||
|
|
if ($$[$0-3].tableReferenceList.suggestJoinConditions) {
|
||
|
|
parser.suggestJoinConditions($$[$0-3].tableReferenceList.suggestJoinConditions);
|
||
|
|
}
|
||
|
|
if ($$[$0-3].tableReferenceList.suggestJoins) {
|
||
|
|
parser.suggestJoins($$[$0-3].tableReferenceList.suggestJoins);
|
||
|
|
}
|
||
|
|
if (!$$[$0-3].hasLateralViews && $$[$0-3].tableReferenceList.suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-3].tableReferenceList.suggestKeywords, 3));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Lower the weights for 'TABLESAMPLE' and 'LATERAL VIEW'
|
||
|
|
keywords.forEach(function (keyword) {
|
||
|
|
if (keyword.value === 'TABLESAMPLE' || keyword.value === 'LATERAL VIEW') {
|
||
|
|
keyword.weight = 1.1;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (!$$[$0-3].hasLateralViews && $$[$0-3].tableReferenceList.types) {
|
||
|
|
var veKeywords = parser.getValueExpressionKeywords($$[$0-3].tableReferenceList);
|
||
|
|
keywords = keywords.concat(veKeywords.suggestKeywords);
|
||
|
|
if (veKeywords.suggestColRefKeywords) {
|
||
|
|
parser.suggestColRefKeywords(veKeywords.suggestColRefKeywords);
|
||
|
|
parser.addColRefIfExists($$[$0-3].tableReferenceList);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($$[$0-1].empty && $$[$0] && $$[$0].joinType.toUpperCase() === 'JOIN') {
|
||
|
|
keywords = keywords.concat(['FULL', 'FULL OUTER', 'LEFT', 'LEFT OUTER', 'RIGHT', 'RIGHT OUTER']);
|
||
|
|
if (parser.isHive()) {
|
||
|
|
keywords = keywords.concat(['CROSS', 'INNER', 'LEFT SEMI']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat(['ANTI', 'CROSS', 'INNER', 'LEFT ANTI', 'LEFT INNER', 'LEFT SEMI', 'OUTER', 'RIGHT ANTI', 'RIGHT INNER', 'RIGHT SEMI', 'SEMI']);
|
||
|
|
} else {
|
||
|
|
keywords.push('INNER');
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2));
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestFilters) {
|
||
|
|
parser.suggestFilters($$[$0-1].suggestFilters);
|
||
|
|
}
|
||
|
|
if ($$[$0-1].suggestGroupBys) {
|
||
|
|
parser.suggestGroupBys($$[$0-1].suggestGroupBys);
|
||
|
|
}
|
||
|
|
if ($$[$0-1].suggestOrderBys) {
|
||
|
|
parser.suggestOrderBys($$[$0-1].suggestOrderBys);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($$[$0-1].empty) {
|
||
|
|
keywords.push({ value: 'UNION', weight: 2.11 });
|
||
|
|
}
|
||
|
|
|
||
|
|
keywords = keywords.concat([
|
||
|
|
{ value: 'FULL JOIN', weight: 1 },
|
||
|
|
{ value: 'FULL OUTER JOIN', weight: 1 },
|
||
|
|
{ value: 'JOIN', weight: 1 },
|
||
|
|
{ value: 'LEFT JOIN', weight: 1 },
|
||
|
|
{ value: 'LEFT OUTER JOIN', weight: 1 },
|
||
|
|
{ value: 'RIGHT JOIN', weight: 1 },
|
||
|
|
{ value: 'RIGHT OUTER JOIN', weight: 1 }
|
||
|
|
]);
|
||
|
|
if (parser.isHive()) {
|
||
|
|
keywords = keywords.concat([
|
||
|
|
{ value: 'CROSS JOIN', weight: 1 },
|
||
|
|
{ value: 'INNER JOIN', weight: 1 },
|
||
|
|
{ value: 'LEFT SEMI JOIN', weight: 1 }
|
||
|
|
]);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat([
|
||
|
|
{ value: 'ANTI JOIN', weight: 1 },
|
||
|
|
{ value: 'INNER JOIN', weight: 1 },
|
||
|
|
{ value: 'LEFT ANTI JOIN', weight: 1 },
|
||
|
|
{ value: 'LEFT INNER JOIN', weight: 1 },
|
||
|
|
{ value: 'LEFT SEMI JOIN', weight: 1 },
|
||
|
|
{ value: 'OUTER JOIN', weight: 1 },
|
||
|
|
{ value: 'RIGHT ANTI JOIN', weight: 1 },
|
||
|
|
{ value: 'RIGHT INNER JOIN', weight: 1 },
|
||
|
|
{ value: 'RIGHT SEMI JOIN', weight: 1 },
|
||
|
|
{ value: 'SEMI JOIN', weight: 1 }
|
||
|
|
]);
|
||
|
|
} else {
|
||
|
|
keywords.push({ value: 'INNER JOIN', weight: 1 });
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 914:
|
||
|
|
|
||
|
|
// A couple of things are going on here:
|
||
|
|
// - If there are no SelectConditions (WHERE, GROUP BY, etc.) we should suggest complete join options
|
||
|
|
// - If there's an OptionalJoin at the end, i.e. 'SELECT * FROM foo | JOIN ...' we should suggest
|
||
|
|
// different join types
|
||
|
|
// - The FromClause could end with a valueExpression, in which case we should suggest keywords like '='
|
||
|
|
// or 'AND' based on type
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.addClauseLocation('whereClause', _$[$0-2]);
|
||
|
|
parser.addClauseLocation('limitClause', _$[$0-2]);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
parser.addClauseLocation('whereClause', _$[$0-2], $$[$0-1].whereClauseLocation);
|
||
|
|
parser.addClauseLocation('limitClause', $$[$0-1].limitClausePreceding || _$[$0-2], $$[$0-1].limitClauseLocation);
|
||
|
|
var keywords = [];
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestColRefKeywords) {
|
||
|
|
parser.suggestColRefKeywords($$[$0-1].suggestColRefKeywords);
|
||
|
|
parser.addColRefIfExists($$[$0-1]);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestKeywords && $$[$0-1].suggestKeywords.length) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2));
|
||
|
|
}
|
||
|
|
|
||
|
|
if ($$[$0-1].cursorAtEnd) {
|
||
|
|
keywords.push({ value: 'UNION', weight: 2.11 });
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 918:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
this.$ = { tableReferenceList : $$[$0-1], suggestKeywords: ['LATERAL VIEW'] }
|
||
|
|
} else {
|
||
|
|
this.$ = { tableReferenceList : $$[$0-1] }
|
||
|
|
}
|
||
|
|
if (parser.isHive() && $$[$0]) {
|
||
|
|
parser.yy.lateralViews = $$[$0].lateralViews;
|
||
|
|
this.$.hasLateralViews = true;
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
this.$.suggestKeywords = this.$.suggestKeywords.concat($$[$0].suggestKeywords);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 919: case 1289:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 920:
|
||
|
|
|
||
|
|
if ($$[$0]) {
|
||
|
|
parser.yy.lateralViews = $$[$0].lateralViews;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 922:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR(
|
||
|
|
[$$[$0-7], $$[$0-6], $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-2], $$[$0-1], $$[$0]],
|
||
|
|
[{ value: 'WHERE', weight: 9 }, { value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }], { value: 'SORT BY', weight: 4 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }],
|
||
|
|
[true, true, true, parser.isHive(), true, parser.isHive(), parser.isHive() && !$$[$0-3], true, parser.isImpala()]);
|
||
|
|
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
this.$ = { suggestKeywords: keywords, empty: !$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0] };
|
||
|
|
} else {
|
||
|
|
this.$ = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
this.$.whereClauseLocation = $$[$0-7] ? _$[$0-7] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5], $$[$0-6], _$[$0-6], $$[$0-7], _$[$0-7]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
if (!$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$.suggestFilters = { prefix: 'WHERE', tablePrimaries: parser.yy.latestTablePrimaries.concat() };
|
||
|
|
}
|
||
|
|
if (!$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$.suggestGroupBys = { prefix: 'GROUP BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() };
|
||
|
|
}
|
||
|
|
if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$.suggestOrderBys = { prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 923:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'where';
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 924:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'group by';
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 927:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'order by';
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 931:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR(
|
||
|
|
[$$[$0-6], $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-2], $$[$0-1], $$[$0]],
|
||
|
|
[{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }], { value: 'SORT BY', weight: 4 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }],
|
||
|
|
[true, true, parser.isHive(), true, parser.isHive(), parser.isHive() && !$$[$0-3], true, parser.isImpala()]);
|
||
|
|
if ($$[$0-8].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-8].suggestKeywords, 1));
|
||
|
|
}
|
||
|
|
this.$ = parser.getValueExpressionKeywords($$[$0-8], keywords);
|
||
|
|
this.$.cursorAtEnd = !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0];
|
||
|
|
if ($$[$0-8].columnReference) {
|
||
|
|
this.$.columnReference = $$[$0-8].columnReference;
|
||
|
|
}
|
||
|
|
if (!$$[$0-6]) {
|
||
|
|
parser.suggestGroupBys({ prefix: 'GROUP BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
if (!$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3]) {
|
||
|
|
parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5], $$[$0-6], _$[$0-6], $$[$0-8], _$[$0-8]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 932:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR(
|
||
|
|
[$$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-2], $$[$0-1], $$[$0]],
|
||
|
|
[{ value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }], { value: 'SORT BY', weight: 4 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }],
|
||
|
|
[true, parser.isHive(), true, parser.isHive(), parser.isHive() && !$$[$0-3], true, parser.isImpala()]);
|
||
|
|
if ($$[$0-7].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-7].suggestKeywords, 8));
|
||
|
|
}
|
||
|
|
if ($$[$0-7].valueExpression) {
|
||
|
|
this.$ = parser.getValueExpressionKeywords($$[$0-7].valueExpression, keywords);
|
||
|
|
if ($$[$0-7].valueExpression.columnReference) {
|
||
|
|
this.$.columnReference = $$[$0-7].valueExpression.columnReference;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
this.$ = { suggestKeywords: keywords };
|
||
|
|
}
|
||
|
|
this.$.cursorAtEnd = !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0];
|
||
|
|
if (!$$[$0-5] && !$$[$0-4] && !$$[$0-3]) {
|
||
|
|
parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5], $$[$0-7], _$[$0-7]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 933:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR(
|
||
|
|
[$$[$0-4], $$[$0-3], $$[$0-2], $$[$0-2], $$[$0-1], $$[$0]],
|
||
|
|
[{ value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }], { value: 'SORT BY', weight: 4 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }],
|
||
|
|
[parser.isHive(), true, parser.isHive(), parser.isHive() && !$$[$0-3], true, parser.isImpala()]);
|
||
|
|
this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0] };
|
||
|
|
if (!$$[$0-4] && !$$[$0-3]) {
|
||
|
|
parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-6], _$[$0-6]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 934:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR([$$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], [{ value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isHive(), true, parser.isImpala()]);
|
||
|
|
this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0] };
|
||
|
|
if (!$$[$0-3]) {
|
||
|
|
parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-5], _$[$0-5]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 935:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR([$$[$0-2], $$[$0-1], $$[$0]], [[{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [parser.isHive(), true, parser.isImpala()]);
|
||
|
|
if ($$[$0-4].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-4].suggestKeywords, 5));
|
||
|
|
}
|
||
|
|
this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0-2] && !$$[$0-1] && !$$[$0] };
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-4], _$[$0-4]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 936:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR([$$[$0-1], $$[$0]], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isImpala()]);
|
||
|
|
if ($$[$0-3].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-3].suggestKeywords, 4));
|
||
|
|
}
|
||
|
|
this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0-1] && !$$[$0] };
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = _$[$0-3];
|
||
|
|
this.$.limitClauseLocation = $$[$0-1] ? _$[$0-1] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 937:
|
||
|
|
|
||
|
|
var keywords = parser.getKeywordsForOptionalsLR([$$[$0]], [{ value: 'OFFSET', weight: 2 }], [parser.isImpala()]);
|
||
|
|
this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0] };
|
||
|
|
this.$.whereClauseLocation = $$[$0-8] ? _$[$0-8] : undefined;
|
||
|
|
this.$.limitClausePreceding = parser.firstDefined($$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5], $$[$0-6], _$[$0-6], $$[$0-7], _$[$0-7], $$[$0-8], _$[$0-8]);
|
||
|
|
this.$.limitClauseLocation = $$[$0-2] ? _$[$0-2] : undefined;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 938:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-6], $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], [{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true, parser.isHive(), true, parser.isHive(), true, parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]
|
||
|
|
};
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 939:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], [{ value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [parser.isHive(), true, parser.isHive(), true, parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 940:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], [{ value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isHive(), true, parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 941:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-2], $$[$0-1], $$[$0]], [[{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [parser.isHive(), true, parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0-2] && !$$[$0-1] && !$$[$0]
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 942:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-1], $$[$0]], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0-1] && !$$[$0]
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 943:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0]], [{ value: 'OFFSET', weight: 2 }], [parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0]
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 972:
|
||
|
|
|
||
|
|
if ($$[$0].suggestFilters) {
|
||
|
|
parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 973:
|
||
|
|
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestKeywords(['EXISTS', 'NOT EXISTS']);
|
||
|
|
parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 976:
|
||
|
|
|
||
|
|
this.$ = { valueExpression: $$[$0] ? false : $$[$0-1] };
|
||
|
|
if (!$$[$0] && parser.isHive()) {
|
||
|
|
this.$.suggestKeywords = ['GROUPING SETS', 'WITH CUBE', 'WITH ROLLUP'];
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 977: case 1026: case 1052: case 1056: case 1059:
|
||
|
|
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 978:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
parser.suggestGroupBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 979:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['BY']);
|
||
|
|
parser.suggestGroupBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 986:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['CUBE', 'ROLLUP']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 988:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['SETS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1016:
|
||
|
|
|
||
|
|
if ($$[$0].emptyOrderBy) {
|
||
|
|
parser.suggestOrderBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1017:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['BY']);
|
||
|
|
parser.suggestOrderBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1021:
|
||
|
|
|
||
|
|
this.$ = { emptyOrderBy: false }
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1022: case 1023: case 1024:
|
||
|
|
this.$ = { emptyOrderBy: false };
|
||
|
|
break;
|
||
|
|
case 1025:
|
||
|
|
this.$ = parser.mergeSuggestKeywords($$[$0-1], $$[$0]);
|
||
|
|
break;
|
||
|
|
case 1028:
|
||
|
|
|
||
|
|
this.$ = { emptyOrderBy: true }
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1029:
|
||
|
|
|
||
|
|
this.$ = { suggestKeywords: ['ASC', 'DESC'] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1034:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
this.$ = { suggestKeywords: ['NULLS FIRST', 'NULLS LAST'] };
|
||
|
|
} else {
|
||
|
|
this.$ = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1037:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FIRST', 'LAST']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1041:
|
||
|
|
this.$ = { suggestKeywords: ['SORT BY'] };
|
||
|
|
break;
|
||
|
|
case 1050: case 1054: case 1058:
|
||
|
|
|
||
|
|
suggestKeywords: ['BY'];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1051: case 1055:
|
||
|
|
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1066:
|
||
|
|
|
||
|
|
parser.addColumnLocation($$[$0-1].location, [ $$[$0-1].identifier ]);
|
||
|
|
this.$ = $$[$0];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1077: case 1082:
|
||
|
|
|
||
|
|
parser.suggestFunctions({ types: ['BIGINT'] });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1078: case 1083:
|
||
|
|
|
||
|
|
delete parser.yy.result.suggestColumns;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1087: case 1088:
|
||
|
|
|
||
|
|
// verifyType($$[$0], 'BOOLEAN');
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1090:
|
||
|
|
|
||
|
|
// verifyType($$[$0], 'NUMBER');
|
||
|
|
this.$ = $$[$0];
|
||
|
|
$$[$0].types = ['NUMBER'];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1091: case 1092: case 1093: case 1094: case 1095: case 1102: case 1103: case 1104: case 1105: case 1106: case 1107: case 1113: case 1114: case 1135: case 1193: case 1194: case 1256:
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
break;
|
||
|
|
case 1096:
|
||
|
|
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
// clear correlated flag after completed sub-query (set by lexer)
|
||
|
|
parser.yy.correlatedSubQuery = false;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1098: case 1099: case 1100: case 1101:
|
||
|
|
|
||
|
|
parser.addColRefToVariableIfExists($$[$0-2], $$[$0]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1108: case 1109:
|
||
|
|
|
||
|
|
// verifyType($$[$0-2], 'BOOLEAN');
|
||
|
|
// verifyType($$[$0], 'BOOLEAN');
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1110: case 1111: case 1112:
|
||
|
|
|
||
|
|
// verifyType($$[$0-2], 'NUMBER');
|
||
|
|
// verifyType($$[$0], 'NUMBER');
|
||
|
|
this.$ = { types: [ 'NUMBER' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1118:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['BETWEEN', 'EXISTS', 'IN', 'ILIKE', 'IREGEXP', 'LIKE', 'REGEXP', 'RLIKE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['BETWEEN', 'EXISTS', 'IN', 'LIKE', 'REGEXP', 'RLIKE']);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1119: case 1121:
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1120:
|
||
|
|
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestKeywords(['EXISTS']);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1122:
|
||
|
|
|
||
|
|
parser.suggestFunctions({ types: [ 'BOOLEAN' ] });
|
||
|
|
parser.suggestColumns({ types: [ 'BOOLEAN' ] });
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1123:
|
||
|
|
this.$ = { types: [ 'T' ], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1124:
|
||
|
|
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
this.$ = { types: [ 'T' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1125:
|
||
|
|
|
||
|
|
if (!$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions('NUMBER');
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1126:
|
||
|
|
|
||
|
|
parser.suggestFunctions({ types: [ 'NUMBER' ] });
|
||
|
|
parser.suggestColumns({ types: [ 'NUMBER' ] });
|
||
|
|
this.$ = { types: [ 'NUMBER' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1127:
|
||
|
|
|
||
|
|
var keywords = ['FALSE', 'NOT NULL', 'NOT TRUE', 'NOT FALSE', 'NULL', 'TRUE'];
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat(['DISTINCT FROM', 'NOT DISTINCT FROM', 'NOT UNKNOWN', 'UNKNOWN']);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1128:
|
||
|
|
|
||
|
|
var keywords = ['FALSE', 'NULL', 'TRUE'];
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat(['DISTINCT FROM', 'UNKNOWN']);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1129:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1130: case 1131: case 1132:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['NOT']);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1133:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-5], $$[$0-3] ? 'IS NOT DISTINCT FROM' : 'IS DISTINCT FROM');
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1134:
|
||
|
|
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1136:
|
||
|
|
|
||
|
|
this.$ = $$[$0-1];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1137:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: ['T'], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1138:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1139: case 1140: case 1141:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1142: case 1143: case 1144: case 1145:
|
||
|
|
|
||
|
|
if (!$$[$0-2].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0].types);
|
||
|
|
parser.addColRefIfExists($$[$0]);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1146: case 1148:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-2], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1147:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-2], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] , typeSet: true, endsWithLessThanOrEqual: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1149:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-2], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true, endsWithLessThanOrEqual: $$[$0-1] === '<=' };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1150: case 1151: case 1152: case 1153:
|
||
|
|
|
||
|
|
if (!$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
parser.addColRefIfExists($$[$0-2]);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1154:
|
||
|
|
|
||
|
|
if ($$[$0].inValueEdit) {
|
||
|
|
parser.valueExpressionSuggest($$[$0-3], $$[$0-2] + ' ' + $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-3].types);
|
||
|
|
}
|
||
|
|
if ($$[$0].cursorAtStart) {
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1155:
|
||
|
|
|
||
|
|
if ($$[$0].inValueEdit) {
|
||
|
|
parser.valueExpressionSuggest($$[$0-2], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
}
|
||
|
|
if ($$[$0].cursorAtStart) {
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1156: case 1157:
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-5].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1158: case 1159:
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-4].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1160:
|
||
|
|
|
||
|
|
if ($$[$0-2].types[0] === $$[$0].types[0] && !$$[$0-5].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-5].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1161:
|
||
|
|
|
||
|
|
if ($$[$0-5].types[0] === $$[$0].types[0] && !$$[$0-2].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-5].types);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1162:
|
||
|
|
|
||
|
|
if ($$[$0-5].types[0] === $$[$0-2].types[0] && !$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-5].types);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1163:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-5], $$[$0-1]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1164: case 1170:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-1], ['AND']);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1165:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-3], $$[$0-2] + ' ' + $$[$0-1]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1166:
|
||
|
|
|
||
|
|
if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0-4].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-4].types)
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-4].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1167:
|
||
|
|
|
||
|
|
if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0-2].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-4].types)
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1168:
|
||
|
|
|
||
|
|
if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0-4].types)
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1169:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-4], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-4].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1171:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest($$[$0-2], $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].types);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1172: case 1174: case 1176: case 1178:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0-1]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true, suggestFilters: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1173: case 1177:
|
||
|
|
|
||
|
|
parser.addColRefIfExists($$[$0]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1175: case 1179:
|
||
|
|
|
||
|
|
parser.addColRefIfExists($$[$0-2]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1180: case 1181:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions([ 'NUMBER' ]);
|
||
|
|
this.$ = { types: [ 'NUMBER' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1182: case 1183: case 1184:
|
||
|
|
|
||
|
|
if (!$$[$0-2].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
parser.addColRefIfExists($$[$0]);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0-2].suggestFilters }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1185: case 1186: case 1187:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0-1]);
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
this.$ = { types: [ 'NUMBER' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1188: case 1189: case 1190:
|
||
|
|
|
||
|
|
if (!$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
parser.addColRefIfExists($$[$0-2]);
|
||
|
|
}
|
||
|
|
this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1191:
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-1].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1192:
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1195:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0]);
|
||
|
|
parser.applyTypeToSuggestions([ 'STRING' ]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1196:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0-1] + ' ' + $$[$0]);
|
||
|
|
parser.applyTypeToSuggestions([ 'STRING' ]);
|
||
|
|
this.$ = { types: [ 'BOOLEAN' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1198:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { types: [ 'T' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1200:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], ['WHEN']);
|
||
|
|
this.$ = { types: [ 'T' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1201:
|
||
|
|
|
||
|
|
this.$ = $$[$0];
|
||
|
|
this.$.suggestFilters = $$[$0-1].suggestFilters;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1202:
|
||
|
|
this.$ = { types: [ 'T' ], suggestFilters: $$[$0-1].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1203: case 1532: case 1537: case 1538:
|
||
|
|
this.$ = { types: [ 'T' ] };
|
||
|
|
break;
|
||
|
|
case 1204: case 1206:
|
||
|
|
|
||
|
|
$$[$0].position = 1;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1205:
|
||
|
|
|
||
|
|
$$[$0].position = $$[$0-2].position + 1;
|
||
|
|
this.$ = $$[$0];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1207:
|
||
|
|
|
||
|
|
$$[$0-2].position += 1;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1208:
|
||
|
|
|
||
|
|
$$[$0-2].position = 1;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1209:
|
||
|
|
|
||
|
|
$$[$0-4].position += 1;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1210:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
$$[$0-2].position += 1;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1211:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
$$[$0-4].position += 1;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1212:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1213: case 1214:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { cursorAtStart : true, position: 1 };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1215: case 1216:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { position: 2 };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1220:
|
||
|
|
this.$ = { types: ['COLREF'], columnReference: $$[$0].chain };
|
||
|
|
break;
|
||
|
|
case 1221:
|
||
|
|
|
||
|
|
// We need to handle arbitrary UDFs here instead of inside UserDefinedFunction or there will be a conflict
|
||
|
|
// with columnReference for functions like: db.udf(foo)
|
||
|
|
var fn = $$[$0-1].chain[$$[$0-1].chain.length - 1].name.toLowerCase();
|
||
|
|
$$[$0-1].lastLoc.type = 'function';
|
||
|
|
$$[$0-1].lastLoc.function = fn;
|
||
|
|
$$[$0-1].lastLoc.location = {
|
||
|
|
first_line: $$[$0-1].lastLoc.location.first_line,
|
||
|
|
last_line: $$[$0-1].lastLoc.location.last_line,
|
||
|
|
first_column: $$[$0-1].lastLoc.location.first_column,
|
||
|
|
last_column: $$[$0-1].lastLoc.location.last_column - 1
|
||
|
|
}
|
||
|
|
if ($$[$0-1].lastLoc !== $$[$0-1].firstLoc) {
|
||
|
|
$$[$0-1].firstLoc.type = 'database';
|
||
|
|
} else {
|
||
|
|
delete $$[$0-1].lastLoc.identifierChain;
|
||
|
|
}
|
||
|
|
if ($$[$0].expression) {
|
||
|
|
this.$ = { function: fn, expression: $$[$0].expression, types: parser.findReturnTypes(fn) }
|
||
|
|
} else {
|
||
|
|
this.$ = { function: fn, types: parser.findReturnTypes(fn) }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1222:
|
||
|
|
|
||
|
|
parser.addFunctionLocation(_$[$0-1], $$[$0-1]);
|
||
|
|
if ($$[$0].expression) {
|
||
|
|
this.$ = { function: $$[$0-1], expression: $$[$0].expression, types: parser.findReturnTypes($$[$0-1]) }
|
||
|
|
} else {
|
||
|
|
this.$ = { function: $$[$0-1], types: parser.findReturnTypes($$[$0-1]) }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1224:
|
||
|
|
this.$ = { types: [ 'NULL' ] };
|
||
|
|
break;
|
||
|
|
case 1225:
|
||
|
|
this.$ = { types: [ 'TIMESTAMP' ] };
|
||
|
|
break;
|
||
|
|
case 1227:
|
||
|
|
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
this.$ = { types: ['COLREF'], columnReference: $$[$0], suggestKeywords: $$[$0].suggestKeywords };
|
||
|
|
} else {
|
||
|
|
this.$ = { types: ['COLREF'], columnReference: $$[$0] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1228:
|
||
|
|
|
||
|
|
var fn = $$[$0-1].chain[$$[$0-1].chain.length - 1].name.toLowerCase();
|
||
|
|
$$[$0-1].lastLoc.type = 'function';
|
||
|
|
$$[$0-1].lastLoc.function = fn;
|
||
|
|
$$[$0-1].lastLoc.location = {
|
||
|
|
first_line: $$[$0-1].lastLoc.location.first_line,
|
||
|
|
last_line: $$[$0-1].lastLoc.location.last_line,
|
||
|
|
first_column: $$[$0-1].lastLoc.location.first_column,
|
||
|
|
last_column: $$[$0-1].lastLoc.location.last_column - 1
|
||
|
|
}
|
||
|
|
if ($$[$0-1].lastLoc !== $$[$0-1].firstLoc) {
|
||
|
|
$$[$0-1].firstLoc.type = 'database';
|
||
|
|
} else {
|
||
|
|
delete $$[$0-1].lastLoc.identifierChain;
|
||
|
|
}
|
||
|
|
if ($$[$0].position) {
|
||
|
|
parser.applyArgumentTypesToSuggestions(fn, $$[$0].position);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes(fn) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1229: case 1437: case 1438:
|
||
|
|
|
||
|
|
parser.addFunctionLocation(_$[$0-1], $$[$0-1]);
|
||
|
|
if ($$[$0].position) {
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-1], $$[$0].position);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-1]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1232:
|
||
|
|
|
||
|
|
var lastLoc = parser.yy.locations[parser.yy.locations.length - 1];
|
||
|
|
if (lastLoc.type !== 'variable') {
|
||
|
|
lastLoc.type = 'column';
|
||
|
|
}
|
||
|
|
// used for function references with db prefix
|
||
|
|
var firstLoc = parser.yy.locations[parser.yy.locations.length - $$[$0].length];
|
||
|
|
this.$ = { chain: $$[$0], firstLoc: firstLoc, lastLoc: lastLoc }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1236:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DAYS', 'HOURS', 'MICROSECONDS', 'MILLISECONDS', 'MINUTES', 'MONTHS', 'NANOSECONDS', 'SECONDS', 'WEEKS', 'YEARS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1241:
|
||
|
|
|
||
|
|
parser.suggestValues($$[$0]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1242:
|
||
|
|
this.$ = { types: [ 'NUMBER' ] };
|
||
|
|
break;
|
||
|
|
case 1248: case 1250:
|
||
|
|
this.$ = $$[$0-1] + $$[$0];
|
||
|
|
break;
|
||
|
|
case 1249:
|
||
|
|
this.$ = $$[$0-2] + $$[$0-1] + $$[$0];
|
||
|
|
break;
|
||
|
|
case 1254: case 1255:
|
||
|
|
|
||
|
|
if (/\$\{[^}]*\}/.test($$[$0])) {
|
||
|
|
parser.addVariableLocation(_$[$0], $$[$0]);
|
||
|
|
this.$ = { types: [ 'STRING' ], columnReference: [{ name: $$[$0] }] }
|
||
|
|
} else {
|
||
|
|
this.$ = { types: [ 'STRING' ] }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1257:
|
||
|
|
|
||
|
|
this.$ = { partialQuote: '\'', missingEndQuote: parser.yy.missingEndQuote };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1258:
|
||
|
|
|
||
|
|
this.$ = { partialQuote: '"', missingEndQuote: parser.yy.missingEndQuote };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1263:
|
||
|
|
|
||
|
|
if ($$[$0]) {
|
||
|
|
parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0-1]);
|
||
|
|
this.$ = { valueExpression: $$[$0-1], alias: $$[$0].alias };
|
||
|
|
if (!parser.yy.selectListAliases) {
|
||
|
|
parser.yy.selectListAliases = [];
|
||
|
|
}
|
||
|
|
parser.yy.selectListAliases.push({ name: $$[$0].alias, types: $$[$0-1].types || ['T'] });
|
||
|
|
} else {
|
||
|
|
this.$ = { valueExpression: $$[$0-1] }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1264:
|
||
|
|
|
||
|
|
parser.addAsteriskLocation(_$[$0], [{ asterisk: true }]);
|
||
|
|
this.$ = { asterisk: true }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1265:
|
||
|
|
|
||
|
|
if ($$[$0]) {
|
||
|
|
parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0-1]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1266:
|
||
|
|
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.addColumnAliasLocation(_$[$0], $$[$0], _$[$0-2]);
|
||
|
|
this.$ = { suggestAggregateFunctions: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1268: case 1631:
|
||
|
|
this.$ = [ $$[$0] ];
|
||
|
|
break;
|
||
|
|
case 1269:
|
||
|
|
|
||
|
|
$$[$0-2].push($$[$0]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1271: case 1272: case 1705:
|
||
|
|
|
||
|
|
this.$ = { cursorAtStart : true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1274:
|
||
|
|
|
||
|
|
parser.checkForSelectListKeywords($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1275:
|
||
|
|
|
||
|
|
parser.checkForSelectListKeywords($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1276:
|
||
|
|
|
||
|
|
this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestTables: true, suggestDatabases: true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1278: case 1279: case 1281:
|
||
|
|
|
||
|
|
this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true, };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1292:
|
||
|
|
|
||
|
|
this.$ = $$[$0];
|
||
|
|
|
||
|
|
if (parser.yy.latestTablePrimaries.length > 0) {
|
||
|
|
var idx = parser.yy.latestTablePrimaries.length - 1;
|
||
|
|
var tables = [];
|
||
|
|
do {
|
||
|
|
var tablePrimary = parser.yy.latestTablePrimaries[idx];
|
||
|
|
if (!tablePrimary.subQueryAlias) {
|
||
|
|
tables.unshift(tablePrimary.alias ? { identifierChain: tablePrimary.identifierChain, alias: tablePrimary.alias } : { identifierChain: tablePrimary.identifierChain })
|
||
|
|
}
|
||
|
|
idx--;
|
||
|
|
} while (idx >= 0 && tablePrimary.join && !tablePrimary.subQueryAlias)
|
||
|
|
|
||
|
|
if (tables.length > 0) {
|
||
|
|
this.$.suggestJoins = {
|
||
|
|
prependJoin: true,
|
||
|
|
tables: tables
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1299:
|
||
|
|
|
||
|
|
if ($$[$0] && $$[$0].valueExpression) {
|
||
|
|
this.$ = $$[$0].valueExpression;
|
||
|
|
} else {
|
||
|
|
this.$ = {};
|
||
|
|
}
|
||
|
|
this.$.joinType = $$[$0-3];
|
||
|
|
if ($$[$0].noJoinCondition) {
|
||
|
|
this.$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() }
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
this.$.suggestKeywords = $$[$0].suggestKeywords;
|
||
|
|
}
|
||
|
|
if (parser.yy.latestTablePrimaries.length > 0) {
|
||
|
|
parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1300:
|
||
|
|
|
||
|
|
if ($$[$0] && $$[$0].valueExpression) {
|
||
|
|
this.$ = $$[$0].valueExpression;
|
||
|
|
} else {
|
||
|
|
this.$ = {};
|
||
|
|
}
|
||
|
|
this.$.joinType = $$[$0-4];
|
||
|
|
if ($$[$0].noJoinCondition) {
|
||
|
|
this.$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() }
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
this.$.suggestKeywords = $$[$0].suggestKeywords;
|
||
|
|
}
|
||
|
|
if (parser.yy.latestTablePrimaries.length > 0) {
|
||
|
|
parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1301:
|
||
|
|
this.$ = { joinType: $$[$0-1] };
|
||
|
|
break;
|
||
|
|
case 1302:
|
||
|
|
this.$ = { joinType: $$[$0-2] };
|
||
|
|
break;
|
||
|
|
case 1306:
|
||
|
|
|
||
|
|
if ($$[$0-3].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0-3].suggestKeywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1307: case 1889:
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0-1].suggestKeywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1310:
|
||
|
|
|
||
|
|
if (!$$[$0-2] && parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['[BROADCAST]', '[SHUFFLE]']);
|
||
|
|
}
|
||
|
|
if (!$$[$0-2] && parser.yy.latestTablePrimaries.length > 0) {
|
||
|
|
var idx = parser.yy.latestTablePrimaries.length - 1;
|
||
|
|
var tables = [];
|
||
|
|
do {
|
||
|
|
var tablePrimary = parser.yy.latestTablePrimaries[idx];
|
||
|
|
if (!tablePrimary.subQueryAlias) {
|
||
|
|
tables.unshift(tablePrimary.alias ? { identifierChain: tablePrimary.identifierChain, alias: tablePrimary.alias } : { identifierChain: tablePrimary.identifierChain })
|
||
|
|
}
|
||
|
|
idx--;
|
||
|
|
} while (idx >= 0 && tablePrimary.join && !tablePrimary.subQueryAlias)
|
||
|
|
|
||
|
|
if (tables.length > 0) {
|
||
|
|
parser.suggestJoins({
|
||
|
|
prependJoin: false,
|
||
|
|
joinType: $$[$0-3],
|
||
|
|
tables: tables
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1315:
|
||
|
|
this.$ = 'JOIN';
|
||
|
|
break;
|
||
|
|
case 1316:
|
||
|
|
this.$ = 'ANTI JOIN';
|
||
|
|
break;
|
||
|
|
case 1317:
|
||
|
|
this.$ = 'CROSS JOIN';
|
||
|
|
break;
|
||
|
|
case 1318:
|
||
|
|
this.$ = 'INNER JOIN';
|
||
|
|
break;
|
||
|
|
case 1319:
|
||
|
|
this.$ = 'OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1320:
|
||
|
|
this.$ = 'SEMI JOIN';
|
||
|
|
break;
|
||
|
|
case 1321:
|
||
|
|
this.$ = 'FULL JOIN';
|
||
|
|
break;
|
||
|
|
case 1322:
|
||
|
|
this.$ = 'FULL OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1323:
|
||
|
|
this.$ = 'LEFT JOIN';
|
||
|
|
break;
|
||
|
|
case 1324:
|
||
|
|
this.$ = 'LEFT ANTI JOIN';
|
||
|
|
break;
|
||
|
|
case 1325:
|
||
|
|
this.$ = 'LEFT INNER JOIN';
|
||
|
|
break;
|
||
|
|
case 1326:
|
||
|
|
this.$ = 'LEFT OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1327:
|
||
|
|
this.$ = 'LEFT SEMI JOIN';
|
||
|
|
break;
|
||
|
|
case 1328:
|
||
|
|
this.$ = 'RIGHT JOIN';
|
||
|
|
break;
|
||
|
|
case 1329:
|
||
|
|
this.$ = 'RIGHT ANTI JOIN';
|
||
|
|
break;
|
||
|
|
case 1330: case 1331:
|
||
|
|
this.$ = 'RIGHT OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1332:
|
||
|
|
this.$ = 'RIGHT SEMI JOIN';
|
||
|
|
break;
|
||
|
|
case 1333: case 1334: case 1335: case 1336: case 1337: case 1338: case 1340: case 1341: case 1342: case 1343: case 1345: case 1346: case 1347: case 1348:
|
||
|
|
this.$ = { suggestKeywords: ['JOIN'] };
|
||
|
|
break;
|
||
|
|
case 1339:
|
||
|
|
this.$ = { suggestKeywords: ['OUTER'] };
|
||
|
|
break;
|
||
|
|
case 1344:
|
||
|
|
this.$ = { suggestKeywords: parser.isImpala() ? ['ANTI', 'INNER', 'OUTER', 'SEMI'] : parser.isHive() ? ['OUTER', 'SEMI'] : ['OUTER'] };
|
||
|
|
break;
|
||
|
|
case 1349:
|
||
|
|
this.$ = { suggestKeywords: parser.isImpala() ? ['ANTI', 'INNER', 'OUTER', 'SEMI'] : ['OUTER'] };
|
||
|
|
break;
|
||
|
|
case 1350:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['JOIN', 'OUTER JOIN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1351:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['JOIN', 'OUTER JOIN', 'SEMI JOIN']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['ANTI JOIN', 'INNER JOIN', 'JOIN', 'OUTER JOIN', 'SEMI JOIN']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['JOIN', 'OUTER JOIN']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1352:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['ANTI JOIN', 'INNER JOIN', 'JOIN', 'OUTER JOIN', 'SEMI JOIN']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['JOIN', 'OUTER JOIN']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1353:
|
||
|
|
this.$ = { noJoinCondition: true, suggestKeywords: parser.isImpala() ? ['ON', 'USING'] : ['ON'] };
|
||
|
|
break;
|
||
|
|
case 1354:
|
||
|
|
this.$ = { valueExpression: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 1355: case 2180:
|
||
|
|
this.$ = {};
|
||
|
|
break;
|
||
|
|
case 1359:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestJoinConditions({ prependOn: false });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1360:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
primary: $$[$0-3]
|
||
|
|
}
|
||
|
|
if ($$[$0-3].identifierChain) {
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
$$[$0-3].alias = $$[$0-1].alias
|
||
|
|
parser.addTableAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-3].identifierChain);
|
||
|
|
}
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
}
|
||
|
|
var keywords = [];
|
||
|
|
if ($$[$0] && $$[$0].suggestKeywords) {
|
||
|
|
keywords = $$[$0].suggestKeywords;
|
||
|
|
} else {
|
||
|
|
// Right-to-left for cursor after TablePrimary
|
||
|
|
keywords = parser.getKeywordsForOptionalsLR([$$[$0], $$[$0-1], $$[$0-2]], [{ value: 'TABLESAMPLE', weight: 1 }, { value: 'AS', weight: 2 }, { value: 'TABLESAMPLE', weight: 3 }], [parser.isImpala(), true, parser.isHive()]);
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
this.$.suggestKeywords = keywords;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1361:
|
||
|
|
|
||
|
|
this.$ = {
|
||
|
|
primary: $$[$0-2]
|
||
|
|
};
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
this.$.primary.alias = $$[$0-1].alias;
|
||
|
|
parser.addTablePrimary({ subQueryAlias: $$[$0-1].alias });
|
||
|
|
parser.addSubqueryAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-2].identifierChain);
|
||
|
|
}
|
||
|
|
|
||
|
|
var keywords = [];
|
||
|
|
if ($$[$0] && $$[$0].suggestKeywords) {
|
||
|
|
keywords = $$[$0].suggestKeywords;
|
||
|
|
} else {
|
||
|
|
keywords = parser.getKeywordsForOptionalsLR([$$[$0], $$[$0-1]], [{ value: 'TABLESAMPLE', weight: 1 }, { value: 'AS', weight: 2 }], [parser.isImpala(), true]);
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
this.$.suggestKeywords = keywords;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1362:
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
parser.addTableAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-3].identifierChain);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1363: case 1364:
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
$$[$0-3].alias = $$[$0-1].alias;
|
||
|
|
parser.addTableAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-3].identifierChain);
|
||
|
|
}
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1365:
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
parser.addTablePrimary({ subQueryAlias: $$[$0-1].alias });
|
||
|
|
parser.addSubqueryAliasLocation($$[$0-1].location, $$[$0-1].alias);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1376:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['BUCKET']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1377:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OUT OF']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1378:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OF']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1379:
|
||
|
|
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['ON']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1381:
|
||
|
|
|
||
|
|
if ($$[$0-2].indexOf('.') === -1 ) {
|
||
|
|
parser.suggestKeywords(['PERCENT', 'ROWS']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['PERCENT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1383:
|
||
|
|
this.$ = { suggestKeywords: ['REPEATABLE()'] };
|
||
|
|
break;
|
||
|
|
case 1385:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['SYSTEM()']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1390:
|
||
|
|
|
||
|
|
parser.pushQueryState();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1391:
|
||
|
|
|
||
|
|
parser.popQueryState();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1393:
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
$$[$0-2].alias = $$[$0-1].alias;
|
||
|
|
parser.addTablePrimary({ subQueryAlias: $$[$0-1].alias });
|
||
|
|
parser.addSubqueryAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-2].identifierChain);
|
||
|
|
}
|
||
|
|
this.$ = $$[$0-2];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1396:
|
||
|
|
|
||
|
|
var subQuery = parser.getSubQuery($$[$0]);
|
||
|
|
subQuery.columns.forEach(function (column) {
|
||
|
|
parser.expandIdentifierChain({ wrapper: column });
|
||
|
|
delete column.linked;
|
||
|
|
});
|
||
|
|
parser.popQueryState(subQuery);
|
||
|
|
this.$ = subQuery;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1413: case 1414:
|
||
|
|
this.$ = { alias: $$[$0], location: _$[$0] };
|
||
|
|
break;
|
||
|
|
case 1419:
|
||
|
|
|
||
|
|
if ($$[$0-1] && $$[$0].lateralView) {
|
||
|
|
$$[$0-1].lateralViews.push($$[$0].lateralView);
|
||
|
|
this.$ = $$[$0-1];
|
||
|
|
} else if ($$[$0].lateralView) {
|
||
|
|
this.$ = { lateralViews: [ $$[$0].lateralView ] };
|
||
|
|
}
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
this.$.suggestKeywords = $$[$0].suggestKeywords
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1421:
|
||
|
|
|
||
|
|
if (!$$[$0]) {
|
||
|
|
$$[$0-1].suggestKeywords = ['OVER'];
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1430:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OVER']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1435: case 1436:
|
||
|
|
|
||
|
|
parser.addFunctionLocation(_$[$0-1], $$[$0-1]);
|
||
|
|
if ($$[$0].expression) {
|
||
|
|
this.$ = { function: $$[$0-1], expression: $$[$0].expression, types: parser.findReturnTypes($$[$0-1]) }
|
||
|
|
} else {
|
||
|
|
this.$ = { function: $$[$0-1], types: parser.findReturnTypes($$[$0-1]) }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1446:
|
||
|
|
this.$ = { expression: $$[$0-1] };
|
||
|
|
break;
|
||
|
|
case 1447:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { position: 1 }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1448:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1456: case 1544: case 1610:
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-2]) };
|
||
|
|
break;
|
||
|
|
case 1457:
|
||
|
|
this.$ = { function: $$[$0-3], expression: $$[$0-2], types: parser.findReturnTypes($$[$0-3]) };
|
||
|
|
break;
|
||
|
|
case 1458:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-3], 1);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-3]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1459:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2]);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1460:
|
||
|
|
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-3], $$[$0-1].position);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-3]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1468: case 1469:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestFunctions) {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1470:
|
||
|
|
|
||
|
|
if (!$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'PARTITION BY', weight: 2 }, { value: 'ORDER BY', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['PARTITION BY']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1471:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'ORDER BY', weight: 2 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1475: case 1820: case 2299: case 2300: case 2303: case 2313: case 2347: case 2356: case 2374: case 2429: case 2430: case 2435: case 2440: case 2444:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['BY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1480:
|
||
|
|
|
||
|
|
// Only allowed in last order by
|
||
|
|
delete parser.yy.result.suggestAnalyticFunctions;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1481:
|
||
|
|
|
||
|
|
var keywords = [];
|
||
|
|
if ($$[$0-2].suggestKeywords) {
|
||
|
|
keywords = parser.createWeightedKeywords($$[$0-2].suggestKeywords, 2);
|
||
|
|
}
|
||
|
|
if (!$$[$0]) {
|
||
|
|
keywords = keywords.concat([{ value: 'RANGE BETWEEN', weight: 1 }, { value: 'ROWS BETWEEN', weight: 1 }]);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1487:
|
||
|
|
|
||
|
|
parser.suggestKeywords(parser.isHive() ? ['BETWEEN', 'UNBOUNDED'] : ['BETWEEN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1488:
|
||
|
|
|
||
|
|
if (!$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED PRECEDING']);
|
||
|
|
} else if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['AND']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1491:
|
||
|
|
|
||
|
|
if (!$$[$0-1] && parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['PRECEDING']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1493:
|
||
|
|
|
||
|
|
lexer.popState();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1494:
|
||
|
|
|
||
|
|
lexer.begin('hdfs');
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1496:
|
||
|
|
|
||
|
|
parser.suggestHdfs({ path: $$[$0-3] });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1497:
|
||
|
|
|
||
|
|
parser.suggestHdfs({ path: $$[$0-2] });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1498:
|
||
|
|
|
||
|
|
parser.suggestHdfs({ path: $$[$0-1] });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1499:
|
||
|
|
|
||
|
|
parser.suggestHdfs({ path: '' });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1500:
|
||
|
|
|
||
|
|
parser.suggestHdfs({ path: '' });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1506:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['PRECEDING']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1507: case 1517:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ROW']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1516:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED FOLLOWING']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1518:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FOLLOWING']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1524:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestSelectListAliases(true);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1525:
|
||
|
|
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestSelectListAliases(true);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1531: case 1536:
|
||
|
|
this.$ = { types: [ $$[$0-1].toUpperCase() ] };
|
||
|
|
break;
|
||
|
|
case 1533:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: [ $$[$0-1].toUpperCase() ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1534: case 1535:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: [ 'T' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1539:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'AS', weight: 2 }]);
|
||
|
|
this.$ = { types: [ $$[$0-1].toUpperCase() ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1540:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'AS', weight: 2 }]);
|
||
|
|
this.$ = { types: [ 'T' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1541: case 1542:
|
||
|
|
|
||
|
|
parser.suggestKeywords(parser.getTypeKeywords());
|
||
|
|
this.$ = { types: [ 'T' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1543: case 1565:
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-3]) };
|
||
|
|
break;
|
||
|
|
case 1545: case 1566: case 1609:
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
break;
|
||
|
|
case 1546:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push('ALL');
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestKeywords) {
|
||
|
|
keywords = parser.yy.result.suggestKeywords.concat(keywords);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1547: case 1568: case 1612:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2]);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-5]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1548:
|
||
|
|
|
||
|
|
if ($$[$0-1].cursorAtStart) {
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push('ALL');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1549: case 1553:
|
||
|
|
this.$ = { types: ['INT'] };
|
||
|
|
break;
|
||
|
|
case 1550:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DAY', 'DAYOFWEEK', 'HOUR', 'MINUTE', 'MONTH', 'QUARTER', 'SECOND', 'WEEK', 'YEAR']);
|
||
|
|
this.$ = { types: ['INT'] }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1551: case 1555:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
this.$ = { types: ['INT'] }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1552:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: ['INT'] }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1554:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DAY', 'DAYOFWEEK', 'HOUR', 'MINUTE', 'MONTH', 'QUARTER', 'SECOND', 'WEEK', 'YEAR']);
|
||
|
|
this.$ = { types: ['INT'] }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1567:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
var keywords = parser.getSelectListKeywords(true);
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
if ($$[$0-4].toLowerCase() === 'group_concat') {
|
||
|
|
keywords.push('ALL');
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
keywords.push('ALL');
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
} else {
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestKeywords) {
|
||
|
|
keywords = parser.yy.result.suggestKeywords.concat(keywords);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-4], 1);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1569:
|
||
|
|
|
||
|
|
if ($$[$0-1].cursorAtStart) {
|
||
|
|
var keywords = parser.getSelectListKeywords(true);
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
if ($$[$0-4].toLowerCase() === 'group_concat') {
|
||
|
|
keywords.push('ALL');
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
keywords.push('ALL');
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
} else {
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestKeywords) {
|
||
|
|
keywords = parser.yy.result.suggestKeywords.concat(keywords);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) {
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-4], $$[$0-1].position);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1595:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-5]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1596:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0-1].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1597:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions(['STRING', 'TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-3]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1598:
|
||
|
|
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-5]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1599:
|
||
|
|
|
||
|
|
parser.applyTypeToSuggestions($$[$0-1].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1600:
|
||
|
|
|
||
|
|
parser.applyTypeToSuggestions(['STRING', 'TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-3]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1601:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-5]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1602:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0-1].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1603:
|
||
|
|
|
||
|
|
parser.applyTypeToSuggestions($$[$0-2].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-5]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1604:
|
||
|
|
|
||
|
|
parser.applyTypeToSuggestions($$[$0-1].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1605:
|
||
|
|
|
||
|
|
if ($$[$0-3].types[0] === 'STRING') {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3], ['FROM']);
|
||
|
|
} else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3]);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-5]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1606:
|
||
|
|
|
||
|
|
if ($$[$0-2].types[0] === 'STRING') {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], ['FROM']);
|
||
|
|
} else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2]);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1611:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-4], 1);
|
||
|
|
var keywords = parser.getSelectListKeywords(true);
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
keywords.push('DISTINCT');
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push('ALL');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (parser.yy.result.suggestKeywords) {
|
||
|
|
keywords = parser.yy.result.suggestKeywords.concat(keywords);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1613:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestFunctions && ! parser.yy.result.suggestFunctions.types) {
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0-4], 1);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0-4]) };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1614:
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0-2], tableAlias: $$[$0-1], columnAliases: $$[$0] }};
|
||
|
|
break;
|
||
|
|
case 1615:
|
||
|
|
|
||
|
|
if ($$[$0-1].function.toLowerCase() === 'explode') {
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0-1], tableAlias: $$[$0], columnAliases: ['key', 'value'] }, suggestKeywords: ['AS'] };
|
||
|
|
} else if ($$[$0-1].function.toLowerCase() === 'posexplode') {
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0-1], tableAlias: $$[$0], columnAliases: ['pos', 'val'] }, suggestKeywords: ['AS'] };
|
||
|
|
} else {
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0-1], tableAlias: $$[$0], columnAliases: [] }, suggestKeywords: ['AS'] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1616:
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0-1], columnAliases: $$[$0] }};
|
||
|
|
break;
|
||
|
|
case 1617: case 1618: case 1619: case 1620:
|
||
|
|
this.$ = { };
|
||
|
|
break;
|
||
|
|
case 1627:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'OUTER', weight: 2 }, { value: 'explode', weight: 1 }, { value: 'posexplode', weight: 1 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['explode', 'posexplode']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1628:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['VIEW']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1632:
|
||
|
|
this.$ = [ $$[$0-2], $$[$0] ];
|
||
|
|
break;
|
||
|
|
case 1636:
|
||
|
|
this.$ = { inValueEdit: true };
|
||
|
|
break;
|
||
|
|
case 1637:
|
||
|
|
this.$ = { inValueEdit: true, cursorAtStart: true };
|
||
|
|
break;
|
||
|
|
case 1638: case 1639: case 1640: case 1641: case 1642:
|
||
|
|
this.$ = { suggestKeywords: ['NOT'] };
|
||
|
|
break;
|
||
|
|
case 1648: case 1649: case 1650: case 1651: case 1652:
|
||
|
|
|
||
|
|
parser.suggestFunctions({ types: [ 'STRING' ] });
|
||
|
|
parser.suggestColumns({ types: [ 'STRING' ] });
|
||
|
|
this.$ = { types: ['BOOLEAN'] }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1653: case 1655:
|
||
|
|
this.$ = parser.findCaseType($$[$0-1]);
|
||
|
|
break;
|
||
|
|
case 1654: case 1657:
|
||
|
|
|
||
|
|
$$[$0-3].caseTypes.push($$[$0-1]);
|
||
|
|
this.$ = parser.findCaseType($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1656:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-1], ['END']);
|
||
|
|
$$[$0-3].caseTypes.push($$[$0-1]);
|
||
|
|
this.$ = parser.findCaseType($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1658:
|
||
|
|
this.$ = parser.findCaseType($$[$0-2]);
|
||
|
|
break;
|
||
|
|
case 1659:
|
||
|
|
|
||
|
|
if ($$[$0].toLowerCase() !== 'end') {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'END', weight: 3 }, { value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]);
|
||
|
|
}
|
||
|
|
this.$ = parser.findCaseType($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1660:
|
||
|
|
|
||
|
|
if ($$[$0].toLowerCase() !== 'end') {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'END', weight: 3 }, { value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]);
|
||
|
|
}
|
||
|
|
this.$ = parser.findCaseType($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1661:
|
||
|
|
|
||
|
|
$$[$0-3].caseTypes.push($$[$0-1]);
|
||
|
|
this.$ = parser.findCaseType($$[$0-3]);
|
||
|
|
this.$.suggestFilters = $$[$0-1].suggestFilters
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1662:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = parser.findCaseType($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1663:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: [ 'T' ], typeSet: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1664:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = $$[$0-1];
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1665:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { types: [ 'T' ] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1668:
|
||
|
|
this.$ = { caseTypes: [ $$[$0] ], lastType: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 1669:
|
||
|
|
|
||
|
|
$$[$0-1].caseTypes.push($$[$0]);
|
||
|
|
this.$ = { caseTypes: $$[$0-1].caseTypes, lastType: $$[$0] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1673:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], ['WHEN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1676:
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1677:
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0-1].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1678:
|
||
|
|
this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0-2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1679: case 1680:
|
||
|
|
this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1681:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1682:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [$$[$0]] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1683:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1684:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1685: case 1687:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1686:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['THEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1688:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { caseTypes: [$$[$0]], suggestFilters: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1689:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-1], ['THEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1690:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-2], ['THEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1691: case 1692: case 1693: case 1694:
|
||
|
|
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1703: case 1704:
|
||
|
|
|
||
|
|
this.$ = { cursorAtStart : false, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1712: case 2135:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1714:
|
||
|
|
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1731:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'INDEX', 'SCHEMA', 'TABLE', 'VIEW']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1732: case 1734:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-3], [ { name: $$[$0-3] } ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1733:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1735:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestDatabases();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1736:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-1], [ { name: $$[$0-1] } ]);
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['SET DBPROPERTIES', 'SET LOCATION', 'SET OWNER']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1737:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]);
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DBPROPERTIES', 'LOCATION', 'OWNER']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1738: case 2032:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1739:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-3], [ { name: $$[$0-3] } ]);
|
||
|
|
parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1740:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-3], [ { name: $$[$0-3] } ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1742: case 1825: case 2375: case 2748: case 3072: case 3282: case 3298: case 3300:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ON']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1746:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['PARTITION', 'REBUILD']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['REBUILD']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1767:
|
||
|
|
|
||
|
|
if (!$$[$0-1] && parser.isImpala()) {
|
||
|
|
parser.suggestKeywords([{ value: 'IF NOT EXISTS', weight: 4 }, { value: 'COLUMNS', weight: 3 }, { value: 'PARTITION', weight: 2 }, { value: 'RANGE PARTITION', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-1] && parser.isHive()) {
|
||
|
|
parser.suggestKeywords([{ value: 'IF NOT EXISTS', weight: 3 }, { value: 'COLUMNS', weight: 2 }, { value: 'CONSTRAINT', weight: 1 }, { value: 'PARTITION', weight: 1 }]);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords([{ value: 'PARTITION', weight: 2 }, { value: 'RANGE PARTITION', weight: 1 }]);
|
||
|
|
} else if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1768: case 1789: case 2059:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['COLUMNS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1773:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['LOCATION', 'PARTITION']);
|
||
|
|
} else if ($$[$0-2] && $$[$0-2].suggestKeywords) {
|
||
|
|
var keywords = parser.createWeightedKeywords($$[$0-2].suggestKeywords, 2);
|
||
|
|
keywords.push({ value: 'PARTITION', weight: 1 });
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['LOCATION', 'CACHED IN', 'UNCACHED']);
|
||
|
|
} else if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['CACHED IN', 'UNCACHED']);
|
||
|
|
} else if ($$[$0-1] && $$[$0-1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0-1].suggestKeywords);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1775: case 1808: case 1816: case 1828: case 1906: case 1932: case 3354:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1776: case 1933:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['VALUE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1780:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FOREIGN KEY', 'PRIMARY KEY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1787:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['ADD COLUMNS', 'ADD IF NOT EXISTS', 'ADD PARTITION', 'ARCHIVE PARTITION', 'CHANGE',
|
||
|
|
'CLUSTERED BY', 'CONCATENATE', 'COMPACT', 'DISABLE NO_DROP', 'DISABLE OFFLINE', 'DROP', 'ENABLE NO_DROP',
|
||
|
|
'ENABLE OFFLINE', 'EXCHANGE PARTITION', 'NOT SKEWED', 'NOT STORED AS DIRECTORIES', 'PARTITION',
|
||
|
|
'RECOVER PARTITIONS', 'RENAME TO', 'REPLACE COLUMNS', 'SET FILEFORMAT', 'SET LOCATION', 'SET OWNER', 'SET SERDE',
|
||
|
|
'SET SERDEPROPERTIES', 'SET SKEWED LOCATION', 'SET TBLPROPERTIES', 'SKEWED BY', 'TOUCH', 'UNARCHIVE PARTITION']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['ADD COLUMNS', 'ADD PARTITION', 'ADD RANGE PARTITION', 'ALTER', 'ALTER COLUMN', 'CHANGE',
|
||
|
|
'DROP COLUMN', 'DROP PARTITION', 'DROP RANGE PARTITION', 'PARTITION', 'RECOVER PARTITIONS', 'RENAME TO',
|
||
|
|
'REPLACE COLUMNS', 'SET CACHED IN', 'SET COLUMN STATS', 'SET FILEFORMAT', 'SET LOCATION', 'SET ROW FORMAT',
|
||
|
|
'SET SERDEPROPERTIES', 'SET TBLPROPERTIES', 'SET UNCACHED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1788:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['ADD COLUMNS', 'CHANGE', 'COMPACT', 'CONCATENATE', 'DISABLE NO_DROP', 'DISABLE OFFLINE',
|
||
|
|
'ENABLE NO_DROP', 'ENABLE OFFLINE', 'RENAME TO PARTITION', 'REPLACE COLUMNS', 'SET FILEFORMAT', 'SET LOCATION',
|
||
|
|
'SET SERDE', 'SET SERDEPROPERTIES']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['SET CACHED IN', 'SET FILEFORMAT', 'SET LOCATION', 'SET ROW FORMAT',
|
||
|
|
'SET SERDEPROPERTIES', 'SET TBLPROPERTIES', 'SET UNCACHED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1790:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['FILEFORMAT', 'LOCATION', 'SERDE', 'SERDEPROPERTIES']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['CACHED IN', 'FILEFORMAT', 'LOCATION', 'ROW FORMAT', 'SERDEPROPERTIES','TBLPROPERTIES', 'UNCACHED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1791:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['FILEFORMAT', 'LOCATION', 'OWNER', 'SERDE', 'SERDEPROPERTIES', 'SKEWED LOCATION', 'TBLPROPERTIES']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['CACHED IN', 'COLUMN STATS', 'FILEFORMAT', 'LOCATION', 'ROW FORMAT', 'SERDEPROPERTIES', 'TBLPROPERTIES', 'UNCACHED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1793: case 2020: case 2806: case 2822:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TO']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1795: case 1817: case 2308:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['PARTITIONS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1812:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['SKEWED', 'STORED AS DIRECTORIES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1813: case 2009:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['AS DIRECTORIES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1814: case 2010:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DIRECTORIES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1815:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TO PARTITION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1818: case 2486: case 2505:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['LOCATION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1821: case 2802: case 2807: case 2811: case 2878: case 2879: case 2880: case 2913: case 2921: case 2924: case 2927: case 2932: case 2935:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1826:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['STORED AS DIRECTORIES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1830: case 1837: case 1871: case 1874: case 1876:
|
||
|
|
|
||
|
|
parser.addColumnLocation($$[$0-3].location, [ $$[$0-3].identifier ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1831:
|
||
|
|
|
||
|
|
parser.addColumnLocation($$[$0-2].location, [ $$[$0-2].identifier ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1832: case 1840: case 1841:
|
||
|
|
|
||
|
|
parser.addColumnLocation($$[$0-1].location, [ $$[$0-1].identifier ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1833:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['COLUMN']);
|
||
|
|
}
|
||
|
|
parser.suggestColumns();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1834:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['DROP DEFAULT', 'SET BLOCK_SIZE', 'SET COMMENT', 'SET COMPRESSION', 'SET DEFAULT',
|
||
|
|
'SET ENCODING']);
|
||
|
|
parser.addColumnLocation($$[$0-1].location, [ $$[$0-1].identifier ]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1835:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['DEFAULT']);
|
||
|
|
parser.addColumnLocation($$[$0-2].location, [ $$[$0-2].identifier ]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1836:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['BLOCK_SIZE', 'COMMENT', 'COMPRESSION', 'DEFAULT', 'ENCODING']);
|
||
|
|
parser.addColumnLocation($$[$0-2].location, [ $$[$0-2].identifier ]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1838: case 2089: case 2730: case 3231: case 3355:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['STATS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1858:
|
||
|
|
|
||
|
|
parser.suggestIdentifiers(['\'avgSize\'', '\'maxSize\'', '\'numDVs\'', '\'numNulls\'']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1873:
|
||
|
|
|
||
|
|
if (parser.isHive() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['COLUMN']);
|
||
|
|
}
|
||
|
|
parser.suggestColumns();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1875:
|
||
|
|
|
||
|
|
if (parser.isHive() && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
if ($$[$0-3].suggestKeywords) {
|
||
|
|
var keywords = parser.createWeightedKeywords($$[$0-3].suggestKeywords, 3);
|
||
|
|
keywords = keywords.concat([{ value: 'AFTER', weight: 2 }, { value: 'FIRST', weight: 2 }, { value: 'CASCADE', weight: 1 }, { value: 'RESTRICT', weight: 1 }]);
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords([{ value: 'AFTER', weight: 2 }, { value: 'FIRST', weight: 2 }, { value: 'CASCADE', weight: 1 }, { value: 'RESTRICT', weight: 1 }]);
|
||
|
|
}
|
||
|
|
} else if (parser.isHive() && $$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['CASCADE', 'RESTRICT']);
|
||
|
|
}
|
||
|
|
parser.addColumnLocation($$[$0-4].location, [ $$[$0-4].identifier ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1877:
|
||
|
|
|
||
|
|
if (!$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['AND WAIT', 'WITH OVERWRITE TBLPROPERTIES']);
|
||
|
|
} else if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['WITH OVERWRITE TBLPROPERTIES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1880:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['NO_DROP', 'OFFLINE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1882: case 2394:
|
||
|
|
|
||
|
|
parser.suggestFileFormats();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1885:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['WITH REPLICATION =']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1887:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['FORMAT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1888: case 3018:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DELIMITED']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1891:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['WITH SERDEPROPERTIES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1895:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['WAIT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1898:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OVERWRITE TBLPROPERTIES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1899:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TBLPROPERTIES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1902:
|
||
|
|
|
||
|
|
if (parser.isHive() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['CASCADE', 'RESTRICT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1907:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['WITH TABLE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1908: case 2027: case 2041: case 2598: case 2622: case 2762: case 3152: case 3161: case 3286:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1926:
|
||
|
|
|
||
|
|
parser.addColumnLocation($$[$0].location, [ $$[$0].identifier ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1927:
|
||
|
|
|
||
|
|
if (parser.isHive() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'CONSTRAINT', weight: 1}, { value: 'PARTITION', weight: 1}, { value: 'IF EXISTS', weight: 2 }]);
|
||
|
|
} else if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
} else if (parser.isImpala() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'COLUMN', weight: 1 }, { value: 'PARTITION', weight: 1 }, { value: 'RANGE PARTITION', weight: 1 }, { value: 'IF EXISTS', weight: 2 }]);
|
||
|
|
parser.suggestColumns();
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PARTITION', 'RANGE PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1929:
|
||
|
|
|
||
|
|
if (parser.isHive() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['PURGE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1940: case 2043: case 2739:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestTables) {
|
||
|
|
parser.yy.result.suggestTables.onlyTables = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1941: case 2028: case 2042:
|
||
|
|
|
||
|
|
parser.suggestTables({ onlyTables: true });
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1966:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['CASCADE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1974: case 1975: case 1976:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 1992:
|
||
|
|
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['LOCATION'] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2016:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['AS', 'SET TBLPROPERTIES']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['AS', 'RENAME TO']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['AS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2017:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['TBLPROPERTIES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2023: case 2029: case 2760:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestTables) {
|
||
|
|
parser.yy.result.suggestTables.onlyViews = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2024:
|
||
|
|
|
||
|
|
parser.suggestTables({ onlyViews: true });
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2026:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['REPAIR TABLE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2031: case 2497: case 2708:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FUNCTION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2033:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ON DATABASE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2034:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DATABASE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2036:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-1], [ { name: $$[$0-1] } ]);
|
||
|
|
parser.suggestKeywords(['IS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2037:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]);
|
||
|
|
parser.suggestKeywords(['NULL']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2040:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-6]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2045:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'PARTITION', weight: 2 }, { value: 'COMPUTE STATISTICS', weight: 1 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['COMPUTE STATISTICS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2046:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
parser.suggestKeywords(['STATISTICS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2047:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-7]);
|
||
|
|
parser.suggestKeywords(parser.getKeywordsForOptionalsLR([$$[$0-2], $$[$0-1], $$[$0]], [{ value: 'FOR COLUMNS', weight: 3 }, { value: 'CACHE METADATA', weight: 2 }, { value: 'NOSCAN', weight: 1 }]));
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2048:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-7]);
|
||
|
|
parser.suggestKeywords(parser.getKeywordsForOptionalsLR([$$[$0-1], $$[$0]], [{ value: 'CACHE METADATA', weight: 2 }, { value: 'NOSCAN', weight: 1 }]));
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2049:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-7]);
|
||
|
|
parser.suggestKeywords(parser.getKeywordsForOptionalsLR([$$[$0]], [{ value: 'NOSCAN', weight: 1 }]));
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2050:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2051:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
parser.addTablePrimary($$[$0-6]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2063: case 2075:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['METADATA']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2068:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
parser.suggestKeywords(['FUNCTIONS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2070: case 3124: case 3264:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2078:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
parser.suggestKeywords(['METADATA']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2081:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['STATS', 'INCREMENTAL STATS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2084:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['STATS', 'INCREMENTAL STATS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2085:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['TABLESAMPLE']);
|
||
|
|
} else if ($$[$0-1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0-1].suggestKeywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2088: case 2729:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['INCREMENTAL']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2090:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['STATS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2093:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2108:
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
} else if (parser.isHive()) {
|
||
|
|
if ($$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL TABLE', 'FUNCTION', 'MACRO', 'TABLE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'EXTERNAL TABLE', 'FUNCTION', 'INDEX', 'ROLE', 'SCHEMA', 'TABLE', 'TEMPORARY EXTERNAL TABLE', 'TEMPORARY FUNCTION', 'TEMPORARY MACRO', 'TEMPORARY TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['AGGREGATE FUNCTION', 'DATABASE', 'EXTERNAL TABLE', 'FUNCTION', 'ROLE', 'SCHEMA', 'TABLE', 'VIEW']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'ROLE', 'SCHEMA', 'TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2111:
|
||
|
|
|
||
|
|
var keywords = [];
|
||
|
|
if (!$$[$0] && parser.isHive()) {
|
||
|
|
keywords.push('WITH DBPROPERTIES');
|
||
|
|
}
|
||
|
|
if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
keywords.push('LOCATION');
|
||
|
|
}
|
||
|
|
if (!$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
keywords.push('COMMENT');
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2126:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DBPROPERTIES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2149:
|
||
|
|
|
||
|
|
var keywords = [];
|
||
|
|
if (!$$[$0-11] && !$$[$0-10] && !$$[$0-9] && !$$[$0-8] && !$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'LIKE', weight: 1 });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push({ value: 'LIKE PARQUET', weight: 1 });
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (!$$[$0-10] && !$$[$0-9] && !$$[$0-8] && !$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'COMMENT', weight: 11 });
|
||
|
|
}
|
||
|
|
if (!$$[$0-9] && !$$[$0-8] && !$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'PARTITIONED BY', weight: 10 });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push({ value: 'PARTITION BY', weight: 10 });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0-8] && !$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'SORT BY', weight: 9 });
|
||
|
|
}
|
||
|
|
if (parser.isHive() && !$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'CLUSTERED BY', weight: 8 });
|
||
|
|
}
|
||
|
|
if (parser.isHive() && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'SKEWED BY', weight: 7 });
|
||
|
|
} else if (parser.isHive() && $$[$0-6] && $$[$0-6].suggestKeywords && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-2]) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-6].suggestKeywords, 7)); // Get the last optional from SKEWED BY
|
||
|
|
}
|
||
|
|
if (!$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'ROW FORMAT', weight: 6 });
|
||
|
|
keywords.push({ value: 'STORED AS', weight: 6 });
|
||
|
|
if (parser.isHive()) {
|
||
|
|
keywords.push({ value: 'STORED BY', weight: 6 });
|
||
|
|
}
|
||
|
|
} else if ($$[$0-5] && $$[$0-5].suggestKeywords && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-5].suggestKeywords, 6));
|
||
|
|
}
|
||
|
|
if ((($$[$0-5] && $$[$0-5].storedBy) || parser.isImpala()) && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'WITH SERDEPROPERTIES', weight: 5 });
|
||
|
|
}
|
||
|
|
if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'LOCATION', weight: 4 });
|
||
|
|
}
|
||
|
|
if (!$$[$0-2] && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'TBLPROPERTIES', weight: 3 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'CACHED IN', weight: 2 }, { value: 'UNCACHED', weight: 2 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && $$[$0-1] && $$[$0-1].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2));
|
||
|
|
}
|
||
|
|
keywords.push({ value: 'AS', weight: 1 });
|
||
|
|
}
|
||
|
|
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2159:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PARQUET']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2165:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PRIMARY KEY']);
|
||
|
|
} else if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords([{ value: 'PRIMARY KEY', weight: 2 }, { value: 'CONSTRAINT', weight: 1 }]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2172: case 2174: case 2367:
|
||
|
|
|
||
|
|
parser.checkForKeywords($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2173: case 2175:
|
||
|
|
|
||
|
|
parser.checkForKeywords($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2176:
|
||
|
|
|
||
|
|
this.$ = $$[$0-2];
|
||
|
|
var keywords = [];
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
if (!$$[$0]['primary']) {
|
||
|
|
keywords.push('PRIMARY KEY');
|
||
|
|
}
|
||
|
|
if (!$$[$0]['encoding']) {
|
||
|
|
keywords.push('ENCODING');
|
||
|
|
}
|
||
|
|
if (!$$[$0]['compression']) {
|
||
|
|
keywords.push('COMPRESSION');
|
||
|
|
}
|
||
|
|
if (!$$[$0]['default']) {
|
||
|
|
keywords.push('DEFAULT');
|
||
|
|
}
|
||
|
|
if (!$$[$0]['block_size']) {
|
||
|
|
keywords.push('BLOCK_SIZE');
|
||
|
|
}
|
||
|
|
if (!$$[$0]['null']) {
|
||
|
|
keywords.push('NOT NULL');
|
||
|
|
keywords.push('NULL');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!$$[$0]['comment']) {
|
||
|
|
keywords.push('COMMENT');
|
||
|
|
if (parser.isHive() && $$[$0-1].toLowerCase() === 'double') {
|
||
|
|
keywords.push({ value: 'PRECISION', weight: 2 });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
this.$.suggestKeywords = keywords;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2177: case 2213: case 2219: case 2220: case 2233: case 2236: case 2248: case 2250: case 2648:
|
||
|
|
|
||
|
|
parser.suggestKeywords(parser.getColumnDataTypeKeywords());
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2182:
|
||
|
|
|
||
|
|
this.$ = {};
|
||
|
|
this.$[$$[$0]] = true;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2183:
|
||
|
|
|
||
|
|
$$[$0-1][$$[$0]] = true;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2188:
|
||
|
|
this.$ = 'primary';
|
||
|
|
break;
|
||
|
|
case 2189:
|
||
|
|
this.$ = 'encoding';
|
||
|
|
break;
|
||
|
|
case 2190:
|
||
|
|
this.$ = 'compression';
|
||
|
|
break;
|
||
|
|
case 2191:
|
||
|
|
this.$ = 'default';
|
||
|
|
break;
|
||
|
|
case 2192:
|
||
|
|
this.$ = 'block_size';
|
||
|
|
break;
|
||
|
|
case 2193: case 2194:
|
||
|
|
this.$ = 'null';
|
||
|
|
break;
|
||
|
|
case 2195:
|
||
|
|
this.$ = 'comment';
|
||
|
|
break;
|
||
|
|
case 2197:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['NULL']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2218: case 2532: case 2543: case 2566:
|
||
|
|
|
||
|
|
parser.suggestKeywords(parser.getTypeKeywords());
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2232: case 2235:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['COMMENT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2260:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['CONSTRAINT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2261: case 2264:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FOREIGN KEY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2266:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['PRIMARY KEY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2270:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DISABLE NOVALIDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2271:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['NOVALIDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2273: case 3159: case 3166: case 3173:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-4]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2274: case 2291: case 2293:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['KEY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2276:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['REFERENCES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2280:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
parser.suggestKeywords(['DISABLE NOVALIDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2281:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
parser.suggestKeywords(['NOVALIDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2282:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-5]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['NORELY', 'RELY']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2304:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['HASH', 'RANGE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2316: case 2321: case 2322:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2329:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['VALUE', 'VALUES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2331: case 2636: case 3068:
|
||
|
|
|
||
|
|
parser.suggestFunctions();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2332:
|
||
|
|
|
||
|
|
if ($$[$0].endsWithLessThanOrEqual && parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2333: case 2336: case 2339:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['<', '<=']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2334:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2337: case 2340:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2350:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'INTO', weight: 1 }, { value: 'SORTED BY', weight: 2 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['INTO']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2351:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['BUCKETS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2372:
|
||
|
|
this.$ = { suggestKeywords: ['STORED AS DIRECTORIES'] };
|
||
|
|
break;
|
||
|
|
case 2382:
|
||
|
|
|
||
|
|
this.$ = parser.mergeSuggestKeywords($$[$0-1], $$[$0])
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2383:
|
||
|
|
|
||
|
|
this.$ = { storedBy: true }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2384:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['AS', 'BY']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['AS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2386:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FORMAT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2387:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DELIMITED', 'SERDE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['DELIMITED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2391:
|
||
|
|
this.$ = { suggestKeywords: ['STORED AS'] };
|
||
|
|
break;
|
||
|
|
case 2416:
|
||
|
|
|
||
|
|
if (!$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'FIELDS TERMINATED BY', weight: 5 }, { value: 'COLLECTION ITEMS TERMINATED BY', weight: 4 }, { value: 'MAP KEYS TERMINATED BY', weight: 3 }, { value: 'LINES TERMINATED BY', weight: 2 }, { value: 'NULL DEFINED AS', weight: 1 }]};
|
||
|
|
} else if ($$[$0-4] && $$[$0-4].suggestKeywords && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: parser.createWeightedKeywords($$[$0-4].suggestKeywords, 5).concat([{ value: 'COLLECTION ITEMS TERMINATED BY', weight: 4 }, { value: 'MAP KEYS TERMINATED BY', weight: 3 }, { value: 'LINES TERMINATED BY', weight: 2 }, { value: 'NULL DEFINED AS', weight: 1 }]) };
|
||
|
|
} else if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'COLLECTION ITEMS TERMINATED BY', weight: 4 }, { value: 'MAP KEYS TERMINATED BY', weight: 3 }, { value: 'LINES TERMINATED BY', weight: 2 }, { value: 'NULL DEFINED AS', weight: 1 }] };
|
||
|
|
} else if (!$$[$0-2] && !$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'MAP KEYS TERMINATED BY', weight: 3 }, { value: 'LINES TERMINATED BY', weight: 2 }, { value: 'NULL DEFINED AS', weight: 1 }] };
|
||
|
|
} else if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'LINES TERMINATED BY', weight: 2 }, { value: 'NULL DEFINED AS', weight: 1 }] };
|
||
|
|
} else if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'NULL DEFINED AS', weight: 1 }] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2422:
|
||
|
|
|
||
|
|
if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'FIELDS TERMINATED BY', weight: 2 }, { value: 'LINES TERMINATED BY', weight: 1 }] };
|
||
|
|
} else if ($$[$0-1] && $$[$0-1].suggestKeywords && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2).concat(['LINES TERMINATED BY']) };
|
||
|
|
} else if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'LINES TERMINATED BY', weight: 1 }] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2426:
|
||
|
|
this.$ = { suggestKeywords: ['ESCAPED BY'] };
|
||
|
|
break;
|
||
|
|
case 2428: case 2434: case 2439: case 2443:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TERMINATED BY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2433:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ITEMS TERMINATED BY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2438:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['KEYS TERMINATED BY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2447:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DEFINED AS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2453: case 2454:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['SERDEPROPERTIES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2464:
|
||
|
|
|
||
|
|
parser.commitLocations();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2466: case 2483: case 2499:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2467:
|
||
|
|
|
||
|
|
if (!$$[$0-7]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2470:
|
||
|
|
|
||
|
|
var keywords = [{value: 'AS', weight: 1 }];
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
if (parser.isHive()) {
|
||
|
|
keywords.push({ value: 'TBLPROPERTIES', weight: 2 });
|
||
|
|
}
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
keywords.push({ value: 'COMMENT', weight: 3 });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2484:
|
||
|
|
|
||
|
|
if (!$$[$0-6]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2485: case 2504:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['RETURNS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2487:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['SYMBOL']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2498:
|
||
|
|
|
||
|
|
if (!$$[$0-13]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2506:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{value: 'INIT_FN', weight: 2 }, {value: 'UPDATE_FN', weight: 1 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords([{value: 'UPDATE_FN', weight: 1 }]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2507:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['MERGE_FN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2508:
|
||
|
|
|
||
|
|
if (!$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{value: 'PREPARE_FN', weight: 5 }, {value: 'CLOSE_FN', weight: 4 }, {value: 'SERIALIZE_FN', weight: 3 }, {value: 'FINALIZE_FN', weight: 2 }, {value: 'INTERMEDIATE', weight: 1 }]);
|
||
|
|
} else if ($$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{value: 'CLOSE_FN', weight: 4 }, {value: 'SERIALIZE_FN', weight: 3 }, {value: 'FINALIZE_FN', weight: 2 }, {value: 'INTERMEDIATE', weight: 1 }]);
|
||
|
|
} else if ($$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{value: 'SERIALIZE_FN', weight: 3 }, {value: 'FINALIZE_FN', weight: 2 }, {value: 'INTERMEDIATE', weight: 1 }]);
|
||
|
|
} else if ($$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{value: 'FINALIZE_FN', weight: 2 }, {value: 'INTERMEDIATE', weight: 1 }]);
|
||
|
|
} else if ($$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{value: 'INTERMEDIATE', weight: 1 }]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2527:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['USING']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['ARCHIVE', 'FILE', 'JAR']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2533:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['...']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2568:
|
||
|
|
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2571:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ARCHIVE', 'FILE', 'JAR']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2583:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['COMMENT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2587: case 2589:
|
||
|
|
this.$ = $$[$0-3];
|
||
|
|
break;
|
||
|
|
case 2597:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ON TABLE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2603: case 2613:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['\'BITMAP\'', '\'COMPACT\'']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2611:
|
||
|
|
|
||
|
|
if (!$$[$0-7] && !$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'WITH DEFERRED REBUILD', weight: 7 }, { value: 'IDXPROPERTIES', weight: 6 }, { value: 'IN TABLE', weight: 5 }, { value: 'ROW FORMAT', weight: 4 }, { value: 'STORED AS', weight: 4 }, { value: 'STORED BY', weight: 4 }, { value: 'LOCATION', weight: 3 }, { value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-6] && !$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'IDXPROPERTIES', weight: 6 }, { value: 'IN TABLE', weight: 5 }, { value: 'ROW FORMAT', weight: 4 }, { value: 'STORED AS', weight: 4 }, { value: 'STORED BY', weight: 4 }, { value: 'LOCATION', weight: 3 }, { value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-5] && !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'IN TABLE', weight: 5 }, { value: 'ROW FORMAT', weight: 4 }, { value: 'STORED AS', weight: 4 }, { value: 'STORED BY', weight: 4 }, { value: 'LOCATION', weight: 3 }, { value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'ROW FORMAT', weight: 4 }, { value: 'STORED AS', weight: 4 }, { value: 'STORED BY', weight: 4 }, { value: 'LOCATION', weight: 3 }, { value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]);
|
||
|
|
} else if ($$[$0-4] && $$[$0-4].suggestKeywords && !$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0-4].suggestKeywords, 4).concat([{ value: 'LOCATION', weight: 3 }, { value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]));
|
||
|
|
} else if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'LOCATION', weight: 3 }, { value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-2] && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'TBLPROPERTIES', weight: 2 }, { value: 'COMMENT', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'COMMENT', weight: 1 }]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2616:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DEFERRED REBUILD']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2617:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['REBUILD']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2662: case 2664:
|
||
|
|
|
||
|
|
parser.addCommonTableExpressions($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2688:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'FUNCTION', 'INDEX', 'ROLE', 'SCHEMA', 'TABLE', 'TEMPORARY FUNCTION', 'TEMPORARY MACRO', 'VIEW']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['AGGREGATE FUNCTION', 'DATABASE', 'FUNCTION', 'INCREMENTAL STATS', 'ROLE', 'SCHEMA', 'STATS', 'TABLE', 'VIEW']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['ROLE', 'SCHEMA', 'TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2692:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2693:
|
||
|
|
|
||
|
|
if (parser.isHive() || parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['CASCADE', 'RESTRICT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2695: case 2704: case 2709:
|
||
|
|
|
||
|
|
if (!$$[$0-3]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2702: case 2703:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2706:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['AGGREGATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2716: case 2721: case 2753:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2717:
|
||
|
|
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2728:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
parser.suggestKeywords(['INCREMENTAL']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2734: case 3324:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2738:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestTables({ onlyTables: true });
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2741:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['PURGE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2746:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2752:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FUNCTION', 'MACRO']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2756:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestTables({ onlyViews: true });
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2757:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2763:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
if (parser.isImpala() && !$$[$0-2]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2766:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (parser.isHive() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2768:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (parser.isImpala() && !$$[$0-3]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2771: case 2926: case 2931: case 2934: case 2938: case 2946:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2773:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['WHERE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2777:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
if (parser.isImpala() && !$$[$0-1]) {
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2780:
|
||
|
|
|
||
|
|
var keywords = [{ value: 'FULL JOIN', weight: 1 }, { value: 'FULL OUTER JOIN', weight: 1 }, { value: 'JOIN', weight: 1 }, { value: 'LEFT JOIN', weight: 1 }, { value: 'LEFT OUTER JOIN', weight: 1 }, { value: 'RIGHT JOIN', weight: 1 }, { value: 'RIGHT OUTER JOIN', weight: 1 }, { value: 'INNER JOIN', weight: 1 }, { value: 'LEFT ANTI JOIN', weight: 1 }, { value: 'LEFT SEMI JOIN', weight: 1 }, { value: 'RIGHT ANTI JOIN', weight: 1 }, { value: 'RIGHT SEMI JOIN', weight: 1 }];
|
||
|
|
if (!$$[$0]) {
|
||
|
|
keywords.push({ value: 'WHERE', weight: 3 });
|
||
|
|
}
|
||
|
|
if ($$[$0-2].suggestJoinConditions) {
|
||
|
|
parser.suggestJoinConditions($$[$0-2].suggestJoinConditions);
|
||
|
|
}
|
||
|
|
if ($$[$0-2].suggestJoins) {
|
||
|
|
parser.suggestJoins($$[$0-2].suggestJoins);
|
||
|
|
}
|
||
|
|
if ($$[$0-2].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-2].suggestKeywords, 2));
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2789:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TRANSACTIONS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2798:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'ROLE', 'SELECT', 'UPDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2801:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['ON', 'TO']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['TO']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2804: case 2824: case 2826:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['WITH GRANT OPTION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2809: case 2813:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['WITH ADMIN OPTION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2815: case 2939:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DROP', 'INSERT', 'REFRESH', 'ROLE', 'SELECT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2816:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['TO GROUP']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2817: case 2941: case 3337: case 3338:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['GROUP']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2819: case 2943:
|
||
|
|
|
||
|
|
if ($$[$0-1].isCreate) {
|
||
|
|
parser.suggestKeywords(['ON DATABASE', 'ON SERVER']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['ON DATABASE', 'ON SERVER', 'ON TABLE', 'ON URI']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2820:
|
||
|
|
|
||
|
|
if ($$[$0-2].isCreate) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER', 'TABLE', 'URI']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2823: case 2930: case 2947: case 3287:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ROLE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2830:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DATABASE', 'TABLE']);
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2846:
|
||
|
|
|
||
|
|
if ($$[$0].toUpperCase() === 'ALL') {
|
||
|
|
this.$ = { singleAll: true };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2852: case 2853: case 2854: case 2917:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'SELECT', 'SHOW_DATABASE', 'UPDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2870:
|
||
|
|
this.$ = { isCreate: true };
|
||
|
|
break;
|
||
|
|
case 2892:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['GRANT OPTION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2893: case 2894: case 2898: case 2950:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OPTION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2897:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ADMIN OPTION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2909:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ADMIN OPTION FOR', 'ALL', 'ALL GRANT OPTION FROM', 'ALL PRIVILEGES FROM', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'GRANT OPTION FOR', 'INDEX', 'INSERT', 'LOCK', 'ROLE', 'SELECT', 'UPDATE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2912:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
if ($$[$0-2].singleAll) {
|
||
|
|
parser.suggestKeywords(['FROM', 'GRANT OPTION', 'ON', 'PRIVILEGES FROM']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['FROM', 'ON']);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2915:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OPTION FOR']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2916: case 2929:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FOR']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2920:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['FROM', 'ON']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2923:
|
||
|
|
|
||
|
|
if ($$[$0-1].toUpperCase() === 'ADMIN') {
|
||
|
|
parser.suggestKeywords(['FROM', 'OPTION FOR']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2940:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FROM GROUP']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2944:
|
||
|
|
|
||
|
|
if ($$[$0-2].isCreate) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER', 'TABLE', 'URI']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2961:
|
||
|
|
|
||
|
|
var keywords = [];
|
||
|
|
if ($$[$0-1].suggestKeywords) {
|
||
|
|
keywords = parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2).concat([{ value: 'SELECT', weight: 1}]);
|
||
|
|
} else {
|
||
|
|
keywords = ['SELECT'];
|
||
|
|
}
|
||
|
|
if ($$[$0-1].addValues) {
|
||
|
|
keywords.push({ weight: 1.1, value: 'VALUES' });
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2964:
|
||
|
|
|
||
|
|
if (!$$[$0].keepTables) {
|
||
|
|
delete parser.yy.result.suggestTables;
|
||
|
|
delete parser.yy.result.suggestDatabases;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2968:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['INSERT INTO', 'INSERT OVERWRITE', 'SELECT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2969:
|
||
|
|
|
||
|
|
if ($$[$0-1].cursorAtEnd) {
|
||
|
|
parser.checkForSelectListKeywords($$[$0-1]);
|
||
|
|
var keywords = parser.yy.result.suggestKeywords || [];
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
keywords = keywords.concat($$[$0].suggestKeywords);
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
delete parser.yy.result.suggestTables;
|
||
|
|
delete parser.yy.result.suggestDatabases;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2970:
|
||
|
|
|
||
|
|
if ($$[$0].cursorAtStart) {
|
||
|
|
parser.checkForSelectListKeywords($$[$0-1].tableExpression);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2971:
|
||
|
|
|
||
|
|
$$[$0-2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['PARTITION'] }
|
||
|
|
} else if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['IF NOT EXISTS'] }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2972:
|
||
|
|
|
||
|
|
if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'ROW FORMAT', weight: 2 }, { value: 'STORED AS', weight: 1}] };
|
||
|
|
} else if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['STORED AS'] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2973:
|
||
|
|
|
||
|
|
if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: [{ value: 'ROW FORMAT', weight: 2 }, { value: 'STORED AS', weight: 1}] };
|
||
|
|
} else if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['STORED AS'] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2974:
|
||
|
|
|
||
|
|
$$[$0-2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1] && !$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['PARTITION'], addValues: true };
|
||
|
|
} else if (!$$[$0]) {
|
||
|
|
this.$ = { addValues: true };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2975:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['OVERWRITE', 'INTO']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2976:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['DIRECTORY', 'LOCAL DIRECTORY', 'TABLE']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
this.$ = { keepTables: true }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2977: case 2988:
|
||
|
|
|
||
|
|
this.$ = { keepTables: true }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2978: case 2989: case 2990: case 3052: case 3053:
|
||
|
|
|
||
|
|
$$[$0-2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.owner = 'insert';
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2979: case 3004:
|
||
|
|
|
||
|
|
$$[$0-2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2980:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['DIRECTORY']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 2987:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
this.$ = { keepTables: true }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3000:
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2).concat([{ value: 'SELECT', weight: 1}]));
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3001:
|
||
|
|
|
||
|
|
if ($$[$0-1].cursorAtEnd) {
|
||
|
|
parser.checkForSelectListKeywords($$[$0-1]);
|
||
|
|
var keywords = parser.yy.result.suggestKeywords || [];
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
keywords = keywords.concat($$[$0].suggestKeywords);
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3003:
|
||
|
|
|
||
|
|
$$[$0-3].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3005: case 3042: case 3078:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['INTO']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3006: case 3043: case 3049:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3008:
|
||
|
|
|
||
|
|
$$[$0-1].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3017:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FORMAT DELIMITED']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3020:
|
||
|
|
this.$ = { selectList: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 3021:
|
||
|
|
|
||
|
|
this.$ = $$[$0-1];
|
||
|
|
this.$.cursorAtEnd = true;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3022:
|
||
|
|
|
||
|
|
parser.selectListNoTableSuggest($$[$0], $$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3023:
|
||
|
|
|
||
|
|
var keywords = parser.getSelectListKeywords();
|
||
|
|
if (!$$[$0-2] || $$[$0-2] === 'ALL') {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
}
|
||
|
|
if (!$$[$0-1] && !$$[$0-2]) {
|
||
|
|
keywords.push({ value: 'ALL', weight: 2 });
|
||
|
|
keywords.push({ value: 'DISTINCT', weight: 2 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0-1]) {
|
||
|
|
keywords.push({ value: 'STRAIGHT_JOIN', weight: 1 });
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3031:
|
||
|
|
|
||
|
|
var keywords = $$[$0-2].suggestKeywords && !$$[$0-1] ? parser.createWeightedKeywords($$[$0-2].suggestKeywords, 2) : [];
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
keywords = keywords.concat(['[NOSHUFFLE]', '[SHUFFLE]', 'SELECT', 'VALUES'])
|
||
|
|
} else {
|
||
|
|
keywords = keywords.concat(['SELECT'])
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3041:
|
||
|
|
|
||
|
|
$$[$0-1].owner = 'upsert';
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3044:
|
||
|
|
|
||
|
|
if (!$$[$0-3]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
$$[$0-1].owner = 'upsert';
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3046:
|
||
|
|
|
||
|
|
$$[$0-1].owner = 'upsert';
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.owner = 'upsert';
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3047:
|
||
|
|
|
||
|
|
$$[$0-2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['PARTITION'] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3048:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['INTO', 'OVERWRITE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3050:
|
||
|
|
|
||
|
|
if (!$$[$0-4]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
$$[$0-2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3075:
|
||
|
|
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-1], [{ value: 'WHEN', weight: 2 }]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3077:
|
||
|
|
|
||
|
|
$$[$0-6].alias = $$[$0-4];
|
||
|
|
parser.addTablePrimary($$[$0-6]);
|
||
|
|
if ($$[$0-2].subQuery) {
|
||
|
|
parser.addTablePrimary({ subQueryAlias: $$[$0] });
|
||
|
|
} else {
|
||
|
|
$$[$0-2].alias = $$[$0];
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3079:
|
||
|
|
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
parser.suggestTables();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3081:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['AS T USING']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3082:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
parser.suggestKeywords(['T USING']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3083:
|
||
|
|
|
||
|
|
$$[$0-3].alias = $$[$0-1];
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
parser.suggestKeywords(['USING']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3084:
|
||
|
|
|
||
|
|
$$[$0-4].alias = $$[$0-2];
|
||
|
|
parser.addTablePrimary($$[$0-4]);
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
parser.suggestTables();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3085:
|
||
|
|
|
||
|
|
$$[$0-4].alias = $$[$0-2];
|
||
|
|
parser.addTablePrimary($$[$0-4]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3086:
|
||
|
|
|
||
|
|
$$[$0-5].alias = $$[$0-3];
|
||
|
|
parser.addTablePrimary($$[$0-5]);
|
||
|
|
parser.suggestKeywords(['AS S ON']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3087:
|
||
|
|
|
||
|
|
$$[$0-6].alias = $$[$0-4];
|
||
|
|
parser.addTablePrimary($$[$0-6]);
|
||
|
|
parser.suggestKeywords(['S ON']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3096:
|
||
|
|
|
||
|
|
if ($$[$0].suggestThenKeywords) {
|
||
|
|
parser.suggestKeywords(['DELETE', 'INSERT VALUES', 'UPDATE SET']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3097: case 3099:
|
||
|
|
|
||
|
|
if (!$$[$0-1].notPresent) {
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3098:
|
||
|
|
|
||
|
|
if (!$$[$0-1].notPresent && $$[$0].suggestThenKeywords) {
|
||
|
|
var keywords = [];
|
||
|
|
if (!$$[$0-1].isDelete) {
|
||
|
|
keywords.push('DELETE');
|
||
|
|
}
|
||
|
|
if (!$$[$0-1].isInsert) {
|
||
|
|
keywords.push('INSERT VALUES');
|
||
|
|
}
|
||
|
|
if (!$$[$0-1].isUpdate) {
|
||
|
|
keywords.push('UPDATE SET');
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3100:
|
||
|
|
|
||
|
|
if (!$$[$0-1].notPresent && $$[$0].suggestThenKeywords) {
|
||
|
|
var keywords = [];
|
||
|
|
if (!$$[$0-2].isDelete && !$$[$0-1].isDelete) {
|
||
|
|
keywords.push('DELETE');
|
||
|
|
}
|
||
|
|
if (!$$[$0-2].isInsert && !$$[$0-1].isInsert) {
|
||
|
|
keywords.push('INSERT VALUES');
|
||
|
|
}
|
||
|
|
if (!$$[$0-2].isUpdate && !$$[$0-1].isUpdate) {
|
||
|
|
keywords.push('UPDATE SET');
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3101:
|
||
|
|
this.$ = { notPresent: !!$$[$0-4], isDelete: $$[$0].isDelete, isInsert: $$[$0].isInsert, isUpdate: $$[$0].isUpdate };
|
||
|
|
break;
|
||
|
|
case 3102:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['NOT MATCHED', 'MATCHED']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['MATCHED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3103:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['AND', 'THEN']);
|
||
|
|
} else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0-1], [{ value: 'THEN', weight: 2 }]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3105:
|
||
|
|
this.$ = { suggestThenKeywords: true };
|
||
|
|
break;
|
||
|
|
case 3110:
|
||
|
|
this.$ = { isUpdate: true };
|
||
|
|
break;
|
||
|
|
case 3111:
|
||
|
|
this.$ = { isDelete: true };
|
||
|
|
break;
|
||
|
|
case 3112:
|
||
|
|
this.$ = { isInsert: true };
|
||
|
|
break;
|
||
|
|
case 3113:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['SET']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3117:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DATA LOCAL INPATH', 'DATA INPATH']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['DATA INPATH']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3118:
|
||
|
|
|
||
|
|
if (parser.isHive() && !$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['INPATH', 'LOCAL INPATH']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['INPATH']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3120:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['OVERWRITE INTO TABLE', 'INTO TABLE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['INTO TABLE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3121:
|
||
|
|
|
||
|
|
parser.suggestKeywords([ 'TABLE' ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3139:
|
||
|
|
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL TABLE', 'FROM', 'TABLE']);
|
||
|
|
} else if (!$$[$0].hasExternal) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3140:
|
||
|
|
|
||
|
|
if ($$[$0-1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2).concat(['FROM']));
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3144:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['LOCATION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3145:
|
||
|
|
|
||
|
|
if (!$$[$0-4]) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL TABLE', 'TABLE']);
|
||
|
|
} else if (!$$[$0-4].hasExternal) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3147:
|
||
|
|
|
||
|
|
if ($$[$0-5].suggestKeywords) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0-5].suggestKeywords, 2).concat(['FROM']));
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3150:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { hasExternal: true, suggestKeywords: ['PARTITION'] };
|
||
|
|
} else {
|
||
|
|
this.$ = { hasExternal: true }
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3151:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['PARTITION'] };
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3160: case 3174: case 3175:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-9]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3164:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([{ weight: 2, value: 'PARTITION' }, { weight: 1, value: 'TO' }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords([ 'TO' ]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3167:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-5]);
|
||
|
|
parser.suggestKeywords(['FOR replication()']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3168:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-6]);
|
||
|
|
parser.suggestKeywords(['replication()']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3171:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-5]);
|
||
|
|
if (!$$[$0-4]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3172:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-10]);
|
||
|
|
if (!$$[$0-9]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3188:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'NONE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3211:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['COLUMNS', 'COMPACTIONS', 'CONF', 'CREATE TABLE', 'CURRENT ROLES', 'DATABASES', 'FORMATTED', 'FUNCTIONS', 'GRANT', 'INDEX', 'INDEXES', 'LOCKS', 'PARTITIONS', 'PRINCIPALS', 'ROLE GRANT', 'ROLES', 'SCHEMAS', 'TABLE EXTENDED', 'TABLES', 'TBLPROPERTIES', 'TRANSACTIONS', 'VIEWS']);
|
||
|
|
} else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['AGGREGATE FUNCTIONS', 'ANALYTIC FUNCTIONS', 'COLUMN STATS', 'CREATE TABLE', 'CURRENT ROLES', 'DATABASES', 'FILES IN', 'FUNCTIONS', 'GRANT ROLE', 'PARTITIONS', 'RANGE PARTITIONS', 'ROLE GRANT GROUP', 'ROLES', 'SCHEMAS', 'TABLE STATS', 'TABLES']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['COLUMNS', 'DATABASES', 'TABLES']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3212:
|
||
|
|
|
||
|
|
// ROLES is considered a non-reserved keywords so we can't match it in ShowCurrentRolesStatement_EDIT
|
||
|
|
if ($$[$0].identifierChain && $$[$0].identifierChain.length === 1 && $$[$0].identifierChain[0].name.toLowerCase() === 'roles') {
|
||
|
|
parser.suggestKeywords(['CURRENT']);
|
||
|
|
parser.yy.locations.pop();
|
||
|
|
} else {
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['COLUMN STATS', 'CREATE TABLE', 'FILES IN', 'PARTITIONS', 'RANGE PARTITIONS', 'TABLE STATS']);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3213:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['AGGREGATE FUNCTIONS', 'ANALYTIC FUNCTIONS', 'DATABASES', 'FUNCTIONS', 'SCHEMAS', 'TABLES']);
|
||
|
|
} else if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DATABASES', 'SCHEMAS', 'TABLE EXTENDED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3232: case 3262: case 3322: case 3326: case 3328: case 3356:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3236: case 3237: case 3241: case 3242: case 3301: case 3302:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FROM', 'IN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3238: case 3239: case 3240: case 3285: case 3299:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3247:
|
||
|
|
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['TABLE', 'VIEW']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3248:
|
||
|
|
|
||
|
|
if ($$[$0-1].isView && parser.isImpala()) {
|
||
|
|
parser.suggestTables({ onlyViews: true });
|
||
|
|
} else {
|
||
|
|
parser.suggestTables();
|
||
|
|
}
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3249:
|
||
|
|
|
||
|
|
if (parser.yy.result.suggestTables && $$[$0-1].isView) {
|
||
|
|
parser.yy.result.suggestTables.onlyViews = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3250:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['TABLE', 'VIEW']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3252:
|
||
|
|
this.$ = { isView: true };
|
||
|
|
break;
|
||
|
|
case 3255: case 3256:
|
||
|
|
|
||
|
|
parser.suggestKeywords([ 'ROLES' ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3259: case 3353:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3266:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['IN']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3271: case 3274:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['FUNCTIONS']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3272: case 3275:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['AGGREGATE', 'ANALYTICAL']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3273: case 3362:
|
||
|
|
|
||
|
|
if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['IN', 'LIKE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3276:
|
||
|
|
|
||
|
|
if (!$$[$0-2]) {
|
||
|
|
parser.suggestKeywords([{ value: 'IN', weight: 2 }, { value: 'LIKE', weight: 1 }]);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3284:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ALL', 'TABLE']);
|
||
|
|
parser.suggestTables();
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3304:
|
||
|
|
|
||
|
|
parser.suggestTables({identifierChain: [{name: $$[$0]}]});
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3310:
|
||
|
|
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SCHEMA']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3312:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-1]);
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'PARTITION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3315:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-2]);
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3332: case 3333: case 3334:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['GRANT']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3335: case 3336:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['ROLE', 'USER']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3343: case 3352:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3346:
|
||
|
|
|
||
|
|
if ($$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
} else {
|
||
|
|
parser.suggestKeywords(['FROM', 'IN', 'LIKE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3348:
|
||
|
|
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3349:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3350:
|
||
|
|
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3357:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3364:
|
||
|
|
|
||
|
|
parser.addTablePrimary($$[$0-3]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3369:
|
||
|
|
|
||
|
|
if (!$$[$0-1] && !$$[$0-2]) {
|
||
|
|
parser.suggestKeywords([{ value: 'IN', weight: 2 }, { value: 'FROM', weight: 2 }, { value: 'LIKE', weight: 1 }]);
|
||
|
|
} else if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3373: case 3374:
|
||
|
|
|
||
|
|
parser.addDatabaseLocation(_$[$0], [ { name: $$[$0] } ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3385:
|
||
|
|
|
||
|
|
if (parser.isImpala() && !$$[$0-1] && !$$[$0-2]) {
|
||
|
|
parser.suggestKeywords([{ value: 'FROM', weight: 2 }, { value: 'WHERE', weight: 1 }]);
|
||
|
|
} else if (parser.isImpala() && !$$[$0-1] && $$[$0-2]) {
|
||
|
|
var keywords = [{ value: 'FULL JOIN', weight: 2 }, { value: 'FULL OUTER JOIN', weight: 2 }, { value: 'JOIN', weight: 2 }, { value: 'LEFT JOIN', weight: 2 }, { value: 'LEFT OUTER JOIN', weight: 2 }, { value: 'RIGHT JOIN', weight: 2 }, { value: 'RIGHT OUTER JOIN', weight: 2 }, { value: 'INNER JOIN', weight: 2 }, { value: 'LEFT ANTI JOIN', weight: 2 }, { value: 'LEFT SEMI JOIN', weight: 2 }, { value: 'RIGHT ANTI JOIN', weight: 2 }, { value: 'RIGHT SEMI JOIN', weight: 2 }, { value: 'WHERE', weight: 1 }];
|
||
|
|
if ($$[$0-2].suggestJoinConditions) {
|
||
|
|
parser.suggestJoinConditions($$[$0-2].suggestJoinConditions);
|
||
|
|
}
|
||
|
|
if ($$[$0-2].suggestJoins) {
|
||
|
|
parser.suggestJoins($$[$0-2].suggestJoins);
|
||
|
|
}
|
||
|
|
if ($$[$0-2].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0-2].suggestKeywords, 3));
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
} else if (!$$[$0-1]) {
|
||
|
|
parser.suggestKeywords([ 'WHERE' ]);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3386:
|
||
|
|
|
||
|
|
parser.suggestKeywords([ 'SET' ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3402:
|
||
|
|
|
||
|
|
parser.suggestKeywords([ '=' ]);
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 3413:
|
||
|
|
|
||
|
|
if (! parser.yy.cursorFound) {
|
||
|
|
parser.yy.result.useDatabase = $$[$0];
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
table: [o($V0,$V1,{7:1,4:2}),{1:[3]},o($V2,$V3,{5:3,8:4,9:5,11:7,12:8,13:9,14:10,15:11,16:12,17:354,18:355,20:356,21:357,22:358,23:359,406:361,407:362,408:363,409:364,410:365,411:366,412:367,413:368,414:369,415:370,416:371,417:372,418:373,419:374,420:375,1123:376,1124:377,1125:378,1126:379,1127:380,1128:381,1129:382,571:383,421:388,422:389,423:390,424:391,425:392,426:393,427:394,428:395,429:396,430:397,431:398,432:399,433:400,434:401,1130:402,1131:403,1132:404,1133:405,1134:406,575:407,1137:408,1138:409,1139:410,1140:411,1141:412,573:413,565:414,566:415,810:416,811:417,812:418,813:419,814:420,815:421,816:422,932:427,933:428,934:429,935:430,936:431,937:432,938:433,1142:434,1143:435,1144:436,1145:437,1146:438,1147:439,1148:440,1149:441,1150:442,1256:446,1257:447,1258:448,1259:449,1260:450,1261:451,1262:452,1263:453,1264:454,1265:455,1266:456,1267:457,1268:458,1269:459,1270:460,1271:461,1272:462,1273:463,1274:464,1275:465,1312:466,1135:468,1195:469,1136:470,1196:471,1246:472,567:477,568:478,817:479,818:480,819:481,820:482,821:483,822:484,823:485,807:487,939:488,940:489,941:490,942:491,943:492,438:493,1151:494,1152:495,1153:496,1154:497,1155:498,1156:499,1157:500,1158:501,1276:503,1278:504,1279:505,1280:506,1281:507,1282:508,1283:509,1284:510,1285:511,1286:512,1287:513,1288:514,1289:515,1290:516,1291:517,1292:518,1293:519,1200:520,1197:521,596:522,598:523,1216:525,1234:526,1232:527,828:530,917:531,1060:535,1061:536,1062:537,1063:538,1159:539,1160:540,1215:545,840:548,918:549,1064:550,1065:551,1066:552,1067:553,1161:557,1162:558,1220:561,1217:562,1224:564,1225:565,1222:566,1223:567,2:$V4,19:$V5,24:$V6,26:$V7,28:$V8,30:$V9,32:$Va,33:$Vb,34:$Vc,37:$Vd,38:$Ve,39:$Vf,40:$Vg,42:$Vh,43:$Vi,45:$Vj,46:$Vk,47:$Vl,48:$Vm,49:$Vn,50:$Vo,51:$Vp,52:$Vq,54:$Vr,56:$Vs,58:$Vt,59:$Vu,60:$Vv,61:$Vw,64:$Vx,65:$Vy,66:$Vz,67:$VA,68:$VB,69:$VC,70:$VD,71:$VE,72:$VF,73:$VG,74:$VH,75:$VI,76:$VJ,77:$VK,78:$VL,79:$VM,80:$VN,81:$VO,82:$VP,85:$VQ,86:$VR,87:$VS,88:$VT,89:$VU,90:$VV,91:$VW,92:$VX,93:$VY,95:$VZ,96:$V_,97:$V$,98:$V01,99:$V11,100:$V21,101:$V31,106:$V41,107:$V51,108:$V61,109:$V71,110:$V81,111:$V91,112:$Va1,113:$Vb1,114:$Vc1,115:$Vd1,116:$Ve1,117:$Vf1,118:$Vg1,119:$Vh1,120:$Vi1,121:$Vj1,122:$Vk1,123:$Vl1,124:$Vm1,125:$Vn1,126:$Vo1,128:$Vp1,130:$Vq1,131:$Vr1,132:$Vs1,133:$Vt1,134:$Vu1,135:$Vv1,136:$Vw1,137:$Vx1,138:$Vy1,139:$Vz1,140:$VA1,141:$VB1,142:$VC1,143:$VD1,144:$VE1,145:$VF1,146:$VG1,147:$VH1,148:$VI1,149:$VJ1,150:$VK1,156:$VL1,157:$VM1,158:$VN1,160:$VO1,161:$VP1,163:$VQ1,164:$VR1,165:$VS1,166:$VT1,167:$VU1,168:$VV1,169:$VW1,170:$VX1,171:$VY1,172:$VZ1,173:$V_1,174:$V$1,175:$V02,176:$V12,177:$V22,178:$V32,179:$V42,180:$V52,181:$V62,182:$V72,183:$V82,184:$V92,185:$Va2,186:$Vb2,187:$Vc2,188:$Vd2,189:$Ve2,190:$Vf2,191:$Vg2,192:$Vh2,193:$Vi2,194:$Vj2,195:$Vk2,196:$Vl2,197:$Vm2,198:$Vn2,199:$Vo2,200:$Vp2,201:$Vq2,202:$Vr2,203:$Vs2,204:$Vt2,205:$Vu2,206:$Vv2,207:$Vw2,208:$Vx2,209:$Vy2,210:$Vz2,211:$VA2,212:$VB2,213:$VC2,214:$VD2,215:$VE2,216:$VF2,217:$VG2,218:$VH2,219:$VI2,220:$VJ2,221:$VK2,222:$VL2,223:$VM2,224:$VN2,225:$VO2,226:$VP2,227:$VQ2,228:$VR2,229:$VS2,230:$VT2,231:$VU2,232:$VV2,233:$VW2,234:$VX2,235:$VY2,236:$VZ2,237:$V_2,238:$V$2,239:$V03,240:$V13,241:$V23,242:$V33,243:$V43,244:$V53,245:$V63,246:$V73,247:$V83,248:$V93,249:$Va3,250:$Vb3,251:$Vc3,252:$Vd3,253:$Ve3,254:$Vf3,255:$Vg3,256:$Vh3,257:$Vi3,258:$Vj3,259:$Vk3,260:$Vl3,261:$Vm3,262:$Vn3,263:$Vo3,264:$Vp3,265:$Vq3,266:$Vr3,267:$Vs3,268:$Vt3,269:$Vu3,270:$Vv3,271:$Vw3,272:$Vx3,273:$Vy3,274:$Vz3,275:$VA3,276:$VB3,277:$VC3,278:$VD3,279:$VE3,280:$VF3,281:$VG3,282:$VH3,283:$VI3,284:$VJ3,285:$VK3,286:$VL3,287:$VM3,288:$VN3,289:$VO3,290:$VP3,291:$VQ3,292:$VR3,293:$VS3,294:$VT3,295:$VU3,296:$VV3,297:$VW3,298:$VX3,299:$VY3,300:$VZ3,301:$V_3,302:$V$3,303:$V04,304:$V14,305:$V24,306:$V34,307:$V44,308:$V54,309:$V64,310:$V74,311:$V84,312:$V94,313:$Va4,314:$Vb4,315:$Vc4,316:$Vd4,317:$Ve4,318:$Vf4,319:$Vg4,320:$Vh4,321:$Vi4,322:$Vj4,323:$Vk4,324:$Vl4,325:$Vm4,326:$Vn4,327:$Vo4,328:$Vp4,329:$Vq4,330:$Vr4,331:$Vs4,332:$Vt4,333:$Vu4,334:$Vv4,335:$Vw4,336:$Vx4,337:$Vy4,338:$Vz4,339:$VA4,340:$VB4,341:
|
||
|
|
defaultActions: {13:[2,178],14:[2,179],15:[2,180],16:[2,181],17:[2,182],18:[2,183],19:[2,184],20:[2,185],21:[2,186],22:[2,187],23:[2,188],24:[2,189],25:[2,190],26:[2,191],27:[2,192],28:[2,193],29:[2,194],30:[2,195],31:[2,196],32:[2,197],33:[2,198],34:[2,199],35:[2,200],36:[2,201],37:[2,202],38:[2,203],39:[2,204],40:[2,205],41:[2,206],42:[2,207],43:[2,208],44:[2,209],45:[2,210],46:[2,211],47:[2,212],49:[2,214],50:[2,215],51:[2,216],52:[2,217],53:[2,218],54:[2,219],55:[2,220],56:[2,221],57:[2,222],58:[2,223],59:[2,224],60:[2,225],61:[2,226],62:[2,227],63:[2,228],64:[2,229],65:[2,230],66:[2,231],67:[2,232],68:[2,233],69:[2,234],70:[2,235],71:[2,236],72:[2,237],73:[2,238],74:[2,239],75:[2,240],76:[2,241],77:[2,242],78:[2,243],79:[2,244],80:[2,245],81:[2,246],82:[2,247],83:[2,248],84:[2,249],85:[2,250],86:[2,251],87:[2,252],88:[2,253],89:[2,254],90:[2,255],91:[2,256],92:[2,257],93:[2,258],94:[2,259],95:[2,260],96:[2,261],97:[2,262],98:[2,263],99:[2,264],100:[2,265],101:[2,266],102:[2,267],103:[2,268],104:[2,269],105:[2,270],106:[2,271],107:[2,272],108:[2,273],109:[2,274],110:[2,275],111:[2,276],112:[2,277],113:[2,278],114:[2,279],115:[2,280],116:[2,281],117:[2,282],118:[2,283],119:[2,284],120:[2,285],121:[2,286],122:[2,287],123:[2,288],124:[2,289],125:[2,290],126:[2,291],127:[2,292],128:[2,293],129:[2,294],130:[2,295],131:[2,296],132:[2,297],133:[2,298],134:[2,299],135:[2,300],136:[2,301],137:[2,302],138:[2,303],139:[2,304],140:[2,305],141:[2,306],142:[2,307],143:[2,308],144:[2,309],146:[2,311],147:[2,312],148:[2,313],149:[2,314],150:[2,315],151:[2,316],152:[2,317],153:[2,318],154:[2,319],155:[2,320],156:[2,321],157:[2,322],158:[2,323],159:[2,324],160:[2,325],161:[2,326],162:[2,327],163:[2,328],164:[2,329],165:[2,330],166:[2,331],167:[2,332],168:[2,333],169:[2,334],170:[2,335],171:[2,336],172:[2,337],173:[2,338],174:[2,339],175:[2,340],176:[2,341],177:[2,342],178:[2,343],179:[2,344],180:[2,345],181:[2,346],182:[2,347],183:[2,348],184:[2,349],185:[2,350],186:[2,351],187:[2,352],188:[2,353],189:[2,354],190:[2,355],191:[2,356],192:[2,357],193:[2,358],194:[2,359],195:[2,360],196:[2,361],197:[2,362],198:[2,363],199:[2,364],201:[2,366],202:[2,367],203:[2,368],204:[2,369],205:[2,370],206:[2,371],207:[2,372],208:[2,373],209:[2,374],210:[2,375],211:[2,376],212:[2,377],213:[2,378],214:[2,379],215:[2,380],216:[2,381],217:[2,382],218:[2,383],219:[2,384],220:[2,385],221:[2,386],222:[2,387],223:[2,388],224:[2,389],225:[2,390],226:[2,391],227:[2,392],228:[2,393],229:[2,394],230:[2,395],231:[2,396],232:[2,397],233:[2,398],234:[2,399],235:[2,400],236:[2,401],237:[2,402],238:[2,403],239:[2,404],240:[2,405],241:[2,406],242:[2,407],244:[2,409],245:[2,410],246:[2,411],247:[2,412],248:[2,413],249:[2,414],250:[2,415],251:[2,416],252:[2,417],253:[2,418],254:[2,419],255:[2,420],256:[2,421],257:[2,422],258:[2,423],259:[2,424],260:[2,425],261:[2,426],262:[2,427],263:[2,428],264:[2,429],265:[2,430],266:[2,431],267:[2,432],268:[2,433],269:[2,434],270:[2,435],271:[2,436],272:[2,437],273:[2,438],274:[2,439],275:[2,440],277:[2,442],278:[2,443],279:[2,444],280:[2,445],281:[2,446],282:[2,447],283:[2,448],284:[2,449],285:[2,450],286:[2,451],287:[2,452],288:[2,453],289:[2,454],291:[2,456],292:[2,457],293:[2,458],294:[2,459],295:[2,460],296:[2,461],297:[2,462],298:[2,463],299:[2,464],300:[2,465],301:[2,466],302:[2,467],303:[2,468],304:[2,469],305:[2,470],306:[2,471],307:[2,472],308:[2,473],309:[2,474],310:[2,475],311:[2,476],312:[2,477],313:[2,478],314:[2,479],315:[2,480],316:[2,481],317:[2,482],318:[2,483],319:[2,484],320:[2,485],321:[2,486],322:[2,487],323:[2,488],324:[2,489],325:[2,490],326:[2,491],327:[2,492],328:[2,493],329:[2,494],330:[2,495],331:[2,496],332:[2,497],333:[2,498],334:[2,499],335:[2,500],336:[2,501],337:[2,502],338:[2,503],339:[2,504],340:[2,505],341:[2,506],342:[2,507],343:[2,508],344:[2,509],345:[2,510],346:[2,511],347:[2,512],348:[2,513],349:[2,514],350:[2,515],351:[2,516],352:[2,517],353:[2,518],570:[2,2],572:[2,3],1342:[2,625],1608:[2,1439],1609:[2,1440],1610:[2,1441],1611:[2,1442],1612:[2,1443],1613:[2,1444],1652:[2,1570],1653:[2,1571]
|
||
|
|
parseError: function parseError(str, hash) {
|
||
|
|
if (hash.recoverable) {
|
||
|
|
this.trace(str);
|
||
|
|
} else {
|
||
|
|
var error = new Error(str);
|
||
|
|
error.hash = hash;
|
||
|
|
throw error;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
parse: function parse(input) {
|
||
|
|
var self = this,
|
||
|
|
stack = [0],
|
||
|
|
tstack = [], // token stack
|
||
|
|
vstack = [null], // semantic value stack
|
||
|
|
lstack = [], // location stack
|
||
|
|
table = this.table,
|
||
|
|
yytext = '',
|
||
|
|
yylineno = 0,
|
||
|
|
yyleng = 0,
|
||
|
|
recovering = 0,
|
||
|
|
TERROR = 2,
|
||
|
|
EOF = 1;
|
||
|
|
|
||
|
|
var args = lstack.slice.call(arguments, 1);
|
||
|
|
|
||
|
|
//this.reductionCount = this.shiftCount = 0;
|
||
|
|
|
||
|
|
var lexer = Object.create(this.lexer);
|
||
|
|
var sharedState = { yy: {} };
|
||
|
|
// copy state
|
||
|
|
for (var k in this.yy) {
|
||
|
|
if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
|
||
|
|
sharedState.yy[k] = this.yy[k];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lexer.setInput(input, sharedState.yy);
|
||
|
|
sharedState.yy.lexer = lexer;
|
||
|
|
sharedState.yy.parser = this;
|
||
|
|
if (typeof lexer.yylloc == 'undefined') {
|
||
|
|
lexer.yylloc = {};
|
||
|
|
}
|
||
|
|
var yyloc = lexer.yylloc;
|
||
|
|
lstack.push(yyloc);
|
||
|
|
|
||
|
|
var ranges = lexer.options && lexer.options.ranges;
|
||
|
|
|
||
|
|
if (typeof sharedState.yy.parseError === 'function') {
|
||
|
|
this.parseError = sharedState.yy.parseError;
|
||
|
|
} else {
|
||
|
|
this.parseError = Object.getPrototypeOf(this).parseError;
|
||
|
|
}
|
||
|
|
|
||
|
|
function popStack (n) {
|
||
|
|
stack.length = stack.length - 2 * n;
|
||
|
|
vstack.length = vstack.length - n;
|
||
|
|
lstack.length = lstack.length - n;
|
||
|
|
}
|
||
|
|
|
||
|
|
_token_stack:
|
||
|
|
var lex = function () {
|
||
|
|
var token;
|
||
|
|
token = lexer.lex() || EOF;
|
||
|
|
// if token isn't its numeric value, convert
|
||
|
|
if (typeof token !== 'number') {
|
||
|
|
token = self.symbols_[token] || token;
|
||
|
|
}
|
||
|
|
return token;
|
||
|
|
}
|
||
|
|
|
||
|
|
var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
|
||
|
|
while (true) {
|
||
|
|
// retreive state number from top of stack
|
||
|
|
state = stack[stack.length - 1];
|
||
|
|
|
||
|
|
// use default actions if available
|
||
|
|
if (this.defaultActions[state]) {
|
||
|
|
action = this.defaultActions[state];
|
||
|
|
} else {
|
||
|
|
if (symbol === null || typeof symbol == 'undefined') {
|
||
|
|
symbol = lex();
|
||
|
|
}
|
||
|
|
// read action for current state and first input
|
||
|
|
action = table[state] && table[state][symbol];
|
||
|
|
}
|
||
|
|
|
||
|
|
_handle_error:
|
||
|
|
// handle parse error
|
||
|
|
if (typeof action === 'undefined' || !action.length || !action[0]) {
|
||
|
|
var error_rule_depth;
|
||
|
|
var errStr = '';
|
||
|
|
|
||
|
|
// Return the rule stack depth where the nearest error rule can be found.
|
||
|
|
// Return FALSE when no error recovery rule was found.
|
||
|
|
function locateNearestErrorRecoveryRule(state) {
|
||
|
|
var stack_probe = stack.length - 1;
|
||
|
|
var depth = 0;
|
||
|
|
|
||
|
|
// try to recover from error
|
||
|
|
for(;;) {
|
||
|
|
// check for error recovery rule in this state
|
||
|
|
if ((TERROR.toString()) in table[state]) {
|
||
|
|
return depth;
|
||
|
|
}
|
||
|
|
if (state === 0 || stack_probe < 2) {
|
||
|
|
return false; // No suitable error recovery rule available.
|
||
|
|
}
|
||
|
|
stack_probe -= 2; // popStack(1): [symbol, action]
|
||
|
|
state = stack[stack_probe];
|
||
|
|
++depth;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!recovering) {
|
||
|
|
// first see if there's any chance at hitting an error recovery rule:
|
||
|
|
error_rule_depth = locateNearestErrorRecoveryRule(state);
|
||
|
|
|
||
|
|
// Report error
|
||
|
|
expected = [];
|
||
|
|
for (p in table[state]) {
|
||
|
|
if (this.terminals_[p] && p > TERROR) {
|
||
|
|
expected.push("'"+this.terminals_[p]+"'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (lexer.showPosition) {
|
||
|
|
errStr = 'Parse error on line '+(yylineno+1)+":\n"+lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + (this.terminals_[symbol] || symbol)+ "'";
|
||
|
|
} else {
|
||
|
|
errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " +
|
||
|
|
(symbol == EOF ? "end of input" :
|
||
|
|
("'"+(this.terminals_[symbol] || symbol)+"'"));
|
||
|
|
}
|
||
|
|
this.parseError(errStr, {
|
||
|
|
text: lexer.match,
|
||
|
|
token: this.terminals_[symbol] || symbol,
|
||
|
|
line: lexer.yylineno,
|
||
|
|
loc: yyloc,
|
||
|
|
expected: expected,
|
||
|
|
recoverable: (error_rule_depth !== false)
|
||
|
|
});
|
||
|
|
} else if (preErrorSymbol !== EOF) {
|
||
|
|
error_rule_depth = locateNearestErrorRecoveryRule(state);
|
||
|
|
}
|
||
|
|
|
||
|
|
// just recovered from another error
|
||
|
|
if (recovering == 3) {
|
||
|
|
if (symbol === EOF || preErrorSymbol === EOF) {
|
||
|
|
throw new Error(errStr || 'Parsing halted while starting to recover from another error.');
|
||
|
|
}
|
||
|
|
|
||
|
|
// discard current lookahead and grab another
|
||
|
|
yyleng = lexer.yyleng;
|
||
|
|
yytext = lexer.yytext;
|
||
|
|
yylineno = lexer.yylineno;
|
||
|
|
yyloc = lexer.yylloc;
|
||
|
|
symbol = lex();
|
||
|
|
}
|
||
|
|
|
||
|
|
// try to recover from error
|
||
|
|
if (error_rule_depth === false) {
|
||
|
|
throw new Error(errStr || 'Parsing halted. No suitable error recovery rule available.');
|
||
|
|
}
|
||
|
|
popStack(error_rule_depth);
|
||
|
|
|
||
|
|
preErrorSymbol = (symbol == TERROR ? null : symbol); // save the lookahead token
|
||
|
|
symbol = TERROR; // insert generic error symbol as new lookahead
|
||
|
|
state = stack[stack.length-1];
|
||
|
|
action = table[state] && table[state][TERROR];
|
||
|
|
recovering = 3; // allow 3 real symbols to be shifted before reporting a new error
|
||
|
|
}
|
||
|
|
|
||
|
|
// this shouldn't happen, unless resolve defaults are off
|
||
|
|
if (action[0] instanceof Array && action.length > 1) {
|
||
|
|
throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol);
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (action[0]) {
|
||
|
|
case 1: // shift
|
||
|
|
//this.shiftCount++;
|
||
|
|
|
||
|
|
stack.push(symbol);
|
||
|
|
vstack.push(lexer.yytext);
|
||
|
|
lstack.push(lexer.yylloc);
|
||
|
|
stack.push(action[1]); // push state
|
||
|
|
symbol = null;
|
||
|
|
if (!preErrorSymbol) { // normal execution/no error
|
||
|
|
yyleng = lexer.yyleng;
|
||
|
|
yytext = lexer.yytext;
|
||
|
|
yylineno = lexer.yylineno;
|
||
|
|
yyloc = lexer.yylloc;
|
||
|
|
if (recovering > 0) {
|
||
|
|
recovering--;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// error just occurred, resume old lookahead f/ before error
|
||
|
|
symbol = preErrorSymbol;
|
||
|
|
preErrorSymbol = null;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 2:
|
||
|
|
// reduce
|
||
|
|
//this.reductionCount++;
|
||
|
|
|
||
|
|
len = this.productions_[action[1]][1];
|
||
|
|
|
||
|
|
// perform semantic action
|
||
|
|
yyval.$ = vstack[vstack.length-len]; // default to $$ = $1
|
||
|
|
// default location, uses first token for firsts, last for lasts
|
||
|
|
yyval._$ = {
|
||
|
|
first_line: lstack[lstack.length-(len||1)].first_line,
|
||
|
|
last_line: lstack[lstack.length-1].last_line,
|
||
|
|
first_column: lstack[lstack.length-(len||1)].first_column,
|
||
|
|
last_column: lstack[lstack.length-1].last_column
|
||
|
|
};
|
||
|
|
if (ranges) {
|
||
|
|
yyval._$.range = [lstack[lstack.length-(len||1)].range[0], lstack[lstack.length-1].range[1]];
|
||
|
|
}
|
||
|
|
r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
|
||
|
|
|
||
|
|
if (typeof r !== 'undefined') {
|
||
|
|
return r;
|
||
|
|
}
|
||
|
|
|
||
|
|
// pop off stack
|
||
|
|
if (len) {
|
||
|
|
stack = stack.slice(0,-1*len*2);
|
||
|
|
vstack = vstack.slice(0, -1*len);
|
||
|
|
lstack = lstack.slice(0, -1*len);
|
||
|
|
}
|
||
|
|
|
||
|
|
stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce)
|
||
|
|
vstack.push(yyval.$);
|
||
|
|
lstack.push(yyval._$);
|
||
|
|
// goto new state = table[STATE][NONTERMINAL]
|
||
|
|
newState = table[stack[stack.length-2]][stack[stack.length-1]];
|
||
|
|
stack.push(newState);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 3:
|
||
|
|
// accept
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}};
|
||
|
|
|
||
|
|
|
||
|
|
SqlParseSupport.initSqlParser(parser);/* generated by jison-lex 0.3.4 */
|
||
|
|
var lexer = (function(){
|
||
|
|
var lexer = ({
|
||
|
|
|
||
|
|
EOF:1,
|
||
|
|
|
||
|
|
parseError:function parseError(str, hash) {
|
||
|
|
if (this.yy.parser) {
|
||
|
|
this.yy.parser.parseError(str, hash);
|
||
|
|
} else {
|
||
|
|
throw new Error(str);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
// resets the lexer, sets new input
|
||
|
|
setInput:function (input, yy) {
|
||
|
|
this.yy = yy || this.yy || {};
|
||
|
|
this._input = input;
|
||
|
|
this._more = this._backtrack = this.done = false;
|
||
|
|
this.yylineno = this.yyleng = 0;
|
||
|
|
this.yytext = this.matched = this.match = '';
|
||
|
|
this.conditionStack = ['INITIAL'];
|
||
|
|
this.yylloc = {
|
||
|
|
first_line: 1,
|
||
|
|
first_column: 0,
|
||
|
|
last_line: 1,
|
||
|
|
last_column: 0
|
||
|
|
};
|
||
|
|
if (this.options.ranges) {
|
||
|
|
this.yylloc.range = [0,0];
|
||
|
|
}
|
||
|
|
this.offset = 0;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
// consumes and returns one char from the input
|
||
|
|
input:function () {
|
||
|
|
var ch = this._input[0];
|
||
|
|
this.yytext += ch;
|
||
|
|
this.yyleng++;
|
||
|
|
this.offset++;
|
||
|
|
this.match += ch;
|
||
|
|
this.matched += ch;
|
||
|
|
var lines = ch.match(/(?:\r\n?|\n).*/g);
|
||
|
|
if (lines) {
|
||
|
|
this.yylineno++;
|
||
|
|
this.yylloc.last_line++;
|
||
|
|
} else {
|
||
|
|
this.yylloc.last_column++;
|
||
|
|
}
|
||
|
|
if (this.options.ranges) {
|
||
|
|
this.yylloc.range[1]++;
|
||
|
|
}
|
||
|
|
|
||
|
|
this._input = this._input.slice(1);
|
||
|
|
return ch;
|
||
|
|
},
|
||
|
|
|
||
|
|
// unshifts one char (or a string) into the input
|
||
|
|
unput:function (ch) {
|
||
|
|
var len = ch.length;
|
||
|
|
var lines = ch.split(/(?:\r\n?|\n)/g);
|
||
|
|
|
||
|
|
this._input = ch + this._input;
|
||
|
|
this.yytext = this.yytext.substr(0, this.yytext.length - len);
|
||
|
|
//this.yyleng -= len;
|
||
|
|
this.offset -= len;
|
||
|
|
var oldLines = this.match.split(/(?:\r\n?|\n)/g);
|
||
|
|
this.match = this.match.substr(0, this.match.length - 1);
|
||
|
|
this.matched = this.matched.substr(0, this.matched.length - 1);
|
||
|
|
|
||
|
|
if (lines.length - 1) {
|
||
|
|
this.yylineno -= lines.length - 1;
|
||
|
|
}
|
||
|
|
var r = this.yylloc.range;
|
||
|
|
|
||
|
|
this.yylloc = {
|
||
|
|
first_line: this.yylloc.first_line,
|
||
|
|
last_line: this.yylineno + 1,
|
||
|
|
first_column: this.yylloc.first_column,
|
||
|
|
last_column: lines ?
|
||
|
|
(lines.length === oldLines.length ? this.yylloc.first_column : 0)
|
||
|
|
+ oldLines[oldLines.length - lines.length].length - lines[0].length :
|
||
|
|
this.yylloc.first_column - len
|
||
|
|
};
|
||
|
|
|
||
|
|
if (this.options.ranges) {
|
||
|
|
this.yylloc.range = [r[0], r[0] + this.yyleng - len];
|
||
|
|
}
|
||
|
|
this.yyleng = this.yytext.length;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
// When called from action, caches matched text and appends it on next action
|
||
|
|
more:function () {
|
||
|
|
this._more = true;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
|
||
|
|
reject:function () {
|
||
|
|
if (this.options.backtrack_lexer) {
|
||
|
|
this._backtrack = true;
|
||
|
|
} else {
|
||
|
|
return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
|
||
|
|
text: "",
|
||
|
|
token: null,
|
||
|
|
line: this.yylineno
|
||
|
|
});
|
||
|
|
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
// retain first n characters of the match
|
||
|
|
less:function (n) {
|
||
|
|
this.unput(this.match.slice(n));
|
||
|
|
},
|
||
|
|
|
||
|
|
// displays already matched input, i.e. for error messages
|
||
|
|
pastInput:function () {
|
||
|
|
var past = this.matched.substr(0, this.matched.length - this.match.length);
|
||
|
|
return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
|
||
|
|
},
|
||
|
|
|
||
|
|
// displays upcoming input, i.e. for error messages
|
||
|
|
upcomingInput:function () {
|
||
|
|
var next = this.match;
|
||
|
|
if (next.length < 20) {
|
||
|
|
next += this._input.substr(0, 20-next.length);
|
||
|
|
}
|
||
|
|
return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
|
||
|
|
},
|
||
|
|
|
||
|
|
// displays the character position where the lexing error occurred, i.e. for error messages
|
||
|
|
showPosition:function () {
|
||
|
|
var pre = this.pastInput();
|
||
|
|
var c = new Array(pre.length + 1).join("-");
|
||
|
|
return pre + this.upcomingInput() + "\n" + c + "^";
|
||
|
|
},
|
||
|
|
|
||
|
|
// test the lexed token: return FALSE when not a match, otherwise return token
|
||
|
|
test_match:function (match, indexed_rule) {
|
||
|
|
var token,
|
||
|
|
lines,
|
||
|
|
backup;
|
||
|
|
|
||
|
|
if (this.options.backtrack_lexer) {
|
||
|
|
// save context
|
||
|
|
backup = {
|
||
|
|
yylineno: this.yylineno,
|
||
|
|
yylloc: {
|
||
|
|
first_line: this.yylloc.first_line,
|
||
|
|
last_line: this.last_line,
|
||
|
|
first_column: this.yylloc.first_column,
|
||
|
|
last_column: this.yylloc.last_column
|
||
|
|
},
|
||
|
|
yytext: this.yytext,
|
||
|
|
match: this.match,
|
||
|
|
matches: this.matches,
|
||
|
|
matched: this.matched,
|
||
|
|
yyleng: this.yyleng,
|
||
|
|
offset: this.offset,
|
||
|
|
_more: this._more,
|
||
|
|
_input: this._input,
|
||
|
|
yy: this.yy,
|
||
|
|
conditionStack: this.conditionStack.slice(0),
|
||
|
|
done: this.done
|
||
|
|
};
|
||
|
|
if (this.options.ranges) {
|
||
|
|
backup.yylloc.range = this.yylloc.range.slice(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lines = match[0].match(/(?:\r\n?|\n).*/g);
|
||
|
|
if (lines) {
|
||
|
|
this.yylineno += lines.length;
|
||
|
|
}
|
||
|
|
this.yylloc = {
|
||
|
|
first_line: this.yylloc.last_line,
|
||
|
|
last_line: this.yylineno + 1,
|
||
|
|
first_column: this.yylloc.last_column,
|
||
|
|
last_column: lines ?
|
||
|
|
lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
|
||
|
|
this.yylloc.last_column + match[0].length
|
||
|
|
};
|
||
|
|
this.yytext += match[0];
|
||
|
|
this.match += match[0];
|
||
|
|
this.matches = match;
|
||
|
|
this.yyleng = this.yytext.length;
|
||
|
|
if (this.options.ranges) {
|
||
|
|
this.yylloc.range = [this.offset, this.offset += this.yyleng];
|
||
|
|
}
|
||
|
|
this._more = false;
|
||
|
|
this._backtrack = false;
|
||
|
|
this._input = this._input.slice(match[0].length);
|
||
|
|
this.matched += match[0];
|
||
|
|
token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
|
||
|
|
if (this.done && this._input) {
|
||
|
|
this.done = false;
|
||
|
|
}
|
||
|
|
if (token) {
|
||
|
|
return token;
|
||
|
|
} else if (this._backtrack) {
|
||
|
|
// recover context
|
||
|
|
for (var k in backup) {
|
||
|
|
this[k] = backup[k];
|
||
|
|
}
|
||
|
|
return false; // rule action called reject() implying the next rule should be tested instead.
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
},
|
||
|
|
|
||
|
|
// return next match in input
|
||
|
|
next:function () {
|
||
|
|
if (this.done) {
|
||
|
|
return this.EOF;
|
||
|
|
}
|
||
|
|
if (!this._input) {
|
||
|
|
this.done = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
var token,
|
||
|
|
match,
|
||
|
|
tempMatch,
|
||
|
|
index;
|
||
|
|
if (!this._more) {
|
||
|
|
this.yytext = '';
|
||
|
|
this.match = '';
|
||
|
|
}
|
||
|
|
var rules = this._currentRules();
|
||
|
|
for (var i = 0; i < rules.length; i++) {
|
||
|
|
tempMatch = this._input.match(this.rules[rules[i]]);
|
||
|
|
if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
|
||
|
|
match = tempMatch;
|
||
|
|
index = i;
|
||
|
|
if (this.options.backtrack_lexer) {
|
||
|
|
token = this.test_match(tempMatch, rules[i]);
|
||
|
|
if (token !== false) {
|
||
|
|
return token;
|
||
|
|
} else if (this._backtrack) {
|
||
|
|
match = false;
|
||
|
|
continue; // rule action called reject() implying a rule MISmatch.
|
||
|
|
} else {
|
||
|
|
// else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else if (!this.options.flex) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (match) {
|
||
|
|
token = this.test_match(match, rules[index]);
|
||
|
|
if (token !== false) {
|
||
|
|
return token;
|
||
|
|
}
|
||
|
|
// else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (this._input === "") {
|
||
|
|
return this.EOF;
|
||
|
|
} else {
|
||
|
|
return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
|
||
|
|
text: "",
|
||
|
|
token: null,
|
||
|
|
line: this.yylineno
|
||
|
|
});
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
// return next match that has a token
|
||
|
|
lex:function lex() {
|
||
|
|
var r = this.next();
|
||
|
|
if (r) {
|
||
|
|
return r;
|
||
|
|
} else {
|
||
|
|
return this.lex();
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
|
||
|
|
begin:function begin(condition) {
|
||
|
|
this.conditionStack.push(condition);
|
||
|
|
},
|
||
|
|
|
||
|
|
// pop the previously active lexer condition state off the condition stack
|
||
|
|
popState:function popState() {
|
||
|
|
var n = this.conditionStack.length - 1;
|
||
|
|
if (n > 0) {
|
||
|
|
return this.conditionStack.pop();
|
||
|
|
} else {
|
||
|
|
return this.conditionStack[0];
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
// produce the lexer rule set which is active for the currently active lexer condition state
|
||
|
|
_currentRules:function _currentRules() {
|
||
|
|
if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
|
||
|
|
return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
|
||
|
|
} else {
|
||
|
|
return this.conditions["INITIAL"].rules;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
|
||
|
|
topState:function topState(n) {
|
||
|
|
n = this.conditionStack.length - 1 - Math.abs(n || 0);
|
||
|
|
if (n >= 0) {
|
||
|
|
return this.conditionStack[n];
|
||
|
|
} else {
|
||
|
|
return "INITIAL";
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
// alias for begin(condition)
|
||
|
|
pushState:function pushState(condition) {
|
||
|
|
this.begin(condition);
|
||
|
|
},
|
||
|
|
|
||
|
|
// return the number of states currently on the stack
|
||
|
|
stateStackSize:function stateStackSize() {
|
||
|
|
return this.conditionStack.length;
|
||
|
|
},
|
||
|
|
options: {"case-insensitive":true,"flex":true},
|
||
|
|
performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
|
||
|
|
var YYSTATE=YY_START;
|
||
|
|
switch($avoiding_name_collisions) {
|
||
|
|
case 0: /* skip whitespace */
|
||
|
|
break;
|
||
|
|
case 1: /* skip comments */
|
||
|
|
break;
|
||
|
|
case 2: /* skip comments */
|
||
|
|
break;
|
||
|
|
case 3: parser.yy.partialCursor = false; parser.yy.cursorFound = yy_.yylloc; return 19;
|
||
|
|
break;
|
||
|
|
case 4: parser.yy.partialCursor = true; parser.yy.cursorFound = yy_.yylloc; return 442;
|
||
|
|
break;
|
||
|
|
case 5: return 166;
|
||
|
|
break;
|
||
|
|
case 6: return 286;
|
||
|
|
break;
|
||
|
|
case 7: return 167;
|
||
|
|
break;
|
||
|
|
case 8: return 164;
|
||
|
|
break;
|
||
|
|
case 9: return 168;
|
||
|
|
break;
|
||
|
|
case 10: return 169;
|
||
|
|
break;
|
||
|
|
case 11: return 858;
|
||
|
|
break;
|
||
|
|
case 12: return 171;
|
||
|
|
break;
|
||
|
|
case 13: return 172;
|
||
|
|
break;
|
||
|
|
case 14: parser.determineCase(yy_.yytext); return 440;
|
||
|
|
break;
|
||
|
|
case 15: return 173;
|
||
|
|
break;
|
||
|
|
case 16: return 174;
|
||
|
|
break;
|
||
|
|
case 17: return 175;
|
||
|
|
break;
|
||
|
|
case 18: parser.determineCase(yy_.yytext); return 1164;
|
||
|
|
break;
|
||
|
|
case 19: parser.determineCase(yy_.yytext); return 569;
|
||
|
|
break;
|
||
|
|
case 20: return 165;
|
||
|
|
break;
|
||
|
|
case 21: return 178;
|
||
|
|
break;
|
||
|
|
case 22: return 179;
|
||
|
|
break;
|
||
|
|
case 23: return 180;
|
||
|
|
break;
|
||
|
|
case 24: return 181;
|
||
|
|
break;
|
||
|
|
case 25: return 182;
|
||
|
|
break;
|
||
|
|
case 26: return 183;
|
||
|
|
break;
|
||
|
|
case 27: parser.determineCase(yy_.yytext); return 1252;
|
||
|
|
break;
|
||
|
|
case 28: parser.determineCase(yy_.yytext); return 1188;
|
||
|
|
break;
|
||
|
|
case 29: return 184;
|
||
|
|
break;
|
||
|
|
case 30: return 185;
|
||
|
|
break;
|
||
|
|
case 31: return 187;
|
||
|
|
break;
|
||
|
|
case 32: return 322;
|
||
|
|
break;
|
||
|
|
case 33: return 199;
|
||
|
|
break;
|
||
|
|
case 34: return 200;
|
||
|
|
break;
|
||
|
|
case 35: return 201;
|
||
|
|
break;
|
||
|
|
case 36: return 189;
|
||
|
|
break;
|
||
|
|
case 37: return 190;
|
||
|
|
break;
|
||
|
|
case 38: return 1191;
|
||
|
|
break;
|
||
|
|
case 39: return 191;
|
||
|
|
break;
|
||
|
|
case 40: return 193;
|
||
|
|
break;
|
||
|
|
case 41: return 125;
|
||
|
|
break;
|
||
|
|
case 42: return 132;
|
||
|
|
break;
|
||
|
|
case 43: return 205;
|
||
|
|
break;
|
||
|
|
case 44: return 206;
|
||
|
|
break;
|
||
|
|
case 45: return 955;
|
||
|
|
break;
|
||
|
|
case 46: parser.determineCase(yy_.yytext); return 26;
|
||
|
|
break;
|
||
|
|
case 47: return 27;
|
||
|
|
break;
|
||
|
|
case 48: return 28;
|
||
|
|
break;
|
||
|
|
case 49: return 29;
|
||
|
|
break;
|
||
|
|
case 50: parser.determineCase(yy_.yytext); return 30;
|
||
|
|
break;
|
||
|
|
case 51: return 31;
|
||
|
|
break;
|
||
|
|
case 52: return 194;
|
||
|
|
break;
|
||
|
|
case 53: return 32;
|
||
|
|
break;
|
||
|
|
case 54: return 33;
|
||
|
|
break;
|
||
|
|
case 55: return 34;
|
||
|
|
break;
|
||
|
|
case 56: return 35;
|
||
|
|
break;
|
||
|
|
case 57: return 36;
|
||
|
|
break;
|
||
|
|
case 58: return 170;
|
||
|
|
break;
|
||
|
|
case 59: return 37;
|
||
|
|
break;
|
||
|
|
case 60: return 38;
|
||
|
|
break;
|
||
|
|
case 61: return 39;
|
||
|
|
break;
|
||
|
|
case 62: return 40;
|
||
|
|
break;
|
||
|
|
case 63: return 41;
|
||
|
|
break;
|
||
|
|
case 64: return 42;
|
||
|
|
break;
|
||
|
|
case 65: return 43;
|
||
|
|
break;
|
||
|
|
case 66: return 44;
|
||
|
|
break;
|
||
|
|
case 67: return 45;
|
||
|
|
break;
|
||
|
|
case 68: return 46;
|
||
|
|
break;
|
||
|
|
case 69: return 135;
|
||
|
|
break;
|
||
|
|
case 70: return 370;
|
||
|
|
break;
|
||
|
|
case 71: return 47;
|
||
|
|
break;
|
||
|
|
case 72: return 48;
|
||
|
|
break;
|
||
|
|
case 73: return 49;
|
||
|
|
break;
|
||
|
|
case 74: return 50;
|
||
|
|
break;
|
||
|
|
case 75: return 51;
|
||
|
|
break;
|
||
|
|
case 76: return 195;
|
||
|
|
break;
|
||
|
|
case 77: this.begin('hdfs'); return 52;
|
||
|
|
break;
|
||
|
|
case 78: return 53;
|
||
|
|
break;
|
||
|
|
case 79: return 176;
|
||
|
|
break;
|
||
|
|
case 80: return 54;
|
||
|
|
break;
|
||
|
|
case 81: return 56;
|
||
|
|
break;
|
||
|
|
case 82: return 55;
|
||
|
|
break;
|
||
|
|
case 83: return 57;
|
||
|
|
break;
|
||
|
|
case 84: parser.determineCase(yy_.yytext); return 58;
|
||
|
|
break;
|
||
|
|
case 85: parser.determineCase(yy_.yytext); return 59;
|
||
|
|
break;
|
||
|
|
case 86: return 60;
|
||
|
|
break;
|
||
|
|
case 87: return 61;
|
||
|
|
break;
|
||
|
|
case 88: return 62;
|
||
|
|
break;
|
||
|
|
case 89: return 63;
|
||
|
|
break;
|
||
|
|
case 90: return 64;
|
||
|
|
break;
|
||
|
|
case 91: return 196;
|
||
|
|
break;
|
||
|
|
case 92: return 181;
|
||
|
|
break;
|
||
|
|
case 93: return 65;
|
||
|
|
break;
|
||
|
|
case 94: return 136;
|
||
|
|
break;
|
||
|
|
case 95: return 69;
|
||
|
|
break;
|
||
|
|
case 96: return 197;
|
||
|
|
break;
|
||
|
|
case 97: return 198;
|
||
|
|
break;
|
||
|
|
case 98: this.begin('hdfs'); return 66;
|
||
|
|
break;
|
||
|
|
case 99: return 67;
|
||
|
|
break;
|
||
|
|
case 100: return 70;
|
||
|
|
break;
|
||
|
|
case 101: return 68;
|
||
|
|
break;
|
||
|
|
case 102: return 71;
|
||
|
|
break;
|
||
|
|
case 103: return 72;
|
||
|
|
break;
|
||
|
|
case 104: return 73;
|
||
|
|
break;
|
||
|
|
case 105: parser.determineCase(yy_.yytext); return 74;
|
||
|
|
break;
|
||
|
|
case 106: this.begin('hdfs'); return 75;
|
||
|
|
break;
|
||
|
|
case 107: return 186;
|
||
|
|
break;
|
||
|
|
case 108: return 76;
|
||
|
|
break;
|
||
|
|
case 109: return 77;
|
||
|
|
break;
|
||
|
|
case 110: return 79;
|
||
|
|
break;
|
||
|
|
case 111: return 78;
|
||
|
|
break;
|
||
|
|
case 112: return 137;
|
||
|
|
break;
|
||
|
|
case 113: return 138;
|
||
|
|
break;
|
||
|
|
case 114: return 80;
|
||
|
|
break;
|
||
|
|
case 115: return 99;
|
||
|
|
break;
|
||
|
|
case 116: return 81;
|
||
|
|
break;
|
||
|
|
case 117: return 82;
|
||
|
|
break;
|
||
|
|
case 118: return 83;
|
||
|
|
break;
|
||
|
|
case 119: return 84;
|
||
|
|
break;
|
||
|
|
case 120: return 85;
|
||
|
|
break;
|
||
|
|
case 121: return 86;
|
||
|
|
break;
|
||
|
|
case 122: return 87;
|
||
|
|
break;
|
||
|
|
case 123: this.begin('hdfs'); return 1205;
|
||
|
|
break;
|
||
|
|
case 124: return 88;
|
||
|
|
break;
|
||
|
|
case 125: return 89;
|
||
|
|
break;
|
||
|
|
case 126: return 90;
|
||
|
|
break;
|
||
|
|
case 127: return 91;
|
||
|
|
break;
|
||
|
|
case 128: return 92;
|
||
|
|
break;
|
||
|
|
case 129: return 93;
|
||
|
|
break;
|
||
|
|
case 130: return 94;
|
||
|
|
break;
|
||
|
|
case 131: return 139;
|
||
|
|
break;
|
||
|
|
case 132: return 95;
|
||
|
|
break;
|
||
|
|
case 133: return 96;
|
||
|
|
break;
|
||
|
|
case 134: parser.determineCase(yy_.yytext); return 97;
|
||
|
|
break;
|
||
|
|
case 135: return 98;
|
||
|
|
break;
|
||
|
|
case 136: return 100;
|
||
|
|
break;
|
||
|
|
case 137: return 101;
|
||
|
|
break;
|
||
|
|
case 138: return 102;
|
||
|
|
break;
|
||
|
|
case 139: return 103;
|
||
|
|
break;
|
||
|
|
case 140: return 104;
|
||
|
|
break;
|
||
|
|
case 141: return 105;
|
||
|
|
break;
|
||
|
|
case 142: return 106;
|
||
|
|
break;
|
||
|
|
case 143: return 107;
|
||
|
|
break;
|
||
|
|
case 144: return 140;
|
||
|
|
break;
|
||
|
|
case 145: return 202;
|
||
|
|
break;
|
||
|
|
case 146: return 108;
|
||
|
|
break;
|
||
|
|
case 147: return 109;
|
||
|
|
break;
|
||
|
|
case 148: return 110;
|
||
|
|
break;
|
||
|
|
case 149: return 111;
|
||
|
|
break;
|
||
|
|
case 150: return 112;
|
||
|
|
break;
|
||
|
|
case 151: parser.determineCase(yy_.yytext); return 113;
|
||
|
|
break;
|
||
|
|
case 152: return 192;
|
||
|
|
break;
|
||
|
|
case 153: return 114;
|
||
|
|
break;
|
||
|
|
case 154: return 855;
|
||
|
|
break;
|
||
|
|
case 155: return 655;
|
||
|
|
break;
|
||
|
|
case 156: return 115;
|
||
|
|
break;
|
||
|
|
case 157: return 116;
|
||
|
|
break;
|
||
|
|
case 158: return 117;
|
||
|
|
break;
|
||
|
|
case 159: return 203;
|
||
|
|
break;
|
||
|
|
case 160: return 118;
|
||
|
|
break;
|
||
|
|
case 161: return 119;
|
||
|
|
break;
|
||
|
|
case 162: return 120;
|
||
|
|
break;
|
||
|
|
case 163: return 204;
|
||
|
|
break;
|
||
|
|
case 164: return 121;
|
||
|
|
break;
|
||
|
|
case 165: return 122;
|
||
|
|
break;
|
||
|
|
case 166: return 123;
|
||
|
|
break;
|
||
|
|
case 167: return 124;
|
||
|
|
break;
|
||
|
|
case 168: return 126;
|
||
|
|
break;
|
||
|
|
case 169: return 127;
|
||
|
|
break;
|
||
|
|
case 170: return 128;
|
||
|
|
break;
|
||
|
|
case 171: return 129;
|
||
|
|
break;
|
||
|
|
case 172: return 130;
|
||
|
|
break;
|
||
|
|
case 173: parser.determineCase(yy_.yytext); return 131;
|
||
|
|
break;
|
||
|
|
case 174: return 133;
|
||
|
|
break;
|
||
|
|
case 175: return 134;
|
||
|
|
break;
|
||
|
|
case 176: return 141;
|
||
|
|
break;
|
||
|
|
case 177: return 207;
|
||
|
|
break;
|
||
|
|
case 178: return 142;
|
||
|
|
break;
|
||
|
|
case 179: return 208;
|
||
|
|
break;
|
||
|
|
case 180: return 209;
|
||
|
|
break;
|
||
|
|
case 181: return 210;
|
||
|
|
break;
|
||
|
|
case 182: return 906;
|
||
|
|
break;
|
||
|
|
case 183: return 211;
|
||
|
|
break;
|
||
|
|
case 184: return 212;
|
||
|
|
break;
|
||
|
|
case 185: return 213;
|
||
|
|
break;
|
||
|
|
case 186: return 214;
|
||
|
|
break;
|
||
|
|
case 187: return 904;
|
||
|
|
break;
|
||
|
|
case 188: return 215;
|
||
|
|
break;
|
||
|
|
case 189: return 216;
|
||
|
|
break;
|
||
|
|
case 190: return 896;
|
||
|
|
break;
|
||
|
|
case 191: parser.determineCase(yy_.yytext); return 453;
|
||
|
|
break;
|
||
|
|
case 192: parser.determineCase(yy_.yytext); return 931;
|
||
|
|
break;
|
||
|
|
case 193: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('CREATE', yy_.yylloc, yy.lexer.upcomingInput()); return 441;
|
||
|
|
break;
|
||
|
|
case 194: return 217;
|
||
|
|
break;
|
||
|
|
case 195: return 218;
|
||
|
|
break;
|
||
|
|
case 196: return 219;
|
||
|
|
break;
|
||
|
|
case 197: return 220;
|
||
|
|
break;
|
||
|
|
case 198: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('DESCRIBE', yy_.yylloc); return 570;
|
||
|
|
break;
|
||
|
|
case 199: return 221;
|
||
|
|
break;
|
||
|
|
case 200: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('EXPLAIN', yy_.yylloc); return 163;
|
||
|
|
break;
|
||
|
|
case 201: return 223;
|
||
|
|
break;
|
||
|
|
case 202: return 222;
|
||
|
|
break;
|
||
|
|
case 203: return 224;
|
||
|
|
break;
|
||
|
|
case 204: return 905;
|
||
|
|
break;
|
||
|
|
case 205: return 225;
|
||
|
|
break;
|
||
|
|
case 206: return 226;
|
||
|
|
break;
|
||
|
|
case 207: return 227;
|
||
|
|
break;
|
||
|
|
case 208: return 228;
|
||
|
|
break;
|
||
|
|
case 209: return 229;
|
||
|
|
break;
|
||
|
|
case 210: return 230;
|
||
|
|
break;
|
||
|
|
case 211: return 231;
|
||
|
|
break;
|
||
|
|
case 212: return 232;
|
||
|
|
break;
|
||
|
|
case 213: return 233;
|
||
|
|
break;
|
||
|
|
case 214: return 234;
|
||
|
|
break;
|
||
|
|
case 215: return 235;
|
||
|
|
break;
|
||
|
|
case 216: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('INSERT', yy_.yylloc); return 1190;
|
||
|
|
break;
|
||
|
|
case 217: return 237;
|
||
|
|
break;
|
||
|
|
case 218: return 236;
|
||
|
|
break;
|
||
|
|
case 219: return 238;
|
||
|
|
break;
|
||
|
|
case 220: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('INVALIDATE', yy_.yylloc, yy.lexer.upcomingInput()); return 929;
|
||
|
|
break;
|
||
|
|
case 221: this.begin('hdfs'); return 239;
|
||
|
|
break;
|
||
|
|
case 222: return 240;
|
||
|
|
break;
|
||
|
|
case 223: return 156;
|
||
|
|
break;
|
||
|
|
case 224: return 241;
|
||
|
|
break;
|
||
|
|
case 225: return 242;
|
||
|
|
break;
|
||
|
|
case 226: this.begin('hdfs'); return 973;
|
||
|
|
break;
|
||
|
|
case 227: return 243;
|
||
|
|
break;
|
||
|
|
case 228: return 244;
|
||
|
|
break;
|
||
|
|
case 229: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('LOAD', yy_.yylloc, yy.lexer.upcomingInput()); return 1251;
|
||
|
|
break;
|
||
|
|
case 230: this.begin('hdfs'); return 245;
|
||
|
|
break;
|
||
|
|
case 231: return 246;
|
||
|
|
break;
|
||
|
|
case 232: return 930;
|
||
|
|
break;
|
||
|
|
case 233: return 247;
|
||
|
|
break;
|
||
|
|
case 234: return 662;
|
||
|
|
break;
|
||
|
|
case 235: return 1038;
|
||
|
|
break;
|
||
|
|
case 236: return 1229;
|
||
|
|
break;
|
||
|
|
case 237: return 269;
|
||
|
|
break;
|
||
|
|
case 238: return 270;
|
||
|
|
break;
|
||
|
|
case 239: return 248;
|
||
|
|
break;
|
||
|
|
case 240: return 249;
|
||
|
|
break;
|
||
|
|
case 241: return 250;
|
||
|
|
break;
|
||
|
|
case 242: return 271;
|
||
|
|
break;
|
||
|
|
case 243: return 251;
|
||
|
|
break;
|
||
|
|
case 244: return 252;
|
||
|
|
break;
|
||
|
|
case 245: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('REFRESH', yy_.yylloc); return 928;
|
||
|
|
break;
|
||
|
|
case 246: return 908;
|
||
|
|
break;
|
||
|
|
case 247: return 253;
|
||
|
|
break;
|
||
|
|
case 248: return 761;
|
||
|
|
break;
|
||
|
|
case 249: return 254;
|
||
|
|
break;
|
||
|
|
case 250: return 255;
|
||
|
|
break;
|
||
|
|
case 251: return 256;
|
||
|
|
break;
|
||
|
|
case 252: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('REVOKE', yy_.yylloc); return 1193;
|
||
|
|
break;
|
||
|
|
case 253: return 272;
|
||
|
|
break;
|
||
|
|
case 254: return 273;
|
||
|
|
break;
|
||
|
|
case 255: return 257;
|
||
|
|
break;
|
||
|
|
case 256: return 258;
|
||
|
|
break;
|
||
|
|
case 257: return 150;
|
||
|
|
break;
|
||
|
|
case 258: return 259;
|
||
|
|
break;
|
||
|
|
case 259: return 260;
|
||
|
|
break;
|
||
|
|
case 260: return 275;
|
||
|
|
break;
|
||
|
|
case 261: return 261;
|
||
|
|
break;
|
||
|
|
case 262: return 262;
|
||
|
|
break;
|
||
|
|
case 263: return 263;
|
||
|
|
break;
|
||
|
|
case 264: return 264;
|
||
|
|
break;
|
||
|
|
case 265: return 265;
|
||
|
|
break;
|
||
|
|
case 266: return 276;
|
||
|
|
break;
|
||
|
|
case 267: return 277;
|
||
|
|
break;
|
||
|
|
case 268: return 278;
|
||
|
|
break;
|
||
|
|
case 269: return 544;
|
||
|
|
break;
|
||
|
|
case 270: return 279;
|
||
|
|
break;
|
||
|
|
case 271: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('UPSERT', yy_.yylloc); return 1226;
|
||
|
|
break;
|
||
|
|
case 272: return 149;
|
||
|
|
break;
|
||
|
|
case 273: return 266;
|
||
|
|
break;
|
||
|
|
case 274: return 831;
|
||
|
|
break;
|
||
|
|
case 275: return 143;
|
||
|
|
break;
|
||
|
|
case 276: return 267;
|
||
|
|
break;
|
||
|
|
case 277: return 286;
|
||
|
|
break;
|
||
|
|
case 278: return 152;
|
||
|
|
break;
|
||
|
|
case 279: return 153;
|
||
|
|
break;
|
||
|
|
case 280: return 144;
|
||
|
|
break;
|
||
|
|
case 281: return 154;
|
||
|
|
break;
|
||
|
|
case 282: return 155;
|
||
|
|
break;
|
||
|
|
case 283: return 145;
|
||
|
|
break;
|
||
|
|
case 284: return 322;
|
||
|
|
break;
|
||
|
|
case 285: return 146;
|
||
|
|
break;
|
||
|
|
case 286: return 147;
|
||
|
|
break;
|
||
|
|
case 287: return 148;
|
||
|
|
break;
|
||
|
|
case 288: return 119;
|
||
|
|
break;
|
||
|
|
case 289: return 151;
|
||
|
|
break;
|
||
|
|
case 290: return 280;
|
||
|
|
break;
|
||
|
|
case 291: return 268;
|
||
|
|
break;
|
||
|
|
case 292: return 274;
|
||
|
|
break;
|
||
|
|
case 293: return 281;
|
||
|
|
break;
|
||
|
|
case 294: return 282;
|
||
|
|
break;
|
||
|
|
case 295: return 283;
|
||
|
|
break;
|
||
|
|
case 296: return 284;
|
||
|
|
break;
|
||
|
|
case 297: this.popState(); return 667;
|
||
|
|
break;
|
||
|
|
case 298: return 285;
|
||
|
|
break;
|
||
|
|
case 299: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('ALTER', yy_.yylloc, yy.lexer.upcomingInput()); return 824;
|
||
|
|
break;
|
||
|
|
case 300: return 386;
|
||
|
|
break;
|
||
|
|
case 301: return 287;
|
||
|
|
break;
|
||
|
|
case 302: return 288;
|
||
|
|
break;
|
||
|
|
case 303: this.begin('between'); return 289;
|
||
|
|
break;
|
||
|
|
case 304: return 290;
|
||
|
|
break;
|
||
|
|
case 305: return 291;
|
||
|
|
break;
|
||
|
|
case 306: return 292;
|
||
|
|
break;
|
||
|
|
case 307: return 293;
|
||
|
|
break;
|
||
|
|
case 308: return 294;
|
||
|
|
break;
|
||
|
|
case 309: parser.determineCase(yy_.yytext); return 439;
|
||
|
|
break;
|
||
|
|
case 310: return 295;
|
||
|
|
break;
|
||
|
|
case 311: return 296;
|
||
|
|
break;
|
||
|
|
case 312: return 297;
|
||
|
|
break;
|
||
|
|
case 313: return 298;
|
||
|
|
break;
|
||
|
|
case 314: return 299;
|
||
|
|
break;
|
||
|
|
case 315: return 394;
|
||
|
|
break;
|
||
|
|
case 316: return 300;
|
||
|
|
break;
|
||
|
|
case 317: return 301;
|
||
|
|
break;
|
||
|
|
case 318: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('DROP', yy_.yylloc, yy.lexer.upcomingInput()); return 866;
|
||
|
|
break;
|
||
|
|
case 319: return 302;
|
||
|
|
break;
|
||
|
|
case 320: return 303;
|
||
|
|
break;
|
||
|
|
case 321: parser.yy.correlatedSubQuery = true; return 304;
|
||
|
|
break;
|
||
|
|
case 322: return 305;
|
||
|
|
break;
|
||
|
|
case 323: return 306;
|
||
|
|
break;
|
||
|
|
case 324: return 307;
|
||
|
|
break;
|
||
|
|
case 325: parser.determineCase(yy_.yytext); return 308;
|
||
|
|
break;
|
||
|
|
case 326: return 309;
|
||
|
|
break;
|
||
|
|
case 327: return 310;
|
||
|
|
break;
|
||
|
|
case 328: return 311;
|
||
|
|
break;
|
||
|
|
case 329: return 312;
|
||
|
|
break;
|
||
|
|
case 330: return 313;
|
||
|
|
break;
|
||
|
|
case 331: return 314;
|
||
|
|
break;
|
||
|
|
case 332: return 1211;
|
||
|
|
break;
|
||
|
|
case 333: return 315;
|
||
|
|
break;
|
||
|
|
case 334: return 316;
|
||
|
|
break;
|
||
|
|
case 335: return 317;
|
||
|
|
break;
|
||
|
|
case 336: return 318;
|
||
|
|
break;
|
||
|
|
case 337: return 319;
|
||
|
|
break;
|
||
|
|
case 338: return 320;
|
||
|
|
break;
|
||
|
|
case 339: return 321;
|
||
|
|
break;
|
||
|
|
case 340: return 323;
|
||
|
|
break;
|
||
|
|
case 341: return 324;
|
||
|
|
break;
|
||
|
|
case 342: return 325;
|
||
|
|
break;
|
||
|
|
case 343: return 158;
|
||
|
|
break;
|
||
|
|
case 344: return 387;
|
||
|
|
break;
|
||
|
|
case 345: return 326;
|
||
|
|
break;
|
||
|
|
case 346: return 327;
|
||
|
|
break;
|
||
|
|
case 347: return 329;
|
||
|
|
break;
|
||
|
|
case 348: return 330;
|
||
|
|
break;
|
||
|
|
case 349: return 331;
|
||
|
|
break;
|
||
|
|
case 350: return 332;
|
||
|
|
break;
|
||
|
|
case 351: return 333;
|
||
|
|
break;
|
||
|
|
case 352: return 334;
|
||
|
|
break;
|
||
|
|
case 353: return 335;
|
||
|
|
break;
|
||
|
|
case 354: return 336;
|
||
|
|
break;
|
||
|
|
case 355: return 337;
|
||
|
|
break;
|
||
|
|
case 356: return 338;
|
||
|
|
break;
|
||
|
|
case 357: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SELECT', yy_.yylloc); return 576;
|
||
|
|
break;
|
||
|
|
case 358: return 339;
|
||
|
|
break;
|
||
|
|
case 359: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SET', yy_.yylloc); return 340;
|
||
|
|
break;
|
||
|
|
case 360: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SHOW', yy_.yylloc); return 1277;
|
||
|
|
break;
|
||
|
|
case 361: return 341;
|
||
|
|
break;
|
||
|
|
case 362: return 342;
|
||
|
|
break;
|
||
|
|
case 363: return 343;
|
||
|
|
break;
|
||
|
|
case 364: return 344;
|
||
|
|
break;
|
||
|
|
case 365: return 345;
|
||
|
|
break;
|
||
|
|
case 366: return 346;
|
||
|
|
break;
|
||
|
|
case 367: return 835;
|
||
|
|
break;
|
||
|
|
case 368: return 347;
|
||
|
|
break;
|
||
|
|
case 369: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('TRUNCATE', yy_.yylloc, yy.lexer.upcomingInput()); return 762;
|
||
|
|
break;
|
||
|
|
case 370: return 783;
|
||
|
|
break;
|
||
|
|
case 371: parser.determineCase(yy_.yytext); return 1189;
|
||
|
|
break;
|
||
|
|
case 372: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('USE', yy_.yylloc); return 1313;
|
||
|
|
break;
|
||
|
|
case 373: return 348;
|
||
|
|
break;
|
||
|
|
case 374: return 1099;
|
||
|
|
break;
|
||
|
|
case 375: return 350;
|
||
|
|
break;
|
||
|
|
case 376: return 349;
|
||
|
|
break;
|
||
|
|
case 377: return 351;
|
||
|
|
break;
|
||
|
|
case 378: return 352;
|
||
|
|
break;
|
||
|
|
case 379: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('WITH', yy_.yylloc); return 353;
|
||
|
|
break;
|
||
|
|
case 380: return 328;
|
||
|
|
break;
|
||
|
|
case 381: return 157;
|
||
|
|
break;
|
||
|
|
case 382: yy.lexer.unput('('); yy_.yytext = 'avg'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 354;
|
||
|
|
break;
|
||
|
|
case 383: yy.lexer.unput('('); yy_.yytext = 'cast'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 355;
|
||
|
|
break;
|
||
|
|
case 384: yy.lexer.unput('('); yy_.yytext = 'count'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 356;
|
||
|
|
break;
|
||
|
|
case 385: yy.lexer.unput('('); yy_.yytext = 'max'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 357;
|
||
|
|
break;
|
||
|
|
case 386: yy.lexer.unput('('); yy_.yytext = 'min'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 358;
|
||
|
|
break;
|
||
|
|
case 387: yy.lexer.unput('('); yy_.yytext = 'stddev_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 359;
|
||
|
|
break;
|
||
|
|
case 388: yy.lexer.unput('('); yy_.yytext = 'stddev_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 360;
|
||
|
|
break;
|
||
|
|
case 389: yy.lexer.unput('('); yy_.yytext = 'sum'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 361;
|
||
|
|
break;
|
||
|
|
case 390: yy.lexer.unput('('); yy_.yytext = 'variance'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 362;
|
||
|
|
break;
|
||
|
|
case 391: yy.lexer.unput('('); yy_.yytext = 'var_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 363;
|
||
|
|
break;
|
||
|
|
case 392: yy.lexer.unput('('); yy_.yytext = 'var_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 364;
|
||
|
|
break;
|
||
|
|
case 393: yy.lexer.unput('('); yy_.yytext = 'collect_set'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 365;
|
||
|
|
break;
|
||
|
|
case 394: yy.lexer.unput('('); yy_.yytext = 'collect_list'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 366;
|
||
|
|
break;
|
||
|
|
case 395: yy.lexer.unput('('); yy_.yytext = 'corr'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 367;
|
||
|
|
break;
|
||
|
|
case 396: yy.lexer.unput('('); yy_.yytext = 'covar_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 368;
|
||
|
|
break;
|
||
|
|
case 397: yy.lexer.unput('('); yy_.yytext = 'covar_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 369;
|
||
|
|
break;
|
||
|
|
case 398: yy.lexer.unput('('); yy_.yytext = 'extract'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 792;
|
||
|
|
break;
|
||
|
|
case 399: yy.lexer.unput('('); yy_.yytext = 'histogram_numeric'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 371;
|
||
|
|
break;
|
||
|
|
case 400: yy.lexer.unput('('); yy_.yytext = 'ntile'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 372;
|
||
|
|
break;
|
||
|
|
case 401: yy.lexer.unput('('); yy_.yytext = 'percentile'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 373;
|
||
|
|
break;
|
||
|
|
case 402: yy.lexer.unput('('); yy_.yytext = 'percentile_approx'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 374;
|
||
|
|
break;
|
||
|
|
case 403: yy.lexer.unput('('); yy_.yytext = 'appx_median'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 375;
|
||
|
|
break;
|
||
|
|
case 404: yy.lexer.unput('('); yy_.yytext = 'extract'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 376;
|
||
|
|
break;
|
||
|
|
case 405: yy.lexer.unput('('); yy_.yytext = 'group_concat'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 377;
|
||
|
|
break;
|
||
|
|
case 406: yy.lexer.unput('('); yy_.yytext = 'ndv'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 378;
|
||
|
|
break;
|
||
|
|
case 407: yy.lexer.unput('('); yy_.yytext = 'stddev'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 379;
|
||
|
|
break;
|
||
|
|
case 408: yy.lexer.unput('('); yy_.yytext = 'variance_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 380;
|
||
|
|
break;
|
||
|
|
case 409: yy.lexer.unput('('); yy_.yytext = 'variance_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 381;
|
||
|
|
break;
|
||
|
|
case 410: yy.lexer.unput('('); yy_.yytext = 'cume_dist'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 411: yy.lexer.unput('('); yy_.yytext = 'dense_rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 412: yy.lexer.unput('('); yy_.yytext = 'first_value'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 413: yy.lexer.unput('('); yy_.yytext = 'lag'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 414: yy.lexer.unput('('); yy_.yytext = 'last_value'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 415: yy.lexer.unput('('); yy_.yytext = 'lead'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 416: yy.lexer.unput('('); yy_.yytext = 'rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 417: yy.lexer.unput('('); yy_.yytext = 'row_number'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 418: yy.lexer.unput('('); yy_.yytext = 'cume_dist'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 419: yy.lexer.unput('('); yy_.yytext = 'percent_rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 420: yy.lexer.unput('('); yy_.yytext = 'ntile'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 421: yy.lexer.unput('('); yy_.yytext = 'percent_rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 382;
|
||
|
|
break;
|
||
|
|
case 422: yy.lexer.unput('('); yy_.yytext = 'system'; return 726;
|
||
|
|
break;
|
||
|
|
case 423: return 383;
|
||
|
|
break;
|
||
|
|
case 424: return 383;
|
||
|
|
break;
|
||
|
|
case 425: return 384;
|
||
|
|
break;
|
||
|
|
case 426: return 160;
|
||
|
|
break;
|
||
|
|
case 427: parser.yy.cursorFound = true; return 19;
|
||
|
|
break;
|
||
|
|
case 428: parser.yy.cursorFound = true; return 442;
|
||
|
|
break;
|
||
|
|
case 429: return 385;
|
||
|
|
break;
|
||
|
|
case 430: parser.addFileLocation(yy_.yylloc, yy_.yytext); return 787;
|
||
|
|
break;
|
||
|
|
case 431: this.popState(); return 788;
|
||
|
|
break;
|
||
|
|
case 432: return 6;
|
||
|
|
break;
|
||
|
|
case 433: return 386;
|
||
|
|
break;
|
||
|
|
case 434: return 387;
|
||
|
|
break;
|
||
|
|
case 435: return 388;
|
||
|
|
break;
|
||
|
|
case 436: return 389;
|
||
|
|
break;
|
||
|
|
case 437: return 390;
|
||
|
|
break;
|
||
|
|
case 438: return 391;
|
||
|
|
break;
|
||
|
|
case 439: return 391;
|
||
|
|
break;
|
||
|
|
case 440: return 391;
|
||
|
|
break;
|
||
|
|
case 441: return 391;
|
||
|
|
break;
|
||
|
|
case 442: return 391;
|
||
|
|
break;
|
||
|
|
case 443: return 392;
|
||
|
|
break;
|
||
|
|
case 444: return 393;
|
||
|
|
break;
|
||
|
|
case 445: return 394;
|
||
|
|
break;
|
||
|
|
case 446: return 394;
|
||
|
|
break;
|
||
|
|
case 447: return 394;
|
||
|
|
break;
|
||
|
|
case 448: return 394;
|
||
|
|
break;
|
||
|
|
case 449: return 394;
|
||
|
|
break;
|
||
|
|
case 450: return 394;
|
||
|
|
break;
|
||
|
|
case 451: return 395;
|
||
|
|
break;
|
||
|
|
case 452: return 396;
|
||
|
|
break;
|
||
|
|
case 453: return 1004;
|
||
|
|
break;
|
||
|
|
case 454: return 10;
|
||
|
|
break;
|
||
|
|
case 455: return 397;
|
||
|
|
break;
|
||
|
|
case 456: return 398;
|
||
|
|
break;
|
||
|
|
case 457: return 399;
|
||
|
|
break;
|
||
|
|
case 458: return 400;
|
||
|
|
break;
|
||
|
|
case 459: return 401;
|
||
|
|
break;
|
||
|
|
case 460: return 402;
|
||
|
|
break;
|
||
|
|
case 461: return 161;
|
||
|
|
break;
|
||
|
|
case 462: this.begin('backtickedValue'); return 403;
|
||
|
|
break;
|
||
|
|
case 463:
|
||
|
|
if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '`')) {
|
||
|
|
return 472;
|
||
|
|
}
|
||
|
|
return 470;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 464: this.popState(); return 403;
|
||
|
|
break;
|
||
|
|
case 465: this.begin('singleQuotedValue'); return 404;
|
||
|
|
break;
|
||
|
|
case 466:
|
||
|
|
if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '\'')) {
|
||
|
|
return 472;
|
||
|
|
}
|
||
|
|
return 470;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 467: this.popState(); return 404;
|
||
|
|
break;
|
||
|
|
case 468: this.begin('doubleQuotedValue'); return 405;
|
||
|
|
break;
|
||
|
|
case 469:
|
||
|
|
if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '"')) {
|
||
|
|
return 472;
|
||
|
|
}
|
||
|
|
return 470;
|
||
|
|
|
||
|
|
break;
|
||
|
|
case 470: this.popState(); return 405;
|
||
|
|
break;
|
||
|
|
case 471: return 6;
|
||
|
|
break;
|
||
|
|
case 472: /* To prevent console logging of unknown chars */
|
||
|
|
break;
|
||
|
|
case 473:
|
||
|
|
break;
|
||
|
|
case 474:
|
||
|
|
break;
|
||
|
|
case 475:
|
||
|
|
break;
|
||
|
|
case 476:
|
||
|
|
break;
|
||
|
|
case 477:
|
||
|
|
break;
|
||
|
|
case 478:
|
||
|
|
break;
|
||
|
|
case 479:
|
||
|
|
break;
|
||
|
|
case 480:console.log(yy_.yytext);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
rules: [/^(?:\s)/i,/^(?:--.*)/i,/^(?:[\/][*][^*]*[*]+([^\/*][^*]*[*]+)*[\/])/i,/^(?:\u2020)/i,/^(?:\u2021)/i,/^(?:ALL)/i,/^(?:ARRAY)/i,/^(?:AS)/i,/^(?:AUTHORIZATION)/i,/^(?:BINARY)/i,/^(?:CACHE)/i,/^(?:COLUMN)/i,/^(?:CONF)/i,/^(?:CONSTRAINT)/i,/^(?:CREATE)/i,/^(?:CUBE)/i,/^(?:CURRENT)/i,/^(?:DATE)/i,/^(?:DELETE)/i,/^(?:DESCRIBE)/i,/^(?:EXTENDED)/i,/^(?:EXTERNAL)/i,/^(?:FOR)/i,/^(?:FOREIGN)/i,/^(?:FUNCTION)/i,/^(?:GRANT)/i,/^(?:GROUPING)/i,/^(?:IMPORT)/i,/^(?:INSERT)/i,/^(?:LATERAL)/i,/^(?:LOCAL)/i,/^(?:MACRO)/i,/^(?:MAP)/i,/^(?:NONE)/i,/^(?:OF)/i,/^(?:OUT)/i,/^(?:PRIMARY)/i,/^(?:REFERENCES)/i,/^(?:REVOKE)/i,/^(?:ROLLUP)/i,/^(?:TABLE)/i,/^(?:TIMESTAMP)/i,/^(?:USER)/i,/^(?:USING)/i,/^(?:VIEWS)/i,/^(?:LIFECYCLE)/i,/^(?:ABORT)/i,/^(?:ADD)/i,/^(?:ADMIN)/i,/^(?:AFTER)/i,/^(?:ANALYZE)/i,/^(?:ARCHIVE)/i,/^(?:ASC)/i,/^(?:AVRO)/i,/^(?:BUCKET)/i,/^(?:BUCKETS)/i,/^(?:CASCADE)/i,/^(?:CHANGE)/i,/^(?:CLUSTER)/i,/^(?:CLUSTERED)/i,/^(?:COLLECTION)/i,/^(?:COLUMNS)/i,/^(?:COMMENT)/i,/^(?:COMPACT)/i,/^(?:COMPACTIONS)/i,/^(?:COMPUTE)/i,/^(?:CONCATENATE)/i,/^(?:DATA)/i,/^(?:DATABASES)/i,/^(?:DAY)/i,/^(?:DAYOFWEEK)/i,/^(?:DBPROPERTIES)/i,/^(?:DEFERRED)/i,/^(?:DEFINED)/i,/^(?:DELIMITED)/i,/^(?:DEPENDENCY)/i,/^(?:DESC)/i,/^(?:DIRECTORY)/i,/^(?:DISABLE)/i,/^(?:DISTRIBUTE)/i,/^(?:DOUBLE\s+PRECISION)/i,/^(?:ESCAPED)/i,/^(?:ENABLE)/i,/^(?:EXCHANGE)/i,/^(?:EXPLAIN)/i,/^(?:EXPORT)/i,/^(?:FIELDS)/i,/^(?:FILE)/i,/^(?:FILEFORMAT)/i,/^(?:FIRST)/i,/^(?:FORMAT)/i,/^(?:FORMATTED)/i,/^(?:FUNCTION)/i,/^(?:FUNCTIONS)/i,/^(?:HOUR)/i,/^(?:IDXPROPERTIES)/i,/^(?:INDEX)/i,/^(?:INDEXES)/i,/^(?:INPATH)/i,/^(?:INPUTFORMAT)/i,/^(?:ITEMS)/i,/^(?:JAR)/i,/^(?:KEY)/i,/^(?:KEYS)/i,/^(?:LINES)/i,/^(?:LOAD)/i,/^(?:LOCATION)/i,/^(?:LOCK)/i,/^(?:LOCKS)/i,/^(?:MATCHED)/i,/^(?:MERGE)/i,/^(?:METADATA)/i,/^(?:MINUTE)/i,/^(?:MONTH)/i,/^(?:MSCK)/i,/^(?:NORELY)/i,/^(?:NOSCAN)/i,/^(?:NOVALIDATE)/i,/^(?:NO_DROP)/i,/^(?:OFFLINE)/i,/^(?:ORC)/i,/^(?:OUTPUTFORMAT)/i,/^(?:OVERWRITE)/i,/^(?:OVERWRITE\s+DIRECTORY)/i,/^(?:OWNER)/i,/^(?:PARQUET)/i,/^(?:PARTITIONED)/i,/^(?:PARTITIONS)/i,/^(?:PERCENT)/i,/^(?:PRIVILEGES)/i,/^(?:PURGE)/i,/^(?:QUARTER)/i,/^(?:RCFILE)/i,/^(?:REBUILD)/i,/^(?:RELOAD)/i,/^(?:RELY)/i,/^(?:REPAIR)/i,/^(?:REPLICATION)/i,/^(?:RECOVER)/i,/^(?:RENAME)/i,/^(?:REPLACE)/i,/^(?:RESTRICT)/i,/^(?:ROLE)/i,/^(?:ROLES)/i,/^(?:SECOND)/i,/^(?:SCHEMA)/i,/^(?:SCHEMAS)/i,/^(?:SEQUENCEFILE)/i,/^(?:SERDE)/i,/^(?:SERDEPROPERTIES)/i,/^(?:SETS)/i,/^(?:SHOW)/i,/^(?:SHOW_DATABASE)/i,/^(?:SKEWED)/i,/^(?:SKEWED LOCATION)/i,/^(?:SORT)/i,/^(?:SORTED)/i,/^(?:STATISTICS)/i,/^(?:STORED)/i,/^(?:STORED\s+AS\s+DIRECTORIES)/i,/^(?:STRING)/i,/^(?:STRUCT)/i,/^(?:TABLES)/i,/^(?:TABLESAMPLE)/i,/^(?:TBLPROPERTIES)/i,/^(?:TEMPORARY)/i,/^(?:TERMINATED)/i,/^(?:TEXTFILE)/i,/^(?:TINYINT)/i,/^(?:TOUCH)/i,/^(?:TRANSACTIONS)/i,/^(?:UNARCHIVE)/i,/^(?:UNIONTYPE)/i,/^(?:USE)/i,/^(?:VIEW)/i,/^(?:WAIT)/i,/^(?:WEEK)/i,/^(?:WINDOW)/i,/^(?:YEAR)/i,/^(?:\.)/i,/^(?:\[)/i,/^(?:\])/i,/^(?:ADD)/i,/^(?:AGGREGATE)/i,/^(?:AVRO)/i,/^(?:CACHED)/i,/^(?:CASCADE)/i,/^(?:CHANGE)/i,/^(?:CLOSE_FN)/i,/^(?:COLUMN)/i,/^(?:COLUMNS)/i,/^(?:COMMENT)/i,/^(?:COMPUTE)/i,/^(?:CREATE)/i,/^(?:DATA)/i,/^(?:DATABASES)/i,/^(?:DELETE)/i,/^(?:DELIMITED)/i,/^(?:DESCRIBE)/i,/^(?:ESCAPED)/i,/^(?:EXPLAIN)/i,/^(?:EXTERNAL)/i,/^(?:EXTENDED)/i,/^(?:FIELDS)/i,/^(?:FILEFORMAT)/i,/^(?:FILES)/i,/^(?:FINALIZE_FN)/i,/^(?:FIRST)/i,/^(?:FORMAT)/i,/^(?:FORMATTED)/i,/^(?:FUNCTION)/i,/^(?:FUNCTIONS)/i,/^(?:GROUP)/i,/^(?:HASH)/i,/^(?:ILIKE)/i,/^(?:INCREMENTAL)/i,/^(?:INSERT)/i,/^(?:INTERVAL)/i,/^(?:INTERMEDIATE)/i,/^(?:INIT_FN)/i,/^(?:INVALIDATE)/i,/^(?:INPATH)/i,/^(?:IREGEXP)/i,/^(?:KEY)/i,/^(?:KUDU)/i,/^(?:LAST)/i,/^(?:LIKE\s+PARQUET)/i,/^(?:LIMIT)/i,/^(?:LINES)/i,/^(?:LOAD)/i,/^(?:LOCATION)/i,/^(?:MERGE_FN)/i,/^(?:METADATA)/i,/^(?:NULLS)/i,/^(?:OFFSET)/i,/^(?:ORC)/i,/^(?:OVERWRITE)/i,/^(?:PARQUET)/i,/^(?:PARTITIONED)/i,/^(?:PARTITIONS)/i,/^(?:PREPARE_FN)/i,/^(?:PRIMARY)/i,/^(?:RCFILE)/i,/^(?:RANGE)/i,/^(?:REAL)/i,/^(?:REFRESH)/i,/^(?:RENAME)/i,/^(?:REPEATABLE)/i,/^(?:REPLACE)/i,/^(?:REPLICATION)/i,/^(?:RESTRICT)/i,/^(?:RETURNS)/i,/^(?:REVOKE)/i,/^(?:SEQUENCEFILE)/i,/^(?:SERDEP
|
||
|
|
conditions: {"hdfs":{"rules":[427,428,429,430,431,432,476],"inclusive":false},"doubleQuotedValue":{"rules":[469,470,479],"inclusive":false},"singleQuotedValue":{"rules":[466,467,478],"inclusive":false},"backtickedValue":{"rules":[463,464,477],"inclusive":false},"between":{"rules":[0,1,2,3,4,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,410,411,412,413,414,415,416,417,423,424,425,426,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,465,468,471,472,473,480],"inclusive":true},"hive":{"rules":[0,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,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,410,411,412,413,414,415,416,417,418,419,423,424,425,426,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,465,468,471,472,474,480],"inclusive":true},"impala":{"rules":[0,1,2,3,4,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,420,421,422,423,424,425,426,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,465,468,471,472,475,480],"inclusive":true},"INITIAL":{"rules":[0,1,2,3,4,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,410,411,412,413,414,415,416,417,423,424,425,426,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,465,468,471,472,480],"inclusive":true}}
|
||
|
|
});
|
||
|
|
return lexer;
|
||
|
|
})();
|
||
|
|
parser.lexer = lexer;
|
||
|
|
function Parser () {
|
||
|
|
this.yy = {};
|
||
|
|
}
|
||
|
|
Parser.prototype = parser;parser.Parser = Parser;
|
||
|
|
return new Parser;
|
||
|
|
})();
|
||
|
|
|
||
|
|
|
||
|
|
if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
|
||
|
|
exports.parser = sqlAutocompleteParser;
|
||
|
|
exports.Parser = sqlAutocompleteParser.Parser;
|
||
|
|
exports.parse = function () { return sqlAutocompleteParser.parse.apply(sqlAutocompleteParser, arguments); };
|
||
|
|
exports.main = function commonjsMain(args) {
|
||
|
|
if (!args[1]) {
|
||
|
|
console.log('Usage: '+args[0]+' FILE');
|
||
|
|
process.exit(1);
|
||
|
|
}
|
||
|
|
var source = require('fs').readFileSync(require('path').normalize(args[1]), "utf8");
|
||
|
|
return exports.parser.parse(source);
|
||
|
|
};
|
||
|
|
if (typeof module !== 'undefined' && require.main === module) {
|
||
|
|
exports.main(process.argv.slice(1));
|
||
|
|
}
|
||
|
|
}
|