9124 lines
2.1 MiB
JavaScript
9124 lines
2.1 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,
|
||
|
|
'CURSOR': true,
|
||
|
|
'PARTIAL_CURSOR': true,
|
||
|
|
'HDFS_START_QUOTE': true,
|
||
|
|
'HDFS_PATH': true,
|
||
|
|
'HDFS_END_QUOTE': true,
|
||
|
|
'COMPARISON_OPERATOR': true,
|
||
|
|
'ARITHMETIC_OPERATOR': true,
|
||
|
|
'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, 438, 439, 440, 441, 452, 569, 570, 571, 577, 763, 826, 868, 930, 931, 933, 1166, 1190, 1191, 1192, 1193, 1195, 1213, 1227, 1252, 1253, 1278, 1314], $V1 = [2, 4], $V2 = [6, 10], $V3 = [2, 5], $V4 = [1, 6], $V5 = [1, 385], $V6 = [1, 359], $V7 = [1, 442], $V8 = [1, 13], $V9 = [1, 422], $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, 383], $Vu = [1, 473], $Vv = [1, 42], $Vw = [1, 43], $Vx = [1, 46], $Vy = [1, 85], $Vz = [1, 88], $VA = [1, 89], $VB = [1, 91], $VC = [1, 50], $VD = [1, 90], $VE = [1, 51], $VF = [1, 92], $VG = [1, 93], $VH = [1, 545], $VI = [1, 94], $VJ = [1, 95], $VK = [1, 56], $VL = [1, 96], $VM = [1, 562], $VN = [1, 531], $VO = [1, 98], $VP = [1, 58], $VQ = [1, 100], $VR = [1, 102], $VS = [1, 59], $VT = [1, 60], $VU = [1, 103], $VV = [1, 104], $VW = [1, 105], $VX = [1, 62], $VY = [1, 63], $VZ = [1, 106], $V_ = [1, 65], $V$ = [1, 532], $V01 = [1, 67], $V11 = [1, 57], $V21 = [1, 68], $V31 = [1, 69], $V41 = [1, 107], $V51 = [1, 108], $V61 = [1, 110], $V71 = [1, 111], $V81 = [1, 112], $V91 = [1, 113], $Va1 = [1, 71], $Vb1 = [1, 559], $Vc1 = [1, 114], $Vd1 = [1, 115], $Ve1 = [1, 72], $Vf1 = [1, 116], $Vg1 = [1, 118], $Vh1 = [1, 278], $Vi1 = [1, 119], $Vj1 = [1, 121], $Vk1 = [1, 122], $Vl1 = [1, 123], $Vm1 = [1, 124], $Vn1 = [1, 75], $Vo1 = [1, 125], $Vp1 = [1, 126], $Vq1 = [1, 127], $Vr1 = [1, 542], $Vs1 = [1, 76], $Vt1 = [1, 129], $Vu1 = [1, 131], $Vv1 = [1, 307], $Vw1 = [1, 310], $Vx1 = [1, 311], $Vy1 = [1, 312], $Vz1 = [1, 316], $VA1 = [1, 317], $VB1 = [1, 318], $VC1 = [1, 319], $VD1 = [1, 196], $VE1 = [1, 198], $VF1 = [1, 199], $VG1 = [1, 179], $VH1 = [1, 204], $VI1 = [1, 205], $VJ1 = [1, 194], $VK1 = [1, 186], $VL1 = [1, 166], $VM1 = [1, 290], $VN1 = [1, 260], $VO1 = [1, 330], $VP1 = [1, 349], $VQ1 = [1, 384], $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],
|
||
|
|
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>
|
||
|
|
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>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: "<hive>]", 210: "<impala>AGGREGATE", 211: "<impala>AVRO", 212: "<impala>CACHED", 213: "<impala>CASC
|
||
|
|
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,
|
||
|
|
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 545:
|
||
|
|
parser.suggestSetOptions();
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['ROLE']);
|
||
|
|
}
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['ALL']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 613:
|
||
|
|
case 616:
|
||
|
|
case 721:
|
||
|
|
case 762:
|
||
|
|
case 856:
|
||
|
|
case 1098:
|
||
|
|
case 1281:
|
||
|
|
case 1393:
|
||
|
|
case 1453:
|
||
|
|
case 2591:
|
||
|
|
case 2593:
|
||
|
|
case 3094:
|
||
|
|
this.$ = $$[$0 - 1];
|
||
|
|
break;
|
||
|
|
case 614:
|
||
|
|
case 617:
|
||
|
|
case 763:
|
||
|
|
this.$ = '';
|
||
|
|
break;
|
||
|
|
case 638:
|
||
|
|
parser.suggestKeywords(['INDEX', 'INDEXES']);
|
||
|
|
break;
|
||
|
|
case 639:
|
||
|
|
parser.suggestKeywords(['FORMATTED']);
|
||
|
|
break;
|
||
|
|
case 656:
|
||
|
|
case 659:
|
||
|
|
parser.yy.correlatedSubQuery = false;
|
||
|
|
break;
|
||
|
|
case 657:
|
||
|
|
case 661:
|
||
|
|
parser.suggestKeywords(['EXISTS']);
|
||
|
|
break;
|
||
|
|
case 660:
|
||
|
|
parser.suggestKeywords(['NOT EXISTS']);
|
||
|
|
break;
|
||
|
|
case 671:
|
||
|
|
case 673:
|
||
|
|
case 674:
|
||
|
|
case 676:
|
||
|
|
parser.suggestKeywords(['<', '<=', '<>', '=', '>', '>=']);
|
||
|
|
break;
|
||
|
|
case 672:
|
||
|
|
case 675:
|
||
|
|
case 3121:
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
break;
|
||
|
|
case 699:
|
||
|
|
case 703:
|
||
|
|
case 707:
|
||
|
|
case 743:
|
||
|
|
case 744:
|
||
|
|
case 789:
|
||
|
|
case 792:
|
||
|
|
case 1000:
|
||
|
|
case 1069:
|
||
|
|
case 1843:
|
||
|
|
case 1941:
|
||
|
|
case 1960:
|
||
|
|
case 2006:
|
||
|
|
case 2008:
|
||
|
|
case 2372:
|
||
|
|
case 2631:
|
||
|
|
case 3409:
|
||
|
|
parser.suggestColumns();
|
||
|
|
break;
|
||
|
|
case 711:
|
||
|
|
case 764:
|
||
|
|
parser.addTableLocation(_$[$0], [{ name: $$[$0] }]);
|
||
|
|
this.$ = { identifierChain: [{ name: $$[$0] }] };
|
||
|
|
break;
|
||
|
|
case 712:
|
||
|
|
case 765:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 2], [{ name: $$[$0 - 2] }]);
|
||
|
|
parser.addTableLocation(_$[$0], [{ name: $$[$0 - 2] }, { name: $$[$0] }]);
|
||
|
|
this.$ = { identifierChain: [{ name: $$[$0 - 2] }, { name: $$[$0] }] };
|
||
|
|
break;
|
||
|
|
case 713:
|
||
|
|
// 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 714:
|
||
|
|
case 1747:
|
||
|
|
case 1913:
|
||
|
|
case 2080:
|
||
|
|
case 2086:
|
||
|
|
case 2095:
|
||
|
|
case 2280:
|
||
|
|
case 2604:
|
||
|
|
case 2628:
|
||
|
|
case 2731:
|
||
|
|
case 2736:
|
||
|
|
case 2754:
|
||
|
|
case 2777:
|
||
|
|
case 2784:
|
||
|
|
case 2841:
|
||
|
|
case 2849:
|
||
|
|
case 3128:
|
||
|
|
case 3159:
|
||
|
|
case 3162:
|
||
|
|
case 3168:
|
||
|
|
case 3395:
|
||
|
|
case 3415:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 715:
|
||
|
|
case 729:
|
||
|
|
parser.suggestDatabases();
|
||
|
|
this.$ = { identifierChain: [{ name: $$[$0 - 2] }] };
|
||
|
|
break;
|
||
|
|
case 716:
|
||
|
|
// In Impala you can have statements like 'SELECT ... FROM testTable t, t.|'
|
||
|
|
parser.suggestTablesOrColumns($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 717:
|
||
|
|
// 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 718:
|
||
|
|
case 898:
|
||
|
|
this.$ = [$$[$0]];
|
||
|
|
break;
|
||
|
|
case 719:
|
||
|
|
$$[$0 - 1].push($$[$0]);
|
||
|
|
break;
|
||
|
|
case 720:
|
||
|
|
case 723:
|
||
|
|
this.$ = [];
|
||
|
|
break;
|
||
|
|
case 722:
|
||
|
|
case 858:
|
||
|
|
case 1283:
|
||
|
|
this.$ = $$[$0 - 2];
|
||
|
|
break;
|
||
|
|
case 724:
|
||
|
|
this.$ = { name: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 728:
|
||
|
|
case 1798:
|
||
|
|
case 2025:
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 732:
|
||
|
|
case 2039:
|
||
|
|
case 2076:
|
||
|
|
case 2840:
|
||
|
|
case 2848:
|
||
|
|
case 3249:
|
||
|
|
case 3309:
|
||
|
|
case 3323:
|
||
|
|
case 3381:
|
||
|
|
case 3382:
|
||
|
|
case 3420:
|
||
|
|
parser.suggestDatabases();
|
||
|
|
break;
|
||
|
|
case 742:
|
||
|
|
case 1005:
|
||
|
|
case 1006:
|
||
|
|
case 1012:
|
||
|
|
case 1013:
|
||
|
|
case 1389:
|
||
|
|
case 1480:
|
||
|
|
case 3079:
|
||
|
|
case 3115:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
break;
|
||
|
|
case 750:
|
||
|
|
case 753:
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['WITH REPLICATION ='] };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 755:
|
||
|
|
case 3267:
|
||
|
|
parser.suggestKeywords(['IN']);
|
||
|
|
break;
|
||
|
|
case 759:
|
||
|
|
parser.suggestKeywords(['REPLICATION =']);
|
||
|
|
break;
|
||
|
|
case 760:
|
||
|
|
case 1781:
|
||
|
|
case 1938:
|
||
|
|
case 2333:
|
||
|
|
parser.suggestKeywords(['=']);
|
||
|
|
break;
|
||
|
|
case 766:
|
||
|
|
case 3372:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ prependDot: true });
|
||
|
|
break;
|
||
|
|
case 767:
|
||
|
|
parser.suggestTablesOrColumns($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 769:
|
||
|
|
this.$ = { identifierChain: $$[$0 - 1].identifierChain, alias: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 772:
|
||
|
|
parser.yy.locations[parser.yy.locations.length - 1].type = 'column';
|
||
|
|
break;
|
||
|
|
case 773:
|
||
|
|
case 1234:
|
||
|
|
parser.addAsteriskLocation(_$[$0], $$[$0 - 2].concat({ asterisk: true }));
|
||
|
|
break;
|
||
|
|
case 775:
|
||
|
|
this.$ = [$$[$0].identifier];
|
||
|
|
parser.yy.firstChainLocation = parser.addUnknownLocation($$[$0].location, [$$[$0].identifier]);
|
||
|
|
break;
|
||
|
|
case 776:
|
||
|
|
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 777:
|
||
|
|
case 785:
|
||
|
|
if ($$[$0].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: [$$[$0].identifier] });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 778:
|
||
|
|
case 786:
|
||
|
|
if ($$[$0].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: $$[$0 - 2].concat([$$[$0].identifier]) });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 781:
|
||
|
|
parser.suggestColumns({
|
||
|
|
identifierChain: $$[$0 - 2]
|
||
|
|
});
|
||
|
|
this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] };
|
||
|
|
break;
|
||
|
|
case 782:
|
||
|
|
parser.suggestColumns({
|
||
|
|
identifierChain: $$[$0 - 4]
|
||
|
|
});
|
||
|
|
this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] };
|
||
|
|
break;
|
||
|
|
case 783:
|
||
|
|
this.$ = [$$[$0].identifier];
|
||
|
|
break;
|
||
|
|
case 784:
|
||
|
|
$$[$0 - 2].push($$[$0].identifier);
|
||
|
|
break;
|
||
|
|
case 787:
|
||
|
|
if ($$[$0 - 2].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: $$[$0 - 4].concat([$$[$0 - 2].identifier]) });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 788:
|
||
|
|
if ($$[$0 - 2].insideKey) {
|
||
|
|
parser.suggestKeyValues({ identifierChain: [$$[$0 - 2].identifier] });
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 790:
|
||
|
|
parser.suggestColumns({ identifierChain: $$[$0 - 2] });
|
||
|
|
break;
|
||
|
|
case 791:
|
||
|
|
parser.suggestColumns({ identifierChain: $$[$0 - 4] });
|
||
|
|
break;
|
||
|
|
case 793:
|
||
|
|
this.$ = { identifier: { name: $$[$0] }, location: _$[$0] };
|
||
|
|
;
|
||
|
|
break;
|
||
|
|
case 794:
|
||
|
|
this.$ = { identifier: { name: $$[$0 - 3], keySet: true }, location: _$[$0 - 3] };
|
||
|
|
break;
|
||
|
|
case 795:
|
||
|
|
this.$ = { identifier: { name: $$[$0 - 2], keySet: true }, location: _$[$0 - 2] };
|
||
|
|
break;
|
||
|
|
case 796:
|
||
|
|
this.$ = { identifier: { name: $$[$0 - 3] }, insideKey: true };
|
||
|
|
break;
|
||
|
|
case 797:
|
||
|
|
this.$ = { identifier: { name: $$[$0 - 3] } };
|
||
|
|
;
|
||
|
|
break;
|
||
|
|
case 830:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
parser.addColumnLocation(_$[$0 - 1], $$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 831:
|
||
|
|
case 1749:
|
||
|
|
case 2048:
|
||
|
|
case 2070:
|
||
|
|
case 2084:
|
||
|
|
case 2098:
|
||
|
|
case 2282:
|
||
|
|
case 2730:
|
||
|
|
case 2740:
|
||
|
|
case 2741:
|
||
|
|
case 2766:
|
||
|
|
case 2772:
|
||
|
|
case 2775:
|
||
|
|
case 2780:
|
||
|
|
case 3122:
|
||
|
|
case 3131:
|
||
|
|
case 3132:
|
||
|
|
case 3161:
|
||
|
|
case 3171:
|
||
|
|
case 3266:
|
||
|
|
case 3312:
|
||
|
|
case 3313:
|
||
|
|
case 3325:
|
||
|
|
case 3327:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 832:
|
||
|
|
case 848:
|
||
|
|
case 2071:
|
||
|
|
parser.addDatabaseLocation(_$[$0], [{ name: $$[$0] }]);
|
||
|
|
break;
|
||
|
|
case 835:
|
||
|
|
case 1745:
|
||
|
|
case 2083:
|
||
|
|
case 2090:
|
||
|
|
case 2091:
|
||
|
|
case 3314:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 836:
|
||
|
|
if (!$$[$0 - 4]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 837:
|
||
|
|
if (!$$[$0 - 3]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 838:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
parser.suggestColumns();
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 839:
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 842:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'EXTENDED', 'FORMATTED', 'FUNCTION', 'SCHEMA']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 843:
|
||
|
|
case 845:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 844:
|
||
|
|
case 846:
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 847:
|
||
|
|
case 1943:
|
||
|
|
case 2026:
|
||
|
|
case 2029:
|
||
|
|
case 2078:
|
||
|
|
case 2600:
|
||
|
|
case 2729:
|
||
|
|
case 2750:
|
||
|
|
case 2760:
|
||
|
|
case 2764:
|
||
|
|
case 2838:
|
||
|
|
case 2839:
|
||
|
|
case 2845:
|
||
|
|
case 3095:
|
||
|
|
case 3164:
|
||
|
|
case 3236:
|
||
|
|
case 3252:
|
||
|
|
case 3311:
|
||
|
|
case 3324:
|
||
|
|
case 3326:
|
||
|
|
case 3369:
|
||
|
|
case 3398:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
break;
|
||
|
|
case 849:
|
||
|
|
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 851:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords([{ value: 'DATABASE', weight: 2 }, { value: 'EXTENDED', weight: 1 }, { value: 'FORMATTED', weight: 1 }]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 852:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases();
|
||
|
|
break;
|
||
|
|
case 853:
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'FORMATTED']);
|
||
|
|
}
|
||
|
|
parser.addDatabaseLocation(_$[$0], [{ name: $$[$0] }]);
|
||
|
|
break;
|
||
|
|
case 861:
|
||
|
|
parser.addCommonTableExpressions($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 862:
|
||
|
|
case 863:
|
||
|
|
case 901:
|
||
|
|
parser.addCommonTableExpressions($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 867:
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0 - 1], _$[$0 - 1], $$[$0 - 2], _$[$0 - 2], $$[$0 - 3], _$[$0 - 3]), _$[$0]);
|
||
|
|
this.$ = { selectList: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 868:
|
||
|
|
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 881:
|
||
|
|
parser.suggestKeywords(['ALL', 'DISTINCT', 'SELECT']);
|
||
|
|
break;
|
||
|
|
case 882:
|
||
|
|
parser.suggestKeywords(['ALL', 'DISTINCT']);
|
||
|
|
break;
|
||
|
|
case 884:
|
||
|
|
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 885:
|
||
|
|
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 886:
|
||
|
|
parser.addClauseLocation('selectList', parser.firstDefined($$[$0 - 2], _$[$0 - 2], $$[$0 - 3], _$[$0 - 3], $$[$0 - 4], _$[$0 - 4]), _$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 887:
|
||
|
|
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 888:
|
||
|
|
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 889:
|
||
|
|
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 890:
|
||
|
|
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 891:
|
||
|
|
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 892:
|
||
|
|
parser.selectListNoTableSuggest($$[$0 - 1], $$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 896:
|
||
|
|
case 972:
|
||
|
|
case 1003:
|
||
|
|
case 1016:
|
||
|
|
case 1020:
|
||
|
|
case 1058:
|
||
|
|
case 1062:
|
||
|
|
case 1090:
|
||
|
|
case 1116:
|
||
|
|
case 1117:
|
||
|
|
case 1198:
|
||
|
|
case 1200:
|
||
|
|
case 1268:
|
||
|
|
case 1278:
|
||
|
|
case 1285:
|
||
|
|
case 1297:
|
||
|
|
case 1478:
|
||
|
|
case 1678:
|
||
|
|
case 1679:
|
||
|
|
case 1704:
|
||
|
|
case 1705:
|
||
|
|
case 1706:
|
||
|
|
case 1989:
|
||
|
|
case 2153:
|
||
|
|
case 2170:
|
||
|
|
case 3114:
|
||
|
|
case 3414:
|
||
|
|
this.$ = $$[$0];
|
||
|
|
break;
|
||
|
|
case 899:
|
||
|
|
this.$ = $$[$0 - 2].concat([$$[$0]]);
|
||
|
|
;
|
||
|
|
break;
|
||
|
|
case 903:
|
||
|
|
parser.addCommonTableExpressions($$[$0 - 4]);
|
||
|
|
break;
|
||
|
|
case 904:
|
||
|
|
parser.addCteAliasLocation(_$[$0 - 4], $$[$0 - 4]);
|
||
|
|
$$[$0 - 1].alias = $$[$0 - 4];
|
||
|
|
this.$ = $$[$0 - 1];
|
||
|
|
break;
|
||
|
|
case 905:
|
||
|
|
case 1533:
|
||
|
|
case 2393:
|
||
|
|
case 2453:
|
||
|
|
case 2530:
|
||
|
|
case 2534:
|
||
|
|
case 2607:
|
||
|
|
parser.suggestKeywords(['AS']);
|
||
|
|
break;
|
||
|
|
case 906:
|
||
|
|
case 1396:
|
||
|
|
case 2022:
|
||
|
|
case 2467:
|
||
|
|
case 2476:
|
||
|
|
case 3096:
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
break;
|
||
|
|
case 912:
|
||
|
|
case 913:
|
||
|
|
parser.addClauseLocation('whereClause', _$[$0 - 1], $$[$0].whereClauseLocation);
|
||
|
|
parser.addClauseLocation('limitClause', $$[$0].limitClausePreceding || _$[$0 - 1], $$[$0].limitClauseLocation);
|
||
|
|
break;
|
||
|
|
case 914:
|
||
|
|
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 915:
|
||
|
|
// 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 919:
|
||
|
|
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 920:
|
||
|
|
case 1290:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 921:
|
||
|
|
if ($$[$0]) {
|
||
|
|
parser.yy.lateralViews = $$[$0].lateralViews;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 923:
|
||
|
|
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 924:
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'where';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 925:
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'group by';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 928:
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.source = 'order by';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 932:
|
||
|
|
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 933:
|
||
|
|
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 934:
|
||
|
|
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 935:
|
||
|
|
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 936:
|
||
|
|
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 937:
|
||
|
|
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 938:
|
||
|
|
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 939:
|
||
|
|
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 940:
|
||
|
|
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 941:
|
||
|
|
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 942:
|
||
|
|
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 943:
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0 - 1], $$[$0]], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0 - 1] && !$$[$0]
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
case 944:
|
||
|
|
this.$ = {
|
||
|
|
suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0]], [{ value: 'OFFSET', weight: 2 }], [parser.isImpala()]),
|
||
|
|
cursorAtEnd: !$$[$0]
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
case 973:
|
||
|
|
if ($$[$0].suggestFilters) {
|
||
|
|
parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 974:
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestKeywords(['EXISTS', 'NOT EXISTS']);
|
||
|
|
parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
break;
|
||
|
|
case 977:
|
||
|
|
this.$ = { valueExpression: $$[$0] ? false : $$[$0 - 1] };
|
||
|
|
if (!$$[$0] && parser.isHive()) {
|
||
|
|
this.$.suggestKeywords = ['GROUPING SETS', 'WITH CUBE', 'WITH ROLLUP'];
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 978:
|
||
|
|
case 1027:
|
||
|
|
case 1053:
|
||
|
|
case 1057:
|
||
|
|
case 1060:
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
break;
|
||
|
|
case 979:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
parser.suggestGroupBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
break;
|
||
|
|
case 980:
|
||
|
|
parser.suggestKeywords(['BY']);
|
||
|
|
parser.suggestGroupBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
break;
|
||
|
|
case 987:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['CUBE', 'ROLLUP']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 989:
|
||
|
|
parser.suggestKeywords(['SETS']);
|
||
|
|
break;
|
||
|
|
case 1017:
|
||
|
|
if ($$[$0].emptyOrderBy) {
|
||
|
|
parser.suggestOrderBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1018:
|
||
|
|
parser.suggestKeywords(['BY']);
|
||
|
|
parser.suggestOrderBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() });
|
||
|
|
break;
|
||
|
|
case 1022:
|
||
|
|
this.$ = { emptyOrderBy: false };
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
break;
|
||
|
|
case 1023:
|
||
|
|
case 1024:
|
||
|
|
case 1025:
|
||
|
|
this.$ = { emptyOrderBy: false };
|
||
|
|
break;
|
||
|
|
case 1026:
|
||
|
|
this.$ = parser.mergeSuggestKeywords($$[$0 - 1], $$[$0]);
|
||
|
|
break;
|
||
|
|
case 1029:
|
||
|
|
this.$ = { emptyOrderBy: true };
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
break;
|
||
|
|
case 1030:
|
||
|
|
this.$ = { suggestKeywords: ['ASC', 'DESC'] };
|
||
|
|
break;
|
||
|
|
case 1035:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
this.$ = { suggestKeywords: ['NULLS FIRST', 'NULLS LAST'] };
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
this.$ = {};
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1038:
|
||
|
|
parser.suggestKeywords(['FIRST', 'LAST']);
|
||
|
|
break;
|
||
|
|
case 1042:
|
||
|
|
this.$ = { suggestKeywords: ['SORT BY'] };
|
||
|
|
break;
|
||
|
|
case 1051:
|
||
|
|
case 1055:
|
||
|
|
case 1059:
|
||
|
|
suggestKeywords: ['BY'];
|
||
|
|
break;
|
||
|
|
case 1052:
|
||
|
|
case 1056:
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestSelectListAliases();
|
||
|
|
break;
|
||
|
|
case 1067:
|
||
|
|
parser.addColumnLocation($$[$0 - 1].location, [$$[$0 - 1].identifier]);
|
||
|
|
this.$ = $$[$0];
|
||
|
|
break;
|
||
|
|
case 1078:
|
||
|
|
case 1083:
|
||
|
|
parser.suggestFunctions({ types: ['BIGINT'] });
|
||
|
|
break;
|
||
|
|
case 1079:
|
||
|
|
case 1084:
|
||
|
|
delete parser.yy.result.suggestColumns;
|
||
|
|
break;
|
||
|
|
case 1088:
|
||
|
|
case 1089:
|
||
|
|
// verifyType($$[$0], 'BOOLEAN');
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1091:
|
||
|
|
// verifyType($$[$0], 'NUMBER');
|
||
|
|
this.$ = $$[$0];
|
||
|
|
$$[$0].types = ['NUMBER'];
|
||
|
|
break;
|
||
|
|
case 1092:
|
||
|
|
case 1093:
|
||
|
|
case 1094:
|
||
|
|
case 1095:
|
||
|
|
case 1096:
|
||
|
|
case 1103:
|
||
|
|
case 1104:
|
||
|
|
case 1105:
|
||
|
|
case 1106:
|
||
|
|
case 1107:
|
||
|
|
case 1108:
|
||
|
|
case 1114:
|
||
|
|
case 1115:
|
||
|
|
case 1136:
|
||
|
|
case 1194:
|
||
|
|
case 1195:
|
||
|
|
case 1257:
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1097:
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
// clear correlated flag after completed sub-query (set by lexer)
|
||
|
|
parser.yy.correlatedSubQuery = false;
|
||
|
|
break;
|
||
|
|
case 1099:
|
||
|
|
case 1100:
|
||
|
|
case 1101:
|
||
|
|
case 1102:
|
||
|
|
parser.addColRefToVariableIfExists($$[$0 - 2], $$[$0]);
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1109:
|
||
|
|
case 1110:
|
||
|
|
// verifyType($$[$0-2], 'BOOLEAN');
|
||
|
|
// verifyType($$[$0], 'BOOLEAN');
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1111:
|
||
|
|
case 1112:
|
||
|
|
case 1113:
|
||
|
|
// verifyType($$[$0-2], 'NUMBER');
|
||
|
|
// verifyType($$[$0], 'NUMBER');
|
||
|
|
this.$ = { types: ['NUMBER'] };
|
||
|
|
break;
|
||
|
|
case 1119:
|
||
|
|
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 1120:
|
||
|
|
case 1122:
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1121:
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.suggestKeywords(['EXISTS']);
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1123:
|
||
|
|
parser.suggestFunctions({ types: ['BOOLEAN'] });
|
||
|
|
parser.suggestColumns({ types: ['BOOLEAN'] });
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1124:
|
||
|
|
this.$ = { types: ['T'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1125:
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
this.$ = { types: ['T'] };
|
||
|
|
break;
|
||
|
|
case 1126:
|
||
|
|
if (!$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions('NUMBER');
|
||
|
|
}
|
||
|
|
this.$ = { types: ['NUMBER'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1127:
|
||
|
|
parser.suggestFunctions({ types: ['NUMBER'] });
|
||
|
|
parser.suggestColumns({ types: ['NUMBER'] });
|
||
|
|
this.$ = { types: ['NUMBER'] };
|
||
|
|
break;
|
||
|
|
case 1128:
|
||
|
|
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 1129:
|
||
|
|
var keywords = ['FALSE', 'NULL', 'TRUE'];
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords = keywords.concat(['DISTINCT FROM', 'UNKNOWN']);
|
||
|
|
}
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1130:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1131:
|
||
|
|
case 1132:
|
||
|
|
case 1133:
|
||
|
|
parser.suggestKeywords(['NOT']);
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1134:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 5], $$[$0 - 3] ? 'IS NOT DISTINCT FROM' : 'IS DISTINCT FROM');
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1135:
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1137:
|
||
|
|
this.$ = $$[$0 - 1];
|
||
|
|
break;
|
||
|
|
case 1138:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: ['T'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1139:
|
||
|
|
parser.valueExpressionSuggest($$[$0], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1140:
|
||
|
|
case 1141:
|
||
|
|
case 1142:
|
||
|
|
parser.valueExpressionSuggest($$[$0], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1143:
|
||
|
|
case 1144:
|
||
|
|
case 1145:
|
||
|
|
case 1146:
|
||
|
|
if (!$$[$0 - 2].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0].types);
|
||
|
|
parser.addColRefIfExists($$[$0]);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0 - 2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1147:
|
||
|
|
case 1149:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 2], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1148:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 2], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true, endsWithLessThanOrEqual: true };
|
||
|
|
break;
|
||
|
|
case 1150:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 2], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true, endsWithLessThanOrEqual: $$[$0 - 1] === '<=' };
|
||
|
|
break;
|
||
|
|
case 1151:
|
||
|
|
case 1152:
|
||
|
|
case 1153:
|
||
|
|
case 1154:
|
||
|
|
if (!$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].types);
|
||
|
|
parser.addColRefIfExists($$[$0 - 2]);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1155:
|
||
|
|
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 1156:
|
||
|
|
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 1157:
|
||
|
|
case 1158:
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0 - 5].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1159:
|
||
|
|
case 1160:
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0 - 4].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1161:
|
||
|
|
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 1162:
|
||
|
|
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 1163:
|
||
|
|
if ($$[$0 - 5].types[0] === $$[$0 - 2].types[0] && !$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 5].types);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1164:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 5], $$[$0 - 1]);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1165:
|
||
|
|
case 1171:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 1], ['AND']);
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1166:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 3], $$[$0 - 2] + ' ' + $$[$0 - 1]);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1167:
|
||
|
|
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 1168:
|
||
|
|
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 1169:
|
||
|
|
if ($$[$0 - 4].types[0] === $$[$0 - 2].types[0] && !$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 4].types);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1170:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 4], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 4].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1172:
|
||
|
|
parser.valueExpressionSuggest($$[$0 - 2], $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].types);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1173:
|
||
|
|
case 1175:
|
||
|
|
case 1177:
|
||
|
|
case 1179:
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0 - 1]);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true, suggestFilters: true };
|
||
|
|
break;
|
||
|
|
case 1174:
|
||
|
|
case 1178:
|
||
|
|
parser.addColRefIfExists($$[$0]);
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0 - 2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1176:
|
||
|
|
case 1180:
|
||
|
|
parser.addColRefIfExists($$[$0 - 2]);
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1181:
|
||
|
|
case 1182:
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
this.$ = { types: ['NUMBER'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1183:
|
||
|
|
case 1184:
|
||
|
|
case 1185:
|
||
|
|
if (!$$[$0 - 2].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
parser.addColRefIfExists($$[$0]);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['NUMBER'], suggestFilters: $$[$0 - 2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1186:
|
||
|
|
case 1187:
|
||
|
|
case 1188:
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0 - 1]);
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
this.$ = { types: ['NUMBER'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1189:
|
||
|
|
case 1190:
|
||
|
|
case 1191:
|
||
|
|
if (!$$[$0].typeSet) {
|
||
|
|
parser.applyTypeToSuggestions(['NUMBER']);
|
||
|
|
parser.addColRefIfExists($$[$0 - 2]);
|
||
|
|
}
|
||
|
|
this.$ = { types: ['NUMBER'], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1192:
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0 - 1].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1193:
|
||
|
|
this.$ = { types: ['BOOLEAN'], suggestFilters: $$[$0 - 2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1196:
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0]);
|
||
|
|
parser.applyTypeToSuggestions(['STRING']);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1197:
|
||
|
|
parser.valueExpressionSuggest(undefined, $$[$0 - 1] + ' ' + $$[$0]);
|
||
|
|
parser.applyTypeToSuggestions(['STRING']);
|
||
|
|
this.$ = { types: ['BOOLEAN'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1199:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { types: ['T'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1201:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2], ['WHEN']);
|
||
|
|
this.$ = { types: ['T'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1202:
|
||
|
|
this.$ = $$[$0];
|
||
|
|
this.$.suggestFilters = $$[$0 - 1].suggestFilters;
|
||
|
|
break;
|
||
|
|
case 1203:
|
||
|
|
this.$ = { types: ['T'], suggestFilters: $$[$0 - 1].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1204:
|
||
|
|
case 1536:
|
||
|
|
case 1541:
|
||
|
|
case 1542:
|
||
|
|
this.$ = { types: ['T'] };
|
||
|
|
break;
|
||
|
|
case 1205:
|
||
|
|
case 1207:
|
||
|
|
$$[$0].position = 1;
|
||
|
|
break;
|
||
|
|
case 1206:
|
||
|
|
$$[$0].position = $$[$0 - 2].position + 1;
|
||
|
|
this.$ = $$[$0];
|
||
|
|
break;
|
||
|
|
case 1208:
|
||
|
|
$$[$0 - 2].position += 1;
|
||
|
|
break;
|
||
|
|
case 1209:
|
||
|
|
$$[$0 - 2].position = 1;
|
||
|
|
break;
|
||
|
|
case 1210:
|
||
|
|
$$[$0 - 4].position += 1;
|
||
|
|
break;
|
||
|
|
case 1211:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
$$[$0 - 2].position += 1;
|
||
|
|
break;
|
||
|
|
case 1212:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
$$[$0 - 4].position += 1;
|
||
|
|
break;
|
||
|
|
case 1213:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 1214:
|
||
|
|
case 1215:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { cursorAtStart: true, position: 1 };
|
||
|
|
break;
|
||
|
|
case 1216:
|
||
|
|
case 1217:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { position: 2 };
|
||
|
|
break;
|
||
|
|
case 1221:
|
||
|
|
this.$ = { types: ['COLREF'], columnReference: $$[$0].chain };
|
||
|
|
break;
|
||
|
|
case 1222:
|
||
|
|
// 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;
|
||
|
|
if ($$[$0 - 1].lastLoc.location) {
|
||
|
|
$$[$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 1223:
|
||
|
|
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 1225:
|
||
|
|
this.$ = { types: ['NULL'] };
|
||
|
|
break;
|
||
|
|
case 1226:
|
||
|
|
this.$ = { types: ['TIMESTAMP'] };
|
||
|
|
break;
|
||
|
|
case 1228:
|
||
|
|
if ($$[$0].suggestKeywords) {
|
||
|
|
this.$ = { types: ['COLREF'], columnReference: $$[$0], suggestKeywords: $$[$0].suggestKeywords };
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
this.$ = { types: ['COLREF'], columnReference: $$[$0] };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1229:
|
||
|
|
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 1230:
|
||
|
|
case 1438:
|
||
|
|
case 1439:
|
||
|
|
parser.addFunctionLocation(_$[$0 - 1], $$[$0 - 1]);
|
||
|
|
if ($$[$0].position) {
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0 - 1], $$[$0].position);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 1]) };
|
||
|
|
break;
|
||
|
|
case 1233:
|
||
|
|
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 1237:
|
||
|
|
parser.suggestKeywords(['DAYS', 'HOURS', 'MICROSECONDS', 'MILLISECONDS', 'MINUTES', 'MONTHS', 'NANOSECONDS', 'SECONDS', 'WEEKS', 'YEARS']);
|
||
|
|
break;
|
||
|
|
case 1242:
|
||
|
|
parser.suggestValues($$[$0]);
|
||
|
|
break;
|
||
|
|
case 1243:
|
||
|
|
this.$ = { types: ['NUMBER'] };
|
||
|
|
break;
|
||
|
|
case 1249:
|
||
|
|
case 1251:
|
||
|
|
this.$ = $$[$0 - 1] + $$[$0];
|
||
|
|
break;
|
||
|
|
case 1250:
|
||
|
|
this.$ = $$[$0 - 2] + $$[$0 - 1] + $$[$0];
|
||
|
|
break;
|
||
|
|
case 1255:
|
||
|
|
case 1256:
|
||
|
|
if (/\$\{[^}]*\}/.test($$[$0])) {
|
||
|
|
parser.addVariableLocation(_$[$0], $$[$0]);
|
||
|
|
this.$ = { types: ['STRING'], columnReference: [{ name: $$[$0] }] };
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
this.$ = { types: ['STRING'] };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1258:
|
||
|
|
this.$ = { partialQuote: '\'', missingEndQuote: parser.yy.missingEndQuote };
|
||
|
|
break;
|
||
|
|
case 1259:
|
||
|
|
this.$ = { partialQuote: '"', missingEndQuote: parser.yy.missingEndQuote };
|
||
|
|
break;
|
||
|
|
case 1264:
|
||
|
|
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 1265:
|
||
|
|
parser.addAsteriskLocation(_$[$0], [{ asterisk: true }]);
|
||
|
|
this.$ = { asterisk: true };
|
||
|
|
break;
|
||
|
|
case 1266:
|
||
|
|
if ($$[$0]) {
|
||
|
|
parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0 - 1]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1267:
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestColumns();
|
||
|
|
parser.addColumnAliasLocation(_$[$0], $$[$0], _$[$0 - 2]);
|
||
|
|
this.$ = { suggestAggregateFunctions: true };
|
||
|
|
break;
|
||
|
|
case 1269:
|
||
|
|
case 1635:
|
||
|
|
this.$ = [$$[$0]];
|
||
|
|
break;
|
||
|
|
case 1270:
|
||
|
|
$$[$0 - 2].push($$[$0]);
|
||
|
|
break;
|
||
|
|
case 1272:
|
||
|
|
case 1273:
|
||
|
|
case 1709:
|
||
|
|
this.$ = { cursorAtStart: true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
|
||
|
|
break;
|
||
|
|
case 1275:
|
||
|
|
parser.checkForSelectListKeywords($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 1276:
|
||
|
|
parser.checkForSelectListKeywords($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 1277:
|
||
|
|
this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestTables: true, suggestDatabases: true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
|
||
|
|
break;
|
||
|
|
case 1279:
|
||
|
|
case 1280:
|
||
|
|
case 1282:
|
||
|
|
this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true, };
|
||
|
|
break;
|
||
|
|
case 1293:
|
||
|
|
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 1300:
|
||
|
|
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 1301:
|
||
|
|
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 1302:
|
||
|
|
this.$ = { joinType: $$[$0 - 1] };
|
||
|
|
break;
|
||
|
|
case 1303:
|
||
|
|
this.$ = { joinType: $$[$0 - 2] };
|
||
|
|
break;
|
||
|
|
case 1307:
|
||
|
|
if ($$[$0 - 3].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0 - 3].suggestKeywords);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1308:
|
||
|
|
case 1893:
|
||
|
|
if ($$[$0 - 1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0 - 1].suggestKeywords);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1311:
|
||
|
|
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 1316:
|
||
|
|
this.$ = 'JOIN';
|
||
|
|
break;
|
||
|
|
case 1317:
|
||
|
|
this.$ = 'ANTI JOIN';
|
||
|
|
break;
|
||
|
|
case 1318:
|
||
|
|
this.$ = 'CROSS JOIN';
|
||
|
|
break;
|
||
|
|
case 1319:
|
||
|
|
this.$ = 'INNER JOIN';
|
||
|
|
break;
|
||
|
|
case 1320:
|
||
|
|
this.$ = 'OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1321:
|
||
|
|
this.$ = 'SEMI JOIN';
|
||
|
|
break;
|
||
|
|
case 1322:
|
||
|
|
this.$ = 'FULL JOIN';
|
||
|
|
break;
|
||
|
|
case 1323:
|
||
|
|
this.$ = 'FULL OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1324:
|
||
|
|
this.$ = 'LEFT JOIN';
|
||
|
|
break;
|
||
|
|
case 1325:
|
||
|
|
this.$ = 'LEFT ANTI JOIN';
|
||
|
|
break;
|
||
|
|
case 1326:
|
||
|
|
this.$ = 'LEFT INNER JOIN';
|
||
|
|
break;
|
||
|
|
case 1327:
|
||
|
|
this.$ = 'LEFT OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1328:
|
||
|
|
this.$ = 'LEFT SEMI JOIN';
|
||
|
|
break;
|
||
|
|
case 1329:
|
||
|
|
this.$ = 'RIGHT JOIN';
|
||
|
|
break;
|
||
|
|
case 1330:
|
||
|
|
this.$ = 'RIGHT ANTI JOIN';
|
||
|
|
break;
|
||
|
|
case 1331:
|
||
|
|
case 1332:
|
||
|
|
this.$ = 'RIGHT OUTER JOIN';
|
||
|
|
break;
|
||
|
|
case 1333:
|
||
|
|
this.$ = 'RIGHT SEMI JOIN';
|
||
|
|
break;
|
||
|
|
case 1334:
|
||
|
|
case 1335:
|
||
|
|
case 1336:
|
||
|
|
case 1337:
|
||
|
|
case 1338:
|
||
|
|
case 1339:
|
||
|
|
case 1341:
|
||
|
|
case 1342:
|
||
|
|
case 1343:
|
||
|
|
case 1344:
|
||
|
|
case 1346:
|
||
|
|
case 1347:
|
||
|
|
case 1348:
|
||
|
|
case 1349:
|
||
|
|
this.$ = { suggestKeywords: ['JOIN'] };
|
||
|
|
break;
|
||
|
|
case 1340:
|
||
|
|
this.$ = { suggestKeywords: ['OUTER'] };
|
||
|
|
break;
|
||
|
|
case 1345:
|
||
|
|
this.$ = { suggestKeywords: parser.isImpala() ? ['ANTI', 'INNER', 'OUTER', 'SEMI'] : parser.isHive() ? ['OUTER', 'SEMI'] : ['OUTER'] };
|
||
|
|
break;
|
||
|
|
case 1350:
|
||
|
|
this.$ = { suggestKeywords: parser.isImpala() ? ['ANTI', 'INNER', 'OUTER', 'SEMI'] : ['OUTER'] };
|
||
|
|
break;
|
||
|
|
case 1351:
|
||
|
|
parser.suggestKeywords(['JOIN', 'OUTER JOIN']);
|
||
|
|
break;
|
||
|
|
case 1352:
|
||
|
|
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 1353:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['ANTI JOIN', 'INNER JOIN', 'JOIN', 'OUTER JOIN', 'SEMI JOIN']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['JOIN', 'OUTER JOIN']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1354:
|
||
|
|
this.$ = { noJoinCondition: true, suggestKeywords: parser.isImpala() ? ['ON', 'USING'] : ['ON'] };
|
||
|
|
break;
|
||
|
|
case 1355:
|
||
|
|
this.$ = { valueExpression: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 1356:
|
||
|
|
case 2183:
|
||
|
|
this.$ = {};
|
||
|
|
break;
|
||
|
|
case 1360:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestJoinConditions({ prependOn: false });
|
||
|
|
break;
|
||
|
|
case 1361:
|
||
|
|
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 1362:
|
||
|
|
this.$ = {
|
||
|
|
primary: $$[$0 - 2]
|
||
|
|
};
|
||
|
|
if ($$[$0 - 1]) {
|
||
|
|
if (this.$.primary) {
|
||
|
|
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 1363:
|
||
|
|
if ($$[$0 - 1]) {
|
||
|
|
parser.addTableAliasLocation($$[$0 - 1].location, $$[$0 - 1].alias, $$[$0 - 3].identifierChain);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1364:
|
||
|
|
case 1365:
|
||
|
|
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 1366:
|
||
|
|
if ($$[$0 - 1]) {
|
||
|
|
parser.addTablePrimary({ subQueryAlias: $$[$0 - 1].alias });
|
||
|
|
parser.addSubqueryAliasLocation($$[$0 - 1].location, $$[$0 - 1].alias);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1377:
|
||
|
|
parser.suggestKeywords(['BUCKET']);
|
||
|
|
break;
|
||
|
|
case 1378:
|
||
|
|
parser.suggestKeywords(['OUT OF']);
|
||
|
|
break;
|
||
|
|
case 1379:
|
||
|
|
parser.suggestKeywords(['OF']);
|
||
|
|
break;
|
||
|
|
case 1380:
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['ON']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1382:
|
||
|
|
if ($$[$0 - 2].indexOf('.') === -1) {
|
||
|
|
parser.suggestKeywords(['PERCENT', 'ROWS']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['PERCENT']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1384:
|
||
|
|
this.$ = { suggestKeywords: ['REPEATABLE()'] };
|
||
|
|
break;
|
||
|
|
case 1386:
|
||
|
|
parser.suggestKeywords(['SYSTEM()']);
|
||
|
|
break;
|
||
|
|
case 1391:
|
||
|
|
parser.pushQueryState();
|
||
|
|
break;
|
||
|
|
case 1392:
|
||
|
|
parser.popQueryState();
|
||
|
|
break;
|
||
|
|
case 1394:
|
||
|
|
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 1397:
|
||
|
|
var subQuery = parser.getSubQuery($$[$0]);
|
||
|
|
if (subQuery) {
|
||
|
|
subQuery.columns.forEach(function (column) {
|
||
|
|
parser.expandIdentifierChain({ wrapper: column });
|
||
|
|
delete column.linked;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
parser.popQueryState(subQuery);
|
||
|
|
this.$ = subQuery;
|
||
|
|
break;
|
||
|
|
case 1414:
|
||
|
|
case 1415:
|
||
|
|
this.$ = { alias: $$[$0], location: _$[$0] };
|
||
|
|
break;
|
||
|
|
case 1420:
|
||
|
|
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 1422:
|
||
|
|
if (!$$[$0]) {
|
||
|
|
$$[$0 - 1].suggestKeywords = ['OVER'];
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1431:
|
||
|
|
parser.suggestKeywords(['OVER']);
|
||
|
|
break;
|
||
|
|
case 1436:
|
||
|
|
case 1437:
|
||
|
|
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 1450:
|
||
|
|
this.$ = { expression: $$[$0 - 2] };
|
||
|
|
break;
|
||
|
|
case 1451:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { position: 1 };
|
||
|
|
break;
|
||
|
|
case 1452:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 1460:
|
||
|
|
case 1548:
|
||
|
|
case 1614:
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 2]) };
|
||
|
|
break;
|
||
|
|
case 1461:
|
||
|
|
this.$ = { function: $$[$0 - 3], expression: $$[$0 - 2], types: parser.findReturnTypes($$[$0 - 3]) };
|
||
|
|
break;
|
||
|
|
case 1462:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0 - 3], 1);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 3]) };
|
||
|
|
break;
|
||
|
|
case 1463:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2]);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1464:
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0 - 3], $$[$0 - 1].position);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 3]) };
|
||
|
|
break;
|
||
|
|
case 1472:
|
||
|
|
case 1473:
|
||
|
|
if (parser.yy.result.suggestFunctions) {
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1474:
|
||
|
|
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 1475:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 3], [{ value: 'ORDER BY', weight: 2 }]);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 3]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1479:
|
||
|
|
case 1824:
|
||
|
|
case 2302:
|
||
|
|
case 2303:
|
||
|
|
case 2306:
|
||
|
|
case 2316:
|
||
|
|
case 2350:
|
||
|
|
case 2359:
|
||
|
|
case 2377:
|
||
|
|
case 2434:
|
||
|
|
case 2435:
|
||
|
|
case 2440:
|
||
|
|
case 2445:
|
||
|
|
case 2449:
|
||
|
|
parser.suggestKeywords(['BY']);
|
||
|
|
break;
|
||
|
|
case 1484:
|
||
|
|
// Only allowed in last order by
|
||
|
|
delete parser.yy.result.suggestAnalyticFunctions;
|
||
|
|
break;
|
||
|
|
case 1485:
|
||
|
|
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 1491:
|
||
|
|
parser.suggestKeywords(parser.isHive() ? ['BETWEEN', 'UNBOUNDED'] : ['BETWEEN']);
|
||
|
|
break;
|
||
|
|
case 1492:
|
||
|
|
if (!$$[$0 - 2] && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED PRECEDING']);
|
||
|
|
}
|
||
|
|
else if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['AND']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1495:
|
||
|
|
if (!$$[$0 - 1] && parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['PRECEDING']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1497:
|
||
|
|
lexer.popState();
|
||
|
|
break;
|
||
|
|
case 1498:
|
||
|
|
lexer.begin('hdfs');
|
||
|
|
break;
|
||
|
|
case 1500:
|
||
|
|
parser.suggestHdfs({ path: $$[$0 - 3] });
|
||
|
|
break;
|
||
|
|
case 1501:
|
||
|
|
parser.suggestHdfs({ path: $$[$0 - 2] });
|
||
|
|
break;
|
||
|
|
case 1502:
|
||
|
|
parser.suggestHdfs({ path: $$[$0 - 1] });
|
||
|
|
break;
|
||
|
|
case 1503:
|
||
|
|
parser.suggestHdfs({ path: '' });
|
||
|
|
break;
|
||
|
|
case 1504:
|
||
|
|
parser.suggestHdfs({ path: '' });
|
||
|
|
break;
|
||
|
|
case 1510:
|
||
|
|
parser.suggestKeywords(['PRECEDING']);
|
||
|
|
break;
|
||
|
|
case 1511:
|
||
|
|
case 1521:
|
||
|
|
parser.suggestKeywords(['ROW']);
|
||
|
|
break;
|
||
|
|
case 1520:
|
||
|
|
parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED FOLLOWING']);
|
||
|
|
break;
|
||
|
|
case 1522:
|
||
|
|
parser.suggestKeywords(['FOLLOWING']);
|
||
|
|
break;
|
||
|
|
case 1528:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestSelectListAliases(true);
|
||
|
|
break;
|
||
|
|
case 1529:
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestSelectListAliases(true);
|
||
|
|
break;
|
||
|
|
case 1535:
|
||
|
|
case 1540:
|
||
|
|
this.$ = { types: [$$[$0 - 1].toUpperCase()] };
|
||
|
|
break;
|
||
|
|
case 1537:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: [$$[$0 - 1].toUpperCase()] };
|
||
|
|
break;
|
||
|
|
case 1538:
|
||
|
|
case 1539:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: ['T'] };
|
||
|
|
break;
|
||
|
|
case 1543:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 3], [{ value: 'AS', weight: 2 }]);
|
||
|
|
this.$ = { types: [$$[$0 - 1].toUpperCase()] };
|
||
|
|
break;
|
||
|
|
case 1544:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2], [{ value: 'AS', weight: 2 }]);
|
||
|
|
this.$ = { types: ['T'] };
|
||
|
|
break;
|
||
|
|
case 1545:
|
||
|
|
case 1546:
|
||
|
|
parser.suggestKeywords(parser.getTypeKeywords());
|
||
|
|
this.$ = { types: ['T'] };
|
||
|
|
break;
|
||
|
|
case 1547:
|
||
|
|
case 1569:
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 3]) };
|
||
|
|
break;
|
||
|
|
case 1549:
|
||
|
|
case 1570:
|
||
|
|
case 1613:
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1550:
|
||
|
|
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 1551:
|
||
|
|
case 1572:
|
||
|
|
case 1616:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2]);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 5]) };
|
||
|
|
break;
|
||
|
|
case 1552:
|
||
|
|
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 1553:
|
||
|
|
case 1557:
|
||
|
|
this.$ = { types: ['INT'] };
|
||
|
|
break;
|
||
|
|
case 1554:
|
||
|
|
parser.suggestKeywords(['DAY', 'DAYOFWEEK', 'HOUR', 'MINUTE', 'MONTH', 'QUARTER', 'SECOND', 'WEEK', 'YEAR']);
|
||
|
|
this.$ = { types: ['INT'] };
|
||
|
|
break;
|
||
|
|
case 1555:
|
||
|
|
case 1559:
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
this.$ = { types: ['INT'] };
|
||
|
|
break;
|
||
|
|
case 1556:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: ['INT'] };
|
||
|
|
break;
|
||
|
|
case 1558:
|
||
|
|
parser.suggestKeywords(['DAY', 'DAYOFWEEK', 'HOUR', 'MINUTE', 'MONTH', 'QUARTER', 'SECOND', 'WEEK', 'YEAR']);
|
||
|
|
this.$ = { types: ['INT'] };
|
||
|
|
break;
|
||
|
|
case 1571:
|
||
|
|
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 1573:
|
||
|
|
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 1599:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 5]) };
|
||
|
|
break;
|
||
|
|
case 1600:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 1].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1601:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions(['STRING', 'TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 3]) };
|
||
|
|
break;
|
||
|
|
case 1602:
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 5]) };
|
||
|
|
break;
|
||
|
|
case 1603:
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 1].toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1604:
|
||
|
|
parser.applyTypeToSuggestions(['STRING', 'TIMESTAMP']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 3]) };
|
||
|
|
break;
|
||
|
|
case 1605:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 5]) };
|
||
|
|
break;
|
||
|
|
case 1606:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 1].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1607:
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 2].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 5]) };
|
||
|
|
break;
|
||
|
|
case 1608:
|
||
|
|
parser.applyTypeToSuggestions($$[$0 - 1].toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1609:
|
||
|
|
if ($$[$0 - 3].types[0] === 'STRING') {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 3], ['FROM']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 3]);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 5]) };
|
||
|
|
break;
|
||
|
|
case 1610:
|
||
|
|
if ($$[$0 - 2].types[0] === 'STRING') {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2], ['FROM']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2]);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1615:
|
||
|
|
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 1617:
|
||
|
|
if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) {
|
||
|
|
parser.applyArgumentTypesToSuggestions($$[$0 - 4], 1);
|
||
|
|
}
|
||
|
|
this.$ = { types: parser.findReturnTypes($$[$0 - 4]) };
|
||
|
|
break;
|
||
|
|
case 1618:
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0 - 2], tableAlias: $$[$0 - 1], columnAliases: $$[$0] } };
|
||
|
|
break;
|
||
|
|
case 1619:
|
||
|
|
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 1620:
|
||
|
|
this.$ = { lateralView: { udtf: $$[$0 - 1], columnAliases: $$[$0] } };
|
||
|
|
break;
|
||
|
|
case 1621:
|
||
|
|
case 1622:
|
||
|
|
case 1623:
|
||
|
|
case 1624:
|
||
|
|
this.$ = {};
|
||
|
|
break;
|
||
|
|
case 1631:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'OUTER', weight: 2 }, { value: 'explode', weight: 1 }, { value: 'posexplode', weight: 1 }]);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['explode', 'posexplode']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1632:
|
||
|
|
parser.suggestKeywords(['VIEW']);
|
||
|
|
break;
|
||
|
|
case 1636:
|
||
|
|
this.$ = [$$[$0 - 2], $$[$0]];
|
||
|
|
break;
|
||
|
|
case 1640:
|
||
|
|
this.$ = { inValueEdit: true };
|
||
|
|
break;
|
||
|
|
case 1641:
|
||
|
|
this.$ = { inValueEdit: true, cursorAtStart: true };
|
||
|
|
break;
|
||
|
|
case 1642:
|
||
|
|
case 1643:
|
||
|
|
case 1644:
|
||
|
|
case 1645:
|
||
|
|
case 1646:
|
||
|
|
this.$ = { suggestKeywords: ['NOT'] };
|
||
|
|
break;
|
||
|
|
case 1652:
|
||
|
|
case 1653:
|
||
|
|
case 1654:
|
||
|
|
case 1655:
|
||
|
|
case 1656:
|
||
|
|
parser.suggestFunctions({ types: ['STRING'] });
|
||
|
|
parser.suggestColumns({ types: ['STRING'] });
|
||
|
|
this.$ = { types: ['BOOLEAN'] };
|
||
|
|
break;
|
||
|
|
case 1657:
|
||
|
|
case 1659:
|
||
|
|
this.$ = parser.findCaseType($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 1658:
|
||
|
|
case 1661:
|
||
|
|
$$[$0 - 3].caseTypes.push($$[$0 - 1]);
|
||
|
|
this.$ = parser.findCaseType($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 1660:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 1], ['END']);
|
||
|
|
$$[$0 - 3].caseTypes.push($$[$0 - 1]);
|
||
|
|
this.$ = parser.findCaseType($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 1662:
|
||
|
|
this.$ = parser.findCaseType($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 1663:
|
||
|
|
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 1664:
|
||
|
|
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 1665:
|
||
|
|
$$[$0 - 3].caseTypes.push($$[$0 - 1]);
|
||
|
|
this.$ = parser.findCaseType($$[$0 - 3]);
|
||
|
|
this.$.suggestFilters = $$[$0 - 1].suggestFilters;
|
||
|
|
break;
|
||
|
|
case 1666:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = parser.findCaseType($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 1667:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { types: ['T'], typeSet: true };
|
||
|
|
break;
|
||
|
|
case 1668:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = $$[$0 - 1];
|
||
|
|
break;
|
||
|
|
case 1669:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { types: ['T'] };
|
||
|
|
break;
|
||
|
|
case 1672:
|
||
|
|
this.$ = { caseTypes: [$$[$0]], lastType: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 1673:
|
||
|
|
$$[$0 - 1].caseTypes.push($$[$0]);
|
||
|
|
this.$ = { caseTypes: $$[$0 - 1].caseTypes, lastType: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 1677:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2], ['WHEN']);
|
||
|
|
break;
|
||
|
|
case 1680:
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1681:
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0 - 1].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1682:
|
||
|
|
this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0 - 2].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1683:
|
||
|
|
case 1684:
|
||
|
|
this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0].suggestFilters };
|
||
|
|
break;
|
||
|
|
case 1685:
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
break;
|
||
|
|
case 1686:
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [$$[$0]] };
|
||
|
|
break;
|
||
|
|
case 1687:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
break;
|
||
|
|
case 1688:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
break;
|
||
|
|
case 1689:
|
||
|
|
case 1691:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true };
|
||
|
|
break;
|
||
|
|
case 1690:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
parser.suggestKeywords(['THEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true };
|
||
|
|
break;
|
||
|
|
case 1692:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { caseTypes: [$$[$0]], suggestFilters: true };
|
||
|
|
break;
|
||
|
|
case 1693:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 1], ['THEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
break;
|
||
|
|
case 1694:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 2], ['THEN']);
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
break;
|
||
|
|
case 1695:
|
||
|
|
case 1696:
|
||
|
|
case 1697:
|
||
|
|
case 1698:
|
||
|
|
parser.valueExpressionSuggest();
|
||
|
|
this.$ = { caseTypes: [{ types: ['T'] }] };
|
||
|
|
break;
|
||
|
|
case 1707:
|
||
|
|
case 1708:
|
||
|
|
this.$ = { cursorAtStart: false, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
|
||
|
|
break;
|
||
|
|
case 1716:
|
||
|
|
case 2139:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1718:
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1735:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'INDEX', 'SCHEMA', 'TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1736:
|
||
|
|
case 1738:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 3], [{ name: $$[$0 - 3] }]);
|
||
|
|
break;
|
||
|
|
case 1737:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 2], [{ name: $$[$0 - 2] }]);
|
||
|
|
break;
|
||
|
|
case 1739:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestDatabases();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1740:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 1], [{ name: $$[$0 - 1] }]);
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['SET DBPROPERTIES', 'SET LOCATION', 'SET OWNER']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1741:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 2], [{ name: $$[$0 - 2] }]);
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DBPROPERTIES', 'LOCATION', 'OWNER']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1742:
|
||
|
|
case 2036:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 2], [{ name: $$[$0 - 2] }]);
|
||
|
|
break;
|
||
|
|
case 1743:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 3], [{ name: $$[$0 - 3] }]);
|
||
|
|
parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
|
||
|
|
break;
|
||
|
|
case 1744:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 3], [{ name: $$[$0 - 3] }]);
|
||
|
|
break;
|
||
|
|
case 1746:
|
||
|
|
case 1829:
|
||
|
|
case 2378:
|
||
|
|
case 2753:
|
||
|
|
case 3078:
|
||
|
|
case 3288:
|
||
|
|
case 3304:
|
||
|
|
case 3306:
|
||
|
|
parser.suggestKeywords(['ON']);
|
||
|
|
break;
|
||
|
|
case 1750:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['PARTITION', 'REBUILD']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['REBUILD']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1771:
|
||
|
|
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 1772:
|
||
|
|
case 1793:
|
||
|
|
case 2063:
|
||
|
|
parser.suggestKeywords(['COLUMNS']);
|
||
|
|
break;
|
||
|
|
case 1777:
|
||
|
|
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 1779:
|
||
|
|
case 1812:
|
||
|
|
case 1820:
|
||
|
|
case 1832:
|
||
|
|
case 1910:
|
||
|
|
case 1936:
|
||
|
|
case 3360:
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
break;
|
||
|
|
case 1780:
|
||
|
|
case 1937:
|
||
|
|
parser.suggestKeywords(['VALUE']);
|
||
|
|
break;
|
||
|
|
case 1784:
|
||
|
|
parser.suggestKeywords(['FOREIGN KEY', 'PRIMARY KEY']);
|
||
|
|
break;
|
||
|
|
case 1791:
|
||
|
|
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 1792:
|
||
|
|
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 1794:
|
||
|
|
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 1795:
|
||
|
|
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 1797:
|
||
|
|
case 2024:
|
||
|
|
case 2811:
|
||
|
|
case 2827:
|
||
|
|
parser.suggestKeywords(['TO']);
|
||
|
|
break;
|
||
|
|
case 1799:
|
||
|
|
case 1821:
|
||
|
|
case 2311:
|
||
|
|
parser.suggestKeywords(['PARTITIONS']);
|
||
|
|
break;
|
||
|
|
case 1816:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['SKEWED', 'STORED AS DIRECTORIES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1817:
|
||
|
|
case 2013:
|
||
|
|
parser.suggestKeywords(['AS DIRECTORIES']);
|
||
|
|
break;
|
||
|
|
case 1818:
|
||
|
|
case 2014:
|
||
|
|
parser.suggestKeywords(['DIRECTORIES']);
|
||
|
|
break;
|
||
|
|
case 1819:
|
||
|
|
parser.suggestKeywords(['TO PARTITION']);
|
||
|
|
break;
|
||
|
|
case 1822:
|
||
|
|
case 2491:
|
||
|
|
case 2510:
|
||
|
|
parser.suggestKeywords(['LOCATION']);
|
||
|
|
break;
|
||
|
|
case 1825:
|
||
|
|
case 2807:
|
||
|
|
case 2812:
|
||
|
|
case 2816:
|
||
|
|
case 2883:
|
||
|
|
case 2884:
|
||
|
|
case 2885:
|
||
|
|
case 2918:
|
||
|
|
case 2926:
|
||
|
|
case 2929:
|
||
|
|
case 2932:
|
||
|
|
case 2937:
|
||
|
|
case 2940:
|
||
|
|
parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
|
||
|
|
break;
|
||
|
|
case 1830:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['STORED AS DIRECTORIES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1834:
|
||
|
|
case 1841:
|
||
|
|
case 1875:
|
||
|
|
case 1878:
|
||
|
|
case 1880:
|
||
|
|
parser.addColumnLocation($$[$0 - 3].location, [$$[$0 - 3].identifier]);
|
||
|
|
break;
|
||
|
|
case 1835:
|
||
|
|
parser.addColumnLocation($$[$0 - 2].location, [$$[$0 - 2].identifier]);
|
||
|
|
break;
|
||
|
|
case 1836:
|
||
|
|
case 1844:
|
||
|
|
case 1845:
|
||
|
|
parser.addColumnLocation($$[$0 - 1].location, [$$[$0 - 1].identifier]);
|
||
|
|
break;
|
||
|
|
case 1837:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['COLUMN']);
|
||
|
|
}
|
||
|
|
parser.suggestColumns();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1838:
|
||
|
|
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 1839:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['DEFAULT']);
|
||
|
|
parser.addColumnLocation($$[$0 - 2].location, [$$[$0 - 2].identifier]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1840:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['BLOCK_SIZE', 'COMMENT', 'COMPRESSION', 'DEFAULT', 'ENCODING']);
|
||
|
|
parser.addColumnLocation($$[$0 - 2].location, [$$[$0 - 2].identifier]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1842:
|
||
|
|
case 2093:
|
||
|
|
case 2735:
|
||
|
|
case 3237:
|
||
|
|
case 3361:
|
||
|
|
parser.suggestKeywords(['STATS']);
|
||
|
|
break;
|
||
|
|
case 1862:
|
||
|
|
parser.suggestIdentifiers(['\'avgSize\'', '\'maxSize\'', '\'numDVs\'', '\'numNulls\'']);
|
||
|
|
break;
|
||
|
|
case 1877:
|
||
|
|
if (parser.isHive() && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['COLUMN']);
|
||
|
|
}
|
||
|
|
parser.suggestColumns();
|
||
|
|
break;
|
||
|
|
case 1879:
|
||
|
|
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 1881:
|
||
|
|
if (!$$[$0 - 2] && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['AND WAIT', 'WITH OVERWRITE TBLPROPERTIES']);
|
||
|
|
}
|
||
|
|
else if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['WITH OVERWRITE TBLPROPERTIES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1884:
|
||
|
|
parser.suggestKeywords(['NO_DROP', 'OFFLINE']);
|
||
|
|
break;
|
||
|
|
case 1886:
|
||
|
|
case 2398:
|
||
|
|
parser.suggestFileFormats();
|
||
|
|
break;
|
||
|
|
case 1889:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['WITH REPLICATION =']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1891:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['FORMAT']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1892:
|
||
|
|
case 3024:
|
||
|
|
parser.suggestKeywords(['DELIMITED']);
|
||
|
|
break;
|
||
|
|
case 1895:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['WITH SERDEPROPERTIES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1899:
|
||
|
|
parser.suggestKeywords(['WAIT']);
|
||
|
|
break;
|
||
|
|
case 1902:
|
||
|
|
parser.suggestKeywords(['OVERWRITE TBLPROPERTIES']);
|
||
|
|
break;
|
||
|
|
case 1903:
|
||
|
|
parser.suggestKeywords(['TBLPROPERTIES']);
|
||
|
|
break;
|
||
|
|
case 1906:
|
||
|
|
if (parser.isHive() && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['CASCADE', 'RESTRICT']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1911:
|
||
|
|
parser.suggestKeywords(['WITH TABLE']);
|
||
|
|
break;
|
||
|
|
case 1912:
|
||
|
|
case 2031:
|
||
|
|
case 2045:
|
||
|
|
case 2603:
|
||
|
|
case 2627:
|
||
|
|
case 2767:
|
||
|
|
case 3158:
|
||
|
|
case 3167:
|
||
|
|
case 3292:
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
break;
|
||
|
|
case 1930:
|
||
|
|
parser.addColumnLocation($$[$0].location, [$$[$0].identifier]);
|
||
|
|
break;
|
||
|
|
case 1931:
|
||
|
|
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 1933:
|
||
|
|
if (parser.isHive() && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['PURGE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1944:
|
||
|
|
case 2047:
|
||
|
|
case 2744:
|
||
|
|
if (parser.yy.result.suggestTables) {
|
||
|
|
parser.yy.result.suggestTables.onlyTables = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1945:
|
||
|
|
case 2032:
|
||
|
|
case 2046:
|
||
|
|
parser.suggestTables({ onlyTables: true });
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 1970:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['CASCADE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1978:
|
||
|
|
case 1979:
|
||
|
|
case 1980:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 1996:
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['LOCATION'] };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2020:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['AS', 'SET TBLPROPERTIES']);
|
||
|
|
}
|
||
|
|
else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['AS', 'RENAME TO']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['AS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2021:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['TBLPROPERTIES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2027:
|
||
|
|
case 2033:
|
||
|
|
case 2765:
|
||
|
|
if (parser.yy.result.suggestTables) {
|
||
|
|
parser.yy.result.suggestTables.onlyViews = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2028:
|
||
|
|
parser.suggestTables({ onlyViews: true });
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 2030:
|
||
|
|
parser.suggestKeywords(['REPAIR TABLE']);
|
||
|
|
break;
|
||
|
|
case 2035:
|
||
|
|
case 2502:
|
||
|
|
case 2713:
|
||
|
|
parser.suggestKeywords(['FUNCTION']);
|
||
|
|
break;
|
||
|
|
case 2037:
|
||
|
|
parser.suggestKeywords(['ON DATABASE']);
|
||
|
|
break;
|
||
|
|
case 2038:
|
||
|
|
parser.suggestKeywords(['DATABASE']);
|
||
|
|
break;
|
||
|
|
case 2040:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 1], [{ name: $$[$0 - 1] }]);
|
||
|
|
parser.suggestKeywords(['IS']);
|
||
|
|
break;
|
||
|
|
case 2041:
|
||
|
|
parser.addDatabaseLocation(_$[$0 - 2], [{ name: $$[$0 - 2] }]);
|
||
|
|
parser.suggestKeywords(['NULL']);
|
||
|
|
break;
|
||
|
|
case 2044:
|
||
|
|
parser.addTablePrimary($$[$0 - 6]);
|
||
|
|
break;
|
||
|
|
case 2049:
|
||
|
|
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 2050:
|
||
|
|
parser.addTablePrimary($$[$0 - 3]);
|
||
|
|
parser.suggestKeywords(['STATISTICS']);
|
||
|
|
break;
|
||
|
|
case 2051:
|
||
|
|
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 2052:
|
||
|
|
parser.addTablePrimary($$[$0 - 7]);
|
||
|
|
parser.suggestKeywords(parser.getKeywordsForOptionalsLR([$$[$0 - 1], $$[$0]], [{ value: 'CACHE METADATA', weight: 2 }, { value: 'NOSCAN', weight: 1 }]));
|
||
|
|
break;
|
||
|
|
case 2053:
|
||
|
|
parser.addTablePrimary($$[$0 - 7]);
|
||
|
|
parser.suggestKeywords(parser.getKeywordsForOptionalsLR([$$[$0]], [{ value: 'NOSCAN', weight: 1 }]));
|
||
|
|
break;
|
||
|
|
case 2054:
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 2055:
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
parser.addTablePrimary($$[$0 - 6]);
|
||
|
|
break;
|
||
|
|
case 2067:
|
||
|
|
case 2079:
|
||
|
|
parser.suggestKeywords(['METADATA']);
|
||
|
|
break;
|
||
|
|
case 2072:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
parser.suggestKeywords(['FUNCTIONS']);
|
||
|
|
break;
|
||
|
|
case 2074:
|
||
|
|
case 3130:
|
||
|
|
case 3270:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2082:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
parser.suggestKeywords(['METADATA']);
|
||
|
|
break;
|
||
|
|
case 2085:
|
||
|
|
parser.suggestKeywords(['STATS', 'INCREMENTAL STATS']);
|
||
|
|
break;
|
||
|
|
case 2088:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['STATS', 'INCREMENTAL STATS']);
|
||
|
|
break;
|
||
|
|
case 2089:
|
||
|
|
parser.addTablePrimary($$[$0 - 3]);
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['TABLESAMPLE']);
|
||
|
|
}
|
||
|
|
else if ($$[$0 - 1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords($$[$0 - 1].suggestKeywords);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2092:
|
||
|
|
case 2734:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['INCREMENTAL']);
|
||
|
|
break;
|
||
|
|
case 2094:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['STATS']);
|
||
|
|
break;
|
||
|
|
case 2097:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2112:
|
||
|
|
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 2115:
|
||
|
|
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 2130:
|
||
|
|
parser.suggestKeywords(['DBPROPERTIES']);
|
||
|
|
break;
|
||
|
|
case 2152:
|
||
|
|
var keywords = [];
|
||
|
|
if (!$$[$0 - 10] && !$$[$0 - 9] && !$$[$0 - 8] && !$$[$0 - 7] && !$$[$0 - 6] && !$$[$0 - 5] && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'LIKE', weight: 1 });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push({ value: 'LIKE PARQUET', weight: 1 });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if (!$$[$0 - 9] && !$$[$0 - 8] && !$$[$0 - 7] && !$$[$0 - 6] && !$$[$0 - 5] && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'COMMENT', weight: 11 });
|
||
|
|
}
|
||
|
|
if (!$$[$0 - 8] && !$$[$0 - 7] && !$$[$0 - 6] && !$$[$0 - 5] && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'PARTITIONED BY', weight: 10 });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
keywords.push({ value: 'PARTITION BY', weight: 10 });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0 - 7] && !$$[$0 - 6] && !$$[$0 - 5] && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'SORT BY', weight: 9 });
|
||
|
|
}
|
||
|
|
if (parser.isHive() && !$$[$0 - 6] && !$$[$0 - 5] && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'CLUSTERED BY', weight: 8 });
|
||
|
|
}
|
||
|
|
if (parser.isHive() && !$$[$0 - 5] && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'SKEWED BY', weight: 7 });
|
||
|
|
}
|
||
|
|
else if (parser.isHive() && $$[$0 - 5] && $$[$0 - 5].suggestKeywords && !$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0 - 1]) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0 - 5].suggestKeywords, 7)); // Get the last optional from SKEWED BY
|
||
|
|
}
|
||
|
|
if (!$$[$0 - 4] && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
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 - 4] && $$[$0 - 4].suggestKeywords && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0 - 4].suggestKeywords, 6));
|
||
|
|
}
|
||
|
|
if ((($$[$0 - 4] && $$[$0 - 4].storedBy) || parser.isImpala()) && !$$[$0 - 3] && !$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'WITH SERDEPROPERTIES', weight: 5 });
|
||
|
|
}
|
||
|
|
if (!$$[$0 - 2] && !$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'LOCATION', weight: 4 });
|
||
|
|
}
|
||
|
|
if (!$$[$0 - 1] && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'TBLPROPERTIES', weight: 3 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && !$$[$0]) {
|
||
|
|
keywords.push({ value: 'CACHED IN', weight: 2 }, { value: 'UNCACHED', weight: 2 });
|
||
|
|
}
|
||
|
|
if (parser.isImpala() && $$[$0] && $$[$0].suggestKeywords) {
|
||
|
|
keywords = keywords.concat(parser.createWeightedKeywords($$[$0].suggestKeywords, 2));
|
||
|
|
}
|
||
|
|
keywords.push({ value: 'AS', weight: 1 });
|
||
|
|
}
|
||
|
|
if (keywords.length > 0) {
|
||
|
|
parser.suggestKeywords(keywords);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2162:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PARQUET']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2168:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PRIMARY KEY']);
|
||
|
|
}
|
||
|
|
else if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords([{ value: 'PRIMARY KEY', weight: 2 }, { value: 'CONSTRAINT', weight: 1 }]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2175:
|
||
|
|
case 2177:
|
||
|
|
case 2370:
|
||
|
|
parser.checkForKeywords($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 2176:
|
||
|
|
case 2178:
|
||
|
|
parser.checkForKeywords($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 2179:
|
||
|
|
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 2180:
|
||
|
|
case 2216:
|
||
|
|
case 2222:
|
||
|
|
case 2223:
|
||
|
|
case 2236:
|
||
|
|
case 2239:
|
||
|
|
case 2251:
|
||
|
|
case 2253:
|
||
|
|
case 2653:
|
||
|
|
parser.suggestKeywords(parser.getColumnDataTypeKeywords());
|
||
|
|
break;
|
||
|
|
case 2185:
|
||
|
|
this.$ = {};
|
||
|
|
this.$[$$[$0]] = true;
|
||
|
|
break;
|
||
|
|
case 2186:
|
||
|
|
$$[$0 - 1][$$[$0]] = true;
|
||
|
|
break;
|
||
|
|
case 2191:
|
||
|
|
this.$ = 'primary';
|
||
|
|
break;
|
||
|
|
case 2192:
|
||
|
|
this.$ = 'encoding';
|
||
|
|
break;
|
||
|
|
case 2193:
|
||
|
|
this.$ = 'compression';
|
||
|
|
break;
|
||
|
|
case 2194:
|
||
|
|
this.$ = 'default';
|
||
|
|
break;
|
||
|
|
case 2195:
|
||
|
|
this.$ = 'block_size';
|
||
|
|
break;
|
||
|
|
case 2196:
|
||
|
|
case 2197:
|
||
|
|
this.$ = 'null';
|
||
|
|
break;
|
||
|
|
case 2198:
|
||
|
|
this.$ = 'comment';
|
||
|
|
break;
|
||
|
|
case 2200:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['NULL']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2221:
|
||
|
|
case 2537:
|
||
|
|
case 2548:
|
||
|
|
case 2571:
|
||
|
|
parser.suggestKeywords(parser.getTypeKeywords());
|
||
|
|
break;
|
||
|
|
case 2235:
|
||
|
|
case 2238:
|
||
|
|
parser.suggestKeywords(['COMMENT']);
|
||
|
|
break;
|
||
|
|
case 2263:
|
||
|
|
parser.suggestKeywords(['CONSTRAINT']);
|
||
|
|
break;
|
||
|
|
case 2264:
|
||
|
|
case 2267:
|
||
|
|
parser.suggestKeywords(['FOREIGN KEY']);
|
||
|
|
break;
|
||
|
|
case 2269:
|
||
|
|
parser.suggestKeywords(['PRIMARY KEY']);
|
||
|
|
break;
|
||
|
|
case 2273:
|
||
|
|
parser.suggestKeywords(['DISABLE NOVALIDATE']);
|
||
|
|
break;
|
||
|
|
case 2274:
|
||
|
|
parser.suggestKeywords(['NOVALIDATE']);
|
||
|
|
break;
|
||
|
|
case 2276:
|
||
|
|
case 3165:
|
||
|
|
case 3172:
|
||
|
|
case 3179:
|
||
|
|
parser.addTablePrimary($$[$0 - 4]);
|
||
|
|
break;
|
||
|
|
case 2277:
|
||
|
|
case 2294:
|
||
|
|
case 2296:
|
||
|
|
parser.suggestKeywords(['KEY']);
|
||
|
|
break;
|
||
|
|
case 2279:
|
||
|
|
parser.suggestKeywords(['REFERENCES']);
|
||
|
|
break;
|
||
|
|
case 2283:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
parser.suggestKeywords(['DISABLE NOVALIDATE']);
|
||
|
|
break;
|
||
|
|
case 2284:
|
||
|
|
parser.addTablePrimary($$[$0 - 3]);
|
||
|
|
parser.suggestKeywords(['NOVALIDATE']);
|
||
|
|
break;
|
||
|
|
case 2285:
|
||
|
|
parser.addTablePrimary($$[$0 - 5]);
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['NORELY', 'RELY']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2307:
|
||
|
|
parser.suggestKeywords(['HASH', 'RANGE']);
|
||
|
|
break;
|
||
|
|
case 2319:
|
||
|
|
case 2324:
|
||
|
|
case 2325:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2332:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['VALUE', 'VALUES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2334:
|
||
|
|
case 2641:
|
||
|
|
case 3074:
|
||
|
|
parser.suggestFunctions();
|
||
|
|
break;
|
||
|
|
case 2335:
|
||
|
|
if ($$[$0].endsWithLessThanOrEqual && parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2336:
|
||
|
|
case 2339:
|
||
|
|
case 2342:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['<', '<=']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2337:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2340:
|
||
|
|
case 2343:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestFunctions();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2353:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords([{ value: 'INTO', weight: 1 }, { value: 'SORTED BY', weight: 2 }]);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['INTO']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2354:
|
||
|
|
parser.suggestKeywords(['BUCKETS']);
|
||
|
|
break;
|
||
|
|
case 2375:
|
||
|
|
this.$ = { suggestKeywords: ['STORED AS DIRECTORIES'] };
|
||
|
|
break;
|
||
|
|
case 2385:
|
||
|
|
this.$ = parser.mergeSuggestKeywords($$[$0 - 1], $$[$0]);
|
||
|
|
break;
|
||
|
|
case 2386:
|
||
|
|
case 2387:
|
||
|
|
this.$ = { storedBy: true };
|
||
|
|
break;
|
||
|
|
case 2388:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['AS', 'BY']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['AS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2390:
|
||
|
|
parser.suggestKeywords(['FORMAT']);
|
||
|
|
break;
|
||
|
|
case 2391:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DELIMITED', 'SERDE']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['DELIMITED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2395:
|
||
|
|
this.$ = { suggestKeywords: ['STORED AS'] };
|
||
|
|
break;
|
||
|
|
case 2421:
|
||
|
|
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 2427:
|
||
|
|
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 2431:
|
||
|
|
this.$ = { suggestKeywords: ['ESCAPED BY'] };
|
||
|
|
break;
|
||
|
|
case 2433:
|
||
|
|
case 2439:
|
||
|
|
case 2444:
|
||
|
|
case 2448:
|
||
|
|
parser.suggestKeywords(['TERMINATED BY']);
|
||
|
|
break;
|
||
|
|
case 2438:
|
||
|
|
parser.suggestKeywords(['ITEMS TERMINATED BY']);
|
||
|
|
break;
|
||
|
|
case 2443:
|
||
|
|
parser.suggestKeywords(['KEYS TERMINATED BY']);
|
||
|
|
break;
|
||
|
|
case 2452:
|
||
|
|
parser.suggestKeywords(['DEFINED AS']);
|
||
|
|
break;
|
||
|
|
case 2458:
|
||
|
|
case 2459:
|
||
|
|
parser.suggestKeywords(['SERDEPROPERTIES']);
|
||
|
|
break;
|
||
|
|
case 2469:
|
||
|
|
parser.commitLocations();
|
||
|
|
break;
|
||
|
|
case 2471:
|
||
|
|
case 2488:
|
||
|
|
case 2504:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 2472:
|
||
|
|
if (!$$[$0 - 7]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2475:
|
||
|
|
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 2489:
|
||
|
|
if (!$$[$0 - 6]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2490:
|
||
|
|
case 2509:
|
||
|
|
parser.suggestKeywords(['RETURNS']);
|
||
|
|
break;
|
||
|
|
case 2492:
|
||
|
|
parser.suggestKeywords(['SYMBOL']);
|
||
|
|
break;
|
||
|
|
case 2503:
|
||
|
|
if (!$$[$0 - 13]) {
|
||
|
|
parser.suggestKeywords(['IF NOT EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2511:
|
||
|
|
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 2512:
|
||
|
|
parser.suggestKeywords(['MERGE_FN']);
|
||
|
|
break;
|
||
|
|
case 2513:
|
||
|
|
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 2532:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['USING']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['ARCHIVE', 'FILE', 'JAR']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2538:
|
||
|
|
parser.suggestKeywords(['...']);
|
||
|
|
break;
|
||
|
|
case 2573:
|
||
|
|
parser.suggestFunctions();
|
||
|
|
parser.suggestAggregateFunctions();
|
||
|
|
parser.suggestAnalyticFunctions();
|
||
|
|
break;
|
||
|
|
case 2576:
|
||
|
|
parser.suggestKeywords(['ARCHIVE', 'FILE', 'JAR']);
|
||
|
|
break;
|
||
|
|
case 2588:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['COMMENT']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2592:
|
||
|
|
case 2594:
|
||
|
|
this.$ = $$[$0 - 3];
|
||
|
|
break;
|
||
|
|
case 2602:
|
||
|
|
parser.suggestKeywords(['ON TABLE']);
|
||
|
|
break;
|
||
|
|
case 2608:
|
||
|
|
case 2618:
|
||
|
|
parser.suggestKeywords(['\'BITMAP\'', '\'COMPACT\'']);
|
||
|
|
break;
|
||
|
|
case 2616:
|
||
|
|
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 2621:
|
||
|
|
parser.suggestKeywords(['DEFERRED REBUILD']);
|
||
|
|
break;
|
||
|
|
case 2622:
|
||
|
|
parser.suggestKeywords(['REBUILD']);
|
||
|
|
break;
|
||
|
|
case 2667:
|
||
|
|
case 2669:
|
||
|
|
parser.addCommonTableExpressions($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 2693:
|
||
|
|
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 2697:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases();
|
||
|
|
break;
|
||
|
|
case 2698:
|
||
|
|
if (parser.isHive() || parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['CASCADE', 'RESTRICT']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2700:
|
||
|
|
case 2709:
|
||
|
|
case 2714:
|
||
|
|
if (!$$[$0 - 3]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2707:
|
||
|
|
case 2708:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 2711:
|
||
|
|
parser.suggestKeywords(['AGGREGATE']);
|
||
|
|
break;
|
||
|
|
case 2721:
|
||
|
|
case 2726:
|
||
|
|
case 2758:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2722:
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2733:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
parser.suggestKeywords(['INCREMENTAL']);
|
||
|
|
break;
|
||
|
|
case 2739:
|
||
|
|
case 3330:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
break;
|
||
|
|
case 2743:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestTables({ onlyTables: true });
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
case 2746:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['PURGE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2751:
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
break;
|
||
|
|
case 2757:
|
||
|
|
parser.suggestKeywords(['FUNCTION', 'MACRO']);
|
||
|
|
break;
|
||
|
|
case 2761:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
parser.suggestTables({ onlyViews: true });
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 2762:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2768:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
if (parser.isImpala() && !$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2771:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (parser.isHive() && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2773:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (parser.isImpala() && !$$[$0 - 3]) {
|
||
|
|
parser.suggestKeywords(['IF EXISTS']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2776:
|
||
|
|
case 2931:
|
||
|
|
case 2936:
|
||
|
|
case 2939:
|
||
|
|
case 2943:
|
||
|
|
case 2951:
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
break;
|
||
|
|
case 2778:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['WHERE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2782:
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
if (parser.isImpala() && !$$[$0 - 1]) {
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2785:
|
||
|
|
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 2794:
|
||
|
|
parser.suggestKeywords(['TRANSACTIONS']);
|
||
|
|
break;
|
||
|
|
case 2803:
|
||
|
|
parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'ROLE', 'SELECT', 'UPDATE']);
|
||
|
|
break;
|
||
|
|
case 2806:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['ON', 'TO']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['TO']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2809:
|
||
|
|
case 2829:
|
||
|
|
case 2831:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['WITH GRANT OPTION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2814:
|
||
|
|
case 2818:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['WITH ADMIN OPTION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2820:
|
||
|
|
case 2944:
|
||
|
|
parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DROP', 'INSERT', 'REFRESH', 'ROLE', 'SELECT']);
|
||
|
|
break;
|
||
|
|
case 2821:
|
||
|
|
parser.suggestKeywords(['TO GROUP']);
|
||
|
|
break;
|
||
|
|
case 2822:
|
||
|
|
case 2946:
|
||
|
|
case 3343:
|
||
|
|
case 3344:
|
||
|
|
parser.suggestKeywords(['GROUP']);
|
||
|
|
break;
|
||
|
|
case 2824:
|
||
|
|
case 2948:
|
||
|
|
if ($$[$0 - 1].isCreate) {
|
||
|
|
parser.suggestKeywords(['ON DATABASE', 'ON SERVER']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['ON DATABASE', 'ON SERVER', 'ON TABLE', 'ON URI']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2825:
|
||
|
|
if ($$[$0 - 2].isCreate) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER', 'TABLE', 'URI']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2828:
|
||
|
|
case 2935:
|
||
|
|
case 2952:
|
||
|
|
case 3293:
|
||
|
|
parser.suggestKeywords(['ROLE']);
|
||
|
|
break;
|
||
|
|
case 2835:
|
||
|
|
parser.suggestKeywords(['DATABASE', 'TABLE']);
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 2851:
|
||
|
|
if ($$[$0].toUpperCase() === 'ALL') {
|
||
|
|
this.$ = { singleAll: true };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2857:
|
||
|
|
case 2858:
|
||
|
|
case 2859:
|
||
|
|
case 2922:
|
||
|
|
parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'SELECT', 'SHOW_DATABASE', 'UPDATE']);
|
||
|
|
break;
|
||
|
|
case 2875:
|
||
|
|
this.$ = { isCreate: true };
|
||
|
|
break;
|
||
|
|
case 2897:
|
||
|
|
parser.suggestKeywords(['GRANT OPTION']);
|
||
|
|
break;
|
||
|
|
case 2898:
|
||
|
|
case 2899:
|
||
|
|
case 2903:
|
||
|
|
case 2955:
|
||
|
|
parser.suggestKeywords(['OPTION']);
|
||
|
|
break;
|
||
|
|
case 2902:
|
||
|
|
parser.suggestKeywords(['ADMIN OPTION']);
|
||
|
|
break;
|
||
|
|
case 2914:
|
||
|
|
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 2917:
|
||
|
|
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 2920:
|
||
|
|
parser.suggestKeywords(['OPTION FOR']);
|
||
|
|
break;
|
||
|
|
case 2921:
|
||
|
|
case 2934:
|
||
|
|
parser.suggestKeywords(['FOR']);
|
||
|
|
break;
|
||
|
|
case 2925:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['FROM', 'ON']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2928:
|
||
|
|
if ($$[$0 - 1].toUpperCase() === 'ADMIN') {
|
||
|
|
parser.suggestKeywords(['FROM', 'OPTION FOR']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2945:
|
||
|
|
parser.suggestKeywords(['FROM GROUP']);
|
||
|
|
break;
|
||
|
|
case 2949:
|
||
|
|
if ($$[$0 - 2].isCreate) {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SERVER', 'TABLE', 'URI']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2966:
|
||
|
|
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 2969:
|
||
|
|
if (!$$[$0].keepTables) {
|
||
|
|
delete parser.yy.result.suggestTables;
|
||
|
|
delete parser.yy.result.suggestDatabases;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2973:
|
||
|
|
parser.suggestKeywords(['INSERT INTO', 'INSERT OVERWRITE', 'SELECT']);
|
||
|
|
break;
|
||
|
|
case 2974:
|
||
|
|
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 2975:
|
||
|
|
if ($$[$0].cursorAtStart) {
|
||
|
|
parser.checkForSelectListKeywords($$[$0 - 1].tableExpression);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2976:
|
||
|
|
$$[$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 2977:
|
||
|
|
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 2978:
|
||
|
|
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 2979:
|
||
|
|
$$[$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 2980:
|
||
|
|
parser.suggestKeywords(['OVERWRITE', 'INTO']);
|
||
|
|
break;
|
||
|
|
case 2981:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['DIRECTORY', 'LOCAL DIRECTORY', 'TABLE']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
this.$ = { keepTables: true };
|
||
|
|
break;
|
||
|
|
case 2982:
|
||
|
|
case 2993:
|
||
|
|
this.$ = { keepTables: true };
|
||
|
|
break;
|
||
|
|
case 2983:
|
||
|
|
case 2994:
|
||
|
|
case 2995:
|
||
|
|
case 3058:
|
||
|
|
case 3059:
|
||
|
|
$$[$0 - 2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.owner = 'insert';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2984:
|
||
|
|
case 3010:
|
||
|
|
$$[$0 - 2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 2985:
|
||
|
|
parser.suggestKeywords(['DIRECTORY']);
|
||
|
|
break;
|
||
|
|
case 2992:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
this.$ = { keepTables: true };
|
||
|
|
break;
|
||
|
|
case 3005:
|
||
|
|
if ($$[$0 - 1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0 - 1].suggestKeywords, 2).concat([{ value: 'SELECT', weight: 1 }]));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['SELECT']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3006:
|
||
|
|
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 3008:
|
||
|
|
case 3009:
|
||
|
|
$$[$0 - 3].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 3011:
|
||
|
|
case 3048:
|
||
|
|
case 3084:
|
||
|
|
parser.suggestKeywords(['INTO']);
|
||
|
|
break;
|
||
|
|
case 3012:
|
||
|
|
case 3049:
|
||
|
|
case 3055:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
break;
|
||
|
|
case 3014:
|
||
|
|
$$[$0 - 1].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['VALUES']);
|
||
|
|
break;
|
||
|
|
case 3023:
|
||
|
|
parser.suggestKeywords(['FORMAT DELIMITED']);
|
||
|
|
break;
|
||
|
|
case 3026:
|
||
|
|
this.$ = { selectList: $$[$0] };
|
||
|
|
break;
|
||
|
|
case 3027:
|
||
|
|
this.$ = $$[$0 - 1];
|
||
|
|
this.$.cursorAtEnd = true;
|
||
|
|
break;
|
||
|
|
case 3028:
|
||
|
|
parser.selectListNoTableSuggest($$[$0], $$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 3029:
|
||
|
|
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 3037:
|
||
|
|
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 3047:
|
||
|
|
$$[$0 - 1].owner = 'upsert';
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 3050:
|
||
|
|
if (!$$[$0 - 3]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
$$[$0 - 1].owner = 'upsert';
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
break;
|
||
|
|
case 3052:
|
||
|
|
$$[$0 - 1].owner = 'upsert';
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
if (parser.yy.result.suggestColumns) {
|
||
|
|
parser.yy.result.suggestColumns.owner = 'upsert';
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3053:
|
||
|
|
$$[$0 - 2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['PARTITION'] };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3054:
|
||
|
|
parser.suggestKeywords(['INTO', 'OVERWRITE']);
|
||
|
|
break;
|
||
|
|
case 3056:
|
||
|
|
if (!$$[$0 - 4]) {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
$$[$0 - 2].owner = 'insert';
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
break;
|
||
|
|
case 3081:
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 1], [{ value: 'WHEN', weight: 2 }]);
|
||
|
|
break;
|
||
|
|
case 3083:
|
||
|
|
$$[$0 - 6].alias = $$[$0 - 4];
|
||
|
|
parser.addTablePrimary($$[$0 - 6]);
|
||
|
|
if ($$[$0 - 2].subQuery) {
|
||
|
|
parser.addTablePrimary({ subQueryAlias: $$[$0] });
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$$[$0 - 2].alias = $$[$0];
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3085:
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
parser.suggestTables();
|
||
|
|
break;
|
||
|
|
case 3087:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['AS T USING']);
|
||
|
|
break;
|
||
|
|
case 3088:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
parser.suggestKeywords(['T USING']);
|
||
|
|
break;
|
||
|
|
case 3089:
|
||
|
|
$$[$0 - 3].alias = $$[$0 - 1];
|
||
|
|
parser.addTablePrimary($$[$0 - 3]);
|
||
|
|
parser.suggestKeywords(['USING']);
|
||
|
|
break;
|
||
|
|
case 3090:
|
||
|
|
$$[$0 - 4].alias = $$[$0 - 2];
|
||
|
|
parser.addTablePrimary($$[$0 - 4]);
|
||
|
|
parser.suggestDatabases({ appendDot: true });
|
||
|
|
parser.suggestTables();
|
||
|
|
break;
|
||
|
|
case 3091:
|
||
|
|
$$[$0 - 4].alias = $$[$0 - 2];
|
||
|
|
parser.addTablePrimary($$[$0 - 4]);
|
||
|
|
break;
|
||
|
|
case 3092:
|
||
|
|
$$[$0 - 5].alias = $$[$0 - 3];
|
||
|
|
parser.addTablePrimary($$[$0 - 5]);
|
||
|
|
parser.suggestKeywords(['AS S ON']);
|
||
|
|
break;
|
||
|
|
case 3093:
|
||
|
|
$$[$0 - 6].alias = $$[$0 - 4];
|
||
|
|
parser.addTablePrimary($$[$0 - 6]);
|
||
|
|
parser.suggestKeywords(['S ON']);
|
||
|
|
break;
|
||
|
|
case 3102:
|
||
|
|
if ($$[$0].suggestThenKeywords) {
|
||
|
|
parser.suggestKeywords(['DELETE', 'INSERT VALUES', 'UPDATE SET']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3103:
|
||
|
|
case 3105:
|
||
|
|
if (!$$[$0 - 1].notPresent) {
|
||
|
|
parser.suggestKeywords(['WHEN']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3104:
|
||
|
|
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 3106:
|
||
|
|
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 3107:
|
||
|
|
this.$ = { notPresent: !!$$[$0 - 4], isDelete: $$[$0].isDelete, isInsert: $$[$0].isInsert, isUpdate: $$[$0].isUpdate };
|
||
|
|
break;
|
||
|
|
case 3108:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['NOT MATCHED', 'MATCHED']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['MATCHED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3109:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['AND', 'THEN']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestValueExpressionKeywords($$[$0 - 1], [{ value: 'THEN', weight: 2 }]);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3111:
|
||
|
|
this.$ = { suggestThenKeywords: true };
|
||
|
|
break;
|
||
|
|
case 3116:
|
||
|
|
this.$ = { isUpdate: true };
|
||
|
|
break;
|
||
|
|
case 3117:
|
||
|
|
this.$ = { isDelete: true };
|
||
|
|
break;
|
||
|
|
case 3118:
|
||
|
|
this.$ = { isInsert: true };
|
||
|
|
break;
|
||
|
|
case 3119:
|
||
|
|
parser.suggestKeywords(['SET']);
|
||
|
|
break;
|
||
|
|
case 3123:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['DATA LOCAL INPATH', 'DATA INPATH']);
|
||
|
|
}
|
||
|
|
else if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['DATA INPATH']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3124:
|
||
|
|
if (parser.isHive() && !$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['INPATH', 'LOCAL INPATH']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['INPATH']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3126:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['OVERWRITE INTO TABLE', 'INTO TABLE']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['INTO TABLE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3127:
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
break;
|
||
|
|
case 3145:
|
||
|
|
if (!$$[$0]) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL TABLE', 'FROM', 'TABLE']);
|
||
|
|
}
|
||
|
|
else if (!$$[$0].hasExternal) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3146:
|
||
|
|
if ($$[$0 - 1].suggestKeywords) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0 - 1].suggestKeywords, 2).concat(['FROM']));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['FROM']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3150:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['LOCATION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3151:
|
||
|
|
if (!$$[$0 - 4]) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL TABLE', 'TABLE']);
|
||
|
|
}
|
||
|
|
else if (!$$[$0 - 4].hasExternal) {
|
||
|
|
parser.suggestKeywords(['EXTERNAL']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3153:
|
||
|
|
if ($$[$0 - 5].suggestKeywords) {
|
||
|
|
parser.suggestKeywords(parser.createWeightedKeywords($$[$0 - 5].suggestKeywords, 2).concat(['FROM']));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3156:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { hasExternal: true, suggestKeywords: ['PARTITION'] };
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
this.$ = { hasExternal: true };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3157:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
if (!$$[$0]) {
|
||
|
|
this.$ = { suggestKeywords: ['PARTITION'] };
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3166:
|
||
|
|
case 3180:
|
||
|
|
case 3181:
|
||
|
|
parser.addTablePrimary($$[$0 - 9]);
|
||
|
|
break;
|
||
|
|
case 3170:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords([{ weight: 2, value: 'PARTITION' }, { weight: 1, value: 'TO' }]);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['TO']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3173:
|
||
|
|
parser.addTablePrimary($$[$0 - 5]);
|
||
|
|
parser.suggestKeywords(['FOR replication()']);
|
||
|
|
break;
|
||
|
|
case 3174:
|
||
|
|
parser.addTablePrimary($$[$0 - 6]);
|
||
|
|
parser.suggestKeywords(['replication()']);
|
||
|
|
break;
|
||
|
|
case 3177:
|
||
|
|
parser.addTablePrimary($$[$0 - 5]);
|
||
|
|
if (!$$[$0 - 4]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3178:
|
||
|
|
parser.addTablePrimary($$[$0 - 10]);
|
||
|
|
if (!$$[$0 - 9]) {
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3194:
|
||
|
|
parser.suggestKeywords(['ALL', 'NONE']);
|
||
|
|
break;
|
||
|
|
case 3217:
|
||
|
|
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 3218:
|
||
|
|
// 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 3219:
|
||
|
|
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 3238:
|
||
|
|
case 3268:
|
||
|
|
case 3328:
|
||
|
|
case 3332:
|
||
|
|
case 3334:
|
||
|
|
case 3362:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
case 3242:
|
||
|
|
case 3243:
|
||
|
|
case 3247:
|
||
|
|
case 3248:
|
||
|
|
case 3307:
|
||
|
|
case 3308:
|
||
|
|
parser.suggestKeywords(['FROM', 'IN']);
|
||
|
|
break;
|
||
|
|
case 3244:
|
||
|
|
case 3245:
|
||
|
|
case 3246:
|
||
|
|
case 3291:
|
||
|
|
case 3305:
|
||
|
|
parser.suggestTables();
|
||
|
|
break;
|
||
|
|
case 3253:
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3254:
|
||
|
|
if ($$[$0 - 1].isView && parser.isImpala()) {
|
||
|
|
parser.suggestTables({ onlyViews: true });
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestTables();
|
||
|
|
}
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
case 3255:
|
||
|
|
if (parser.yy.result.suggestTables && $$[$0 - 1].isView) {
|
||
|
|
parser.yy.result.suggestTables.onlyViews = true;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3256:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
if (parser.isImpala()) {
|
||
|
|
parser.suggestKeywords(['TABLE', 'VIEW']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['TABLE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3258:
|
||
|
|
this.$ = { isView: true };
|
||
|
|
break;
|
||
|
|
case 3261:
|
||
|
|
case 3262:
|
||
|
|
parser.suggestKeywords(['ROLES']);
|
||
|
|
break;
|
||
|
|
case 3265:
|
||
|
|
case 3359:
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
break;
|
||
|
|
case 3272:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['IN']);
|
||
|
|
break;
|
||
|
|
case 3277:
|
||
|
|
case 3280:
|
||
|
|
parser.suggestKeywords(['FUNCTIONS']);
|
||
|
|
break;
|
||
|
|
case 3278:
|
||
|
|
case 3281:
|
||
|
|
parser.suggestKeywords(['AGGREGATE', 'ANALYTICAL']);
|
||
|
|
break;
|
||
|
|
case 3279:
|
||
|
|
case 3368:
|
||
|
|
if (!$$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['IN', 'LIKE']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3282:
|
||
|
|
if (!$$[$0 - 2]) {
|
||
|
|
parser.suggestKeywords([{ value: 'IN', weight: 2 }, { value: 'LIKE', weight: 1 }]);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3290:
|
||
|
|
parser.suggestKeywords(['ALL', 'TABLE']);
|
||
|
|
parser.suggestTables();
|
||
|
|
break;
|
||
|
|
case 3310:
|
||
|
|
parser.suggestTables({ identifierChain: [{ name: $$[$0] }] });
|
||
|
|
break;
|
||
|
|
case 3316:
|
||
|
|
parser.suggestTables();
|
||
|
|
parser.suggestDatabases({
|
||
|
|
appendDot: true
|
||
|
|
});
|
||
|
|
parser.suggestKeywords(['DATABASE', 'SCHEMA']);
|
||
|
|
break;
|
||
|
|
case 3318:
|
||
|
|
parser.addTablePrimary($$[$0 - 1]);
|
||
|
|
parser.suggestKeywords(['EXTENDED', 'PARTITION']);
|
||
|
|
break;
|
||
|
|
case 3321:
|
||
|
|
parser.addTablePrimary($$[$0 - 2]);
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
break;
|
||
|
|
case 3338:
|
||
|
|
case 3339:
|
||
|
|
case 3340:
|
||
|
|
parser.suggestKeywords(['GRANT']);
|
||
|
|
break;
|
||
|
|
case 3341:
|
||
|
|
case 3342:
|
||
|
|
parser.suggestKeywords(['ROLE', 'USER']);
|
||
|
|
break;
|
||
|
|
case 3349:
|
||
|
|
case 3358:
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
break;
|
||
|
|
case 3352:
|
||
|
|
if ($$[$0 - 1]) {
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
parser.suggestKeywords(['FROM', 'IN', 'LIKE']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3354:
|
||
|
|
if (parser.isHive()) {
|
||
|
|
parser.suggestKeywords(['EXTENDED']);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 3355:
|
||
|
|
parser.suggestKeywords(['LIKE']);
|
||
|
|
break;
|
||
|
|
case 3356:
|
||
|
|
parser.suggestKeywords(['PARTITION']);
|
||
|
|
break;
|
||
|
|
case 3363:
|
||
|
|
parser.addTablePrimary($$[$0]);
|
||
|
|
break;
|
||
|
|
case 3370:
|
||
|
|
parser.addTablePrimary($$[$0 - 3]);
|
||
|
|
break;
|
||
|
|
case 3375:
|
||
|
|
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 3379:
|
||
|
|
case 3380:
|
||
|
|
parser.addDatabaseLocation(_$[$0], [{ name: $$[$0] }]);
|
||
|
|
break;
|
||
|
|
case 3391:
|
||
|
|
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 3392:
|
||
|
|
parser.suggestKeywords(['SET']);
|
||
|
|
break;
|
||
|
|
case 3408:
|
||
|
|
parser.suggestKeywords(['=']);
|
||
|
|
break;
|
||
|
|
case 3419:
|
||
|
|
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: 353, 18: 354, 20: 355, 21: 356, 22: 357, 23: 358, 405: 360, 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, 1125: 375, 1126: 376, 1127: 377, 1128: 378, 1129: 379, 1130: 380, 1131: 381, 572: 382, 420: 387, 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, 1132: 401, 1133: 402, 1134: 403, 1135: 404, 1136: 405, 576: 406, 1139: 407, 1140: 408, 1141: 409, 1142: 410, 1143: 411, 574: 412, 564: 413, 565: 414, 812: 415, 813: 416, 814: 417, 815: 418, 816: 419, 817: 420, 818: 421, 934: 426, 935: 427, 936: 428, 937: 429, 938: 430, 939: 431, 940: 432, 1144: 433, 1145: 434, 1146: 435, 1147: 436, 1148: 437, 1149: 438, 1150: 439, 1151: 440, 1152: 441, 1257: 445, 1258: 446, 1259: 447, 1260: 448, 1261: 449, 1262: 450, 1263: 451, 1264: 452, 1265: 453, 1266: 454, 1267: 455, 1268: 456, 1269: 457, 1270: 458, 1271: 459, 1272: 460, 1273: 461, 1274: 462, 1275: 463, 1276: 464, 1313: 465, 1137: 467, 1197: 468, 1138: 469, 1198: 470, 1247: 471, 566: 476, 567: 477, 819: 478, 820: 479, 821: 480, 822: 481, 823: 482, 824: 483, 825: 484, 809: 486, 941: 487, 942: 488, 943: 489, 944: 490, 945: 491, 437: 492, 1153: 493, 1154: 494, 1155: 495, 1156: 496, 1157: 497, 1158: 498, 1159: 499, 1160: 500, 1277: 502, 1279: 503, 1280: 504, 1281: 505, 1282: 506, 1283: 507, 1284: 508, 1285: 509, 1286: 510, 1287: 511, 1288: 512, 1289: 513, 1290: 514, 1291: 515, 1292: 516, 1293: 517, 1294: 518, 1202: 519, 1199: 520, 597: 521, 599: 522, 1217: 524, 1235: 525, 1233: 526, 568: 527, 830: 529, 919: 530, 1062: 534, 1063: 535, 1064: 536, 1065: 537, 1161: 538, 1162: 539, 1216: 544, 842: 547, 920: 548, 1066: 549, 1067: 550, 1068: 551, 1069: 552, 1163: 556, 1164: 557, 1221: 560, 1218: 561, 1225: 565, 1226: 566, 1223: 567, 1224: 568, 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
|
||
|
|
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], 145: [2, 310], 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], 200: [2, 365], 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], 243: [2, 408], 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], 276: [2, 441], 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], 290: [2, 455], 291: [2, 456], 292: [2, 457], 293: [2, 458], 294: [2, 459], 295: [2, 460],
|
||
|
|
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 441;
|
||
|
|
break;
|
||
|
|
case 5:
|
||
|
|
return 166;
|
||
|
|
break;
|
||
|
|
case 6:
|
||
|
|
return 285;
|
||
|
|
break;
|
||
|
|
case 7:
|
||
|
|
return 167;
|
||
|
|
break;
|
||
|
|
case 8:
|
||
|
|
return 164;
|
||
|
|
break;
|
||
|
|
case 9:
|
||
|
|
return 168;
|
||
|
|
break;
|
||
|
|
case 10:
|
||
|
|
return 169;
|
||
|
|
break;
|
||
|
|
case 11:
|
||
|
|
return 860;
|
||
|
|
break;
|
||
|
|
case 12:
|
||
|
|
return 171;
|
||
|
|
break;
|
||
|
|
case 13:
|
||
|
|
return 172;
|
||
|
|
break;
|
||
|
|
case 14:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 439;
|
||
|
|
break;
|
||
|
|
case 15:
|
||
|
|
return 173;
|
||
|
|
break;
|
||
|
|
case 16:
|
||
|
|
return 174;
|
||
|
|
break;
|
||
|
|
case 17:
|
||
|
|
return 175;
|
||
|
|
break;
|
||
|
|
case 18:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 1166;
|
||
|
|
break;
|
||
|
|
case 19:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 570;
|
||
|
|
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 1253;
|
||
|
|
break;
|
||
|
|
case 28:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 1190;
|
||
|
|
break;
|
||
|
|
case 29:
|
||
|
|
return 184;
|
||
|
|
break;
|
||
|
|
case 30:
|
||
|
|
return 185;
|
||
|
|
break;
|
||
|
|
case 31:
|
||
|
|
return 187;
|
||
|
|
break;
|
||
|
|
case 32:
|
||
|
|
return 321;
|
||
|
|
break;
|
||
|
|
case 33:
|
||
|
|
return 198;
|
||
|
|
break;
|
||
|
|
case 34:
|
||
|
|
return 199;
|
||
|
|
break;
|
||
|
|
case 35:
|
||
|
|
return 200;
|
||
|
|
break;
|
||
|
|
case 36:
|
||
|
|
return 189;
|
||
|
|
break;
|
||
|
|
case 37:
|
||
|
|
return 190;
|
||
|
|
break;
|
||
|
|
case 38:
|
||
|
|
return 1193;
|
||
|
|
break;
|
||
|
|
case 39:
|
||
|
|
return 191;
|
||
|
|
break;
|
||
|
|
case 40:
|
||
|
|
return 193;
|
||
|
|
break;
|
||
|
|
case 41:
|
||
|
|
return 125;
|
||
|
|
break;
|
||
|
|
case 42:
|
||
|
|
return 132;
|
||
|
|
break;
|
||
|
|
case 43:
|
||
|
|
return 204;
|
||
|
|
break;
|
||
|
|
case 44:
|
||
|
|
return 205;
|
||
|
|
break;
|
||
|
|
case 45:
|
||
|
|
return 957;
|
||
|
|
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 369;
|
||
|
|
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 571;
|
||
|
|
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 195;
|
||
|
|
break;
|
||
|
|
case 92:
|
||
|
|
return 181;
|
||
|
|
break;
|
||
|
|
case 93:
|
||
|
|
return 65;
|
||
|
|
break;
|
||
|
|
case 94:
|
||
|
|
return 136;
|
||
|
|
break;
|
||
|
|
case 95:
|
||
|
|
return 69;
|
||
|
|
break;
|
||
|
|
case 96:
|
||
|
|
return 196;
|
||
|
|
break;
|
||
|
|
case 97:
|
||
|
|
return 197;
|
||
|
|
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 1207;
|
||
|
|
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 201;
|
||
|
|
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 857;
|
||
|
|
break;
|
||
|
|
case 155:
|
||
|
|
return 656;
|
||
|
|
break;
|
||
|
|
case 156:
|
||
|
|
return 115;
|
||
|
|
break;
|
||
|
|
case 157:
|
||
|
|
return 116;
|
||
|
|
break;
|
||
|
|
case 158:
|
||
|
|
return 117;
|
||
|
|
break;
|
||
|
|
case 159:
|
||
|
|
return 202;
|
||
|
|
break;
|
||
|
|
case 160:
|
||
|
|
return 118;
|
||
|
|
break;
|
||
|
|
case 161:
|
||
|
|
return 119;
|
||
|
|
break;
|
||
|
|
case 162:
|
||
|
|
return 120;
|
||
|
|
break;
|
||
|
|
case 163:
|
||
|
|
return 203;
|
||
|
|
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 206;
|
||
|
|
break;
|
||
|
|
case 178:
|
||
|
|
return 142;
|
||
|
|
break;
|
||
|
|
case 179:
|
||
|
|
return 207;
|
||
|
|
break;
|
||
|
|
case 180:
|
||
|
|
return 208;
|
||
|
|
break;
|
||
|
|
case 181:
|
||
|
|
return 209;
|
||
|
|
break;
|
||
|
|
case 182:
|
||
|
|
return 908;
|
||
|
|
break;
|
||
|
|
case 183:
|
||
|
|
return 210;
|
||
|
|
break;
|
||
|
|
case 184:
|
||
|
|
return 211;
|
||
|
|
break;
|
||
|
|
case 185:
|
||
|
|
return 212;
|
||
|
|
break;
|
||
|
|
case 186:
|
||
|
|
return 213;
|
||
|
|
break;
|
||
|
|
case 187:
|
||
|
|
return 906;
|
||
|
|
break;
|
||
|
|
case 188:
|
||
|
|
return 214;
|
||
|
|
break;
|
||
|
|
case 189:
|
||
|
|
return 215;
|
||
|
|
break;
|
||
|
|
case 190:
|
||
|
|
return 898;
|
||
|
|
break;
|
||
|
|
case 191:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 452;
|
||
|
|
break;
|
||
|
|
case 192:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 933;
|
||
|
|
break;
|
||
|
|
case 193:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('CREATE', yy_.yylloc, yy.lexer.upcomingInput());
|
||
|
|
return 440;
|
||
|
|
break;
|
||
|
|
case 194:
|
||
|
|
return 216;
|
||
|
|
break;
|
||
|
|
case 195:
|
||
|
|
return 217;
|
||
|
|
break;
|
||
|
|
case 196:
|
||
|
|
return 218;
|
||
|
|
break;
|
||
|
|
case 197:
|
||
|
|
return 219;
|
||
|
|
break;
|
||
|
|
case 198:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('DESCRIBE', yy_.yylloc);
|
||
|
|
return 569;
|
||
|
|
break;
|
||
|
|
case 199:
|
||
|
|
return 220;
|
||
|
|
break;
|
||
|
|
case 200:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('EXPLAIN', yy_.yylloc);
|
||
|
|
return 163;
|
||
|
|
break;
|
||
|
|
case 201:
|
||
|
|
return 222;
|
||
|
|
break;
|
||
|
|
case 202:
|
||
|
|
return 221;
|
||
|
|
break;
|
||
|
|
case 203:
|
||
|
|
return 223;
|
||
|
|
break;
|
||
|
|
case 204:
|
||
|
|
return 907;
|
||
|
|
break;
|
||
|
|
case 205:
|
||
|
|
return 224;
|
||
|
|
break;
|
||
|
|
case 206:
|
||
|
|
return 225;
|
||
|
|
break;
|
||
|
|
case 207:
|
||
|
|
return 226;
|
||
|
|
break;
|
||
|
|
case 208:
|
||
|
|
return 227;
|
||
|
|
break;
|
||
|
|
case 209:
|
||
|
|
return 228;
|
||
|
|
break;
|
||
|
|
case 210:
|
||
|
|
return 229;
|
||
|
|
break;
|
||
|
|
case 211:
|
||
|
|
return 230;
|
||
|
|
break;
|
||
|
|
case 212:
|
||
|
|
return 231;
|
||
|
|
break;
|
||
|
|
case 213:
|
||
|
|
return 232;
|
||
|
|
break;
|
||
|
|
case 214:
|
||
|
|
return 233;
|
||
|
|
break;
|
||
|
|
case 215:
|
||
|
|
return 234;
|
||
|
|
break;
|
||
|
|
case 216:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('INSERT', yy_.yylloc);
|
||
|
|
return 1192;
|
||
|
|
break;
|
||
|
|
case 217:
|
||
|
|
return 236;
|
||
|
|
break;
|
||
|
|
case 218:
|
||
|
|
return 235;
|
||
|
|
break;
|
||
|
|
case 219:
|
||
|
|
return 237;
|
||
|
|
break;
|
||
|
|
case 220:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('INVALIDATE', yy_.yylloc, yy.lexer.upcomingInput());
|
||
|
|
return 931;
|
||
|
|
break;
|
||
|
|
case 221:
|
||
|
|
this.begin('hdfs');
|
||
|
|
return 238;
|
||
|
|
break;
|
||
|
|
case 222:
|
||
|
|
return 239;
|
||
|
|
break;
|
||
|
|
case 223:
|
||
|
|
return 156;
|
||
|
|
break;
|
||
|
|
case 224:
|
||
|
|
return 240;
|
||
|
|
break;
|
||
|
|
case 225:
|
||
|
|
return 241;
|
||
|
|
break;
|
||
|
|
case 226:
|
||
|
|
this.begin('hdfs');
|
||
|
|
return 975;
|
||
|
|
break;
|
||
|
|
case 227:
|
||
|
|
return 242;
|
||
|
|
break;
|
||
|
|
case 228:
|
||
|
|
return 243;
|
||
|
|
break;
|
||
|
|
case 229:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('LOAD', yy_.yylloc, yy.lexer.upcomingInput());
|
||
|
|
return 1252;
|
||
|
|
break;
|
||
|
|
case 230:
|
||
|
|
this.begin('hdfs');
|
||
|
|
return 244;
|
||
|
|
break;
|
||
|
|
case 231:
|
||
|
|
return 245;
|
||
|
|
break;
|
||
|
|
case 232:
|
||
|
|
return 932;
|
||
|
|
break;
|
||
|
|
case 233:
|
||
|
|
return 246;
|
||
|
|
break;
|
||
|
|
case 234:
|
||
|
|
return 663;
|
||
|
|
break;
|
||
|
|
case 235:
|
||
|
|
return 1040;
|
||
|
|
break;
|
||
|
|
case 236:
|
||
|
|
return 1230;
|
||
|
|
break;
|
||
|
|
case 237:
|
||
|
|
return 268;
|
||
|
|
break;
|
||
|
|
case 238:
|
||
|
|
return 269;
|
||
|
|
break;
|
||
|
|
case 239:
|
||
|
|
return 247;
|
||
|
|
break;
|
||
|
|
case 240:
|
||
|
|
return 248;
|
||
|
|
break;
|
||
|
|
case 241:
|
||
|
|
return 249;
|
||
|
|
break;
|
||
|
|
case 242:
|
||
|
|
return 270;
|
||
|
|
break;
|
||
|
|
case 243:
|
||
|
|
return 250;
|
||
|
|
break;
|
||
|
|
case 244:
|
||
|
|
return 251;
|
||
|
|
break;
|
||
|
|
case 245:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('REFRESH', yy_.yylloc);
|
||
|
|
return 930;
|
||
|
|
break;
|
||
|
|
case 246:
|
||
|
|
return 910;
|
||
|
|
break;
|
||
|
|
case 247:
|
||
|
|
return 252;
|
||
|
|
break;
|
||
|
|
case 248:
|
||
|
|
return 762;
|
||
|
|
break;
|
||
|
|
case 249:
|
||
|
|
return 253;
|
||
|
|
break;
|
||
|
|
case 250:
|
||
|
|
return 254;
|
||
|
|
break;
|
||
|
|
case 251:
|
||
|
|
return 255;
|
||
|
|
break;
|
||
|
|
case 252:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('REVOKE', yy_.yylloc);
|
||
|
|
return 1195;
|
||
|
|
break;
|
||
|
|
case 253:
|
||
|
|
return 271;
|
||
|
|
break;
|
||
|
|
case 254:
|
||
|
|
return 272;
|
||
|
|
break;
|
||
|
|
case 255:
|
||
|
|
return 256;
|
||
|
|
break;
|
||
|
|
case 256:
|
||
|
|
return 257;
|
||
|
|
break;
|
||
|
|
case 257:
|
||
|
|
return 150;
|
||
|
|
break;
|
||
|
|
case 258:
|
||
|
|
return 258;
|
||
|
|
break;
|
||
|
|
case 259:
|
||
|
|
return 259;
|
||
|
|
break;
|
||
|
|
case 260:
|
||
|
|
return 274;
|
||
|
|
break;
|
||
|
|
case 261:
|
||
|
|
return 260;
|
||
|
|
break;
|
||
|
|
case 262:
|
||
|
|
return 261;
|
||
|
|
break;
|
||
|
|
case 263:
|
||
|
|
return 262;
|
||
|
|
break;
|
||
|
|
case 264:
|
||
|
|
return 263;
|
||
|
|
break;
|
||
|
|
case 265:
|
||
|
|
return 264;
|
||
|
|
break;
|
||
|
|
case 266:
|
||
|
|
return 275;
|
||
|
|
break;
|
||
|
|
case 267:
|
||
|
|
return 276;
|
||
|
|
break;
|
||
|
|
case 268:
|
||
|
|
return 277;
|
||
|
|
break;
|
||
|
|
case 269:
|
||
|
|
return 543;
|
||
|
|
break;
|
||
|
|
case 270:
|
||
|
|
return 278;
|
||
|
|
break;
|
||
|
|
case 271:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('UPSERT', yy_.yylloc);
|
||
|
|
return 1227;
|
||
|
|
break;
|
||
|
|
case 272:
|
||
|
|
return 149;
|
||
|
|
break;
|
||
|
|
case 273:
|
||
|
|
return 265;
|
||
|
|
break;
|
||
|
|
case 274:
|
||
|
|
return 833;
|
||
|
|
break;
|
||
|
|
case 275:
|
||
|
|
return 143;
|
||
|
|
break;
|
||
|
|
case 276:
|
||
|
|
return 266;
|
||
|
|
break;
|
||
|
|
case 277:
|
||
|
|
return 285;
|
||
|
|
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 321;
|
||
|
|
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 279;
|
||
|
|
break;
|
||
|
|
case 291:
|
||
|
|
return 267;
|
||
|
|
break;
|
||
|
|
case 292:
|
||
|
|
return 273;
|
||
|
|
break;
|
||
|
|
case 293:
|
||
|
|
return 280;
|
||
|
|
break;
|
||
|
|
case 294:
|
||
|
|
return 281;
|
||
|
|
break;
|
||
|
|
case 295:
|
||
|
|
return 282;
|
||
|
|
break;
|
||
|
|
case 296:
|
||
|
|
return 283;
|
||
|
|
break;
|
||
|
|
case 297:
|
||
|
|
this.popState();
|
||
|
|
return 668;
|
||
|
|
break;
|
||
|
|
case 298:
|
||
|
|
return 284;
|
||
|
|
break;
|
||
|
|
case 299:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('ALTER', yy_.yylloc, yy.lexer.upcomingInput());
|
||
|
|
return 826;
|
||
|
|
break;
|
||
|
|
case 300:
|
||
|
|
return 385;
|
||
|
|
break;
|
||
|
|
case 301:
|
||
|
|
return 286;
|
||
|
|
break;
|
||
|
|
case 302:
|
||
|
|
return 287;
|
||
|
|
break;
|
||
|
|
case 303:
|
||
|
|
this.begin('between');
|
||
|
|
return 288;
|
||
|
|
break;
|
||
|
|
case 304:
|
||
|
|
return 289;
|
||
|
|
break;
|
||
|
|
case 305:
|
||
|
|
return 290;
|
||
|
|
break;
|
||
|
|
case 306:
|
||
|
|
return 291;
|
||
|
|
break;
|
||
|
|
case 307:
|
||
|
|
return 292;
|
||
|
|
break;
|
||
|
|
case 308:
|
||
|
|
return 293;
|
||
|
|
break;
|
||
|
|
case 309:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 438;
|
||
|
|
break;
|
||
|
|
case 310:
|
||
|
|
return 294;
|
||
|
|
break;
|
||
|
|
case 311:
|
||
|
|
return 295;
|
||
|
|
break;
|
||
|
|
case 312:
|
||
|
|
return 296;
|
||
|
|
break;
|
||
|
|
case 313:
|
||
|
|
return 297;
|
||
|
|
break;
|
||
|
|
case 314:
|
||
|
|
return 298;
|
||
|
|
break;
|
||
|
|
case 315:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 316:
|
||
|
|
return 299;
|
||
|
|
break;
|
||
|
|
case 317:
|
||
|
|
return 300;
|
||
|
|
break;
|
||
|
|
case 318:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('DROP', yy_.yylloc, yy.lexer.upcomingInput());
|
||
|
|
return 868;
|
||
|
|
break;
|
||
|
|
case 319:
|
||
|
|
return 301;
|
||
|
|
break;
|
||
|
|
case 320:
|
||
|
|
return 302;
|
||
|
|
break;
|
||
|
|
case 321:
|
||
|
|
parser.yy.correlatedSubQuery = true;
|
||
|
|
return 303;
|
||
|
|
break;
|
||
|
|
case 322:
|
||
|
|
return 304;
|
||
|
|
break;
|
||
|
|
case 323:
|
||
|
|
return 305;
|
||
|
|
break;
|
||
|
|
case 324:
|
||
|
|
return 306;
|
||
|
|
break;
|
||
|
|
case 325:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 307;
|
||
|
|
break;
|
||
|
|
case 326:
|
||
|
|
return 308;
|
||
|
|
break;
|
||
|
|
case 327:
|
||
|
|
return 309;
|
||
|
|
break;
|
||
|
|
case 328:
|
||
|
|
return 310;
|
||
|
|
break;
|
||
|
|
case 329:
|
||
|
|
return 311;
|
||
|
|
break;
|
||
|
|
case 330:
|
||
|
|
return 312;
|
||
|
|
break;
|
||
|
|
case 331:
|
||
|
|
return 313;
|
||
|
|
break;
|
||
|
|
case 332:
|
||
|
|
return 1213;
|
||
|
|
break;
|
||
|
|
case 333:
|
||
|
|
return 314;
|
||
|
|
break;
|
||
|
|
case 334:
|
||
|
|
return 315;
|
||
|
|
break;
|
||
|
|
case 335:
|
||
|
|
return 316;
|
||
|
|
break;
|
||
|
|
case 336:
|
||
|
|
return 317;
|
||
|
|
break;
|
||
|
|
case 337:
|
||
|
|
return 318;
|
||
|
|
break;
|
||
|
|
case 338:
|
||
|
|
return 319;
|
||
|
|
break;
|
||
|
|
case 339:
|
||
|
|
return 320;
|
||
|
|
break;
|
||
|
|
case 340:
|
||
|
|
return 322;
|
||
|
|
break;
|
||
|
|
case 341:
|
||
|
|
return 323;
|
||
|
|
break;
|
||
|
|
case 342:
|
||
|
|
return 324;
|
||
|
|
break;
|
||
|
|
case 343:
|
||
|
|
return 158;
|
||
|
|
break;
|
||
|
|
case 344:
|
||
|
|
return 386;
|
||
|
|
break;
|
||
|
|
case 345:
|
||
|
|
return 325;
|
||
|
|
break;
|
||
|
|
case 346:
|
||
|
|
return 326;
|
||
|
|
break;
|
||
|
|
case 347:
|
||
|
|
return 328;
|
||
|
|
break;
|
||
|
|
case 348:
|
||
|
|
return 329;
|
||
|
|
break;
|
||
|
|
case 349:
|
||
|
|
return 330;
|
||
|
|
break;
|
||
|
|
case 350:
|
||
|
|
return 331;
|
||
|
|
break;
|
||
|
|
case 351:
|
||
|
|
return 332;
|
||
|
|
break;
|
||
|
|
case 352:
|
||
|
|
return 333;
|
||
|
|
break;
|
||
|
|
case 353:
|
||
|
|
return 334;
|
||
|
|
break;
|
||
|
|
case 354:
|
||
|
|
return 335;
|
||
|
|
break;
|
||
|
|
case 355:
|
||
|
|
return 336;
|
||
|
|
break;
|
||
|
|
case 356:
|
||
|
|
return 337;
|
||
|
|
break;
|
||
|
|
case 357:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('SELECT', yy_.yylloc);
|
||
|
|
return 577;
|
||
|
|
break;
|
||
|
|
case 358:
|
||
|
|
return 338;
|
||
|
|
break;
|
||
|
|
case 359:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('SET', yy_.yylloc);
|
||
|
|
return 339;
|
||
|
|
break;
|
||
|
|
case 360:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('SHOW', yy_.yylloc);
|
||
|
|
return 1278;
|
||
|
|
break;
|
||
|
|
case 361:
|
||
|
|
return 340;
|
||
|
|
break;
|
||
|
|
case 362:
|
||
|
|
return 341;
|
||
|
|
break;
|
||
|
|
case 363:
|
||
|
|
return 342;
|
||
|
|
break;
|
||
|
|
case 364:
|
||
|
|
return 343;
|
||
|
|
break;
|
||
|
|
case 365:
|
||
|
|
return 344;
|
||
|
|
break;
|
||
|
|
case 366:
|
||
|
|
return 345;
|
||
|
|
break;
|
||
|
|
case 367:
|
||
|
|
return 837;
|
||
|
|
break;
|
||
|
|
case 368:
|
||
|
|
return 346;
|
||
|
|
break;
|
||
|
|
case 369:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('TRUNCATE', yy_.yylloc, yy.lexer.upcomingInput());
|
||
|
|
return 763;
|
||
|
|
break;
|
||
|
|
case 370:
|
||
|
|
return 785;
|
||
|
|
break;
|
||
|
|
case 371:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
return 1191;
|
||
|
|
break;
|
||
|
|
case 372:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('USE', yy_.yylloc);
|
||
|
|
return 1314;
|
||
|
|
break;
|
||
|
|
case 373:
|
||
|
|
return 347;
|
||
|
|
break;
|
||
|
|
case 374:
|
||
|
|
return 1101;
|
||
|
|
break;
|
||
|
|
case 375:
|
||
|
|
return 349;
|
||
|
|
break;
|
||
|
|
case 376:
|
||
|
|
return 348;
|
||
|
|
break;
|
||
|
|
case 377:
|
||
|
|
return 350;
|
||
|
|
break;
|
||
|
|
case 378:
|
||
|
|
return 351;
|
||
|
|
break;
|
||
|
|
case 379:
|
||
|
|
parser.determineCase(yy_.yytext);
|
||
|
|
parser.addStatementTypeLocation('WITH', yy_.yylloc);
|
||
|
|
return 352;
|
||
|
|
break;
|
||
|
|
case 380:
|
||
|
|
return 327;
|
||
|
|
break;
|
||
|
|
case 381:
|
||
|
|
return 157;
|
||
|
|
break;
|
||
|
|
case 382:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'avg';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 353;
|
||
|
|
break;
|
||
|
|
case 383:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'cast';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 354;
|
||
|
|
break;
|
||
|
|
case 384:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'count';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 355;
|
||
|
|
break;
|
||
|
|
case 385:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'max';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 356;
|
||
|
|
break;
|
||
|
|
case 386:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'min';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 357;
|
||
|
|
break;
|
||
|
|
case 387:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'stddev_pop';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 358;
|
||
|
|
break;
|
||
|
|
case 388:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'stddev_samp';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 359;
|
||
|
|
break;
|
||
|
|
case 389:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'sum';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 360;
|
||
|
|
break;
|
||
|
|
case 390:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'variance';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 361;
|
||
|
|
break;
|
||
|
|
case 391:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'var_pop';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 362;
|
||
|
|
break;
|
||
|
|
case 392:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'var_samp';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 363;
|
||
|
|
break;
|
||
|
|
case 393:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'collect_set';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 364;
|
||
|
|
break;
|
||
|
|
case 394:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'collect_list';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 365;
|
||
|
|
break;
|
||
|
|
case 395:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'corr';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 366;
|
||
|
|
break;
|
||
|
|
case 396:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'covar_pop';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 367;
|
||
|
|
break;
|
||
|
|
case 397:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'covar_samp';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 368;
|
||
|
|
break;
|
||
|
|
case 398:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'extract';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 794;
|
||
|
|
break;
|
||
|
|
case 399:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'histogram_numeric';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 370;
|
||
|
|
break;
|
||
|
|
case 400:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'ntile';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 371;
|
||
|
|
break;
|
||
|
|
case 401:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'percentile';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 372;
|
||
|
|
break;
|
||
|
|
case 402:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'percentile_approx';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 373;
|
||
|
|
break;
|
||
|
|
case 403:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'appx_median';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 374;
|
||
|
|
break;
|
||
|
|
case 404:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'extract';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 375;
|
||
|
|
break;
|
||
|
|
case 405:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'group_concat';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 376;
|
||
|
|
break;
|
||
|
|
case 406:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'ndv';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 377;
|
||
|
|
break;
|
||
|
|
case 407:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'stddev';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 378;
|
||
|
|
break;
|
||
|
|
case 408:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'variance_pop';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 379;
|
||
|
|
break;
|
||
|
|
case 409:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'variance_samp';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 380;
|
||
|
|
break;
|
||
|
|
case 410:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'cume_dist';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 411:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'dense_rank';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 412:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'first_value';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 413:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'lag';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 414:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'last_value';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 415:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'lead';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 416:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'rank';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 417:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'row_number';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 418:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'cume_dist';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 419:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'percent_rank';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 420:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'ntile';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 421:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'percent_rank';
|
||
|
|
parser.addFunctionLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 381;
|
||
|
|
break;
|
||
|
|
case 422:
|
||
|
|
yy.lexer.unput('(');
|
||
|
|
yy_.yytext = 'system';
|
||
|
|
return 727;
|
||
|
|
break;
|
||
|
|
case 423:
|
||
|
|
return 382;
|
||
|
|
break;
|
||
|
|
case 424:
|
||
|
|
return 382;
|
||
|
|
break;
|
||
|
|
case 425:
|
||
|
|
return 383;
|
||
|
|
break;
|
||
|
|
case 426:
|
||
|
|
return 160;
|
||
|
|
break;
|
||
|
|
case 427:
|
||
|
|
parser.yy.cursorFound = true;
|
||
|
|
return 19;
|
||
|
|
break;
|
||
|
|
case 428:
|
||
|
|
parser.yy.cursorFound = true;
|
||
|
|
return 441;
|
||
|
|
break;
|
||
|
|
case 429:
|
||
|
|
return 384;
|
||
|
|
break;
|
||
|
|
case 430:
|
||
|
|
parser.addFileLocation(yy_.yylloc, yy_.yytext);
|
||
|
|
return 789;
|
||
|
|
break;
|
||
|
|
case 431:
|
||
|
|
this.popState();
|
||
|
|
return 790;
|
||
|
|
break;
|
||
|
|
case 432:
|
||
|
|
return 6;
|
||
|
|
break;
|
||
|
|
case 433:
|
||
|
|
return 385;
|
||
|
|
break;
|
||
|
|
case 434:
|
||
|
|
return 386;
|
||
|
|
break;
|
||
|
|
case 435:
|
||
|
|
return 387;
|
||
|
|
break;
|
||
|
|
case 436:
|
||
|
|
return 388;
|
||
|
|
break;
|
||
|
|
case 437:
|
||
|
|
return 389;
|
||
|
|
break;
|
||
|
|
case 438:
|
||
|
|
return 390;
|
||
|
|
break;
|
||
|
|
case 439:
|
||
|
|
return 390;
|
||
|
|
break;
|
||
|
|
case 440:
|
||
|
|
return 390;
|
||
|
|
break;
|
||
|
|
case 441:
|
||
|
|
return 390;
|
||
|
|
break;
|
||
|
|
case 442:
|
||
|
|
return 390;
|
||
|
|
break;
|
||
|
|
case 443:
|
||
|
|
return 391;
|
||
|
|
break;
|
||
|
|
case 444:
|
||
|
|
return 392;
|
||
|
|
break;
|
||
|
|
case 445:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 446:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 447:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 448:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 449:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 450:
|
||
|
|
return 393;
|
||
|
|
break;
|
||
|
|
case 451:
|
||
|
|
return 394;
|
||
|
|
break;
|
||
|
|
case 452:
|
||
|
|
return 395;
|
||
|
|
break;
|
||
|
|
case 453:
|
||
|
|
return 1006;
|
||
|
|
break;
|
||
|
|
case 454:
|
||
|
|
return 10;
|
||
|
|
break;
|
||
|
|
case 455:
|
||
|
|
return 396;
|
||
|
|
break;
|
||
|
|
case 456:
|
||
|
|
return 397;
|
||
|
|
break;
|
||
|
|
case 457:
|
||
|
|
return 398;
|
||
|
|
break;
|
||
|
|
case 458:
|
||
|
|
return 399;
|
||
|
|
break;
|
||
|
|
case 459:
|
||
|
|
return 400;
|
||
|
|
break;
|
||
|
|
case 460:
|
||
|
|
return 401;
|
||
|
|
break;
|
||
|
|
case 461:
|
||
|
|
return 161;
|
||
|
|
break;
|
||
|
|
case 462:
|
||
|
|
this.begin('backtickedValue');
|
||
|
|
return 402;
|
||
|
|
break;
|
||
|
|
case 463:
|
||
|
|
if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '`')) {
|
||
|
|
return 471;
|
||
|
|
}
|
||
|
|
return 469;
|
||
|
|
break;
|
||
|
|
case 464:
|
||
|
|
this.popState();
|
||
|
|
return 402;
|
||
|
|
break;
|
||
|
|
case 465:
|
||
|
|
this.begin('singleQuotedValue');
|
||
|
|
return 403;
|
||
|
|
break;
|
||
|
|
case 466:
|
||
|
|
if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '\'')) {
|
||
|
|
return 471;
|
||
|
|
}
|
||
|
|
return 469;
|
||
|
|
break;
|
||
|
|
case 467:
|
||
|
|
this.popState();
|
||
|
|
return 403;
|
||
|
|
break;
|
||
|
|
case 468:
|
||
|
|
this.begin('doubleQuotedValue');
|
||
|
|
return 404;
|
||
|
|
break;
|
||
|
|
case 469:
|
||
|
|
if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '"')) {
|
||
|
|
return 471;
|
||
|
|
}
|
||
|
|
return 469;
|
||
|
|
break;
|
||
|
|
case 470:
|
||
|
|
this.popState();
|
||
|
|
return 404;
|
||
|
|
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, /^(?:PARTIT
|
||
|
|
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], "incl
|
||
|
|
});
|
||
|
|
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));
|
||
|
|
}
|
||
|
|
}
|