Explorar el Código

HUE-8856 [autocomplete] Extract jison for Impala DROP, LOAD, GRANT and INSERT

Johan Ahlen hace 6 años
padre
commit
1e42581e96

+ 51 - 201
desktop/core/src/desktop/js/parse/jison/impala/sql_drop.jison

@@ -16,22 +16,18 @@
 
 DataDefinition
  : DropStatement
- | HiveAbortStatement
  ;
 
 DataDefinition_EDIT
  : DropStatement_EDIT
- | HiveAbortStatement_EDIT
  ;
 
 DataManipulation
- : HiveDeleteStatement
- | ImpalaDeleteStatement
+ : DeleteStatement
  ;
 
 DataManipulation_EDIT
- : HiveDeleteStatement_EDIT
- | ImpalaDeleteStatement_EDIT
+ : DeleteStatement_EDIT
  ;
 
 DropStatement
@@ -40,8 +36,6 @@ DropStatement
  | DropRoleStatement
  | DropStatsStatement
  | DropTableStatement
- | DropIndexStatement
- | DropMacroStatement
  | DropViewStatement
  | TruncateTableStatement
  ;
@@ -51,19 +45,11 @@ DropStatement_EDIT
  | DropFunctionStatement_EDIT
  | DropStatsStatement_EDIT
  | DropTableStatement_EDIT
- | DropIndexStatement_EDIT
- | DropMacroStatement_EDIT
  | DropViewStatement_EDIT
  | TruncateTableStatement_EDIT
  | 'DROP' 'CURSOR'
    {
-     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']);
-     }
+     parser.suggestKeywords(['AGGREGATE FUNCTION', 'DATABASE', 'FUNCTION', 'INCREMENTAL STATS', 'ROLE', 'SCHEMA', 'STATS', 'TABLE', 'VIEW']);
    }
  ;
 
@@ -83,9 +69,7 @@ DropDatabaseStatement_EDIT
    }
  | 'DROP' DatabaseOrSchema OptionalIfExists RegularOrBacktickedIdentifier 'CURSOR'
    {
-     if (parser.isHive() || parser.isImpala()) {
-       parser.suggestKeywords(['CASCADE', 'RESTRICT']);
-     }
+     parser.suggestKeywords(['CASCADE', 'RESTRICT']);
    }
  | 'DROP' DatabaseOrSchema OptionalIfExists_EDIT RegularOrBacktickedIdentifier OptionalCascadeOrRestrict
  | 'DROP' DatabaseOrSchema OptionalIfExists 'CURSOR' RegularOrBacktickedIdentifier OptionalCascadeOrRestrict
@@ -96,93 +80,53 @@ DropDatabaseStatement_EDIT
    }
  ;
 
+// OptionalAggregate is no go for look ahead reasons
 DropFunctionStatement
- : DropImpalaFunction
- | DropHiveFunction
+ : 'DROP' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList
+ | 'DROP' 'AGGREGATE' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList
  ;
 
 DropFunctionStatement_EDIT
- : DropImpalaFunction_EDIT
- | DropHiveFunction_EDIT
- ;
-
-// OptionalAggregate is no go for look ahead reasons
-DropImpalaFunction
- : 'DROP' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList
- | 'DROP' '<impala>AGGREGATE' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList
- ;
-
-DropImpalaFunction_EDIT
- : 'DROP' '<impala>FUNCTION' OptionalIfExists 'CURSOR'
+ : 'DROP' 'FUNCTION' OptionalIfExists 'CURSOR'
    {
      if (!$3) {
        parser.suggestKeywords(['IF EXISTS']);
      }
      parser.suggestDatabases({ appendDot: true });
    }
- | 'DROP' '<impala>AGGREGATE' '<impala>FUNCTION' OptionalIfExists 'CURSOR'
+ | 'DROP' 'AGGREGATE' 'FUNCTION' OptionalIfExists 'CURSOR'
    {
      if (!$4) {
        parser.suggestKeywords(['IF EXISTS']);
      }
      parser.suggestDatabases({ appendDot: true });
    }
- | 'DROP' '<impala>FUNCTION' OptionalIfExists 'CURSOR' SchemaQualifiedIdentifier ParenthesizedArgumentList
+ | 'DROP' 'FUNCTION' OptionalIfExists 'CURSOR' SchemaQualifiedIdentifier ParenthesizedArgumentList
    {
      if (!$3) {
        parser.suggestKeywords(['IF EXISTS']);
      }
    }
- | 'DROP' '<impala>FUNCTION' OptionalIfExists_EDIT
- | 'DROP' 'CURSOR' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList
+ | 'DROP' 'FUNCTION' OptionalIfExists_EDIT
+ | 'DROP' 'CURSOR' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList
    {
      parser.suggestKeywords(['AGGREGATE']);
    }
- | 'DROP' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList_EDIT
- | 'DROP' '<impala>AGGREGATE' 'CURSOR'
+ | 'DROP' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList_EDIT
+ | 'DROP' 'AGGREGATE' 'CURSOR'
    {
      parser.suggestKeywords(['FUNCTION']);
    }
- | 'DROP' '<impala>AGGREGATE' '<impala>FUNCTION' OptionalIfExists 'CURSOR' SchemaQualifiedIdentifier ParenthesizedArgumentList
-   {
-     if (!$4) {
-       parser.suggestKeywords(['IF EXISTS']);
-     }
-   }
- | 'DROP' '<impala>AGGREGATE' '<impala>FUNCTION' OptionalIfExists_EDIT
- | 'DROP' '<impala>AGGREGATE' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList_EDIT
- | 'DROP' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier_EDIT ParenthesizedArgumentList
- | 'DROP' '<impala>AGGREGATE' '<impala>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier_EDIT ParenthesizedArgumentList
- ;
-
-DropHiveFunction
- : 'DROP' '<hive>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier
- | 'DROP' '<hive>TEMPORARY' '<hive>FUNCTION' OptionalIfExists RegularIdentifier
- ;
-
-DropHiveFunction_EDIT
- : 'DROP' '<hive>FUNCTION' OptionalIfExists 'CURSOR'
-   {
-     if (!$3) {
-       parser.suggestKeywords(['IF EXISTS']);
-     }
-   }
- | 'DROP' '<hive>FUNCTION' OptionalIfExists 'CURSOR' SchemaQualifiedIdentifier
-   {
-     if (!$3) {
-       parser.suggestKeywords(['IF EXISTS']);
-     }
-   }
- | 'DROP' '<hive>FUNCTION' OptionalIfExists_EDIT
- | 'DROP' '<hive>FUNCTION' OptionalIfExists_EDIT SchemaQualifiedIdentifier
- | 'DROP' '<hive>FUNCTION' OptionalIfExists SchemaQualifiedIdentifier_EDIT
- | 'DROP' '<hive>TEMPORARY' '<hive>FUNCTION' OptionalIfExists 'CURSOR'
+ | 'DROP' 'AGGREGATE' 'FUNCTION' OptionalIfExists 'CURSOR' SchemaQualifiedIdentifier ParenthesizedArgumentList
    {
      if (!$4) {
        parser.suggestKeywords(['IF EXISTS']);
      }
    }
- | 'DROP' '<hive>TEMPORARY' '<hive>FUNCTION' OptionalIfExists_EDIT
+ | 'DROP' 'AGGREGATE' 'FUNCTION' OptionalIfExists_EDIT
+ | 'DROP' 'AGGREGATE' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier ParenthesizedArgumentList_EDIT
+ | 'DROP' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier_EDIT ParenthesizedArgumentList
+ | 'DROP' 'AGGREGATE' 'FUNCTION' OptionalIfExists SchemaQualifiedIdentifier_EDIT ParenthesizedArgumentList
  ;
 
 DropRoleStatement
@@ -190,50 +134,50 @@ DropRoleStatement
  ;
 
 DropStatsStatement
- : 'DROP' '<impala>STATS' SchemaQualifiedTableIdentifier
+ : 'DROP' 'STATS' SchemaQualifiedTableIdentifier
    {
      parser.addTablePrimary($3);
    }
- | 'DROP' '<impala>INCREMENTAL' '<impala>STATS' SchemaQualifiedTableIdentifier PartitionSpec
+ | 'DROP' 'INCREMENTAL' 'STATS' SchemaQualifiedTableIdentifier PartitionSpec
    {
      parser.addTablePrimary($4);
    }
  ;
 
 DropStatsStatement_EDIT
