diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java index 48b7ee1..28df22d 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java @@ -44,6 +44,7 @@ import org.apache.hadoop.hive.ql.parse.SemanticException; import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.hadoop.hive.ql.udf.SettableUDF; import org.apache.hadoop.hive.ql.udf.UDAFPercentile; import org.apache.hadoop.hive.ql.udf.UDFAcos; @@ -167,7 +168,6 @@ static Map windowFunctions = Collections.synchronizedMap(new LinkedHashMap()); - static { registerGenericUDF("concat", GenericUDFConcat.class); registerUDF("substr", UDFSubstr.class, false); @@ -417,8 +417,8 @@ registerGenericUDTF("stack", GenericUDTFStack.class); //PTF declarations - registerGenericUDF(true, LEAD_FUNC_NAME, GenericUDFLead.class); - registerGenericUDF(true, LAG_FUNC_NAME, GenericUDFLag.class); + registerGenericUDF(LEAD_FUNC_NAME, GenericUDFLead.class); + registerGenericUDF(LAG_FUNC_NAME, GenericUDFLag.class); registerWindowFunction("row_number", new GenericUDAFRowNumber()); registerWindowFunction("rank", new GenericUDAFRank()); @@ -517,8 +517,32 @@ public static void registerGenericUDTF(boolean isNative, String functionName, } } + private static T getQualifiedFunctionInfo(Map mFunctions, String functionName) { + T functionInfo = mFunctions.get(functionName); + // Eventually this would check metastore for registered functions. + return functionInfo; + } + + private static T getFunctionInfo(Map mFunctions, String functionName) { + functionName = functionName.toLowerCase(); + T functionInfo = null; + if (FunctionUtils.isQualifiedFunctionName(functionName)) { + functionInfo = getQualifiedFunctionInfo(mFunctions, functionName); + } else { + // First try without qualifiers - would resolve builtin/temp functions. + // Otherwise try qualifying with current db name. + functionInfo = mFunctions.get(functionName); + if (functionInfo == null && !FunctionUtils.isQualifiedFunctionName(functionName)) { + String qualifiedName = FunctionUtils.qualifyFunctionName(functionName, + SessionState.get().getCurrentDatabase()); + functionInfo = getQualifiedFunctionInfo(mFunctions, qualifiedName); + } + } + return functionInfo; + } + public static FunctionInfo getFunctionInfo(String functionName) { - return mFunctions.get(functionName.toLowerCase()); + return getFunctionInfo(mFunctions, functionName); } /** @@ -1047,7 +1071,7 @@ public static GenericUDAFResolver getGenericUDAFResolver(String functionName) { if (LOG.isDebugEnabled()) { LOG.debug("Looking up GenericUDAF: " + functionName); } - FunctionInfo finfo = mFunctions.get(functionName.toLowerCase()); + FunctionInfo finfo = getFunctionInfo(functionName); if (finfo == null) { return null; } @@ -1693,9 +1717,8 @@ public static void registerWindowFunction(String name, GenericUDAFResolver wFn, } } - public static WindowFunctionInfo getWindowFunctionInfo(String name) - { - return windowFunctions.get(name.toLowerCase()); + public static WindowFunctionInfo getWindowFunctionInfo(String functionName) { + return getFunctionInfo(windowFunctions, functionName); } /** @@ -1708,7 +1731,7 @@ public static WindowFunctionInfo getWindowFunctionInfo(String name) */ public static boolean impliesOrder(String functionName) { - FunctionInfo info = mFunctions.get(functionName.toLowerCase()); + FunctionInfo info = getFunctionInfo(functionName); if (info != null) { if (info.isGenericUDF()) { UDFType type = info.getGenericUDF().getClass().getAnnotation(UDFType.class); @@ -1717,7 +1740,7 @@ public static boolean impliesOrder(String functionName) { } } } - WindowFunctionInfo windowInfo = windowFunctions.get(functionName.toLowerCase()); + WindowFunctionInfo windowInfo = getWindowFunctionInfo(functionName); if (windowInfo != null) { return windowInfo.isImpliesOrder(); } @@ -1733,13 +1756,13 @@ static private void addFunctionInfoToWindowFunctions(String functionName, public static boolean isTableFunction(String name) { - FunctionInfo tFInfo = mFunctions.get(name.toLowerCase()); + FunctionInfo tFInfo = getFunctionInfo(name); return tFInfo != null && !tFInfo.isInternalTableFunction() && tFInfo.isTableFunction(); } public static TableFunctionResolver getTableFunctionResolver(String name) { - FunctionInfo tfInfo = mFunctions.get(name.toLowerCase()); + FunctionInfo tfInfo = getFunctionInfo(name); if(tfInfo.isTableFunction()) { return (TableFunctionResolver) ReflectionUtils.newInstance(tfInfo.getFunctionClass(), null); } @@ -1772,7 +1795,7 @@ public static void registerTableFunction(String name, Class= 0; + } + + public static String qualifyFunctionName(String functionName, String dbName) { + if (isQualifiedFunctionName(functionName)) { + return functionName; + } + return dbName + "." + functionName; + } + + /** + * Splits a qualified function name into an array containing the database name and function name. + * If the name is not qualified, the database name is null. + * If there is more than one '.', an exception will be thrown. + * @param functionName Function name, which may or may not be qualified + * @return + */ + public static String[] splitQualifiedFunctionName(String functionName) throws HiveException { + String[] names = functionName.split("\\."); + if (names.length == 1) { + String[] retval = { null, functionName }; + return retval; + } else if (names.length > 2) { + throw new HiveException("Function name does not have correct format: " + functionName); + } + return names; + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/FromClauseParser.g ql/src/java/org/apache/hadoop/hive/ql/parse/FromClauseParser.g index 2adefcb..97ce484 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/FromClauseParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/FromClauseParser.g @@ -54,22 +54,22 @@ tableAllColumns // (table|column) tableOrColumn -@init { gParent.msgs.push("table or column identifier"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("table or column identifier", state); } +@after { gParent.popMsg(state); } : identifier -> ^(TOK_TABLE_OR_COL identifier) ; expressionList -@init { gParent.msgs.push("expression list"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("expression list", state); } +@after { gParent.popMsg(state); } : expression (COMMA expression)* -> ^(TOK_EXPLIST expression+) ; aliasList -@init { gParent.msgs.push("alias list"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("alias list", state); } +@after { gParent.popMsg(state); } : identifier (COMMA identifier)* -> ^(TOK_ALIASLIST identifier+) ; @@ -77,40 +77,40 @@ aliasList //----------------------- Rules for parsing fromClause ------------------------------ // from [col1, col2, col3] table1, [col4, col5] table2 fromClause -@init { gParent.msgs.push("from clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("from clause", state); } +@after { gParent.popMsg(state); } : KW_FROM joinSource -> ^(TOK_FROM joinSource) ; joinSource -@init { gParent.msgs.push("join source"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("join source", state); } +@after { gParent.popMsg(state); } : fromSource ( joinToken^ fromSource ( KW_ON! expression {$joinToken.start.getType() != COMMA}? )? )* | uniqueJoinToken^ uniqueJoinSource (COMMA! uniqueJoinSource)+ ; uniqueJoinSource -@init { gParent.msgs.push("join source"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("join source", state); } +@after { gParent.popMsg(state); } : KW_PRESERVE? fromSource uniqueJoinExpr ; uniqueJoinExpr -@init { gParent.msgs.push("unique join expression list"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("unique join expression list", state); } +@after { gParent.popMsg(state); } : LPAREN e1+=expression (COMMA e1+=expression)* RPAREN -> ^(TOK_EXPLIST $e1*) ; uniqueJoinToken -@init { gParent.msgs.push("unique join"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("unique join", state); } +@after { gParent.popMsg(state); } : KW_UNIQUEJOIN -> TOK_UNIQUEJOIN; joinToken -@init { gParent.msgs.push("join type specifier"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("join type specifier", state); } +@after { gParent.popMsg(state); } : KW_JOIN -> TOK_JOIN | KW_INNER KW_JOIN -> TOK_JOIN @@ -123,8 +123,8 @@ joinToken ; lateralView -@init {gParent.msgs.push("lateral view"); } -@after {gParent.msgs.pop(); } +@init {gParent.pushMsg("lateral view", state); } +@after {gParent.popMsg(state); } : KW_LATERAL KW_VIEW KW_OUTER function tableAlias (KW_AS identifier ((COMMA)=> COMMA identifier)*)? -> ^(TOK_LATERAL_VIEW_OUTER ^(TOK_SELECT ^(TOK_SELEXPR function identifier* tableAlias))) @@ -134,29 +134,29 @@ lateralView ; tableAlias -@init {gParent.msgs.push("table alias"); } -@after {gParent.msgs.pop(); } +@init {gParent.pushMsg("table alias", state); } +@after {gParent.popMsg(state); } : identifier -> ^(TOK_TABALIAS identifier) ; fromSource -@init { gParent.msgs.push("from source"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("from source", state); } +@after { gParent.popMsg(state); } : ((Identifier LPAREN)=> partitionedTableFunction | tableSource | subQuerySource) (lateralView^)* ; tableBucketSample -@init { gParent.msgs.push("table bucket sample specification"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("table bucket sample specification", state); } +@after { gParent.popMsg(state); } : KW_TABLESAMPLE LPAREN KW_BUCKET (numerator=Number) KW_OUT KW_OF (denominator=Number) (KW_ON expr+=expression (COMMA expr+=expression)*)? RPAREN -> ^(TOK_TABLEBUCKETSAMPLE $numerator $denominator $expr*) ; splitSample -@init { gParent.msgs.push("table split sample specification"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("table split sample specification", state); } +@after { gParent.popMsg(state); } : KW_TABLESAMPLE LPAREN (numerator=Number) (percent=KW_PERCENT|KW_ROWS) RPAREN -> {percent != null}? ^(TOK_TABLESPLITSAMPLE TOK_PERCENT $numerator) @@ -167,23 +167,23 @@ splitSample ; tableSample -@init { gParent.msgs.push("table sample specification"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("table sample specification", state); } +@after { gParent.popMsg(state); } : tableBucketSample | splitSample ; tableSource -@init { gParent.msgs.push("table source"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("table source", state); } +@after { gParent.popMsg(state); } : tabname=tableName (props=tableProperties)? (ts=tableSample)? (KW_AS? alias=Identifier)? -> ^(TOK_TABREF $tabname $props? $ts? $alias?) ; tableName -@init { gParent.msgs.push("table name"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("table name", state); } +@after { gParent.popMsg(state); } : db=identifier DOT tab=identifier -> ^(TOK_TABNAME $db $tab) @@ -193,24 +193,24 @@ tableName ; viewName -@init { gParent.msgs.push("view name"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("view name", state); } +@after { gParent.popMsg(state); } : (db=identifier DOT)? view=identifier -> ^(TOK_TABNAME $db? $view) ; subQuerySource -@init { gParent.msgs.push("subquery source"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("subquery source", state); } +@after { gParent.popMsg(state); } : LPAREN queryStatementExpression[false] RPAREN identifier -> ^(TOK_SUBQUERY queryStatementExpression identifier) ; //---------------------- Rules for parsing PTF clauses ----------------------------- partitioningSpec -@init { gParent.msgs.push("partitioningSpec clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("partitioningSpec clause", state); } +@after { gParent.popMsg(state); } : partitionByClause orderByClause? -> ^(TOK_PARTITIONINGSPEC partitionByClause orderByClause?) | orderByClause -> ^(TOK_PARTITIONINGSPEC orderByClause) | @@ -220,8 +220,8 @@ partitioningSpec ; partitionTableFunctionSource -@init { gParent.msgs.push("partitionTableFunctionSource clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("partitionTableFunctionSource clause", state); } +@after { gParent.popMsg(state); } : subQuerySource | tableSource | @@ -229,8 +229,8 @@ partitionTableFunctionSource ; partitionedTableFunction -@init { gParent.msgs.push("ptf clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("ptf clause", state); } +@after { gParent.popMsg(state); } : name=Identifier LPAREN KW_ON ptfsrc=partitionTableFunctionSource partitioningSpec? @@ -242,15 +242,15 @@ partitionedTableFunction //----------------------- Rules for parsing whereClause ----------------------------- // where a=b and ... whereClause -@init { gParent.msgs.push("where clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("where clause", state); } +@after { gParent.popMsg(state); } : KW_WHERE searchCondition -> ^(TOK_WHERE searchCondition) ; searchCondition -@init { gParent.msgs.push("search condition"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("search condition", state); } +@after { gParent.popMsg(state); } : expression ; diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/FunctionSemanticAnalyzer.java ql/src/java/org/apache/hadoop/hive/ql/parse/FunctionSemanticAnalyzer.java index da917f7..cc12f30 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/FunctionSemanticAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/FunctionSemanticAnalyzer.java @@ -23,6 +23,7 @@ import org.apache.hadoop.hive.conf.HiveConf.ConfVars; import org.apache.hadoop.hive.ql.ErrorMsg; import org.apache.hadoop.hive.ql.exec.FunctionRegistry; +import org.apache.hadoop.hive.ql.exec.FunctionUtils; import org.apache.hadoop.hive.ql.exec.TaskFactory; import org.apache.hadoop.hive.ql.plan.CreateFunctionDesc; import org.apache.hadoop.hive.ql.plan.DropFunctionDesc; @@ -55,6 +56,12 @@ public void analyzeInternal(ASTNode ast) throws SemanticException { private void analyzeCreateFunction(ASTNode ast) throws SemanticException { String functionName = ast.getChild(0).getText(); String className = unescapeSQLString(ast.getChild(1).getText()); + + // Temp functions are not allowed to have qualified names. + if (FunctionUtils.isQualifiedFunctionName(functionName)) { + throw new SemanticException("Temporary function cannot be created with a qualified name."); + } + CreateFunctionDesc desc = new CreateFunctionDesc(functionName, className); rootTasks.add(TaskFactory.get(new FunctionWork(desc), conf)); } diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g index 216c361..75ddea5 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g @@ -557,6 +557,22 @@ import java.util.HashMap; return msg; } + public void pushMsg(String msg, RecognizerSharedState state) { + // ANTLR generated code does not wrap the @init code wit this backtracking check, + // even if the matching @after has it. If we have parser rules with that are doing + // some lookahead with syntactic predicates this can cause the push() and pop() calls + // to become unbalanced, so make sure both push/pop check the backtracking state. + if (state.backtracking == 0) { + msgs.push(msg); + } + } + + public void popMsg(RecognizerSharedState state) { + if (state.backtracking == 0) { + msgs.pop(); + } + } + // counter to generate unique union aliases private int aliasCounter; @@ -579,15 +595,15 @@ statement ; explainStatement -@init { msgs.push("explain statement"); } -@after { msgs.pop(); } +@init { pushMsg("explain statement", state); } +@after { popMsg(state); } : KW_EXPLAIN (explainOptions=KW_EXTENDED|explainOptions=KW_FORMATTED|explainOptions=KW_DEPENDENCY|explainOptions=KW_LOGICAL)? execStatement -> ^(TOK_EXPLAIN execStatement $explainOptions?) ; execStatement -@init { msgs.push("statement"); } -@after { msgs.pop(); } +@init { pushMsg("statement", state); } +@after { popMsg(state); } : queryStatementExpression[true] | loadStatement | exportStatement @@ -596,29 +612,29 @@ execStatement ; loadStatement -@init { msgs.push("load statement"); } -@after { msgs.pop(); } +@init { pushMsg("load statement", state); } +@after { popMsg(state); } : KW_LOAD KW_DATA (islocal=KW_LOCAL)? KW_INPATH (path=StringLiteral) (isoverwrite=KW_OVERWRITE)? KW_INTO KW_TABLE (tab=tableOrPartition) -> ^(TOK_LOAD $path $tab $islocal? $isoverwrite?) ; exportStatement -@init { msgs.push("export statement"); } -@after { msgs.pop(); } +@init { pushMsg("export statement", state); } +@after { popMsg(state); } : KW_EXPORT KW_TABLE (tab=tableOrPartition) KW_TO (path=StringLiteral) -> ^(TOK_EXPORT $tab $path) ; importStatement -@init { msgs.push("import statement"); } -@after { msgs.pop(); } +@init { pushMsg("import statement", state); } +@after { popMsg(state); } : KW_IMPORT ((ext=KW_EXTERNAL)? KW_TABLE (tab=tableOrPartition))? KW_FROM (path=StringLiteral) tableLocation? -> ^(TOK_IMPORT $path $tab? $ext? tableLocation?) ; ddlStatement -@init { msgs.push("ddl statement"); } -@after { msgs.pop(); } +@init { pushMsg("ddl statement", state); } +@after { popMsg(state); } : createDatabaseStatement | switchDatabaseStatement | dropDatabaseStatement @@ -654,15 +670,15 @@ ddlStatement ; ifExists -@init { msgs.push("if exists clause"); } -@after { msgs.pop(); } +@init { pushMsg("if exists clause", state); } +@after { popMsg(state); } : KW_IF KW_EXISTS -> ^(TOK_IFEXISTS) ; restrictOrCascade -@init { msgs.push("restrict or cascade clause"); } -@after { msgs.pop(); } +@init { pushMsg("restrict or cascade clause", state); } +@after { popMsg(state); } : KW_RESTRICT -> ^(TOK_RESTRICT) | KW_CASCADE @@ -670,36 +686,36 @@ restrictOrCascade ; ifNotExists -@init { msgs.push("if not exists clause"); } -@after { msgs.pop(); } +@init { pushMsg("if not exists clause", state); } +@after { popMsg(state); } : KW_IF KW_NOT KW_EXISTS -> ^(TOK_IFNOTEXISTS) ; storedAsDirs -@init { msgs.push("stored as directories"); } -@after { msgs.pop(); } +@init { pushMsg("stored as directories", state); } +@after { popMsg(state); } : KW_STORED KW_AS KW_DIRECTORIES -> ^(TOK_STOREDASDIRS) ; orReplace -@init { msgs.push("or replace clause"); } -@after { msgs.pop(); } +@init { pushMsg("or replace clause", state); } +@after { popMsg(state); } : KW_OR KW_REPLACE -> ^(TOK_ORREPLACE) ; ignoreProtection -@init { msgs.push("ignore protection clause"); } -@after { msgs.pop(); } +@init { pushMsg("ignore protection clause", state); } +@after { popMsg(state); } : KW_IGNORE KW_PROTECTION -> ^(TOK_IGNOREPROTECTION) ; createDatabaseStatement -@init { msgs.push("create database statement"); } -@after { msgs.pop(); } +@init { pushMsg("create database statement", state); } +@after { popMsg(state); } : KW_CREATE (KW_DATABASE|KW_SCHEMA) ifNotExists? name=identifier @@ -710,51 +726,51 @@ createDatabaseStatement ; dbLocation -@init { msgs.push("database location specification"); } -@after { msgs.pop(); } +@init { pushMsg("database location specification", state); } +@after { popMsg(state); } : KW_LOCATION locn=StringLiteral -> ^(TOK_DATABASELOCATION $locn) ; dbProperties -@init { msgs.push("dbproperties"); } -@after { msgs.pop(); } +@init { pushMsg("dbproperties", state); } +@after { popMsg(state); } : LPAREN dbPropertiesList RPAREN -> ^(TOK_DATABASEPROPERTIES dbPropertiesList) ; dbPropertiesList -@init { msgs.push("database properties list"); } -@after { msgs.pop(); } +@init { pushMsg("database properties list", state); } +@after { popMsg(state); } : keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_DBPROPLIST keyValueProperty+) ; switchDatabaseStatement -@init { msgs.push("switch database statement"); } -@after { msgs.pop(); } +@init { pushMsg("switch database statement", state); } +@after { popMsg(state); } : KW_USE identifier -> ^(TOK_SWITCHDATABASE identifier) ; dropDatabaseStatement -@init { msgs.push("drop database statement"); } -@after { msgs.pop(); } +@init { pushMsg("drop database statement", state); } +@after { popMsg(state); } : KW_DROP (KW_DATABASE|KW_SCHEMA) ifExists? identifier restrictOrCascade? -> ^(TOK_DROPDATABASE identifier ifExists? restrictOrCascade?) ; databaseComment -@init { msgs.push("database's comment"); } -@after { msgs.pop(); } +@init { pushMsg("database's comment", state); } +@after { popMsg(state); } : KW_COMMENT comment=StringLiteral -> ^(TOK_DATABASECOMMENT $comment) ; createTableStatement -@init { msgs.push("create table statement"); } -@after { msgs.pop(); } +@init { pushMsg("create table statement", state); } +@after { popMsg(state); } : KW_CREATE (ext=KW_EXTERNAL)? KW_TABLE ifNotExists? name=tableName ( like=KW_LIKE likeName=tableName tableLocation? @@ -786,13 +802,13 @@ createTableStatement ; truncateTableStatement -@init { msgs.push("truncate table statement"); } -@after { msgs.pop(); } +@init { pushMsg("truncate table statement", state); } +@after { popMsg(state); } : KW_TRUNCATE KW_TABLE tablePartitionPrefix (KW_COLUMNS LPAREN columnNameList RPAREN)? -> ^(TOK_TRUNCATETABLE tablePartitionPrefix columnNameList?); createIndexStatement -@init { msgs.push("create index statement");} -@after {msgs.pop();} +@init { pushMsg("create index statement", state);} +@after {popMsg(state);} : KW_CREATE KW_INDEX indexName=identifier KW_ON KW_TABLE tab=tableName LPAREN indexedCols=columnNameList RPAREN KW_AS typeName=StringLiteral @@ -816,63 +832,63 @@ createIndexStatement ; indexComment -@init { msgs.push("comment on an index");} -@after {msgs.pop();} +@init { pushMsg("comment on an index", state);} +@after {popMsg(state);} : KW_COMMENT comment=StringLiteral -> ^(TOK_INDEXCOMMENT $comment) ; autoRebuild -@init { msgs.push("auto rebuild index");} -@after {msgs.pop();} +@init { pushMsg("auto rebuild index", state);} +@after {popMsg(state);} : KW_WITH KW_DEFERRED KW_REBUILD ->^(TOK_DEFERRED_REBUILDINDEX) ; indexTblName -@init { msgs.push("index table name");} -@after {msgs.pop();} +@init { pushMsg("index table name", state);} +@after {popMsg(state);} : KW_IN KW_TABLE indexTbl=tableName ->^(TOK_CREATEINDEX_INDEXTBLNAME $indexTbl) ; indexPropertiesPrefixed -@init { msgs.push("table properties with prefix"); } -@after { msgs.pop(); } +@init { pushMsg("table properties with prefix", state); } +@after { popMsg(state); } : KW_IDXPROPERTIES! indexProperties ; indexProperties -@init { msgs.push("index properties"); } -@after { msgs.pop(); } +@init { pushMsg("index properties", state); } +@after { popMsg(state); } : LPAREN indexPropertiesList RPAREN -> ^(TOK_INDEXPROPERTIES indexPropertiesList) ; indexPropertiesList -@init { msgs.push("index properties list"); } -@after { msgs.pop(); } +@init { pushMsg("index properties list", state); } +@after { popMsg(state); } : keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_INDEXPROPLIST keyValueProperty+) ; dropIndexStatement -@init { msgs.push("drop index statement");} -@after {msgs.pop();} +@init { pushMsg("drop index statement", state);} +@after {popMsg(state);} : KW_DROP KW_INDEX ifExists? indexName=identifier KW_ON tab=tableName ->^(TOK_DROPINDEX $indexName $tab ifExists?) ; dropTableStatement -@init { msgs.push("drop statement"); } -@after { msgs.pop(); } +@init { pushMsg("drop statement", state); } +@after { popMsg(state); } : KW_DROP KW_TABLE ifExists? tableName -> ^(TOK_DROPTABLE tableName ifExists?) ; alterStatement -@init { msgs.push("alter statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter statement", state); } +@after { popMsg(state); } : KW_ALTER! ( KW_TABLE! alterTableStatementSuffix @@ -886,8 +902,8 @@ alterStatement ; alterTableStatementSuffix -@init { msgs.push("alter table statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter table statement", state); } +@after { popMsg(state); } : alterStatementSuffixRename | alterStatementSuffixAddCol | alterStatementSuffixRenameCol @@ -911,8 +927,8 @@ alterStatementPartitionKeyType ; alterViewStatementSuffix -@init { msgs.push("alter view statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter view statement", state); } +@after { popMsg(state); } : alterViewSuffixProperties | alterStatementSuffixRename -> ^(TOK_ALTERVIEW_RENAME alterStatementSuffixRename) @@ -925,8 +941,8 @@ alterViewStatementSuffix ; alterIndexStatementSuffix -@init { msgs.push("alter index statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter index statement", state); } +@after { popMsg(state); } : indexName=identifier (KW_ON tableNameId=identifier) partitionSpec? @@ -941,36 +957,36 @@ alterIndexStatementSuffix ; alterDatabaseStatementSuffix -@init { msgs.push("alter database statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter database statement", state); } +@after { popMsg(state); } : alterDatabaseSuffixProperties ; alterDatabaseSuffixProperties -@init { msgs.push("alter database properties statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter database properties statement", state); } +@after { popMsg(state); } : name=identifier KW_SET KW_DBPROPERTIES dbProperties -> ^(TOK_ALTERDATABASE_PROPERTIES $name dbProperties) ; alterStatementSuffixRename -@init { msgs.push("rename statement"); } -@after { msgs.pop(); } +@init { pushMsg("rename statement", state); } +@after { popMsg(state); } : oldName=identifier KW_RENAME KW_TO newName=identifier -> ^(TOK_ALTERTABLE_RENAME $oldName $newName) ; alterStatementSuffixAddCol -@init { msgs.push("add column statement"); } -@after { msgs.pop(); } +@init { pushMsg("add column statement", state); } +@after { popMsg(state); } : identifier (add=KW_ADD | replace=KW_REPLACE) KW_COLUMNS LPAREN columnNameTypeList RPAREN -> {$add != null}? ^(TOK_ALTERTABLE_ADDCOLS identifier columnNameTypeList) -> ^(TOK_ALTERTABLE_REPLACECOLS identifier columnNameTypeList) ; alterStatementSuffixRenameCol -@init { msgs.push("rename column name"); } -@after { msgs.pop(); } +@init { pushMsg("rename column name", state); } +@after { popMsg(state); } : identifier KW_CHANGE KW_COLUMN? oldName=identifier newName=identifier colType (KW_COMMENT comment=StringLiteral)? alterStatementChangeColPosition? ->^(TOK_ALTERTABLE_RENAMECOL identifier $oldName $newName colType $comment? alterStatementChangeColPosition?) ; @@ -982,8 +998,8 @@ alterStatementChangeColPosition ; alterStatementSuffixAddPartitions -@init { msgs.push("add partition statement"); } -@after { msgs.pop(); } +@init { pushMsg("add partition statement", state); } +@after { popMsg(state); } : identifier KW_ADD ifNotExists? alterStatementSuffixAddPartitionsElement+ -> ^(TOK_ALTERTABLE_ADDPARTS identifier ifNotExists? alterStatementSuffixAddPartitionsElement+) ; @@ -993,43 +1009,43 @@ alterStatementSuffixAddPartitionsElement ; alterStatementSuffixTouch -@init { msgs.push("touch statement"); } -@after { msgs.pop(); } +@init { pushMsg("touch statement", state); } +@after { popMsg(state); } : identifier KW_TOUCH (partitionSpec)* -> ^(TOK_ALTERTABLE_TOUCH identifier (partitionSpec)*) ; alterStatementSuffixArchive -@init { msgs.push("archive statement"); } -@after { msgs.pop(); } +@init { pushMsg("archive statement", state); } +@after { popMsg(state); } : identifier KW_ARCHIVE (partitionSpec)* -> ^(TOK_ALTERTABLE_ARCHIVE identifier (partitionSpec)*) ; alterStatementSuffixUnArchive -@init { msgs.push("unarchive statement"); } -@after { msgs.pop(); } +@init { pushMsg("unarchive statement", state); } +@after { popMsg(state); } : identifier KW_UNARCHIVE (partitionSpec)* -> ^(TOK_ALTERTABLE_UNARCHIVE identifier (partitionSpec)*) ; partitionLocation -@init { msgs.push("partition location"); } -@after { msgs.pop(); } +@init { pushMsg("partition location", state); } +@after { popMsg(state); } : KW_LOCATION locn=StringLiteral -> ^(TOK_PARTITIONLOCATION $locn) ; alterStatementSuffixDropPartitions -@init { msgs.push("drop partition statement"); } -@after { msgs.pop(); } +@init { pushMsg("drop partition statement", state); } +@after { popMsg(state); } : identifier KW_DROP ifExists? dropPartitionSpec (COMMA dropPartitionSpec)* ignoreProtection? -> ^(TOK_ALTERTABLE_DROPPARTS identifier dropPartitionSpec+ ifExists? ignoreProtection?) ; alterStatementSuffixProperties -@init { msgs.push("alter properties statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter properties statement", state); } +@after { popMsg(state); } : name=identifier KW_SET KW_TBLPROPERTIES tableProperties -> ^(TOK_ALTERTABLE_PROPERTIES $name tableProperties) | name=identifier KW_UNSET KW_TBLPROPERTIES ifExists? tableProperties @@ -1037,8 +1053,8 @@ alterStatementSuffixProperties ; alterViewSuffixProperties -@init { msgs.push("alter view properties statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter view properties statement", state); } +@after { popMsg(state); } : name=identifier KW_SET KW_TBLPROPERTIES tableProperties -> ^(TOK_ALTERVIEW_PROPERTIES $name tableProperties) | name=identifier KW_UNSET KW_TBLPROPERTIES ifExists? tableProperties @@ -1046,8 +1062,8 @@ alterViewSuffixProperties ; alterStatementSuffixSerdeProperties -@init { msgs.push("alter serdes statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter serdes statement", state); } +@after { popMsg(state); } : KW_SET KW_SERDE serdeName=StringLiteral (KW_WITH KW_SERDEPROPERTIES tableProperties)? -> ^(TOK_ALTERTABLE_SERIALIZER $serdeName tableProperties?) | KW_SET KW_SERDEPROPERTIES tableProperties @@ -1055,22 +1071,22 @@ alterStatementSuffixSerdeProperties ; tablePartitionPrefix -@init {msgs.push("table partition prefix");} -@after {msgs.pop();} +@init {pushMsg("table partition prefix", state);} +@after {popMsg(state);} :name=identifier partitionSpec? ->^(TOK_TABLE_PARTITION $name partitionSpec?) ; alterTblPartitionStatement -@init {msgs.push("alter table partition statement");} -@after {msgs.pop();} +@init {pushMsg("alter table partition statement", state);} +@after {popMsg(state);} : tablePartitionPrefix alterTblPartitionStatementSuffix -> ^(TOK_ALTERTABLE_PARTITION tablePartitionPrefix alterTblPartitionStatementSuffix) ; alterTblPartitionStatementSuffix -@init {msgs.push("alter table partition statement suffix");} -@after {msgs.pop();} +@init {pushMsg("alter table partition statement suffix", state);} +@after {popMsg(state);} : alterStatementSuffixFileFormat | alterStatementSuffixLocation | alterStatementSuffixProtectMode @@ -1083,59 +1099,59 @@ alterTblPartitionStatementSuffix ; alterStatementSuffixFileFormat -@init {msgs.push("alter fileformat statement"); } -@after {msgs.pop();} +@init {pushMsg("alter fileformat statement", state); } +@after {popMsg(state);} : KW_SET KW_FILEFORMAT fileFormat -> ^(TOK_ALTERTABLE_FILEFORMAT fileFormat) ; alterStatementSuffixClusterbySortby -@init {msgs.push("alter partition cluster by sort by statement");} -@after {msgs.pop();} +@init {pushMsg("alter partition cluster by sort by statement", state);} +@after {popMsg(state);} : KW_NOT KW_CLUSTERED -> ^(TOK_ALTERTABLE_CLUSTER_SORT TOK_NOT_CLUSTERED) | KW_NOT KW_SORTED -> ^(TOK_ALTERTABLE_CLUSTER_SORT TOK_NOT_SORTED) | tableBuckets -> ^(TOK_ALTERTABLE_CLUSTER_SORT tableBuckets) ; alterTblPartitionStatementSuffixSkewedLocation -@init {msgs.push("alter partition skewed location");} -@after {msgs.pop();} +@init {pushMsg("alter partition skewed location", state);} +@after {popMsg(state);} : KW_SET KW_SKEWED KW_LOCATION skewedLocations -> ^(TOK_ALTERTBLPART_SKEWED_LOCATION skewedLocations) ; skewedLocations -@init { msgs.push("skewed locations"); } -@after { msgs.pop(); } +@init { pushMsg("skewed locations", state); } +@after { popMsg(state); } : LPAREN skewedLocationsList RPAREN -> ^(TOK_SKEWED_LOCATIONS skewedLocationsList) ; skewedLocationsList -@init { msgs.push("skewed locations list"); } -@after { msgs.pop(); } +@init { pushMsg("skewed locations list", state); } +@after { popMsg(state); } : skewedLocationMap (COMMA skewedLocationMap)* -> ^(TOK_SKEWED_LOCATION_LIST skewedLocationMap+) ; skewedLocationMap -@init { msgs.push("specifying skewed location map"); } -@after { msgs.pop(); } +@init { pushMsg("specifying skewed location map", state); } +@after { popMsg(state); } : key=skewedValueLocationElement EQUAL value=StringLiteral -> ^(TOK_SKEWED_LOCATION_MAP $key $value) ; alterStatementSuffixLocation -@init {msgs.push("alter location");} -@after {msgs.pop();} +@init {pushMsg("alter location", state);} +@after {popMsg(state);} : KW_SET KW_LOCATION newLoc=StringLiteral -> ^(TOK_ALTERTABLE_LOCATION $newLoc) ; alterStatementSuffixSkewedby -@init {msgs.push("alter skewed by statement");} -@after{msgs.pop();} +@init {pushMsg("alter skewed by statement", state);} +@after{popMsg(state);} :name=identifier tableSkewed ->^(TOK_ALTERTABLE_SKEWED $name tableSkewed) | @@ -1147,58 +1163,58 @@ alterStatementSuffixSkewedby ; alterStatementSuffixExchangePartition -@init {msgs.push("alter exchange partition");} -@after{msgs.pop();} +@init {pushMsg("alter exchange partition", state);} +@after{popMsg(state);} : name=tableName KW_EXCHANGE partitionSpec KW_WITH KW_TABLE exchangename=tableName -> ^(TOK_EXCHANGEPARTITION $name partitionSpec $exchangename) ; alterStatementSuffixProtectMode -@init { msgs.push("alter partition protect mode statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter partition protect mode statement", state); } +@after { popMsg(state); } : alterProtectMode -> ^(TOK_ALTERTABLE_PROTECTMODE alterProtectMode) ; alterStatementSuffixRenamePart -@init { msgs.push("alter table rename partition statement"); } -@after { msgs.pop(); } +@init { pushMsg("alter table rename partition statement", state); } +@after { popMsg(state); } : KW_RENAME KW_TO partitionSpec ->^(TOK_ALTERTABLE_RENAMEPART partitionSpec) ; alterStatementSuffixMergeFiles -@init { msgs.push(""); } -@after { msgs.pop(); } +@init { pushMsg("", state); } +@after { popMsg(state); } : KW_CONCATENATE -> ^(TOK_ALTERTABLE_MERGEFILES) ; alterProtectMode -@init { msgs.push("protect mode specification enable"); } -@after { msgs.pop(); } +@init { pushMsg("protect mode specification enable", state); } +@after { popMsg(state); } : KW_ENABLE alterProtectModeMode -> ^(TOK_ENABLE alterProtectModeMode) | KW_DISABLE alterProtectModeMode -> ^(TOK_DISABLE alterProtectModeMode) ; alterProtectModeMode -@init { msgs.push("protect mode specification enable"); } -@after { msgs.pop(); } +@init { pushMsg("protect mode specification enable", state); } +@after { popMsg(state); } : KW_OFFLINE -> ^(TOK_OFFLINE) | KW_NO_DROP KW_CASCADE? -> ^(TOK_NO_DROP KW_CASCADE?) | KW_READONLY -> ^(TOK_READONLY) ; alterStatementSuffixBucketNum -@init { msgs.push(""); } -@after { msgs.pop(); } +@init { pushMsg("", state); } +@after { popMsg(state); } : KW_INTO num=Number KW_BUCKETS -> ^(TOK_TABLEBUCKETS $num) ; fileFormat -@init { msgs.push("file format specification"); } -@after { msgs.pop(); } +@init { pushMsg("file format specification", state); } +@after { popMsg(state); } : KW_SEQUENCEFILE -> ^(TOK_TBLSEQUENCEFILE) | KW_TEXTFILE -> ^(TOK_TBLTEXTFILE) | KW_RCFILE -> ^(TOK_TBLRCFILE) @@ -1209,53 +1225,53 @@ fileFormat ; tabTypeExpr -@init { msgs.push("specifying table types"); } -@after { msgs.pop(); } +@init { pushMsg("specifying table types", state); } +@after { popMsg(state); } : identifier (DOT^ (KW_ELEM_TYPE | KW_KEY_TYPE | KW_VALUE_TYPE | identifier))* ; descTabTypeExpr -@init { msgs.push("specifying describe table types"); } -@after { msgs.pop(); } +@init { pushMsg("specifying describe table types", state); } +@after { popMsg(state); } : identifier (DOT^ (KW_ELEM_TYPE | KW_KEY_TYPE | KW_VALUE_TYPE | identifier))* identifier? ; partTypeExpr -@init { msgs.push("specifying table partitions"); } -@after { msgs.pop(); } +@init { pushMsg("specifying table partitions", state); } +@after { popMsg(state); } : tabTypeExpr partitionSpec? -> ^(TOK_TABTYPE tabTypeExpr partitionSpec?) ; descPartTypeExpr -@init { msgs.push("specifying describe table partitions"); } -@after { msgs.pop(); } +@init { pushMsg("specifying describe table partitions", state); } +@after { popMsg(state); } : descTabTypeExpr partitionSpec? -> ^(TOK_TABTYPE descTabTypeExpr partitionSpec?) ; descStatement -@init { msgs.push("describe statement"); } -@after { msgs.pop(); } +@init { pushMsg("describe statement", state); } +@after { popMsg(state); } : (KW_DESCRIBE|KW_DESC) (descOptions=KW_FORMATTED|descOptions=KW_EXTENDED|descOptions=KW_PRETTY)? (parttype=descPartTypeExpr) -> ^(TOK_DESCTABLE $parttype $descOptions?) | (KW_DESCRIBE|KW_DESC) KW_FUNCTION KW_EXTENDED? (name=descFuncNames) -> ^(TOK_DESCFUNCTION $name KW_EXTENDED?) | (KW_DESCRIBE|KW_DESC) KW_DATABASE KW_EXTENDED? (dbName=identifier) -> ^(TOK_DESCDATABASE $dbName KW_EXTENDED?) ; analyzeStatement -@init { msgs.push("analyze statement"); } -@after { msgs.pop(); } +@init { pushMsg("analyze statement", state); } +@after { popMsg(state); } : KW_ANALYZE KW_TABLE (parttype=tableOrPartition) KW_COMPUTE KW_STATISTICS ((noscan=KW_NOSCAN) | (partialscan=KW_PARTIALSCAN) | (KW_FOR KW_COLUMNS statsColumnName=columnNameList))? -> ^(TOK_ANALYZE $parttype $noscan? $partialscan? $statsColumnName?) ; showStatement -@init { msgs.push("show statement"); } -@after { msgs.pop(); } +@init { pushMsg("show statement", state); } +@after { popMsg(state); } : KW_SHOW (KW_DATABASES|KW_SCHEMAS) (KW_LIKE showStmtIdentifier)? -> ^(TOK_SHOWDATABASES showStmtIdentifier?) | KW_SHOW KW_TABLES ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? -> ^(TOK_SHOWTABLES (TOK_FROM $db_name)? showStmtIdentifier?) | KW_SHOW KW_COLUMNS (KW_FROM|KW_IN) tabname=tableName ((KW_FROM|KW_IN) db_name=identifier)? -> ^(TOK_SHOWCOLUMNS $db_name? $tabname) - | KW_SHOW KW_FUNCTIONS showStmtIdentifier? -> ^(TOK_SHOWFUNCTIONS showStmtIdentifier?) + | KW_SHOW KW_FUNCTIONS showFunctionIdentifier? -> ^(TOK_SHOWFUNCTIONS showFunctionIdentifier?) | KW_SHOW KW_PARTITIONS tabName=tableName partitionSpec? -> ^(TOK_SHOWPARTITIONS $tabName partitionSpec?) | KW_SHOW KW_CREATE KW_TABLE tabName=tableName -> ^(TOK_SHOW_CREATETABLE $tabName) | KW_SHOW KW_TABLE KW_EXTENDED ((KW_FROM|KW_IN) db_name=identifier)? KW_LIKE showStmtIdentifier partitionSpec? @@ -1268,52 +1284,52 @@ showStatement ; lockStatement -@init { msgs.push("lock statement"); } -@after { msgs.pop(); } +@init { pushMsg("lock statement", state); } +@after { popMsg(state); } : KW_LOCK KW_TABLE tableName partitionSpec? lockMode -> ^(TOK_LOCKTABLE tableName lockMode partitionSpec?) ; lockDatabase -@init { msgs.push("lock database statement"); } -@after { msgs.pop(); } +@init { pushMsg("lock database statement", state); } +@after { popMsg(state); } : KW_LOCK KW_DATABASE (dbName=Identifier) lockMode -> ^(TOK_LOCKDB $dbName lockMode) ; lockMode -@init { msgs.push("lock mode"); } -@after { msgs.pop(); } +@init { pushMsg("lock mode", state); } +@after { popMsg(state); } : KW_SHARED | KW_EXCLUSIVE ; unlockStatement -@init { msgs.push("unlock statement"); } -@after { msgs.pop(); } +@init { pushMsg("unlock statement", state); } +@after { popMsg(state); } : KW_UNLOCK KW_TABLE tableName partitionSpec? -> ^(TOK_UNLOCKTABLE tableName partitionSpec?) ; unlockDatabase -@init { msgs.push("unlock database statement"); } -@after { msgs.pop(); } +@init { pushMsg("unlock database statement", state); } +@after { popMsg(state); } : KW_UNLOCK KW_DATABASE (dbName=Identifier) -> ^(TOK_UNLOCKDB $dbName) ; createRoleStatement -@init { msgs.push("create role"); } -@after { msgs.pop(); } +@init { pushMsg("create role", state); } +@after { popMsg(state); } : KW_CREATE KW_ROLE roleName=identifier -> ^(TOK_CREATEROLE $roleName) ; dropRoleStatement -@init {msgs.push("drop role");} -@after {msgs.pop();} +@init {pushMsg("drop role", state);} +@after {popMsg(state);} : KW_DROP KW_ROLE roleName=identifier -> ^(TOK_DROPROLE $roleName) ; grantPrivileges -@init {msgs.push("grant privileges");} -@after {msgs.pop();} +@init {pushMsg("grant privileges", state);} +@after {popMsg(state);} : KW_GRANT privList=privilegeList privilegeObject? KW_TO principalSpecification @@ -1322,57 +1338,57 @@ grantPrivileges ; revokePrivileges -@init {msgs.push("revoke privileges");} -@afer {msgs.pop();} +@init {pushMsg("revoke privileges", state);} +@afer {popMsg(state);} : KW_REVOKE privilegeList privilegeObject? KW_FROM principalSpecification -> ^(TOK_REVOKE privilegeList principalSpecification privilegeObject?) ; grantRole -@init {msgs.push("grant role");} -@after {msgs.pop();} +@init {pushMsg("grant role", state);} +@after {popMsg(state);} : KW_GRANT KW_ROLE? identifier (COMMA identifier)* KW_TO principalSpecification withAdminOption? -> ^(TOK_GRANT_ROLE principalSpecification withAdminOption? identifier+) ; revokeRole -@init {msgs.push("revoke role");} -@after {msgs.pop();} +@init {pushMsg("revoke role", state);} +@after {popMsg(state);} : KW_REVOKE KW_ROLE? identifier (COMMA identifier)* KW_FROM principalSpecification withAdminOption? -> ^(TOK_REVOKE_ROLE principalSpecification withAdminOption? identifier+) ; showRoleGrants -@init {msgs.push("show role grants");} -@after {msgs.pop();} +@init {pushMsg("show role grants", state);} +@after {popMsg(state);} : KW_SHOW KW_ROLE KW_GRANT principalName -> ^(TOK_SHOW_ROLE_GRANT principalName) ; showRoles -@init {msgs.push("show roles");} -@after {msgs.pop();} +@init {pushMsg("show roles", state);} +@after {popMsg(state);} : KW_SHOW KW_ROLES -> ^(TOK_SHOW_ROLES) ; showGrants -@init {msgs.push("show grants");} -@after {msgs.pop();} +@init {pushMsg("show grants", state);} +@after {popMsg(state);} : KW_SHOW KW_GRANT principalName privilegeIncludeColObject? -> ^(TOK_SHOW_GRANT principalName privilegeIncludeColObject?) ; privilegeIncludeColObject -@init {msgs.push("privilege object including columns");} -@after {msgs.pop();} +@init {pushMsg("privilege object including columns", state);} +@after {popMsg(state);} : KW_ON privObjectType identifier (LPAREN cols=columnNameList RPAREN)? partitionSpec? -> ^(TOK_PRIV_OBJECT_COL identifier privObjectType $cols? partitionSpec?) ; privilegeObject -@init {msgs.push("privilege subject");} -@after {msgs.pop();} +@init {pushMsg("privilege subject", state);} +@after {popMsg(state);} : KW_ON privObjectType identifier partitionSpec? -> ^(TOK_PRIV_OBJECT identifier privObjectType partitionSpec?) ; @@ -1380,8 +1396,8 @@ privilegeObject // database or table type. Type is optional, default type is table privObjectType -@init {msgs.push("privilege object type type");} -@after {msgs.pop();} +@init {pushMsg("privilege object type type", state);} +@after {popMsg(state);} : KW_DATABASE -> ^(TOK_DB_TYPE) | KW_VIEW -> ^(TOK_TABLE_TYPE) | KW_TABLE? -> ^(TOK_TABLE_TYPE) @@ -1389,22 +1405,22 @@ privObjectType privilegeList -@init {msgs.push("grant privilege list");} -@after {msgs.pop();} +@init {pushMsg("grant privilege list", state);} +@after {popMsg(state);} : privlegeDef (COMMA privlegeDef)* -> ^(TOK_PRIVILEGE_LIST privlegeDef+) ; privlegeDef -@init {msgs.push("grant privilege");} -@after {msgs.pop();} +@init {pushMsg("grant privilege", state);} +@after {popMsg(state);} : privilegeType (LPAREN cols=columnNameList RPAREN)? -> ^(TOK_PRIVILEGE privilegeType $cols?) ; privilegeType -@init {msgs.push("privilege type");} -@after {msgs.pop();} +@init {pushMsg("privilege type", state);} +@after {popMsg(state);} : KW_ALL -> ^(TOK_PRIV_ALL) | KW_ALTER -> ^(TOK_PRIV_ALTER_METADATA) | KW_UPDATE -> ^(TOK_PRIV_ALTER_DATA) @@ -1417,74 +1433,74 @@ privilegeType ; principalSpecification -@init { msgs.push("user/group/role name list"); } -@after { msgs.pop(); } +@init { pushMsg("user/group/role name list", state); } +@after { popMsg(state); } : principalName (COMMA principalName)* -> ^(TOK_PRINCIPAL_NAME principalName+) ; principalName -@init {msgs.push("user|group|role name");} -@after {msgs.pop();} +@init {pushMsg("user|group|role name", state);} +@after {popMsg(state);} : KW_USER identifier -> ^(TOK_USER identifier) | KW_GROUP identifier -> ^(TOK_GROUP identifier) | KW_ROLE identifier -> ^(TOK_ROLE identifier) ; withGrantOption -@init {msgs.push("with grant option");} -@after {msgs.pop();} +@init {pushMsg("with grant option", state);} +@after {popMsg(state);} : KW_WITH KW_GRANT KW_OPTION -> ^(TOK_GRANT_WITH_OPTION) ; withAdminOption -@init {msgs.push("with admin option");} -@after {msgs.pop();} +@init {pushMsg("with admin option", state);} +@after {popMsg(state);} : KW_WITH KW_ADMIN KW_OPTION -> ^(TOK_GRANT_WITH_ADMIN_OPTION) ; metastoreCheck -@init { msgs.push("metastore check statement"); } -@after { msgs.pop(); } +@init { pushMsg("metastore check statement", state); } +@after { popMsg(state); } : KW_MSCK (repair=KW_REPAIR)? (KW_TABLE table=identifier partitionSpec? (COMMA partitionSpec)*)? -> ^(TOK_MSCK $repair? ($table partitionSpec*)?) ; createFunctionStatement -@init { msgs.push("create function statement"); } -@after { msgs.pop(); } - : KW_CREATE KW_TEMPORARY KW_FUNCTION identifier KW_AS StringLiteral - -> ^(TOK_CREATEFUNCTION identifier StringLiteral) +@init { pushMsg("create function statement", state); } +@after { popMsg(state); } + : KW_CREATE KW_TEMPORARY KW_FUNCTION functionIdentifier KW_AS StringLiteral + -> ^(TOK_CREATEFUNCTION functionIdentifier StringLiteral) ; dropFunctionStatement -@init { msgs.push("drop temporary function statement"); } -@after { msgs.pop(); } - : KW_DROP KW_TEMPORARY KW_FUNCTION ifExists? identifier - -> ^(TOK_DROPFUNCTION identifier ifExists?) +@init { pushMsg("drop temporary function statement", state); } +@after { popMsg(state); } + : KW_DROP KW_TEMPORARY KW_FUNCTION ifExists? functionIdentifier + -> ^(TOK_DROPFUNCTION functionIdentifier ifExists?) ; createMacroStatement -@init { msgs.push("create macro statement"); } -@after { msgs.pop(); } +@init { pushMsg("create macro statement", state); } +@after { popMsg(state); } : KW_CREATE KW_TEMPORARY KW_MACRO Identifier LPAREN columnNameTypeList? RPAREN expression -> ^(TOK_CREATEMACRO Identifier columnNameTypeList? expression) ; dropMacroStatement -@init { msgs.push("drop macro statement"); } -@after { msgs.pop(); } +@init { pushMsg("drop macro statement", state); } +@after { popMsg(state); } : KW_DROP KW_TEMPORARY KW_MACRO ifExists? Identifier -> ^(TOK_DROPMACRO Identifier ifExists?) ; createViewStatement @init { - msgs.push("create view statement"); + pushMsg("create view statement", state); } -@after { msgs.pop(); } +@after { popMsg(state); } : KW_CREATE (orReplace)? KW_VIEW (ifNotExists)? name=tableName (LPAREN columnNameCommentList RPAREN)? tableComment? viewPartition? tablePropertiesPrefixed? @@ -1501,95 +1517,102 @@ createViewStatement ; viewPartition -@init { msgs.push("view partition specification"); } -@after { msgs.pop(); } +@init { pushMsg("view partition specification", state); } +@after { popMsg(state); } : KW_PARTITIONED KW_ON LPAREN columnNameList RPAREN -> ^(TOK_VIEWPARTCOLS columnNameList) ; dropViewStatement -@init { msgs.push("drop view statement"); } -@after { msgs.pop(); } +@init { pushMsg("drop view statement", state); } +@after { popMsg(state); } : KW_DROP KW_VIEW ifExists? viewName -> ^(TOK_DROPVIEW viewName ifExists?) ; +showFunctionIdentifier +@init { pushMsg("identifier for show function statement", state); } +@after { popMsg(state); } + : functionIdentifier + | StringLiteral + ; + showStmtIdentifier -@init { msgs.push("identifier for show statement"); } -@after { msgs.pop(); } +@init { pushMsg("identifier for show statement", state); } +@after { popMsg(state); } : identifier | StringLiteral ; tableComment -@init { msgs.push("table's comment"); } -@after { msgs.pop(); } +@init { pushMsg("table's comment", state); } +@after { popMsg(state); } : KW_COMMENT comment=StringLiteral -> ^(TOK_TABLECOMMENT $comment) ; tablePartition -@init { msgs.push("table partition specification"); } -@after { msgs.pop(); } +@init { pushMsg("table partition specification", state); } +@after { popMsg(state); } : KW_PARTITIONED KW_BY LPAREN columnNameTypeList RPAREN -> ^(TOK_TABLEPARTCOLS columnNameTypeList) ; tableBuckets -@init { msgs.push("table buckets specification"); } -@after { msgs.pop(); } +@init { pushMsg("table buckets specification", state); } +@after { popMsg(state); } : KW_CLUSTERED KW_BY LPAREN bucketCols=columnNameList RPAREN (KW_SORTED KW_BY LPAREN sortCols=columnNameOrderList RPAREN)? KW_INTO num=Number KW_BUCKETS -> ^(TOK_TABLEBUCKETS $bucketCols $sortCols? $num) ; tableSkewed -@init { msgs.push("table skewed specification"); } -@after { msgs.pop(); } +@init { pushMsg("table skewed specification", state); } +@after { popMsg(state); } : KW_SKEWED KW_BY LPAREN skewedCols=columnNameList RPAREN KW_ON LPAREN (skewedValues=skewedValueElement) RPAREN (storedAsDirs)? -> ^(TOK_TABLESKEWED $skewedCols $skewedValues storedAsDirs?) ; rowFormat -@init { msgs.push("serde specification"); } -@after { msgs.pop(); } +@init { pushMsg("serde specification", state); } +@after { popMsg(state); } : rowFormatSerde -> ^(TOK_SERDE rowFormatSerde) | rowFormatDelimited -> ^(TOK_SERDE rowFormatDelimited) | -> ^(TOK_SERDE) ; recordReader -@init { msgs.push("record reader specification"); } -@after { msgs.pop(); } +@init { pushMsg("record reader specification", state); } +@after { popMsg(state); } : KW_RECORDREADER StringLiteral -> ^(TOK_RECORDREADER StringLiteral) | -> ^(TOK_RECORDREADER) ; recordWriter -@init { msgs.push("record writer specification"); } -@after { msgs.pop(); } +@init { pushMsg("record writer specification", state); } +@after { popMsg(state); } : KW_RECORDWRITER StringLiteral -> ^(TOK_RECORDWRITER StringLiteral) | -> ^(TOK_RECORDWRITER) ; rowFormatSerde -@init { msgs.push("serde format specification"); } -@after { msgs.pop(); } +@init { pushMsg("serde format specification", state); } +@after { popMsg(state); } : KW_ROW KW_FORMAT KW_SERDE name=StringLiteral (KW_WITH KW_SERDEPROPERTIES serdeprops=tableProperties)? -> ^(TOK_SERDENAME $name $serdeprops?) ; rowFormatDelimited -@init { msgs.push("serde properties specification"); } -@after { msgs.pop(); } +@init { pushMsg("serde properties specification", state); } +@after { popMsg(state); } : KW_ROW KW_FORMAT KW_DELIMITED tableRowFormatFieldIdentifier? tableRowFormatCollItemsIdentifier? tableRowFormatMapKeysIdentifier? tableRowFormatLinesIdentifier? tableRowNullFormat? -> ^(TOK_SERDEPROPS tableRowFormatFieldIdentifier? tableRowFormatCollItemsIdentifier? tableRowFormatMapKeysIdentifier? tableRowFormatLinesIdentifier? tableRowNullFormat?) ; tableRowFormat -@init { msgs.push("table row format specification"); } -@after { msgs.pop(); } +@init { pushMsg("table row format specification", state); } +@after { popMsg(state); } : rowFormatDelimited -> ^(TOK_TABLEROWFORMAT rowFormatDelimited) @@ -1598,22 +1621,22 @@ tableRowFormat ; tablePropertiesPrefixed -@init { msgs.push("table properties with prefix"); } -@after { msgs.pop(); } +@init { pushMsg("table properties with prefix", state); } +@after { popMsg(state); } : KW_TBLPROPERTIES! tableProperties ; tableProperties -@init { msgs.push("table properties"); } -@after { msgs.pop(); } +@init { pushMsg("table properties", state); } +@after { popMsg(state); } : LPAREN tablePropertiesList RPAREN -> ^(TOK_TABLEPROPERTIES tablePropertiesList) ; tablePropertiesList -@init { msgs.push("table properties list"); } -@after { msgs.pop(); } +@init { pushMsg("table properties list", state); } +@after { popMsg(state); } : keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_TABLEPROPLIST keyValueProperty+) | @@ -1621,61 +1644,61 @@ tablePropertiesList ; keyValueProperty -@init { msgs.push("specifying key/value property"); } -@after { msgs.pop(); } +@init { pushMsg("specifying key/value property", state); } +@after { popMsg(state); } : key=StringLiteral EQUAL value=StringLiteral -> ^(TOK_TABLEPROPERTY $key $value) ; keyProperty -@init { msgs.push("specifying key property"); } -@after { msgs.pop(); } +@init { pushMsg("specifying key property", state); } +@after { popMsg(state); } : key=StringLiteral -> ^(TOK_TABLEPROPERTY $key TOK_NULL) ; tableRowFormatFieldIdentifier -@init { msgs.push("table row format's field separator"); } -@after { msgs.pop(); } +@init { pushMsg("table row format's field separator", state); } +@after { popMsg(state); } : KW_FIELDS KW_TERMINATED KW_BY fldIdnt=StringLiteral (KW_ESCAPED KW_BY fldEscape=StringLiteral)? -> ^(TOK_TABLEROWFORMATFIELD $fldIdnt $fldEscape?) ; tableRowFormatCollItemsIdentifier -@init { msgs.push("table row format's column separator"); } -@after { msgs.pop(); } +@init { pushMsg("table row format's column separator", state); } +@after { popMsg(state); } : KW_COLLECTION KW_ITEMS KW_TERMINATED KW_BY collIdnt=StringLiteral -> ^(TOK_TABLEROWFORMATCOLLITEMS $collIdnt) ; tableRowFormatMapKeysIdentifier -@init { msgs.push("table row format's map key separator"); } -@after { msgs.pop(); } +@init { pushMsg("table row format's map key separator", state); } +@after { popMsg(state); } : KW_MAP KW_KEYS KW_TERMINATED KW_BY mapKeysIdnt=StringLiteral -> ^(TOK_TABLEROWFORMATMAPKEYS $mapKeysIdnt) ; tableRowFormatLinesIdentifier -@init { msgs.push("table row format's line separator"); } -@after { msgs.pop(); } +@init { pushMsg("table row format's line separator", state); } +@after { popMsg(state); } : KW_LINES KW_TERMINATED KW_BY linesIdnt=StringLiteral -> ^(TOK_TABLEROWFORMATLINES $linesIdnt) ; tableRowNullFormat -@init { msgs.push("table row format's null specifier"); } -@after { msgs.pop(); } +@init { pushMsg("table row format's null specifier", state); } +@after { popMsg(state); } : KW_NULL KW_DEFINED KW_AS nullIdnt=StringLiteral -> ^(TOK_TABLEROWFORMATNULL $nullIdnt) ; tableFileFormat -@init { msgs.push("table file format specification"); } -@after { msgs.pop(); } +@init { pushMsg("table file format specification", state); } +@after { popMsg(state); } : KW_STORED KW_AS KW_SEQUENCEFILE -> TOK_TBLSEQUENCEFILE | KW_STORED KW_AS KW_TEXTFILE -> TOK_TBLTEXTFILE @@ -1691,140 +1714,140 @@ tableFileFormat ; tableLocation -@init { msgs.push("table location specification"); } -@after { msgs.pop(); } +@init { pushMsg("table location specification", state); } +@after { popMsg(state); } : KW_LOCATION locn=StringLiteral -> ^(TOK_TABLELOCATION $locn) ; columnNameTypeList -@init { msgs.push("column name type list"); } -@after { msgs.pop(); } +@init { pushMsg("column name type list", state); } +@after { popMsg(state); } : columnNameType (COMMA columnNameType)* -> ^(TOK_TABCOLLIST columnNameType+) ; columnNameColonTypeList -@init { msgs.push("column name type list"); } -@after { msgs.pop(); } +@init { pushMsg("column name type list", state); } +@after { popMsg(state); } : columnNameColonType (COMMA columnNameColonType)* -> ^(TOK_TABCOLLIST columnNameColonType+) ; columnNameList -@init { msgs.push("column name list"); } -@after { msgs.pop(); } +@init { pushMsg("column name list", state); } +@after { popMsg(state); } : columnName (COMMA columnName)* -> ^(TOK_TABCOLNAME columnName+) ; columnName -@init { msgs.push("column name"); } -@after { msgs.pop(); } +@init { pushMsg("column name", state); } +@after { popMsg(state); } : identifier ; columnNameOrderList -@init { msgs.push("column name order list"); } -@after { msgs.pop(); } +@init { pushMsg("column name order list", state); } +@after { popMsg(state); } : columnNameOrder (COMMA columnNameOrder)* -> ^(TOK_TABCOLNAME columnNameOrder+) ; skewedValueElement -@init { msgs.push("skewed value element"); } -@after { msgs.pop(); } +@init { pushMsg("skewed value element", state); } +@after { popMsg(state); } : skewedColumnValues | skewedColumnValuePairList ; skewedColumnValuePairList -@init { msgs.push("column value pair list"); } -@after { msgs.pop(); } +@init { pushMsg("column value pair list", state); } +@after { popMsg(state); } : skewedColumnValuePair (COMMA skewedColumnValuePair)* -> ^(TOK_TABCOLVALUE_PAIR skewedColumnValuePair+) ; skewedColumnValuePair -@init { msgs.push("column value pair"); } -@after { msgs.pop(); } +@init { pushMsg("column value pair", state); } +@after { popMsg(state); } : LPAREN colValues=skewedColumnValues RPAREN -> ^(TOK_TABCOLVALUES $colValues) ; skewedColumnValues -@init { msgs.push("column values"); } -@after { msgs.pop(); } +@init { pushMsg("column values", state); } +@after { popMsg(state); } : skewedColumnValue (COMMA skewedColumnValue)* -> ^(TOK_TABCOLVALUE skewedColumnValue+) ; skewedColumnValue -@init { msgs.push("column value"); } -@after { msgs.pop(); } +@init { pushMsg("column value", state); } +@after { popMsg(state); } : constant ; skewedValueLocationElement -@init { msgs.push("skewed value location element"); } -@after { msgs.pop(); } +@init { pushMsg("skewed value location element", state); } +@after { popMsg(state); } : skewedColumnValue | skewedColumnValuePair ; columnNameOrder -@init { msgs.push("column name order"); } -@after { msgs.pop(); } +@init { pushMsg("column name order", state); } +@after { popMsg(state); } : identifier (asc=KW_ASC | desc=KW_DESC)? -> {$desc == null}? ^(TOK_TABSORTCOLNAMEASC identifier) -> ^(TOK_TABSORTCOLNAMEDESC identifier) ; columnNameCommentList -@init { msgs.push("column name comment list"); } -@after { msgs.pop(); } +@init { pushMsg("column name comment list", state); } +@after { popMsg(state); } : columnNameComment (COMMA columnNameComment)* -> ^(TOK_TABCOLNAME columnNameComment+) ; columnNameComment -@init { msgs.push("column name comment"); } -@after { msgs.pop(); } +@init { pushMsg("column name comment", state); } +@after { popMsg(state); } : colName=identifier (KW_COMMENT comment=StringLiteral)? -> ^(TOK_TABCOL $colName TOK_NULL $comment?) ; columnRefOrder -@init { msgs.push("column order"); } -@after { msgs.pop(); } +@init { pushMsg("column order", state); } +@after { popMsg(state); } : expression (asc=KW_ASC | desc=KW_DESC)? -> {$desc == null}? ^(TOK_TABSORTCOLNAMEASC expression) -> ^(TOK_TABSORTCOLNAMEDESC expression) ; columnNameType -@init { msgs.push("column specification"); } -@after { msgs.pop(); } +@init { pushMsg("column specification", state); } +@after { popMsg(state); } : colName=identifier colType (KW_COMMENT comment=StringLiteral)? -> {$comment == null}? ^(TOK_TABCOL $colName colType) -> ^(TOK_TABCOL $colName colType $comment) ; columnNameColonType -@init { msgs.push("column specification"); } -@after { msgs.pop(); } +@init { pushMsg("column specification", state); } +@after { popMsg(state); } : colName=identifier COLON colType (KW_COMMENT comment=StringLiteral)? -> {$comment == null}? ^(TOK_TABCOL $colName colType) -> ^(TOK_TABCOL $colName colType $comment) ; colType -@init { msgs.push("column type"); } -@after { msgs.pop(); } +@init { pushMsg("column type", state); } +@after { popMsg(state); } : type ; colTypeList -@init { msgs.push("column type list"); } -@after { msgs.pop(); } +@init { pushMsg("column type list", state); } +@after { popMsg(state); } : colType (COMMA colType)* -> ^(TOK_COLTYPELIST colType+) ; @@ -1836,8 +1859,8 @@ type | unionType; primitiveType -@init { msgs.push("primitive type specification"); } -@after { msgs.pop(); } +@init { pushMsg("primitive type specification", state); } +@after { popMsg(state); } : KW_TINYINT -> TOK_TINYINT | KW_SMALLINT -> TOK_SMALLINT | KW_INT -> TOK_INT @@ -1856,33 +1879,33 @@ primitiveType ; listType -@init { msgs.push("list type"); } -@after { msgs.pop(); } +@init { pushMsg("list type", state); } +@after { popMsg(state); } : KW_ARRAY LESSTHAN type GREATERTHAN -> ^(TOK_LIST type) ; structType -@init { msgs.push("struct type"); } -@after { msgs.pop(); } +@init { pushMsg("struct type", state); } +@after { popMsg(state); } : KW_STRUCT LESSTHAN columnNameColonTypeList GREATERTHAN -> ^(TOK_STRUCT columnNameColonTypeList) ; mapType -@init { msgs.push("map type"); } -@after { msgs.pop(); } +@init { pushMsg("map type", state); } +@after { popMsg(state); } : KW_MAP LESSTHAN left=primitiveType COMMA right=type GREATERTHAN -> ^(TOK_MAP $left $right) ; unionType -@init { msgs.push("uniontype type"); } -@after { msgs.pop(); } +@init { pushMsg("uniontype type", state); } +@after { popMsg(state); } : KW_UNIONTYPE LESSTHAN colTypeList GREATERTHAN -> ^(TOK_UNIONTYPE colTypeList) ; setOperator -@init { msgs.push("set operator"); } -@after { msgs.pop(); } +@init { pushMsg("set operator", state); } +@after { popMsg(state); } : KW_UNION KW_ALL -> ^(TOK_UNION) ; @@ -1998,8 +2021,8 @@ body ; insertClause -@init { msgs.push("insert clause"); } -@after { msgs.pop(); } +@init { pushMsg("insert clause", state); } +@after { popMsg(state); } : KW_INSERT KW_OVERWRITE destination ifNotExists? -> ^(TOK_DESTINATION destination ifNotExists?) | KW_INSERT KW_INTO KW_TABLE tableOrPartition @@ -2007,8 +2030,8 @@ insertClause ; destination -@init { msgs.push("destination specification"); } -@after { msgs.pop(); } +@init { pushMsg("destination specification", state); } +@after { popMsg(state); } : KW_LOCAL KW_DIRECTORY StringLiteral tableRowFormat? tableFileFormat? -> ^(TOK_LOCAL_DIR StringLiteral tableRowFormat? tableFileFormat?) | KW_DIRECTORY StringLiteral -> ^(TOK_DIR StringLiteral) @@ -2016,8 +2039,8 @@ destination ; limitClause -@init { msgs.push("limit clause"); } -@after { msgs.pop(); } +@init { pushMsg("limit clause", state); } +@after { popMsg(state); } : KW_LIMIT num=Number -> ^(TOK_LIMIT $num) ; diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g index 4147503..405a2bf 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/IdentifiersParser.g @@ -47,8 +47,8 @@ catch (RecognitionException e) { // group by a,b groupByClause -@init { gParent.msgs.push("group by clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("group by clause", state); } +@after { gParent.popMsg(state); } : KW_GROUP KW_BY groupByExpression @@ -63,8 +63,8 @@ groupByClause ; groupingSetExpression -@init {gParent.msgs.push("grouping set expression"); } -@after {gParent.msgs.pop(); } +@init {gParent.pushMsg("grouping set expression", state); } +@after {gParent.popMsg(state); } : groupByExpression -> ^(TOK_GROUPING_SETS_EXPRESSION groupByExpression) @@ -81,30 +81,30 @@ groupingSetExpression groupByExpression -@init { gParent.msgs.push("group by expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("group by expression", state); } +@after { gParent.popMsg(state); } : expression ; havingClause -@init { gParent.msgs.push("having clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("having clause", state); } +@after { gParent.popMsg(state); } : KW_HAVING havingCondition -> ^(TOK_HAVING havingCondition) ; havingCondition -@init { gParent.msgs.push("having condition"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("having condition", state); } +@after { gParent.popMsg(state); } : expression ; // order by a,b orderByClause -@init { gParent.msgs.push("order by clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("order by clause", state); } +@after { gParent.popMsg(state); } : KW_ORDER KW_BY LPAREN columnRefOrder @@ -116,8 +116,8 @@ orderByClause ; clusterByClause -@init { gParent.msgs.push("cluster by clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("cluster by clause", state); } +@after { gParent.popMsg(state); } : KW_CLUSTER KW_BY LPAREN expression (COMMA expression)* RPAREN -> ^(TOK_CLUSTERBY expression+) @@ -128,8 +128,8 @@ clusterByClause ; partitionByClause -@init { gParent.msgs.push("partition by clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("partition by clause", state); } +@after { gParent.popMsg(state); } : KW_PARTITION KW_BY LPAREN expression (COMMA expression)* RPAREN -> ^(TOK_DISTRIBUTEBY expression+) @@ -139,8 +139,8 @@ partitionByClause ; distributeByClause -@init { gParent.msgs.push("distribute by clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("distribute by clause", state); } +@after { gParent.popMsg(state); } : KW_DISTRIBUTE KW_BY LPAREN expression (COMMA expression)* RPAREN -> ^(TOK_DISTRIBUTEBY expression+) @@ -150,8 +150,8 @@ distributeByClause ; sortByClause -@init { gParent.msgs.push("sort by clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("sort by clause", state); } +@after { gParent.popMsg(state); } : KW_SORT KW_BY LPAREN columnRefOrder @@ -164,8 +164,8 @@ sortByClause // fun(par1, par2, par3) function -@init { gParent.msgs.push("function specification"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("function specification", state); } +@after { gParent.popMsg(state); } : functionName LPAREN @@ -180,15 +180,15 @@ function ; functionName -@init { gParent.msgs.push("function name"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("function name", state); } +@after { gParent.popMsg(state); } : // Keyword IF is also a function name - KW_IF | KW_ARRAY | KW_MAP | KW_STRUCT | KW_UNIONTYPE | identifier + KW_IF | KW_ARRAY | KW_MAP | KW_STRUCT | KW_UNIONTYPE | functionIdentifier ; castExpression -@init { gParent.msgs.push("cast expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("cast expression", state); } +@after { gParent.popMsg(state); } : KW_CAST LPAREN @@ -199,8 +199,8 @@ castExpression ; caseExpression -@init { gParent.msgs.push("case expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("case expression", state); } +@after { gParent.popMsg(state); } : KW_CASE expression (KW_WHEN expression KW_THEN expression)+ @@ -209,8 +209,8 @@ caseExpression ; whenExpression -@init { gParent.msgs.push("case expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("case expression", state); } +@after { gParent.popMsg(state); } : KW_CASE ( KW_WHEN expression KW_THEN expression)+ @@ -219,8 +219,8 @@ whenExpression ; constant -@init { gParent.msgs.push("constant"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("constant", state); } +@after { gParent.popMsg(state); } : Number | dateLiteral @@ -240,8 +240,8 @@ stringLiteralSequence ; charSetStringLiteral -@init { gParent.msgs.push("character string literal"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("character string literal", state); } +@after { gParent.popMsg(state); } : csName=CharSetName csLiteral=CharSetLiteral -> ^(TOK_CHARSETLITERAL $csName $csLiteral) ; @@ -257,8 +257,8 @@ dateLiteral ; expression -@init { gParent.msgs.push("expression specification"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("expression specification", state); } +@after { gParent.popMsg(state); } : precedenceOrExpression ; @@ -268,10 +268,10 @@ atomExpression KW_NULL -> TOK_NULL | dateLiteral | constant - | function | castExpression | caseExpression | whenExpression + | (functionName LPAREN) => function | tableOrColumn | LPAREN! expression RPAREN! ; @@ -524,7 +524,7 @@ descFuncNames : sysFuncNames | StringLiteral - | identifier + | functionIdentifier ; identifier @@ -533,6 +533,15 @@ identifier | nonReserved -> Identifier[$nonReserved.text] ; +functionIdentifier +@init { gParent.pushMsg("function identifier", state); } +@after { gParent.popMsg(state); } + : db=identifier DOT fn=identifier + -> Identifier[$db.text + "." + $fn.text] + | + identifier + ; + nonReserved : KW_TRUE | KW_FALSE | KW_LIKE | KW_EXISTS | KW_ASC | KW_DESC | KW_ORDER | KW_GROUP | KW_BY | KW_AS | KW_INSERT | KW_OVERWRITE | KW_OUTER | KW_LEFT | KW_RIGHT | KW_FULL | KW_PARTITION | KW_PARTITIONS | KW_TABLE | KW_TABLES | KW_COLUMNS | KW_INDEX | KW_INDEXES | KW_REBUILD | KW_FUNCTIONS | KW_SHOW | KW_MSCK | KW_REPAIR | KW_DIRECTORY | KW_LOCAL | KW_USING | KW_CLUSTER | KW_DISTRIBUTE | KW_SORT | KW_UNION | KW_LOAD | KW_EXPORT | KW_IMPORT | KW_DATA | KW_INPATH | KW_IS | KW_NULL | KW_CREATE | KW_EXTERNAL | KW_ALTER | KW_CHANGE | KW_FIRST | KW_AFTER | KW_DESCRIBE | KW_DROP | KW_RENAME | KW_IGNORE | KW_PROTECTION | KW_TO | KW_COMMENT | KW_BOOLEAN | KW_TINYINT | KW_SMALLINT | KW_INT | KW_BIGINT | KW_FLOAT | KW_DOUBLE | KW_DATE | KW_DATETIME | KW_TIMESTAMP | KW_DECIMAL | KW_STRING | KW_ARRAY | KW_STRUCT | KW_UNIONTYPE | KW_PARTITIONED | KW_CLUSTERED | KW_SORTED | KW_INTO | KW_BUCKETS | KW_ROW | KW_ROWS | KW_FORMAT | KW_DELIMITED | KW_FIELDS | KW_TERMINATED | KW_ESCAPED | KW_COLLECTION | KW_ITEMS | KW_KEYS | KW_KEY_TYPE | KW_LINES | KW_STORED | KW_FILEFORMAT | KW_SEQUENCEFILE | KW_TEXTFILE | KW_RCFILE | KW_ORCFILE | KW_INPUTFORMAT | KW_OUTPUTFORMAT | KW_INPUTDRIVER | KW_OUTPUTDRIVER | KW_OFFLINE | KW_ENABLE | KW_DISABLE | KW_READONLY | KW_NO_DROP | KW_LOCATION | KW_BUCKET | KW_OUT | KW_OF | KW_PERCENT | KW_ADD | KW_REPLACE | KW_RLIKE | KW_REGEXP | KW_TEMPORARY | KW_EXPLAIN | KW_FORMATTED | KW_PRETTY | KW_DEPENDENCY | KW_LOGICAL | KW_SERDE | KW_WITH | KW_DEFERRED | KW_SERDEPROPERTIES | KW_DBPROPERTIES | KW_LIMIT | KW_SET | KW_UNSET | KW_TBLPROPERTIES | KW_IDXPROPERTIES | KW_VALUE_TYPE | KW_ELEM_TYPE | KW_MAPJOIN | KW_STREAMTABLE | KW_HOLD_DDLTIME | KW_CLUSTERSTATUS | KW_UTC | KW_UTCTIMESTAMP | KW_LONG | KW_DELETE | KW_PLUS | KW_MINUS | KW_FETCH | KW_INTERSECT | KW_VIEW | KW_IN | KW_DATABASES | KW_MATERIALIZED | KW_SCHEMA | KW_SCHEMAS | KW_GRANT | KW_REVOKE | KW_SSL | KW_UNDO | KW_LOCK | KW_LOCKS | KW_UNLOCK | KW_SHARED | KW_EXCLUSIVE | KW_PROCEDURE | KW_UNSIGNED | KW_WHILE | KW_READ | KW_READS | KW_PURGE | KW_RANGE | KW_ANALYZE | KW_BEFORE | KW_BETWEEN | KW_BOTH | KW_BINARY | KW_CONTINUE | KW_CURSOR | KW_TRIGGER | KW_RECORDREADER | KW_RECORDWRITER | KW_SEMI | KW_LATERAL | KW_TOUCH | KW_ARCHIVE | KW_UNARCHIVE | KW_COMPUTE | KW_STATISTICS | KW_USE | KW_OPTION | KW_CONCATENATE | KW_SHOW_DATABASE | KW_UPDATE | KW_RESTRICT | KW_CASCADE | KW_SKEWED | KW_ROLLUP | KW_CUBE | KW_DIRECTORIES | KW_FOR | KW_GROUPING | KW_SETS | KW_TRUNCATE | KW_NOSCAN | KW_USER | KW_ROLE | KW_ROLES | KW_INNER | KW_DEFINED | KW_ADMIN diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/MacroSemanticAnalyzer.java ql/src/java/org/apache/hadoop/hive/ql/parse/MacroSemanticAnalyzer.java index b42a425..36f8f71 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/MacroSemanticAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/MacroSemanticAnalyzer.java @@ -35,6 +35,7 @@ import org.apache.hadoop.hive.ql.ErrorMsg; import org.apache.hadoop.hive.ql.exec.ColumnInfo; import org.apache.hadoop.hive.ql.exec.FunctionRegistry; +import org.apache.hadoop.hive.ql.exec.FunctionUtils; import org.apache.hadoop.hive.ql.exec.TaskFactory; import org.apache.hadoop.hive.ql.lib.Dispatcher; import org.apache.hadoop.hive.ql.lib.Node; @@ -73,6 +74,12 @@ public void analyzeInternal(ASTNode ast) throws SemanticException { @SuppressWarnings("unchecked") private void analyzeCreateMacro(ASTNode ast) throws SemanticException { String functionName = ast.getChild(0).getText(); + + // Temp macros are not allowed to have qualified names. + if (FunctionUtils.isQualifiedFunctionName(functionName)) { + throw new SemanticException("Temporary macro cannot be created with a qualified name."); + } + List arguments = BaseSemanticAnalyzer.getColumns((ASTNode)ast.getChild(1), true); boolean isNoArgumentMacro = arguments.size() == 0; @@ -80,6 +87,7 @@ private void analyzeCreateMacro(ASTNode ast) throws SemanticException { ArrayList macroColNames = new ArrayList(arguments.size()); ArrayList macroColTypes = new ArrayList(arguments.size()); final Set actualColumnNames = new HashSet(); + if(!isNoArgumentMacro) { /* * Walk down expression to see which arguments are actually used. diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/SelectClauseParser.g ql/src/java/org/apache/hadoop/hive/ql/parse/SelectClauseParser.g index f4de252..1855d7f 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/SelectClauseParser.g +++ ql/src/java/org/apache/hadoop/hive/ql/parse/SelectClauseParser.g @@ -46,8 +46,8 @@ catch (RecognitionException e) { //----------------------- Rules for parsing selectClause ----------------------------- // select a,b,c ... selectClause -@init { gParent.msgs.push("select clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("select clause", state); } +@after { gParent.popMsg(state); } : KW_SELECT hintClause? (((KW_ALL | dist=KW_DISTINCT)? selectList) | (transform=KW_TRANSFORM selectTrfmClause)) @@ -59,15 +59,15 @@ selectClause ; selectList -@init { gParent.msgs.push("select list"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("select list", state); } +@after { gParent.popMsg(state); } : selectItem ( COMMA selectItem )* -> selectItem+ ; selectTrfmClause -@init { gParent.msgs.push("transform clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("transform clause", state); } +@after { gParent.popMsg(state); } : LPAREN selectExpressionList RPAREN inSerde=rowFormat inRec=recordWriter @@ -78,29 +78,29 @@ selectTrfmClause ; hintClause -@init { gParent.msgs.push("hint clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("hint clause", state); } +@after { gParent.popMsg(state); } : DIVIDE STAR PLUS hintList STAR DIVIDE -> ^(TOK_HINTLIST hintList) ; hintList -@init { gParent.msgs.push("hint list"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("hint list", state); } +@after { gParent.popMsg(state); } : hintItem (COMMA hintItem)* -> hintItem+ ; hintItem -@init { gParent.msgs.push("hint item"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("hint item", state); } +@after { gParent.popMsg(state); } : hintName (LPAREN hintArgs RPAREN)? -> ^(TOK_HINT hintName hintArgs?) ; hintName -@init { gParent.msgs.push("hint name"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("hint name", state); } +@after { gParent.popMsg(state); } : KW_MAPJOIN -> TOK_MAPJOIN | KW_STREAMTABLE -> TOK_STREAMTABLE @@ -108,22 +108,22 @@ hintName ; hintArgs -@init { gParent.msgs.push("hint arguments"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("hint arguments", state); } +@after { gParent.popMsg(state); } : hintArgName (COMMA hintArgName)* -> ^(TOK_HINTARGLIST hintArgName+) ; hintArgName -@init { gParent.msgs.push("hint argument name"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("hint argument name", state); } +@after { gParent.popMsg(state); } : identifier ; selectItem -@init { gParent.msgs.push("selection target"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("selection target", state); } +@after { gParent.popMsg(state); } : ( selectExpression ((KW_AS? identifier) | (KW_AS LPAREN identifier (COMMA identifier)* RPAREN))? @@ -131,8 +131,8 @@ selectItem ; trfmClause -@init { gParent.msgs.push("transform clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("transform clause", state); } +@after { gParent.popMsg(state); } : ( KW_MAP selectExpressionList | KW_REDUCE selectExpressionList ) @@ -144,37 +144,37 @@ trfmClause ; selectExpression -@init { gParent.msgs.push("select expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("select expression", state); } +@after { gParent.popMsg(state); } : expression | tableAllColumns ; selectExpressionList -@init { gParent.msgs.push("select expression list"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("select expression list", state); } +@after { gParent.popMsg(state); } : selectExpression (COMMA selectExpression)* -> ^(TOK_EXPLIST selectExpression+) ; //---------------------- Rules for windowing clauses ------------------------------- window_clause -@init { gParent.msgs.push("window_clause"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("window_clause", state); } +@after { gParent.popMsg(state); } : KW_WINDOW window_defn (COMMA window_defn)* -> ^(KW_WINDOW window_defn+) ; window_defn -@init { gParent.msgs.push("window_defn"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("window_defn", state); } +@after { gParent.popMsg(state); } : Identifier KW_AS window_specification -> ^(TOK_WINDOWDEF Identifier window_specification) ; window_specification -@init { gParent.msgs.push("window_specification"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("window_specification", state); } +@after { gParent.popMsg(state); } : (Identifier | ( LPAREN Identifier? partitioningSpec? window_frame? RPAREN)) -> ^(TOK_WINDOWSPEC Identifier? partitioningSpec? window_frame?) ; @@ -185,24 +185,24 @@ window_frame : ; window_range_expression -@init { gParent.msgs.push("window_range_expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("window_range_expression", state); } +@after { gParent.popMsg(state); } : KW_ROWS sb=window_frame_start_boundary -> ^(TOK_WINDOWRANGE $sb) | KW_ROWS KW_BETWEEN s=window_frame_boundary KW_AND end=window_frame_boundary -> ^(TOK_WINDOWRANGE $s $end) ; window_value_expression -@init { gParent.msgs.push("window_value_expression"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("window_value_expression", state); } +@after { gParent.popMsg(state); } : KW_RANGE sb=window_frame_start_boundary -> ^(TOK_WINDOWVALUES $sb) | KW_RANGE KW_BETWEEN s=window_frame_boundary KW_AND end=window_frame_boundary -> ^(TOK_WINDOWVALUES $s $end) ; window_frame_start_boundary -@init { gParent.msgs.push("windowframestartboundary"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("windowframestartboundary", state); } +@after { gParent.popMsg(state); } : KW_UNBOUNDED KW_PRECEDING -> ^(KW_PRECEDING KW_UNBOUNDED) | KW_CURRENT KW_ROW -> ^(KW_CURRENT) | @@ -210,8 +210,8 @@ window_frame_start_boundary ; window_frame_boundary -@init { gParent.msgs.push("windowframeboundary"); } -@after { gParent.msgs.pop(); } +@init { gParent.pushMsg("windowframeboundary", state); } +@after { gParent.popMsg(state); } : KW_UNBOUNDED (r=KW_PRECEDING|r=KW_FOLLOWING) -> ^($r KW_UNBOUNDED) | KW_CURRENT KW_ROW -> ^(KW_CURRENT) | diff --git ql/src/test/queries/clientnegative/udf_invalid.q ql/src/test/queries/clientnegative/udf_invalid.q new file mode 100644 index 0000000..68050fd --- /dev/null +++ ql/src/test/queries/clientnegative/udf_invalid.q @@ -0,0 +1 @@ +select default.nonexistfunc() from src; diff --git ql/src/test/queries/clientnegative/udf_qualified_name.q ql/src/test/queries/clientnegative/udf_qualified_name.q new file mode 100644 index 0000000..476dfa2 --- /dev/null +++ ql/src/test/queries/clientnegative/udf_qualified_name.q @@ -0,0 +1 @@ +create temporary function default.myfunc as 'org.apache.hadoop.hive.ql.udf.generic.GenericUDAFSum'; diff --git ql/src/test/results/clientnegative/udf_invalid.q.out ql/src/test/results/clientnegative/udf_invalid.q.out new file mode 100644 index 0000000..c394cc8 --- /dev/null +++ ql/src/test/results/clientnegative/udf_invalid.q.out @@ -0,0 +1 @@ +FAILED: SemanticException Line 0:-1 Invalid function 'default.nonexistfunc' diff --git ql/src/test/results/clientnegative/udf_qualified_name.q.out ql/src/test/results/clientnegative/udf_qualified_name.q.out new file mode 100644 index 0000000..69404b4 --- /dev/null +++ ql/src/test/results/clientnegative/udf_qualified_name.q.out @@ -0,0 +1 @@ +FAILED: SemanticException Temporary function cannot be created with a qualified name.