- : 'DROP' '<impala>STATS' 'CURSOR'
+ : 'DROP' 'STATS' 'CURSOR'
    {
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | 'DROP' '<impala>STATS' SchemaQualifiedTableIdentifier_EDIT
- | 'DROP' 'CURSOR' '<impala>STATS' SchemaQualifiedTableIdentifier
+ | 'DROP' 'STATS' SchemaQualifiedTableIdentifier_EDIT
+ | 'DROP' 'CURSOR' 'STATS' SchemaQualifiedTableIdentifier
    {
      parser.addTablePrimary($4);
      parser.suggestKeywords(['INCREMENTAL']);
    }
- | 'DROP' 'CURSOR' '<impala>STATS' SchemaQualifiedTableIdentifier PartitionSpec
+ | 'DROP' 'CURSOR' 'STATS' SchemaQualifiedTableIdentifier PartitionSpec
    {
      parser.addTablePrimary($4);
      parser.suggestKeywords(['INCREMENTAL']);
    }
- | 'DROP' '<impala>INCREMENTAL' 'CURSOR'
+ | 'DROP' 'INCREMENTAL' 'CURSOR'
    {
      parser.suggestKeywords(['STATS']);
    }
- | 'DROP' '<impala>INCREMENTAL' '<impala>STATS' 'CURSOR'
+ | 'DROP' 'INCREMENTAL' 'STATS' 'CURSOR'
    {
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | 'DROP' '<impala>INCREMENTAL' '<impala>STATS' SchemaQualifiedTableIdentifier_EDIT
- | 'DROP' '<impala>INCREMENTAL' '<impala>STATS' SchemaQualifiedTableIdentifier_EDIT PartitionSpec
- | 'DROP' '<impala>INCREMENTAL' '<impala>STATS' SchemaQualifiedTableIdentifier 'CURSOR'
+ | 'DROP' 'INCREMENTAL' 'STATS' SchemaQualifiedTableIdentifier_EDIT
+ | 'DROP' 'INCREMENTAL' 'STATS' SchemaQualifiedTableIdentifier_EDIT PartitionSpec
+ | 'DROP' 'INCREMENTAL' 'STATS' SchemaQualifiedTableIdentifier 'CURSOR'
    {
      parser.addTablePrimary($4);
      parser.suggestKeywords(['PARTITION']);
    }
- | 'DROP' '<impala>INCREMENTAL' '<impala>STATS' SchemaQualifiedTableIdentifier PartitionSpec_EDIT
+ | 'DROP' 'INCREMENTAL' 'STATS' SchemaQualifiedTableIdentifier PartitionSpec_EDIT
    {
      parser.addTablePrimary($4);
    }
@@ -277,51 +221,6 @@ DropTableStatement_EDIT
 OptionalPurge
  :
  | 'PURGE'
- | '<hive>PURGE'
- ;
-
-
-DropIndexStatement
- : 'DROP' '<hive>INDEX' OptionalIfExists RegularOrBacktickedIdentifier 'ON' SchemaQualifiedTableIdentifier
-   {
-     parser.addTablePrimary($6);
-   }
- ;
-
-DropIndexStatement_EDIT
- : 'DROP' '<hive>INDEX' OptionalIfExists 'CURSOR'
-   {
-     parser.suggestKeywords(['IF EXISTS']);
-   }
- | 'DROP' '<hive>INDEX' OptionalIfExists_EDIT
- | 'DROP' '<hive>INDEX' OptionalIfExists RegularOrBacktickedIdentifier 'CURSOR'
-   {
-     parser.suggestKeywords(['ON']);
-   }
- | 'DROP' '<hive>INDEX' OptionalIfExists RegularOrBacktickedIdentifier 'ON' 'CURSOR'
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | 'DROP' '<hive>INDEX' OptionalIfExists RegularOrBacktickedIdentifier 'ON' SchemaQualifiedTableIdentifier_EDIT
- ;
-
-DropMacroStatement
- : 'DROP' '<hive>TEMPORARY' '<hive>MACRO' OptionalIfExists RegularIdentifier
- ;
-
-DropMacroStatement_EDIT
- : 'DROP' '<hive>TEMPORARY' 'CURSOR'
-   {
-     parser.suggestKeywords(['FUNCTION', 'MACRO']);
-   }
- | 'DROP' '<hive>TEMPORARY' '<hive>MACRO' OptionalIfExists 'CURSOR'
-   {
-     if (!$4) {
-       parser.suggestKeywords(['IF EXISTS']);
-     }
-   }
- | 'DROP' '<hive>TEMPORARY' '<hive>MACRO' OptionalIfExists_EDIT
  ;
 
 DropViewStatement
@@ -376,84 +275,46 @@ TruncateTableStatement_EDIT
    {
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
-     if (parser.isImpala() && !$3) {
+     if (!$3) {
        parser.suggestKeywords(['IF EXISTS']);
      }
    }
  | 'TRUNCATE' AnyTable OptionalIfExists_EDIT OptionalPartitionSpec
- | 'TRUNCATE' AnyTable OptionalIfExists SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec
- | 'TRUNCATE' AnyTable OptionalIfExists SchemaQualifiedTableIdentifier OptionalPartitionSpec 'CURSOR'
-   {
-     parser.addTablePrimary($4);
-     if (parser.isHive() && !$5) {
-       parser.suggestKeywords(['PARTITION']);
-     }
-   }
- | 'TRUNCATE' AnyTable OptionalIfExists SchemaQualifiedTableIdentifier OptionalPartitionSpec_EDIT
+ | 'TRUNCATE' AnyTable OptionalIfExists SchemaQualifiedTableIdentifier_EDIT
+ | 'TRUNCATE' AnyTable OptionalIfExists SchemaQualifiedTableIdentifier 'CURSOR'
    {
      parser.addTablePrimary($4);
    }
- | 'TRUNCATE' AnyTable OptionalIfExists 'CURSOR' SchemaQualifiedTableIdentifier OptionalPartitionSpec
+ | 'TRUNCATE' AnyTable OptionalIfExists 'CURSOR' SchemaQualifiedTableIdentifier
    {
      parser.addTablePrimary($4);
-     if (parser.isImpala() && !$3) {
+     if (!$3) {
        parser.suggestKeywords(['IF EXISTS']);
      }
    }
- | 'TRUNCATE' AnyTable OptionalIfExists_EDIT SchemaQualifiedTableIdentifier OptionalPartitionSpec
+ | 'TRUNCATE' AnyTable OptionalIfExists_EDIT SchemaQualifiedTableIdentifier
  ;
 
-HiveDeleteStatement
- : '<hive>DELETE' 'FROM' SchemaQualifiedTableIdentifier OptionalWhereClause
-   {
-     parser.addTablePrimary($3);
-   }
+DeleteStatement
+ : 'DELETE' OptionalDeleteTableRef 'FROM' TableReference OptionalWhereClause
  ;
 
-HiveDeleteStatement_EDIT
- : '<hive>DELETE' 'CURSOR'
+DeleteStatement_EDIT
+ : 'DELETE' OptionalDeleteTableRef 'CURSOR'
    {
      parser.suggestKeywords(['FROM']);
-   }
- | '<hive>DELETE' 'FROM' 'CURSOR'
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | '<hive>DELETE' 'FROM' SchemaQualifiedTableIdentifier 'CURSOR' OptionalWhereClause
-   {
-     parser.addTablePrimary($3);
-     if (!$5) {
-       parser.suggestKeywords(['WHERE']);
-     }
-   }
- | '<hive>DELETE' 'FROM' SchemaQualifiedTableIdentifier_EDIT OptionalWhereClause
- | '<hive>DELETE' 'FROM' SchemaQualifiedTableIdentifier WhereClause_EDIT
-   {
-     parser.addTablePrimary($3);
-   }
- ;
-
-ImpalaDeleteStatement
- : '<impala>DELETE' OptionalImpalaDeleteTableRef 'FROM' TableReference OptionalWhereClause
- ;
-
-ImpalaDeleteStatement_EDIT
- : '<impala>DELETE' OptionalImpalaDeleteTableRef 'CURSOR'
-   {
-     parser.suggestKeywords(['FROM']);
-     if (parser.isImpala() && !$2) {
+     if (!$2) {
        parser.suggestTables();
        parser.suggestDatabases({ appendDot: true });
      }
    }
- | '<impala>DELETE' ImpalaDeleteTableRef_EDIT
- | '<impala>DELETE' OptionalImpalaDeleteTableRef 'FROM' 'CURSOR'
+ | 'DELETE' DeleteTableRef_EDIT
+ | 'DELETE' OptionalDeleteTableRef 'FROM' 'CURSOR'
    {
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | '<impala>DELETE' OptionalImpalaDeleteTableRef 'FROM' TableReference 'CURSOR' OptionalWhereClause
+ | 'DELETE' OptionalDeleteTableRef 'FROM' TableReference 'CURSOR' OptionalWhereClause
    {
      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 (!$6) {
@@ -472,32 +333,21 @@ ImpalaDeleteStatement_EDIT
        parser.suggestKeywords(keywords);
      }
    }
- | '<impala>DELETE' ImpalaDeleteTableRef_EDIT 'FROM'
- | '<impala>DELETE' ImpalaDeleteTableRef_EDIT 'FROM' TableReference OptionalWhereClause
- | '<impala>DELETE' OptionalImpalaDeleteTableRef 'FROM' TableReference_EDIT OptionalWhereClause
- | '<impala>DELETE' OptionalImpalaDeleteTableRef 'FROM' TableReference WhereClause_EDIT
+ | 'DELETE' DeleteTableRef_EDIT 'FROM'
+ | 'DELETE' DeleteTableRef_EDIT 'FROM' TableReference OptionalWhereClause
+ | 'DELETE' OptionalDeleteTableRef 'FROM' TableReference_EDIT OptionalWhereClause
+ | 'DELETE' OptionalDeleteTableRef 'FROM' TableReference WhereClause_EDIT
  ;
 
-OptionalImpalaDeleteTableRef
+OptionalDeleteTableRef
  :
  | TableReference
  ;
 
-ImpalaDeleteTableRef_EDIT
+DeleteTableRef_EDIT
  : TableReference_EDIT
  ;
 
-HiveAbortStatement
- : '<hive>ABORT' '<hive>TRANSACTIONS' TransactionIdList
- ;
-
-HiveAbortStatement_EDIT
- : '<hive>ABORT' 'CURSOR'
-   {
-     parser.suggestKeywords(['TRANSACTIONS']);
-   }
- ;
-
 TransactionIdList
  : UnsignedNumericLiteral
  | TransactionIdList ',' UnsignedNumericLiteral

+ 15 - 38
desktop/core/src/desktop/js/parse/jison/impala/sql_error.jison

@@ -22,13 +22,7 @@ SqlStatements
 SqlStatement_EDIT
  : AnyCursor error
    {
-     if (parser.isHive()) {
-       parser.suggestDdlAndDmlKeywords(['EXPLAIN', 'FROM']);
-     } else if (parser.isImpala()) {
-       parser.suggestDdlAndDmlKeywords(['EXPLAIN']);
-     } else {
-       parser.suggestDdlAndDmlKeywords();
-     }
+     parser.suggestDdlAndDmlKeywords(['EXPLAIN']);
    }
  ;
 
@@ -80,13 +74,6 @@ ErrorList
  | Errors ',' error
  ;
 
-LateralView
- : '<hive>LATERAL' '<hive>VIEW' OptionalOuter ArbitraryFunction RegularOrBacktickedIdentifier '<hive>AS' error  -> { }
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter ArbitraryFunction error                                           -> { }
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter error                                                               -> { }
- | '<hive>LATERAL' error                                                                                          -> { }
- ;
-
 JoinType_EDIT
  : 'FULL' 'CURSOR' error
    {
@@ -94,64 +81,54 @@ JoinType_EDIT
    }
  | 'LEFT' 'CURSOR' error
    {
-     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']);
-     }
+     parser.suggestKeywords(['ANTI JOIN', 'INNER JOIN', 'JOIN', 'OUTER JOIN', 'SEMI JOIN']);
    }
  | 'RIGHT' 'CURSOR' error
    {
-     if (parser.isImpala()) {
-       parser.suggestKeywords(['ANTI JOIN', 'INNER JOIN', 'JOIN', 'OUTER JOIN', 'SEMI JOIN']);
-     } else {
-       parser.suggestKeywords(['JOIN', 'OUTER JOIN']);
-     }
+     parser.suggestKeywords(['ANTI JOIN', 'INNER JOIN', 'JOIN', 'OUTER JOIN', 'SEMI JOIN']);
    }
  ;
 
 OptionalSelectConditions_EDIT
- : WhereClause error 'CURSOR' OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
+ : WhereClause error 'CURSOR' OptionalGroupByClause OptionalHavingClause OptionalOrderByClause OptionalLimitClause OptionalOffsetClause
    {
      $$ = {
-       suggestKeywords: parser.getKeywordsForOptionalsLR([$4, $5, $6, $7, $8, $9, $10], [{ 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: !$4 && !$5 && !$6 && !$7 && !$8 && !$9 && !$10
+       suggestKeywords: parser.getKeywordsForOptionalsLR([$4, $5, $6, $7, $8], [{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true, true, true, true]),
+       cursorAtEnd: !$4 && !$5 && !$6 && !$7 && !$8
      };
    }
- | OptionalWhereClause OptionalGroupByClause HavingClause error 'CURSOR' OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
+ | OptionalWhereClause OptionalGroupByClause HavingClause error 'CURSOR' OptionalOrderByClause OptionalLimitClause OptionalOffsetClause
    {
      $$ = {
-       suggestKeywords: parser.getKeywordsForOptionalsLR([$6, $7, $8, $9, $10], [{ 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: !$6 && !$7 && !$8 && !$9 && !$10
+       suggestKeywords: parser.getKeywordsForOptionalsLR([$6, $7, $8], [{ value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true, true]),
+       cursorAtEnd: !$6 && !$7 && !$8
      }
    }
  | OptionalWhereClause OptionalGroupByClause OptionalHavingClause WindowClause error 'CURSOR' OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
    {
      $$ = {
-       suggestKeywords: parser.getKeywordsForOptionalsLR([$7, $8, $9, $10], [{ 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: !$7 && !$8 && !$9 && !$10
+       suggestKeywords: parser.getKeywordsForOptionalsLR([$7, $8, $9], [{ value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true, true]),
+       cursorAtEnd: !$7 && !$8 && !$9
      }
    }
  | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OrderByClause error 'CURSOR' OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
    {
      $$ = {
-       suggestKeywords: parser.getKeywordsForOptionalsLR([$8, $9, $10], [[{ 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: !$8 && !$9 && !$10
+       suggestKeywords: parser.getKeywordsForOptionalsLR([$8, $9], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true]),
+       cursorAtEnd: !$8 && !$9
      }
    }
  | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause ClusterOrDistributeBy error 'CURSOR' OptionalLimitClause OptionalOffsetClause
    {
      $$ = {
-       suggestKeywords: parser.getKeywordsForOptionalsLR([$9, $10], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isImpala()]),
+       suggestKeywords: parser.getKeywordsForOptionalsLR([$9, $10], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true]),
        cursorAtEnd: !$9 && !$10
      }
    }
  | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy LimitClause error 'CURSOR' OptionalOffsetClause
    {
      $$ = {
-       suggestKeywords: parser.getKeywordsForOptionalsLR([$10], [{ value: 'OFFSET', weight: 2 }], [parser.isImpala()]),
+       suggestKeywords: parser.getKeywordsForOptionalsLR([$10], [{ value: 'OFFSET', weight: 2 }], [true]),
        cursorAtEnd: !$10
      }
    }

+ 44 - 341
desktop/core/src/desktop/js/parse/jison/impala/sql_grant.jison

@@ -25,83 +25,26 @@ DataDefinition_EDIT
  ;
 
 GrantStatement
- : '<hive>GRANT' HivePrivilegeTypeList OptionalOnSpecification 'TO' PrincipalSpecificationList OptionalWithGrantOption
- | '<hive>GRANT' UserOrRoleList 'TO' PrincipalSpecificationList OptionalWithAdminOption
- | '<hive>GRANT' '<hive>ROLE' UserOrRoleList 'TO' PrincipalSpecificationList OptionalWithAdminOption
- | '<impala>GRANT' '<impala>ROLE' RegularOrBacktickedIdentifier 'TO' '<impala>GROUP' RegularOrBacktickedIdentifier
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' RegularOrBacktickedIdentifier OptionalWithGrantOption
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' '<impala>ROLE' RegularOrBacktickedIdentifier OptionalWithGrantOption
+ : 'GRANT' 'ROLE' RegularOrBacktickedIdentifier 'TO' 'GROUP' RegularOrBacktickedIdentifier
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' RegularOrBacktickedIdentifier OptionalWithGrantOption
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' 'ROLE' RegularOrBacktickedIdentifier OptionalWithGrantOption
  ;
 
 GrantStatement_EDIT
- : '<hive>GRANT' 'CURSOR'
-   {
-     parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'ROLE', 'SELECT', 'UPDATE']);
-   }
- | '<hive>GRANT' HivePrivilegeTypeList_EDIT OptionalOnSpecification
- | '<hive>GRANT' HivePrivilegeTypeList OnSpecification_EDIT
- | '<hive>GRANT' HivePrivilegeTypeList OptionalOnSpecification 'CURSOR'
-   {
-     if (!$3) {
-       parser.suggestKeywords(['ON', 'TO']);
-     } else {
-       parser.suggestKeywords(['TO']);
-     }
-   }
- | '<hive>GRANT' HivePrivilegeTypeList OptionalOnSpecification 'TO' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>GRANT' HivePrivilegeTypeList OptionalOnSpecification 'TO' PrincipalSpecificationList_EDIT
- | '<hive>GRANT' HivePrivilegeTypeList OptionalOnSpecification 'TO' PrincipalSpecificationList OptionalWithGrantOption 'CURSOR'
-   {
-     if (!$6) {
-       parser.suggestKeywords(['WITH GRANT OPTION']);
-     }
-   }
- | '<hive>GRANT' HivePrivilegeTypeList OptionalOnSpecification 'TO' PrincipalSpecificationList WithGrantOption_EDIT
- | '<hive>GRANT' UserOrRoleList 'CURSOR'
-   {
-     parser.suggestKeywords(['TO']);
-   }
- | '<hive>GRANT' UserOrRoleList 'TO' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>GRANT' UserOrRoleList 'TO' PrincipalSpecificationList_EDIT
- | '<hive>GRANT' UserOrRoleList 'TO' PrincipalSpecificationList OptionalWithAdminOption 'CURSOR'
-   {
-     if (!$5) {
-       parser.suggestKeywords(['WITH ADMIN OPTION']);
-     }
-   }
- | '<hive>GRANT' UserOrRoleList 'TO' PrincipalSpecificationList WithAdminOption_EDIT
- | '<hive>GRANT' '<hive>ROLE' UserOrRoleList 'TO' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>GRANT' '<hive>ROLE' UserOrRoleList 'TO' PrincipalSpecificationList_EDIT
- | '<hive>GRANT' '<hive>ROLE' UserOrRoleList 'TO' PrincipalSpecificationList OptionalWithAdminOption 'CURSOR'
-   {
-     if (!$6) {
-       parser.suggestKeywords(['WITH ADMIN OPTION']);
-     }
-   }
- | '<hive>GRANT' '<hive>ROLE' UserOrRoleList 'TO' PrincipalSpecificationList WithAdminOption_EDIT
- | '<impala>GRANT' 'CURSOR'
+ : 'GRANT' 'CURSOR'
    {
      parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DROP', 'INSERT', 'REFRESH', 'ROLE', 'SELECT']);
    }
- | '<impala>GRANT' '<impala>ROLE' RegularOrBacktickedIdentifier 'CURSOR'
+ | 'GRANT' 'ROLE' RegularOrBacktickedIdentifier 'CURSOR'
    {
      parser.suggestKeywords(['TO GROUP']);
    }
- | '<impala>GRANT' '<impala>ROLE' RegularOrBacktickedIdentifier 'TO' 'CURSOR'
+ | 'GRANT' 'ROLE' RegularOrBacktickedIdentifier 'TO' 'CURSOR'
    {
      parser.suggestKeywords(['GROUP']);
    }
- | '<impala>GRANT' ImpalaPrivilegeType_EDIT
- | '<impala>GRANT' ImpalaPrivilegeType 'CURSOR'
+ | 'GRANT' PrivilegeType_EDIT
+ | 'GRANT' PrivilegeType 'CURSOR'
    {
      if ($2.isCreate) {
        parser.suggestKeywords(['ON DATABASE', 'ON SERVER']);
@@ -109,7 +52,7 @@ GrantStatement_EDIT
        parser.suggestKeywords(['ON DATABASE', 'ON SERVER', 'ON TABLE', 'ON URI']);
      }
    }
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' 'CURSOR'
+ | 'GRANT' PrivilegeType 'ON' 'CURSOR'
    {
      if ($2.isCreate) {
         parser.suggestKeywords(['DATABASE', 'SERVER']);
@@ -117,160 +60,68 @@ GrantStatement_EDIT
         parser.suggestKeywords(['DATABASE', 'SERVER', 'TABLE', 'URI']);
      }
    }
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification_EDIT
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'CURSOR'
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification_EDIT
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'CURSOR'
    {
      parser.suggestKeywords(['TO']);
    }
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' 'CURSOR'
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' 'CURSOR'
    {
      parser.suggestKeywords(['ROLE']);
    }
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' RegularOrBacktickedIdentifier OptionalWithGrantOption 'CURSOR'
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' RegularOrBacktickedIdentifier OptionalWithGrantOption 'CURSOR'
    {
      if (!$7) {
        parser.suggestKeywords(['WITH GRANT OPTION']);
      }
    }
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' RegularOrBacktickedIdentifier WithGrantOption_EDIT
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' '<impala>ROLE' RegularOrBacktickedIdentifier OptionalWithGrantOption 'CURSOR'
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' RegularOrBacktickedIdentifier WithGrantOption_EDIT
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' 'ROLE' RegularOrBacktickedIdentifier OptionalWithGrantOption 'CURSOR'
    {
      if (!$8) {
        parser.suggestKeywords(['WITH GRANT OPTION']);
      }
    }
- | '<impala>GRANT' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'TO' '<impala>ROLE' RegularOrBacktickedIdentifier WithGrantOption_EDIT
- ;
-
-OptionalOnSpecification
- :
- | 'ON' HiveObjectSpecification
- ;
-
-OnSpecification_EDIT
- : 'ON' 'CURSOR'
-   {
-     parser.suggestKeywords(['DATABASE', 'TABLE']);
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | 'ON' HiveObjectSpecification_EDIT
- ;
-
-HiveObjectSpecification
- : 'DATABASE' RegularOrBacktickedIdentifier
- | '<hive>TABLE' SchemaQualifiedTableIdentifier
-   {
-     parser.addTablePrimary($2);
-   }
- | SchemaQualifiedTableIdentifier
-   {
-     parser.addTablePrimary($1);
-   }
+ | 'GRANT' PrivilegeType 'ON' ObjectSpecification 'TO' 'ROLE' RegularOrBacktickedIdentifier WithGrantOption_EDIT
  ;
 
-HiveObjectSpecification_EDIT
- : 'DATABASE' 'CURSOR'
-   {
-     parser.suggestDatabases();
-   }
- | '<hive>TABLE' 'CURSOR'
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | '<hive>TABLE' SchemaQualifiedTableIdentifier_EDIT
- | SchemaQualifiedTableIdentifier_EDIT
- ;
-
-ImpalaObjectSpecification
+ObjectSpecification
  : 'DATABASE' RegularOrBacktickedIdentifier
    {
      parser.addDatabaseLocation(@2, [ { name: $2 } ]);
    }
- | '<impala>TABLE' SchemaQualifiedTableIdentifier
+ | 'TABLE' SchemaQualifiedTableIdentifier
    {
      parser.addTablePrimary($2);
    }
- | '<impala>SERVER' RegularOrBacktickedIdentifier
- | '<impala>URI' RegularOrBacktickedIdentifier
+ | 'SERVER' RegularOrBacktickedIdentifier
+ | 'URI' RegularOrBacktickedIdentifier
  ;
 
-ImpalaObjectSpecification_EDIT
+ObjectSpecification_EDIT
  : 'DATABASE' 'CURSOR'
    {
      parser.suggestDatabases();
    }
- | '<impala>TABLE' 'CURSOR'
+ | 'TABLE' 'CURSOR'
    {
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | '<impala>TABLE' SchemaQualifiedTableIdentifier_EDIT
- ;
-
-HivePrivilegeTypeList
- : HivePrivilegeTypeWithOptionalColumn
-   {
-     if ($1.toUpperCase() === 'ALL') {
-       $$ = { singleAll: true };
-     }
-   }
- | HivePrivilegeTypeList ',' HivePrivilegeTypeWithOptionalColumn
- ;
-
-HivePrivilegeTypeList_EDIT
- : HivePrivilegeTypeWithOptionalColumn_EDIT
- | HivePrivilegeTypeList ',' HivePrivilegeTypeWithOptionalColumn_EDIT
- | HivePrivilegeTypeWithOptionalColumn_EDIT ',' HivePrivilegeTypeList
- | HivePrivilegeTypeList ',' HivePrivilegeTypeWithOptionalColumn_EDIT ',' HivePrivilegeTypeList
- | 'CURSOR' ',' HivePrivilegeTypeList
-   {
-     parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'SELECT', 'SHOW_DATABASE', 'UPDATE']);
-   }
- | HivePrivilegeTypeList ',' 'CURSOR'
-   {
-     parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'SELECT', 'SHOW_DATABASE', 'UPDATE']);
-   }
- | HivePrivilegeTypeList ',' 'CURSOR' ',' HivePrivilegeTypeList
-   {
-     parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'SELECT', 'SHOW_DATABASE', 'UPDATE']);
-   }
- ;
-
-HivePrivilegeTypeWithOptionalColumn
- : HivePrivilegeType OptionalParenthesizedColumnList
- ;
-
-HivePrivilegeTypeWithOptionalColumn_EDIT
- : HivePrivilegeType ParenthesizedColumnList_EDIT
- ;
-
-HivePrivilegeType
- : '<hive>INSERT'
- | 'SELECT'
- | 'UPDATE'
- | '<hive>DELETE'
- | 'ALTER'
- | '<hive>CREATE'
- | 'DROP'
- | '<hive>INDEX'
- | '<hive>LOCK'
- | '<hive>SHOW_DATABASE'
- | '<hive>ALL'
+ | 'TABLE' SchemaQualifiedTableIdentifier_EDIT
  ;
 
-ImpalaPrivilegeType
+PrivilegeType
  : 'ALL'
  | 'ALTER'
- | '<impala>CREATE'  --> { isCreate: true }
+ | 'CREATE'  --> { isCreate: true }
  | 'DROP'
- | '<impala>INSERT'
- | '<impala>REFRESH'
+ | 'INSERT'
+ | 'REFRESH'
  | 'SELECT' OptionalParenthesizedColumnList
  ;
 
-ImpalaPrivilegeType_EDIT
+PrivilegeType_EDIT
  : 'SELECT' ParenthesizedColumnList_EDIT
  ;
 
@@ -295,15 +146,11 @@ PrincipalSpecificationList_EDIT
  ;
 
 PrincipalSpecification
- : '<hive>USER' RegularOrBacktickedIdentifier
- | 'GROUP' RegularOrBacktickedIdentifier
- | '<hive>ROLE' RegularOrBacktickedIdentifier
+ : 'GROUP' RegularOrBacktickedIdentifier
  ;
 
 PrincipalSpecification_EDIT
- : '<hive>USER' 'CURSOR'
- | 'GROUP' 'CURSOR'
- | '<hive>ROLE' 'CURSOR'
+ : 'GROUP' 'CURSOR'
  ;
 
 UserOrRoleList
@@ -313,8 +160,7 @@ UserOrRoleList
 
 OptionalWithGrantOption
  :
- | '<hive>WITH' '<hive>GRANT' 'OPTION'
- | '<impala>WITH' '<impala>GRANT' 'OPTION'
+ | 'WITH' 'GRANT' 'OPTION'
  ;
 
 WithGrantOption_EDIT
@@ -322,164 +168,33 @@ WithGrantOption_EDIT
    {
      parser.suggestKeywords(['GRANT OPTION']);
    }
- | '<hive>WITH' '<hive>GRANT' 'CURSOR'
-   {
-     parser.suggestKeywords(['OPTION']);
-   }
- | '<impala>WITH' '<impala>GRANT' 'CURSOR'
-   {
-     parser.suggestKeywords(['OPTION']);
-   }
- ;
-
-OptionalWithAdminOption
- :
- | '<hive>WITH' '<hive>ADMIN' 'OPTION'
- ;
-
-WithAdminOption_EDIT
- : '<hive>WITH' 'CURSOR'
-   {
-     parser.suggestKeywords(['ADMIN OPTION']);
-   }
- | '<hive>WITH' '<hive>ADMIN' 'CURSOR'
+ | 'WITH' 'GRANT' 'CURSOR'
    {
      parser.suggestKeywords(['OPTION']);
    }
  ;
 
 RevokeStatement
- : '<hive>REVOKE' HivePrivilegeTypeList OptionalOnSpecification 'FROM' PrincipalSpecificationList
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' HivePrivilegeTypeList OptionalOnSpecification 'FROM' PrincipalSpecificationList
- | '<hive>REVOKE' UserOrRoleList 'FROM' PrincipalSpecificationList
- | '<hive>REVOKE' '<hive>ROLE' UserOrRoleList 'FROM' PrincipalSpecificationList
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' UserOrRoleList 'FROM' PrincipalSpecificationList
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' '<hive>ROLE' UserOrRoleList 'FROM' PrincipalSpecificationList
- | '<hive>REVOKE' '<hive>ALL' PrivilegesOrGrantOption 'FROM' UserOrRoleList
- | '<impala>REVOKE' '<impala>ROLE' RegularOrBacktickedIdentifier 'FROM' '<impala>GROUP' RegularOrBacktickedIdentifier
- | '<impala>REVOKE' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'FROM' RegularOrBacktickedIdentifier
- | '<impala>REVOKE' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'FROM' '<impala>ROLE' RegularOrBacktickedIdentifier
+ : 'REVOKE' 'ROLE' RegularOrBacktickedIdentifier 'FROM' 'GROUP' RegularOrBacktickedIdentifier
+ | 'REVOKE' PrivilegeType 'ON' ObjectSpecification 'FROM' RegularOrBacktickedIdentifier
+ | 'REVOKE' PrivilegeType 'ON' ObjectSpecification 'FROM' 'ROLE' RegularOrBacktickedIdentifier
  ;
 
 RevokeStatement_EDIT
- : '<hive>REVOKE' 'CURSOR'
-   {
-     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']);
-   }
- | '<hive>REVOKE' HivePrivilegeTypeList_EDIT
- | '<hive>REVOKE' HivePrivilegeTypeList OnSpecification_EDIT
- | '<hive>REVOKE' HivePrivilegeTypeList OptionalOnSpecification 'CURSOR'
-   {
-     if (!$3) {
-       if ($2.singleAll) {
-         parser.suggestKeywords(['FROM', 'GRANT OPTION', 'ON', 'PRIVILEGES FROM']);
-       } else {
-         parser.suggestKeywords(['FROM', 'ON']);
-       }
-     } else {
-       parser.suggestKeywords(['FROM']);
-     }
-   }
- | '<hive>REVOKE' HivePrivilegeTypeList OptionalOnSpecification 'FROM' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>REVOKE' HivePrivilegeTypeList OptionalOnSpecification 'FROM' PrincipalSpecificationList_EDIT
- | '<hive>REVOKE' '<hive>GRANT' 'CURSOR'
-   {
-     parser.suggestKeywords(['OPTION FOR']);
-   }
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' 'CURSOR'
-   {
-     parser.suggestKeywords(['FOR']);
-   }
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' 'CURSOR'
-   {
-     parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DELETE', 'DROP', 'INDEX', 'INSERT', 'LOCK', 'SELECT', 'SHOW_DATABASE', 'UPDATE']);
-   }
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' HivePrivilegeTypeList_EDIT
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' HivePrivilegeTypeList OnSpecification_EDIT
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' HivePrivilegeTypeList OptionalOnSpecification 'CURSOR'
-   {
-     if (!$6) {
-       parser.suggestKeywords(['FROM', 'ON']);
-     } else {
-       parser.suggestKeywords(['FROM']);
-     }
-   }
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' HivePrivilegeTypeList OptionalOnSpecification 'FROM' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>REVOKE' '<hive>GRANT' 'OPTION' '<hive>FOR' HivePrivilegeTypeList OptionalOnSpecification 'FROM' PrincipalSpecificationList_EDIT
- | '<hive>REVOKE' UserOrRoleList 'CURSOR'
-   {
-     if ($2.toUpperCase() === 'ADMIN') {
-       parser.suggestKeywords(['FROM', 'OPTION FOR']);
-     } else {
-       parser.suggestKeywords(['FROM']);
-     }
-   }
- | '<hive>REVOKE' UserOrRoleList 'FROM' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>REVOKE' UserOrRoleList 'FROM' PrincipalSpecificationList_EDIT
- | '<hive>REVOKE' '<hive>ROLE' UserOrRoleList 'CURSOR'
-   {
-     parser.suggestKeywords(['FROM']);
-   }
- | '<hive>REVOKE' '<hive>ROLE' UserOrRoleList 'FROM' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>REVOKE' '<hive>ROLE' UserOrRoleList 'FROM' PrincipalSpecificationList_EDIT
-
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' 'CURSOR'
-   {
-     parser.suggestKeywords(['FOR']);
-   }
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' 'CURSOR'
-   {
-     parser.suggestKeywords(['ROLE']);
-   }
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' UserOrRoleList 'CURSOR'
-   {
-     parser.suggestKeywords(['FROM']);
-   }
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' UserOrRoleList 'FROM' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' UserOrRoleList 'FROM' PrincipalSpecificationList_EDIT
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' '<hive>ROLE' UserOrRoleList 'CURSOR'
-   {
-     parser.suggestKeywords(['FROM']);
-   }
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' '<hive>ROLE' UserOrRoleList 'FROM' 'CURSOR'
-   {
-     parser.suggestKeywords(['GROUP', 'ROLE', 'USER']);
-   }
- | '<hive>REVOKE' '<hive>ADMIN' 'OPTION' '<hive>FOR' '<hive>ROLE' UserOrRoleList 'FROM' PrincipalSpecificationList_EDIT
- | '<hive>REVOKE' '<hive>ALL' PrivilegesOrGrantOption_EDIT
- | '<hive>REVOKE' '<hive>ALL' PrivilegesOrGrantOption 'CURSOR'
-   {
-     parser.suggestKeywords(['FROM']);
-   }
- | '<impala>REVOKE' 'CURSOR'
+ : 'REVOKE' 'CURSOR'
    {
      parser.suggestKeywords(['ALL', 'ALTER', 'CREATE', 'DROP', 'INSERT', 'REFRESH', 'ROLE', 'SELECT']);
    }
- | '<impala>REVOKE' '<impala>ROLE' RegularOrBacktickedIdentifier 'CURSOR'
+ | 'REVOKE' 'ROLE' RegularOrBacktickedIdentifier 'CURSOR'
    {
      parser.suggestKeywords(['FROM GROUP']);
    }
- | '<impala>REVOKE' '<impala>ROLE' RegularOrBacktickedIdentifier 'FROM' 'CURSOR'
+ | 'REVOKE' 'ROLE' RegularOrBacktickedIdentifier 'FROM' 'CURSOR'
    {
      parser.suggestKeywords(['GROUP']);
    }
- | '<impala>REVOKE' ImpalaPrivilegeType_EDIT
- | '<impala>REVOKE' ImpalaPrivilegeType 'CURSOR'
+ | 'REVOKE' PrivilegeType_EDIT
+ | 'REVOKE' PrivilegeType 'CURSOR'
    {
      if ($2.isCreate) {
        parser.suggestKeywords(['ON DATABASE', 'ON SERVER']);
@@ -487,7 +202,7 @@ RevokeStatement_EDIT
        parser.suggestKeywords(['ON DATABASE', 'ON SERVER', 'ON TABLE', 'ON URI']);
      }
    }
- | '<impala>REVOKE' ImpalaPrivilegeType 'ON' 'CURSOR'
+ | 'REVOKE' PrivilegeType 'ON' 'CURSOR'
    {
      if ($2.isCreate) {
        parser.suggestKeywords(['DATABASE', 'SERVER']);
@@ -495,25 +210,13 @@ RevokeStatement_EDIT
        parser.suggestKeywords(['DATABASE', 'SERVER', 'TABLE', 'URI']);
      }
    }
- | '<impala>REVOKE' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification_EDIT
- | '<impala>REVOKE' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'CURSOR'
+ | 'REVOKE' PrivilegeType 'ON' ObjectSpecification_EDIT
+ | 'REVOKE' PrivilegeType 'ON' ObjectSpecification 'CURSOR'
    {
      parser.suggestKeywords(['FROM']);
    }
- | '<impala>REVOKE' ImpalaPrivilegeType 'ON' ImpalaObjectSpecification 'FROM' 'CURSOR'
+ | 'REVOKE' PrivilegeType 'ON' ObjectSpecification 'FROM' 'CURSOR'
    {
      parser.suggestKeywords(['ROLE']);
    }
  ;
-
-PrivilegesOrGrantOption
- : '<hive>PRIVILEGES'
- | '<hive>GRANT' 'OPTION'
- ;
-
-PrivilegesOrGrantOption_EDIT
- : '<hive>GRANT' 'CURSOR'
-   {
-     parser.suggestKeywords(['OPTION']);
-   }
- ;

+ 61 - 528
desktop/core/src/desktop/js/parse/jison/impala/sql_insert.jison

@@ -19,255 +19,23 @@ DataManipulation
  ;
 
 InsertStatement
- : HiveInsertStatement
- | InsertValuesStatement
- | ImpalaInsertOrUpsertStatement
- | CommonTableExpression HiveInsertStatement
- | CommonTableExpression ImpalaInsertOrUpsertStatement
- | HiveMergeStatement
+ : InsertValuesStatement
+ | InsertOrUpsertStatement
+ | CommonTableExpression InsertOrUpsertStatement
  ;
 
 DataManipulation_EDIT
- : HiveInsertStatement_EDIT
- | InsertValuesStatement_EDIT
- | ImpalaInsertOrUpsertStatement_EDIT
- | CommonTableExpression HiveInsertStatement_EDIT
+ : InsertValuesStatement_EDIT
+ | InsertOrUpsertStatement_EDIT
+ | CommonTableExpression InsertOrUpsertStatement_EDIT
    {
      parser.addCommonTableExpressions($1);
    }
- | CommonTableExpression_EDIT HiveInsertStatement
- | CommonTableExpression ImpalaInsertOrUpsertStatement_EDIT
-   {
-     parser.addCommonTableExpressions($1);
-   }
- | CommonTableExpression_EDIT ImpalaInsertOrUpsertStatement
- | HiveMergeStatement_EDIT
- ;
-
-HiveInsertStatement
- : HiveInsertWithoutQuery QuerySpecification
- | FromClause HiveInserts
- | FromClause SelectWithoutTableExpression OptionalSelectConditions
- ;
-
-HiveInsertStatement_EDIT
- : HiveInsertWithoutQuery_EDIT
- | HiveInsertWithoutQuery 'CURSOR'
-   {
-     var keywords = [];
-     if ($1.suggestKeywords) {
-       keywords = parser.createWeightedKeywords($1.suggestKeywords, 2).concat([{ value: 'SELECT', weight: 1}]);
-     } else {
-       keywords = ['SELECT'];
-     }
-     if ($1.addValues) {
-       keywords.push({ weight: 1.1, value: 'VALUES' });
-     }
-     if (keywords.length > 0) {
-       parser.suggestKeywords(keywords);
-     }
-   }
- | HiveInsertWithoutQuery_EDIT QuerySpecification
- | HiveInsertWithoutQuery QuerySpecification_EDIT
- | FromClause HiveInserts_EDIT
-   {
-     if (!$2.keepTables) {
-       delete parser.yy.result.suggestTables;
-       delete parser.yy.result.suggestDatabases;
-     }
-   }
- | FromClause_EDIT
- | FromClause_EDIT HiveInserts
- | FromClause_EDIT SelectWithoutTableExpression OptionalSelectConditions
- | FromClause 'CURSOR'
-   {
-     parser.suggestKeywords(['INSERT INTO', 'INSERT OVERWRITE', 'SELECT']);
-   }
- | FromClause SelectWithoutTableExpression_EDIT OptionalSelectConditions
-   {
-     if ($2.cursorAtEnd) {
-       parser.checkForSelectListKeywords($2);
-       var keywords = parser.yy.result.suggestKeywords || [];
-       if ($3.suggestKeywords) {
-         keywords = keywords.concat($3.suggestKeywords);
-       }
-       if (keywords.length > 0) {
-         parser.suggestKeywords(keywords);
-       }
-     }
-     delete parser.yy.result.suggestTables;
-     delete parser.yy.result.suggestDatabases;
-   }
- | FromClause SelectWithoutTableExpression OptionalSelectConditions_EDIT
-   {
-     if ($3.cursorAtStart) {
-       parser.checkForSelectListKeywords($2.tableExpression);
-     }
-   }
- ;
-
-HiveInsertWithoutQuery
- : '<hive>INSERT' '<hive>OVERWRITE' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec OptionalIfNotExists
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-     if (!$5 && !$6) {
-       $$ = { suggestKeywords: ['PARTITION'] }
-     } else if (!$6) {
-       $$ = { suggestKeywords: ['IF NOT EXISTS'] }
-     }
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' '<hive>LOCAL' '<hive>DIRECTORY' HdfsPath OptionalInsertRowFormat OptionalStoredAs
-   {
-     if (!$6 && !$7) {
-       $$ = { suggestKeywords: [{ value: 'ROW FORMAT', weight: 2 }, { value: 'STORED AS', weight: 1}] };
-     } else if (!$7) {
-       $$ = { suggestKeywords: ['STORED AS'] };
-     }
-   }
- | '<hive>INSERT' '<hive>OVERWRITE_DIRECTORY' HdfsPath OptionalInsertRowFormat OptionalStoredAs
-    {
-      if (!$4 && !$5) {
-        $$ = { suggestKeywords: [{ value: 'ROW FORMAT', weight: 2 }, { value: 'STORED AS', weight: 1}] };
-      } else if (!$5) {
-        $$ = { suggestKeywords: ['STORED AS'] };
-      }
-    }
-  | '<hive>INSERT' 'INTO' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec OptionalParenthesizedColumnList
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-     if (!$5 && !$6) {
-       $$ = { suggestKeywords: ['PARTITION'], addValues: true };
-     } else if (!$6) {
-       $$ = { addValues: true };
-     }
-   }
- ;
-
-HiveInsertWithoutQuery_EDIT
- : '<hive>INSERT' 'CURSOR'
-   {
-     parser.suggestKeywords(['OVERWRITE', 'INTO']);
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' OptionalHiveTable 'CURSOR'
-   {
-     if (!$3) {
-       parser.suggestKeywords(['DIRECTORY', 'LOCAL DIRECTORY', 'TABLE']);
-     }
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-     $$ = { keepTables: true }
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' OptionalHiveTable SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec OptionalParenthesizedColumnList
-   {
-     $$ = { keepTables: true }
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec_EDIT OptionalIfNotExists
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-     if (parser.yy.result.suggestColumns) {
-       parser.yy.result.suggestColumns.owner = 'insert';
-     }
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec OptionalIfNotExists_EDIT
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' '<hive>LOCAL' 'CURSOR'
-   {
-     parser.suggestKeywords(['DIRECTORY']);
-   }
- | '<hive>INSERT' '<hive>OVERWRITE' '<hive>LOCAL' '<hive>DIRECTORY' HdfsPath_EDIT OptionalInsertRowFormat OptionalStoredAs
- | '<hive>INSERT' '<hive>OVERWRITE' '<hive>LOCAL' '<hive>DIRECTORY' HdfsPath OptionalInsertRowFormat_EDIT OptionalStoredAs
- | '<hive>INSERT' '<hive>OVERWRITE' '<hive>LOCAL' '<hive>DIRECTORY' HdfsPath OptionalInsertRowFormat StoredAs_EDIT
- | '<hive>INSERT' '<hive>OVERWRITE_DIRECTORY' HdfsPath_EDIT OptionalInsertRowFormat OptionalStoredAs  // DIRECTORY is a non-reserved keyword
- | '<hive>INSERT' '<hive>OVERWRITE_DIRECTORY' HdfsPath OptionalInsertRowFormat_EDIT OptionalStoredAs
- | '<hive>INSERT' '<hive>OVERWRITE_DIRECTORY' HdfsPath OptionalInsertRowFormat StoredAs_EDIT
- | '<hive>INSERT' 'INTO' OptionalHiveTable 'CURSOR'
-   {
-     if (!$3) {
-       parser.suggestKeywords(['TABLE']);
-     }
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-     $$ = { keepTables: true }
-   }
- | '<hive>INSERT' 'INTO' OptionalHiveTable SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec OptionalParenthesizedColumnList
-   {
-     $$ = { keepTables: true }
-   }
- | '<hive>INSERT' 'INTO' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec_EDIT OptionalParenthesizedColumnList
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-     if (parser.yy.result.suggestColumns) {
-       parser.yy.result.suggestColumns.owner = 'insert';
-     }
-   }
- | '<hive>INSERT' 'INTO' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec OptionalParenthesizedColumnList_EDIT
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-     if (parser.yy.result.suggestColumns) {
-       parser.yy.result.suggestColumns.owner = 'insert';
-     }
-   }
- ;
-
-HiveInserts
- : HiveInsert
- | HiveInserts HiveInsert
- ;
-
-HiveInserts_EDIT
- : HiveInsert_EDIT
- | HiveInserts HiveInsert_EDIT
- | HiveInsert_EDIT HiveInserts
- | HiveInserts HiveInsert_EDIT HiveInserts
- ;
-
-// TODO: Verify Hive unions in insert
-HiveInsert
- : HiveInsertWithoutQuery SelectWithoutTableExpression OptionalSelectConditions
- ;
-
-HiveInsert_EDIT
- : HiveInsertWithoutQuery_EDIT
- | HiveInsertWithoutQuery_EDIT SelectWithoutTableExpression OptionalSelectConditions
- | HiveInsertWithoutQuery 'CURSOR'
-   {
-     if ($1.suggestKeywords) {
-       parser.suggestKeywords(parser.createWeightedKeywords($1.suggestKeywords, 2).concat([{ value: 'SELECT', weight: 1}]));
-     } else {
-       parser.suggestKeywords(['SELECT']);
-     }
-   }
- | HiveInsertWithoutQuery SelectWithoutTableExpression_EDIT OptionalSelectConditions
-   {
-     if ($2.cursorAtEnd) {
-       parser.checkForSelectListKeywords($2);
-       var keywords = parser.yy.result.suggestKeywords || [];
-       if ($3.suggestKeywords) {
-         keywords = keywords.concat($3.suggestKeywords);
-       }
-       if (keywords.length > 0) {
-         parser.suggestKeywords(keywords);
-       }
-     }
-   }
- | HiveInsertWithoutQuery SelectWithoutTableExpression OptionalSelectConditions_EDIT
+ | CommonTableExpression_EDIT InsertOrUpsertStatement
  ;
 
 InsertValuesStatement
- : '<hive>INSERT' 'INTO' OptionalHiveTable SchemaQualifiedTableIdentifier OptionalPartitionSpec 'VALUES' InsertValuesList
-   {
-     $4.owner = 'insert';
-     parser.addTablePrimary($4);
-   }
- | 'INSERT' 'INTO' OptionalTable SchemaQualifiedTableIdentifier 'VALUES' InsertValuesList
+ : 'INSERT' 'INTO' OptionalTable SchemaQualifiedTableIdentifier 'VALUES' InsertValuesList
    {
      $4.owner = 'insert';
      parser.addTablePrimary($4);
@@ -311,23 +79,6 @@ OptionalTable
  | 'TABLE'
  ;
 
-OptionalInsertRowFormat
- :
- | 'ROW' '<hive>FORMAT' [deleted]
- ;
-
-OptionalInsertRowFormat_EDIT
- : 'ROW' 'CURSOR'
-   {
-     parser.suggestKeywords(['FORMAT DELIMITED']);
-   }
- | 'ROW' '<hive>FORMAT' 'CURSOR'
-   {
-     parser.suggestKeywords(['DELIMITED']);
-   }
- | 'ROW' '<hive>FORMAT' [deleted]
- ;
-
 SelectWithoutTableExpression
  : 'SELECT' OptionalAllOrDistinct OptionalStraightJoin SelectList  -> { selectList: $4 }
  ;
@@ -353,7 +104,7 @@ SelectWithoutTableExpression_EDIT
        keywords.push({ value: 'ALL', weight: 2 });
        keywords.push({ value: 'DISTINCT', weight: 2 });
      }
-     if (parser.isImpala() && !$3) {
+     if (!$3) {
        keywords.push({ value: 'STRAIGHT_JOIN', weight: 1 });
      }
      parser.suggestKeywords(keywords);
@@ -362,27 +113,22 @@ SelectWithoutTableExpression_EDIT
    }
  ;
 
-OptionalHiveTable
- :
- | '<hive>TABLE'
+InsertOrUpsertStatement
+ : InsertOrUpsertStatementWithoutCTE
  ;
 
-ImpalaInsertOrUpsertStatement
- : ImpalaInsertOrUpsertStatementWithoutCTE
+InsertOrUpsertStatement_EDIT
+ : InsertOrUpsertStatementWithoutCTE_EDIT
  ;
 
-ImpalaInsertOrUpsertStatement_EDIT
- : ImpalaInsertOrUpsertStatementWithoutCTE_EDIT
+InsertOrUpsertStatementWithoutCTE
+ : InsertOrUpsertLeftPart OptionalShuffleOrNoShuffle SelectStatement OptionalUnions
+ | InsertOrUpsertLeftPart 'VALUES' RowValuesLists
  ;
 
-ImpalaInsertOrUpsertStatementWithoutCTE
- : ImpalaInsertOrUpsertLeftPart OptionalImpalaShuffleOrNoShuffle SelectStatement OptionalUnions
- | ImpalaInsertOrUpsertLeftPart 'VALUES' ImpalaRowValuesLists
- ;
-
-ImpalaInsertOrUpsertStatementWithoutCTE_EDIT
- : ImpalaInsertOrUpsertLeftPart_EDIT
- | ImpalaInsertOrUpsertLeftPart OptionalImpalaShuffleOrNoShuffle 'CURSOR'
+InsertOrUpsertStatementWithoutCTE_EDIT
+ : InsertOrUpsertLeftPart_EDIT
+ | InsertOrUpsertLeftPart OptionalShuffleOrNoShuffle 'CURSOR'
    {
      var keywords = $1.suggestKeywords && !$2 ? parser.createWeightedKeywords($1.suggestKeywords, 2) : [];
      if (!$2) {
@@ -392,37 +138,37 @@ ImpalaInsertOrUpsertStatementWithoutCTE_EDIT
      }
      parser.suggestKeywords(keywords);
    }
- | ImpalaInsertOrUpsertLeftPart_EDIT OptionalImpalaShuffleOrNoShuffle SelectStatement OptionalUnions
- | ImpalaInsertOrUpsertLeftPart OptionalImpalaShuffleOrNoShuffle SelectStatement_EDIT OptionalUnions
- | ImpalaInsertOrUpsertLeftPart OptionalImpalaShuffleOrNoShuffle SelectStatement OptionalUnions_EDIT
- | ImpalaInsertOrUpsertLeftPart_EDIT 'VALUES' ImpalaRowValuesLists
- | ImpalaInsertOrUpsertLeftPart 'VALUES' ImpalaRowValuesLists_EDIT
+ | InsertOrUpsertLeftPart_EDIT OptionalShuffleOrNoShuffle SelectStatement OptionalUnions
+ | InsertOrUpsertLeftPart OptionalShuffleOrNoShuffle SelectStatement_EDIT OptionalUnions
+ | InsertOrUpsertLeftPart OptionalShuffleOrNoShuffle SelectStatement OptionalUnions_EDIT
+ | InsertOrUpsertLeftPart_EDIT 'VALUES' RowValuesLists
+ | InsertOrUpsertLeftPart 'VALUES' RowValuesLists_EDIT
  ;
 
-ImpalaInsertOrUpsertLeftPart
- : ImpalaUpsertStatementLeftPart
- | ImpalaInsertLeftPart
+InsertOrUpsertLeftPart
+ : UpsertStatementLeftPart
+ | InsertLeftPart
  ;
 
-ImpalaInsertOrUpsertLeftPart_EDIT
- : ImpalaUpsertStatementLeftPart_EDIT
- | ImpalaInsertLeftPart_EDIT
+InsertOrUpsertLeftPart_EDIT
+ : UpsertStatementLeftPart_EDIT
+ | InsertLeftPart_EDIT
  ;
 
-ImpalaUpsertStatementLeftPart
- : '<impala>UPSERT' 'INTO' OptionalImpalaTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList
+UpsertStatementLeftPart
+ : 'UPSERT' 'INTO' OptionalTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList
    {
      $4.owner = 'upsert';
      parser.addTablePrimary($4);
    }
  ;
 
-ImpalaUpsertStatementLeftPart_EDIT
- : '<impala>UPSERT' 'CURSOR'
+UpsertStatementLeftPart_EDIT
+ : 'UPSERT' 'CURSOR'
    {
      parser.suggestKeywords(['INTO']);
    }
- | '<impala>UPSERT' 'INTO' OptionalImpalaTable 'CURSOR'
+ | 'UPSERT' 'INTO' OptionalTable 'CURSOR'
    {
      if (!$3) {
        parser.suggestKeywords(['TABLE']);
@@ -430,7 +176,7 @@ ImpalaUpsertStatementLeftPart_EDIT
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | '<impala>UPSERT' 'INTO' OptionalImpalaTable 'CURSOR' SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList
+ | 'UPSERT' 'INTO' OptionalTable 'CURSOR' SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList
    {
      if (!$3) {
        parser.suggestKeywords(['TABLE']);
@@ -438,8 +184,8 @@ ImpalaUpsertStatementLeftPart_EDIT
      $5.owner = 'upsert';
      parser.addTablePrimary($5);
    }
- | '<impala>UPSERT' 'INTO' OptionalImpalaTable SchemaQualifiedTableIdentifier_EDIT OptionalParenthesizedColumnList
- | '<impala>UPSERT' 'INTO' OptionalImpalaTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList_EDIT
+ | 'UPSERT' 'INTO' OptionalTable SchemaQualifiedTableIdentifier_EDIT OptionalParenthesizedColumnList
+ | 'UPSERT' 'INTO' OptionalTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList_EDIT
    {
      $4.owner = 'upsert';
      parser.addTablePrimary($4);
@@ -450,8 +196,8 @@ ImpalaUpsertStatementLeftPart_EDIT
  ;
 
 
-ImpalaInsertLeftPart
- : '<impala>INSERT' IntoOrOverwrite OptionalImpalaTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList OptionalPartitionSpec
+InsertLeftPart
+ : 'INSERT' IntoOrOverwrite OptionalTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList OptionalPartitionSpec
    {
      $4.owner = 'insert';
      parser.addTablePrimary($4);
@@ -461,12 +207,12 @@ ImpalaInsertLeftPart
    }
  ;
 
-ImpalaInsertLeftPart_EDIT
- : '<impala>INSERT' 'CURSOR'
+InsertLeftPart_EDIT
+ : 'INSERT' 'CURSOR'
    {
      parser.suggestKeywords(['INTO', 'OVERWRITE']);
    }
- | '<impala>INSERT' IntoOrOverwrite OptionalImpalaTable 'CURSOR'
+ | 'INSERT' IntoOrOverwrite OptionalTable 'CURSOR'
    {
      if (!$3) {
        parser.suggestKeywords(['TABLE']);
@@ -474,7 +220,7 @@ ImpalaInsertLeftPart_EDIT
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | '<impala>INSERT' IntoOrOverwrite OptionalImpalaTable 'CURSOR' SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList OptionalPartitionSpec
+ | 'INSERT' IntoOrOverwrite OptionalTable 'CURSOR' SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList OptionalPartitionSpec
    {
      if (!$3) {
        parser.suggestKeywords(['TABLE']);
@@ -482,8 +228,8 @@ ImpalaInsertLeftPart_EDIT
      $5.owner = 'insert';
      parser.addTablePrimary($5);
    }
- | '<impala>INSERT' IntoOrOverwrite OptionalImpalaTable SchemaQualifiedTableIdentifier_EDIT OptionalParenthesizedColumnList OptionalPartitionSpec
- | '<impala>INSERT' IntoOrOverwrite OptionalImpalaTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList_EDIT OptionalPartitionSpec
+ | 'INSERT' IntoOrOverwrite OptionalTable SchemaQualifiedTableIdentifier_EDIT OptionalParenthesizedColumnList OptionalPartitionSpec
+ | 'INSERT' IntoOrOverwrite OptionalTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList_EDIT OptionalPartitionSpec
    {
      $4.owner = 'insert';
      parser.addTablePrimary($4);
@@ -491,7 +237,7 @@ ImpalaInsertLeftPart_EDIT
        parser.yy.result.suggestColumns.owner = 'insert';
      }
    }
- | '<impala>INSERT' IntoOrOverwrite OptionalImpalaTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList OptionalPartitionSpec_EDIT
+ | 'INSERT' IntoOrOverwrite OptionalTable SchemaQualifiedTableIdentifier OptionalParenthesizedColumnList OptionalPartitionSpec_EDIT
    {
      $4.owner = 'insert';
      parser.addTablePrimary($4);
@@ -503,37 +249,32 @@ ImpalaInsertLeftPart_EDIT
 
 IntoOrOverwrite
  : 'INTO'
- | '<impala>OVERWRITE'
+ | 'OVERWRITE'
  ;
 
-OptionalImpalaTable
+OptionalShuffleOrNoShuffle
  :
- | '<impala>TABLE'
+ | 'SHUFFLE'
+ | 'NOSHUFFLE'
  ;
 
-OptionalImpalaShuffleOrNoShuffle
- :
- | '<impala>SHUFFLE'
- | '<impala>NOSHUFFLE'
+RowValuesLists
+ : ParenthesizedValueExpressionList
+ | RowValuesLists ',' ParenthesizedValueExpressionList
  ;
 
-ImpalaRowValuesLists
- : ParenthesizedImpalaRowValuesList
- | ImpalaRowValuesLists ',' ParenthesizedImpalaRowValuesList
+RowValuesLists_EDIT
+ : ParenthesizedValueExpressionList_EDIT
+ | RowValuesLists ',' ParenthesizedValueExpressionList_EDIT
+ | RowValuesLists ',' ParenthesizedValueExpressionList_EDIT ',' RowValuesLists
+ | ParenthesizedValueExpressionList_EDIT ',' RowValuesLists
  ;
 
-ImpalaRowValuesLists_EDIT
- : ParenthesizedImpalaRowValuesList_EDIT
- | ImpalaRowValuesLists ',' ParenthesizedImpalaRowValuesList_EDIT
- | ImpalaRowValuesLists ',' ParenthesizedImpalaRowValuesList_EDIT ',' ImpalaRowValuesLists
- | ParenthesizedImpalaRowValuesList_EDIT ',' ImpalaRowValuesLists
- ;
-
-ParenthesizedImpalaRowValuesList
+ParenthesizedValueExpressionList
  : '(' ValueExpressionList ')'
  ;
 
-ParenthesizedImpalaRowValuesList_EDIT
+ParenthesizedValueExpressionList_EDIT
  : '(' AnyCursor RightParenthesisOrError
    {
      parser.suggestFunctions();
@@ -541,212 +282,8 @@ ParenthesizedImpalaRowValuesList_EDIT
  | '(' ValueExpressionList_EDIT RightParenthesisOrError
  ;
 
-HiveMergeStatement
- : HiveMergeStatementLeftPart 'ON' ValueExpression WhenList
- ;
-
-HiveMergeStatement_EDIT
- : HiveMergeStatementLeftPart_EDIT
- | HiveMergeStatementLeftPart 'CURSOR'
-   {
-     parser.suggestKeywords(['ON']);
-   }
- | HiveMergeStatementLeftPart 'ON' 'CURSOR'
-   {
-     parser.valueExpressionSuggest();
-   }
- | HiveMergeStatementLeftPart 'ON' ValueExpression_EDIT
- | HiveMergeStatementLeftPart 'ON' ValueExpression 'CURSOR'
-   {
-     parser.suggestValueExpressionKeywords($3, [{ value: 'WHEN', weight: 2 }]);
-   }
- | HiveMergeStatementLeftPart 'ON' ValueExpression WhenList_EDIT
- ;
-
-HiveMergeStatementLeftPart
- : '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' RegularIdentifier '<hive>USING' MergeSource '<hive>AS' RegularIdentifier
-   {
-     $3.alias = $5;
-     parser.addTablePrimary($3);
-     if ($7.subQuery) {
-       parser.addTablePrimary({ subQueryAlias: $9 });
-     } else {
-       $7.alias = $9;
-     }
-   }
- ;
-
-HiveMergeStatementLeftPart_EDIT
- : '<hive>MERGE' 'CURSOR'
-   {
-     parser.suggestKeywords(['INTO']);
-   }
- | '<hive>MERGE' 'INTO' 'CURSOR'
-   {
-     parser.suggestDatabases({ appendDot: true });
-     parser.suggestTables();
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier_EDIT
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier 'CURSOR'
-   {
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['AS T USING']);
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' 'CURSOR'
-   {
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['T USING']);
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' RegularIdentifier 'CURSOR'
-   {
-     $3.alias = $5;
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['USING']);
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' RegularIdentifier '<hive>USING' 'CURSOR'
-   {
-     $3.alias = $5;
-     parser.addTablePrimary($3);
-     parser.suggestDatabases({ appendDot: true });
-     parser.suggestTables();
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' RegularIdentifier '<hive>USING' MergeSource_EDIT
-   {
-     $3.alias = $5;
-     parser.addTablePrimary($3);
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' RegularIdentifier '<hive>USING' MergeSource 'CURSOR'
-   {
-     $3.alias = $5;
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['AS S ON']);
-   }
- | '<hive>MERGE' 'INTO' SchemaQualifiedTableIdentifier '<hive>AS' RegularIdentifier '<hive>USING' MergeSource '<hive>AS' 'CURSOR'
-   {
-     $3.alias = $5;
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['S ON']);
-   }
- ;
-
-MergeSource
- : '(' TableSubQueryInner ')'  --> $2
- | SchemaQualifiedTableIdentifier
-   {
-     parser.addTablePrimary($1);
-   }
- ;
-
-MergeSource_EDIT
- : '(' 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestKeywords(['SELECT']);
-   }
- | '(' TableSubQueryInner_EDIT RightParenthesisOrError
- | SchemaQualifiedTableIdentifier_EDIT
- ;
-
-WhenList
- : WhenClause
- | WhenClause WhenClause
- | WhenClause WhenClause WhenClause
- ;
-
-WhenList_EDIT
- : WhenClause_EDIT
-   {
-     if ($1.suggestThenKeywords) {
-       parser.suggestKeywords(['DELETE', 'INSERT VALUES', 'UPDATE SET']);
-     }
-   }
- | WhenClause 'CURSOR'
-   {
-     if (!$1.notPresent) {
-       parser.suggestKeywords(['WHEN']);
-     }
-   }
- | WhenClause WhenClause_EDIT
-  {
-     if (!$1.notPresent && $2.suggestThenKeywords) {
-       var keywords = [];
-       if (!$1.isDelete) {
-         keywords.push('DELETE');
-       }
-       if (!$1.isInsert) {
-         keywords.push('INSERT VALUES');
-       }
-       if (!$1.isUpdate) {
-         keywords.push('UPDATE SET');
-       }
-       parser.suggestKeywords(keywords);
-     }
-   }
- | WhenClause WhenClause 'CURSOR'
-   {
-     if (!$2.notPresent) {
-       parser.suggestKeywords(['WHEN']);
-     }
-   }
- | WhenClause WhenClause WhenClause_EDIT
-   {
-     if (!$2.notPresent && $3.suggestThenKeywords) {
-       var keywords = [];
-       if (!$1.isDelete && !$2.isDelete) {
-         keywords.push('DELETE');
-       }
-       if (!$1.isInsert && !$2.isInsert) {
-         keywords.push('INSERT VALUES');
-       }
-       if (!$1.isUpdate && !$2.isUpdate) {
-         keywords.push('UPDATE SET');
-       }
-       parser.suggestKeywords(keywords);
-     }
-   }
- ;
-
-WhenClause
- : 'WHEN' OptionalNot '<hive>MATCHED' OptionalMatchCondition 'THEN' UpdateDeleteOrInsert  --> { notPresent: !!$2, isDelete: $6.isDelete, isInsert: $6.isInsert, isUpdate: $6.isUpdate }
- ;
-
-WhenClause_EDIT
- : 'WHEN' OptionalNot 'CURSOR'
-   {
-     if (!$2) {
-       parser.suggestKeywords(['NOT MATCHED', 'MATCHED']);
-     } else {
-       parser.suggestKeywords(['MATCHED']);
-     }
-   }
- | 'WHEN' OptionalNot '<hive>MATCHED' OptionalMatchCondition 'CURSOR'
-   {
-     if (!$4) {
-       parser.suggestKeywords(['AND', 'THEN']);
-     } else {
-       parser.suggestValueExpressionKeywords($4, [{ value: 'THEN', weight: 2 }]);
-     }
-   }
- | 'WHEN' OptionalNot '<hive>MATCHED' MatchCondition_EDIT
- | 'WHEN' OptionalNot '<hive>MATCHED' OptionalMatchCondition 'THEN' 'CURSOR' --> { suggestThenKeywords: true }
- | 'WHEN' OptionalNot '<hive>MATCHED' OptionalMatchCondition 'THEN' UpdateDeleteOrInsert_EDIT
- ;
-
-OptionalMatchCondition
- :
- | 'AND' ValueExpression --> $2
- ;
-
-MatchCondition_EDIT
- : 'AND' 'CURSOR'
-   {
-     parser.valueExpressionSuggest();
-   }
- ;
-
 UpdateDeleteOrInsert
  : 'UPDATE' 'SET' SetClauseList              --> { isUpdate: true }
- | '<hive>DELETE'                            --> { isDelete: true }
- | '<hive>INSERT' 'VALUES' InsertValuesList  --> { isInsert: true }
  ;
 
 UpdateDeleteOrInsert_EDIT
@@ -755,8 +292,4 @@ UpdateDeleteOrInsert_EDIT
      parser.suggestKeywords(['SET']);
    }
  | 'UPDATE' 'SET' SetClauseList_EDIT
- | '<hive>INSERT' 'CURSOR'
-   {
-     parser.suggestKeywords(['VALUES']);
-   }
  ;

+ 20 - 231
desktop/core/src/desktop/js/parse/jison/impala/sql_load.jison

@@ -16,276 +16,65 @@
 
 DataManipulation
  : LoadStatement
- | ImportStatement
- | ExportStatement
  ;
 
 DataManipulation_EDIT
  : LoadStatement_EDIT
- | ImportStatement_EDIT
- | ExportStatement_EDIT
  ;
 
 LoadStatement
- : AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec
+ : 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec
    {
-     parser.addTablePrimary($9);
+     parser.addTablePrimary($8);
    }
  ;
 
 LoadStatement_EDIT
- : AnyLoad 'CURSOR'
+ : 'LOAD' 'CURSOR'
    {
-     if (parser.isHive()) {
-       parser.suggestKeywords(['DATA LOCAL INPATH', 'DATA INPATH']);
-     } else if (parser.isImpala()) {
-       parser.suggestKeywords(['DATA INPATH']);
-     }
+     parser.suggestKeywords(['DATA INPATH']);
    }
- | AnyLoad AnyData OptionalHiveLocal 'CURSOR'
+ | 'LOAD' 'DATA' 'CURSOR'
    {
-     if (parser.isHive() && !$3) {
-       parser.suggestKeywords(['INPATH', 'LOCAL INPATH']);
-     } else {
-       parser.suggestKeywords(['INPATH']);
-     }
+     parser.suggestKeywords(['INPATH']);
    }
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath_EDIT OptionalOverwrite
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'CURSOR'
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath_EDIT OptionalOverwrite
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'CURSOR'
    {
-     if (!$6) {
+     if (!$5) {
        parser.suggestKeywords(['OVERWRITE INTO TABLE', 'INTO TABLE']);
      } else {
        parser.suggestKeywords(['INTO TABLE']);
      }
    }
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'INTO' 'CURSOR'
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'INTO' 'CURSOR'
    {
      parser.suggestKeywords([ 'TABLE' ]);
    }
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'INTO' AnyTable 'CURSOR'
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'INTO' AnyTable 'CURSOR'
    {
      parser.suggestTables();
      parser.suggestDatabases({ appendDot: true });
    }
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec 'CURSOR'
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec 'CURSOR'
    {
-     parser.addTablePrimary($9);
-     if (!$10) {
+     parser.addTablePrimary($8);
+     if (!$9) {
        parser.suggestKeywords(['PARTITION']);
      }
    }
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec_EDIT
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec_EDIT
    {
-     parser.addTablePrimary($9);
+     parser.addTablePrimary($8);
    }
- | AnyLoad AnyData OptionalHiveLocal AnyInpath HdfsPath_EDIT OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec
+ | 'LOAD' 'DATA' 'INPATH' HdfsPath_EDIT OptionalOverwrite 'INTO' AnyTable SchemaQualifiedTableIdentifier OptionalPartitionSpec
    {
-     parser.addTablePrimary($9);
+     parser.addTablePrimary($8);
    }
  ;
 
 OptionalOverwrite
  :
- | '<hive>OVERWRITE'
- | '<impala>OVERWRITE'
- ;
-
-OptionalHiveLocal
- :
- | '<hive>LOCAL'
- ;
-
-AnyLoad
- : '<hive>LOAD'
- | '<impala>LOAD'
- ;
-
-AnyData
- : '<hive>DATA'
- | '<impala>DATA'
- ;
-
-AnyInpath
- : '<hive>INPATH'
- | '<impala>INPATH'
- ;
-
-ImportStatement
- : '<hive>IMPORT' OptionalTableWithPartition PushHdfsLexerState 'FROM' HdfsPath OptionalHdfsLocation
- ;
-
-ImportStatement_EDIT
- : '<hive>IMPORT' 'CURSOR' OptionalTableWithPartition
-   {
-     if (!$3) {
-       parser.suggestKeywords(['EXTERNAL TABLE', 'FROM', 'TABLE']);
-     } else if (!$3.hasExternal) {
-       parser.suggestKeywords(['EXTERNAL']);
-     }
-   }
- | '<hive>IMPORT' TableWithPartition 'CURSOR'
-   {
-     if ($2.suggestKeywords) {
-        parser.suggestKeywords(parser.createWeightedKeywords($2.suggestKeywords, 2).concat(['FROM']));
-      } else {
-        parser.suggestKeywords(['FROM']);
-      }
-   }
- | '<hive>IMPORT' TableWithPartition_EDIT
- | '<hive>IMPORT' OptionalTableWithPartition PushHdfsLexerState 'FROM' HdfsPath_EDIT OptionalHdfsLocation
- | '<hive>IMPORT' OptionalTableWithPartition PushHdfsLexerState 'FROM' HdfsPath HdfsLocation_EDIT
- | '<hive>IMPORT' OptionalTableWithPartition PushHdfsLexerState 'FROM' HdfsPath OptionalHdfsLocation 'CURSOR'
-   {
-     if (!$6) {
-       parser.suggestKeywords(['LOCATION']);
-     }
-   }
- | '<hive>IMPORT' 'CURSOR' OptionalTableWithPartition PushHdfsLexerState 'FROM' HdfsPath OptionalHdfsLocation
-   {
-     if (!$3) {
-       parser.suggestKeywords(['EXTERNAL TABLE', 'TABLE']);
-     } else if (!$3.hasExternal) {
-       parser.suggestKeywords(['EXTERNAL']);
-     }
-   }
-| '<hive>IMPORT' TableWithPartition_EDIT PushHdfsLexerState 'FROM' HdfsPath OptionalHdfsLocation
- | '<hive>IMPORT' TableWithPartition 'CURSOR' PushHdfsLexerState 'FROM' HdfsPath OptionalHdfsLocation
-    {
-      if ($2.suggestKeywords) {
-        parser.suggestKeywords(parser.createWeightedKeywords($2.suggestKeywords, 2).concat(['FROM']));
-      }
-    }
- ;
-
-OptionalTableWithPartition
- :
- | TableWithPartition
- ;
-
-TableWithPartition
- : '<hive>EXTERNAL' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec
-   {
-     parser.addTablePrimary($3);
-     if (!$4) {
-       $$ = { hasExternal: true, suggestKeywords: ['PARTITION'] };
-     } else {
-       $$ = { hasExternal: true }
-     }
-   }
- | '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec
-   {
-     parser.addTablePrimary($2);
-     if (!$3) {
-       $$ = { suggestKeywords: ['PARTITION'] };
-     }
-   }
+ | 'OVERWRITE'
  ;
-
-TableWithPartition_EDIT
- : '<hive>EXTERNAL' 'CURSOR'
-   {
-     parser.suggestKeywords(['TABLE']);
-   }
- | '<hive>EXTERNAL' '<hive>TABLE' 'CURSOR'
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | '<hive>EXTERNAL' '<hive>TABLE' SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec
- | '<hive>EXTERNAL' '<hive>TABLE' SchemaQualifiedTableIdentifier PartitionSpec_EDIT
-   {
-     parser.addTablePrimary($3);
-   }
- | '<hive>TABLE' 'CURSOR'
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
-
- | '<hive>TABLE' SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec
- | '<hive>TABLE' SchemaQualifiedTableIdentifier PartitionSpec_EDIT
-   {
-     parser.addTablePrimary($3);
-   }
- ;
-
-ExportStatement
- : '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath
-   {
-     parser.addTablePrimary($3);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath '<hive>FOR' '<hive>REPLICATION' '(' QuotedValue ')'
-   {
-     parser.addTablePrimary($3);
-   }
- ;
-
-ExportStatement_EDIT
- : '<hive>EXPORT' 'CURSOR'
-   {
-     parser.suggestKeywords(['TABLE']);
-   }
- | '<hive>EXPORT' '<hive>TABLE' 'CURSOR'
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier_EDIT
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec 'CURSOR'
-   {
-     parser.addTablePrimary($3);
-     if (!$4) {
-       parser.suggestKeywords([{ weight: 2, value: 'PARTITION' }, { weight: 1, value: 'TO' }]);
-     } else {
-       parser.suggestKeywords([ 'TO' ]);
-     }
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier PartitionSpec_EDIT
-   {
-     parser.addTablePrimary($3);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath_EDIT
-   {
-     parser.addTablePrimary($3);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath 'CURSOR'
-   {
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['FOR replication()']);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath '<hive>FOR' 'CURSOR'
-   {
-     parser.addTablePrimary($3);
-     parser.suggestKeywords(['replication()']);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier_EDIT OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath '<hive>FOR' '<hive>REPLICATION' '(' QuotedValue ')'
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec 'CURSOR' PushHdfsLexerState 'TO' HdfsPath
-   {
-     parser.addTablePrimary($3);
-     if (!$4) {
-       parser.suggestKeywords(['PARTITION']);
-     }
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec 'CURSOR' PushHdfsLexerState 'TO' HdfsPath '<hive>FOR' '<hive>REPLICATION' '(' QuotedValue ')'
-   {
-     parser.addTablePrimary($3);
-     if (!$4) {
-       parser.suggestKeywords(['PARTITION']);
-     }
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier PartitionSpec_EDIT PushHdfsLexerState 'TO' HdfsPath
-   {
-     parser.addTablePrimary($3);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier PartitionSpec_EDIT PushHdfsLexerState 'TO' HdfsPath '<hive>FOR' '<hive>REPLICATION' '(' QuotedValue ')'
-   {
-     parser.addTablePrimary($3);
-   }
- | '<hive>EXPORT' '<hive>TABLE' SchemaQualifiedTableIdentifier OptionalPartitionSpec PushHdfsLexerState 'TO' HdfsPath_EDIT '<hive>FOR' '<hive>REPLICATION' '(' QuotedValue ')'
-   {
-     parser.addTablePrimary($3);
-   }
- ;