Przeglądaj źródła

HUE-6835 [autocomplete] Add support for TABLESAMPLE in Impala SELECT statements

Johan Ahlen 8 lat temu
rodzic
commit
09de50c

Plik diff jest za duży
+ 0 - 0
desktop/core/src/desktop/static/desktop/js/ace/mode-impala.js


+ 4 - 0
desktop/core/src/desktop/static/desktop/js/autocomplete/jison/sql.jisonlex

@@ -254,6 +254,7 @@
 <impala>'REAL'                             { return '<impala>REAL'; }
 <impala>'REFRESH'                          { parser.determineCase(yytext); return '<impala>REFRESH'; }
 <impala>'RENAME'                           { return '<impala>RENAME'; }
+<impala>'REPEATABLE'                       { return '<impala>REPEATABLE'; }
 <impala>'REPLACE'                          { return '<impala>REPLACE'; }
 <impala>'REPLICATION'                      { return '<impala>REPLICATION'; }
 <impala>'RESTRICT'                         { return '<impala>RESTRICT'; }
@@ -271,6 +272,7 @@
 <impala>'SYMBOL'                           { return '<impala>SYMBOL'; }
 <impala>'TABLE'                            { return '<impala>TABLE'; }
 <impala>'TABLES'                           { return '<impala>TABLES'; }
+<impala>'TABLESAMPLE'                      { return '<impala>TABLESAMPLE'; }
 <impala>'TBLPROPERTIES'                    { return '<impala>TBLPROPERTIES'; }
 <impala>'TERMINATED'                       { return '<impala>TERMINATED'; }
 <impala>'TEXTFILE'                         { return '<impala>TEXTFILE'; }
@@ -438,6 +440,8 @@ ROW_NUMBER\s*\(                            { yy.lexer.unput('('); yytext = 'row_
 <impala>NTILE\s*\(                         { yy.lexer.unput('('); yytext = 'ntile'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; }
 <impala>PERCENT_RANK\s*\(                  { yy.lexer.unput('('); yytext = 'percent_rank'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; }
 
+<impala>SYSTEM\s*\(                        { yy.lexer.unput('('); yytext = 'system'; return '<impala>SYSTEM'; }
+
 [0-9]+                                     { return 'UNSIGNED_INTEGER'; }
 [0-9]+(?:[YSL]|BD)?                        { return 'UNSIGNED_INTEGER'; }
 [0-9]+E                                    { return 'UNSIGNED_INTEGER_E'; }

+ 62 - 18
desktop/core/src/desktop/static/desktop/js/autocomplete/jison/sql_main.jison

@@ -309,7 +309,7 @@ OptionalHiveExplainTypes
 // it's not a valid statement (see ErrorStatement). It contains everything except valid starting tokens ('SELECT', 'USE' etc.)
 NonStartingToken
  : '<hive>ADMIN' | '<hive>ALL' | '<hive>AS' | '<hive>AUTHORIZATION' | '<hive>AVRO' | '<hive>BINARY' | '<hive>BUCKET' | '<hive>BUCKETS' | '<hive>CACHE' | '<hive>CLUSTER' | '<hive>CLUSTERED' | '<hive>COLLECTION' | '<hive>COMPUTE' | '<hive>CONF' | '<hive>CUBE' | '<hive>CURRENT' | '<hive>DATE' | '<hive>DEFERRED' | '<hive>DELIMITED' | '<hive>DEPENDENCY' | '<hive>DIRECTORY' | '<hive>DISTRIBUTE' | '<hive>DISTRIBUTED' | '<hive>ESCAPED' | '<hive>EXTENDED' | '<hive>EXTERNAL' | '<hive>FIELDS' | '<hive>FILE' | '<hive>FOR' | '<hive>FORMAT' | '<hive>FUNCTION' | '<hive>GRANT' | '<hive>GROUPING' | '<hive>IDXPROPERTIES' | '<hive>LATERAL' | '<hive>LOCAL' | '<hive>LOCK' | '<hive>MACRO' | '<hive>OVERWRITE' | '<hive>PARTITION' | '<hive>PRIVILEGES' | '<hive>REBUILD' | '<hive>REPAIR' | '<hive>REPLICATION' |'<hive>ROLLUP' | '<hive>SETS' | '<hive>STATISTICS' | '<hive>SHOW_DATABASE' | '<hive>TABLE' | '<hive>TIMESTAMP' |'<hive>USER' | '<hive>ASC' | '<hive>COLUMNS' | '<hive>COMMENT' | '<hive>COMPACTIONS' | '<hive>DATA' | '<hive>DATABASES' | '<hive>DEFINED' | '<hive>DESC' |  '<hive>FORMATTED' | '<hive>FUNCTIONS' | '<hive>INDEX' | '<hive>INDEXES' | '<hive>INPATH' | '<hive>INPUTFORMAT' | '<hive>ITEMS' | '<hive>JAR' | '<hive>KEYS' | '<hive>LINES' | '<hive>LOCATION' | '<hive>LOCKS' | '<hive>METADATA' | '<hive>NONE' | '<hive>NOSCAN' | '<hive>OF' | '<hive>ORC' | '<hive>OUT' | '<hive>OUTPUTFORMAT' | '<hive>PARQUET' | '<hive>PARTITIONED' | '<hive>PARTITIONS' | '<hive>RCFILE' | '<hive>ROLE' | '<hive>ROLES' | '<hive>SCHEMA' | '<hive>SCHEMAS' | '<hive>SEQUENCEFILE' | '<hive>SERDE' | '<hive>SERDEPROPERTIES' | '<hive>SKEWED' | '<hive>SORTED' | '<hive>STORED' | '<hive>STORED_AS_DIRECTORIES' | '<hive>STRING' | '<hive>TABLES' | '<hive>TABLESAMPLE' | '<hive>TBLPROPERTIES' | '<hive>TEMPORARY' | '<hive>TERMINATED' | '<hive>TEXTFILE' | '<hive>TINYINT' | '<hive>TRANSACTIONS' | '<hive>UNIONTYPE' | '<hive>USING' | '<hive>VIEW' | '<hive>WINDOW' | '<hive>.' | '<hive>[' | '<hive>]'
- | '<impala>AGGREGATE' | '<impala>AVRO' | '<impala>CACHED' | '<impala>CASCADE' | '<impala>CLOSE_FN' | '<impala>COLUMN' | '<impala>COMMENT' | '<impala>DATA' | '<impala>DATABASES' | '<impala>DELETE' | '<impala>DELIMITED' | '<impala>ESCAPED' | '<impala>EXTENDED' |'<impala>EXTERNAL' | '<impala>FIELDS' | '<impala>FINALIZE_FN' | '<impala>FIRST' | '<impala>FORMAT' | '<impala>FORMATTED' | '<impala>FUNCTION' | '<impala>FUNCTIONS' | '<impala>GROUP' | '<impala>HASH' | '<impala>ILIKE' | '<impala>INCREMENTAL' | '<impala>INTERMEDIATE' | '<impala>INTERVAL' | '<impala>INIT_FN' | '<impala>INPATH' | '<impala>IREGEXP' | '<impala>KEY' | '<impala>KUDU' | '<impala>LAST' | '<impala>LIMIT' | '<impala>LINES' | '<impala>LOCATION' | '<impala>MERGE_FN' | '<impala>NULLS' | '<impala>PARTITIONS' | '<impala>PREPARE_FN' | '<impala>PRIMARY' | '<impala>RANGE' | '<impala>REAL' | '<impala>RECOVER' | '<impala>REPLICATION' | '<impala>RESTRICT' | '<impala>RETURNS' | '<impala>SCHEMAS' | '<impala>SERIALIZE_FN' | '<impala>SERVER' | '<impala>SORT' | '<impala>STATS' | '<impala>STRAIGHT_JOIN' | '<impala>SYMBOL' | '<impala>TABLE' | '<impala>TABLES' | '<impala>URI' | '<impala>USING' | '<impala>ANALYTIC' | '<impala>ANTI' | '<impala>CURRENT' | '<impala>GRANT' | '<impala>NOSHUFFLE' | '<impala>PARQUET' | '<impala>PARTITIONED' | '<impala>RCFILE' | '<impala>ROLE' | '<impala>ROLES' | '<impala>SEQUENCEFILE' | '<impala>SERDEPROPERTIES' | '<impala>SHUFFLE' | '<impala>STORED' | '<impala>TBLPROPERTIES' | '<impala>TERMINATED' | '<impala>TEXTFILE' | '<impala>UPDATE_FN' | '<impala>BROADCAST' | '<impala>...' | '<impala>.' | '<impala>[' | '<impala>]'
+ | '<impala>AGGREGATE' | '<impala>AVRO' | '<impala>CACHED' | '<impala>CASCADE' | '<impala>CLOSE_FN' | '<impala>COLUMN' | '<impala>COMMENT' | '<impala>DATA' | '<impala>DATABASES' | '<impala>DELETE' | '<impala>DELIMITED' | '<impala>ESCAPED' | '<impala>EXTENDED' |'<impala>EXTERNAL' | '<impala>FIELDS' | '<impala>FINALIZE_FN' | '<impala>FIRST' | '<impala>FORMAT' | '<impala>FORMATTED' | '<impala>FUNCTION' | '<impala>FUNCTIONS' | '<impala>GROUP' | '<impala>HASH' | '<impala>ILIKE' | '<impala>INCREMENTAL' | '<impala>INTERMEDIATE' | '<impala>INTERVAL' | '<impala>INIT_FN' | '<impala>INPATH' | '<impala>IREGEXP' | '<impala>KEY' | '<impala>KUDU' | '<impala>LAST' | '<impala>LIMIT' | '<impala>LINES' | '<impala>LOCATION' | '<impala>MERGE_FN' | '<impala>NULLS' | '<impala>PARTITIONS' | '<impala>PREPARE_FN' | '<impala>PRIMARY' | '<impala>RANGE' | '<impala>REAL' | '<impala>RECOVER' | '<impala>REPEATABLE' | '<impala>REPLICATION' | '<impala>RESTRICT' | '<impala>RETURNS' | '<impala>SCHEMAS' | '<impala>SERIALIZE_FN' | '<impala>SERVER' | '<impala>SORT' | '<impala>STATS' | '<impala>STRAIGHT_JOIN' | '<impala>SYMBOL' | '<impala>TABLE' | '<impala>TABLES' | '<impala>TABLESAMPLE' | '<impala>URI' | '<impala>USING' | '<impala>ANALYTIC' | '<impala>ANTI' | '<impala>CURRENT' | '<impala>GRANT' | '<impala>NOSHUFFLE' | '<impala>PARQUET' | '<impala>PARTITIONED' | '<impala>RCFILE' | '<impala>ROLE' | '<impala>ROLES' | '<impala>SEQUENCEFILE' | '<impala>SERDEPROPERTIES' | '<impala>SHUFFLE' | '<impala>STORED' | '<impala>TBLPROPERTIES' | '<impala>TERMINATED' | '<impala>TEXTFILE' | '<impala>UPDATE_FN' | '<impala>BROADCAST' | '<impala>...' | '<impala>.' | '<impala>[' | '<impala>]'
  | 'ALL' | 'ARRAY' | 'AS' | 'ASC' | 'BETWEEN' | 'BIGINT' | 'BOOLEAN' | 'BY' | 'CASE' | 'CHAR' | 'CROSS' | 'CURRENT' | 'DATABASE' | 'DECIMAL' | 'DISTINCT' | 'DOUBLE' | 'DESC' | 'ELSE' | 'END' | 'EXISTS' | 'FALSE' | 'FLOAT' | 'FOLLOWING' | 'FROM' | 'FULL' | 'GROUP' | 'HAVING' | 'IF' | 'IN' | 'INNER' | 'INT' | 'INTO' | 'IS' | 'JOIN' | 'LEFT' | 'LIKE' | 'LIMIT' | 'MAP' | 'NOT' | 'NULL' | 'ON' | 'OPTION' | 'ORDER' | 'OUTER' | 'OVER' | 'PARTITION' | 'PRECEDING' | 'PURGE' | 'RANGE' | 'REGEXP' | 'RIGHT' | 'RLIKE' | 'ROW' | 'ROWS' | 'SCHEMA' | 'SEMI' | 'SET' | 'SMALLINT' | 'STRING' | 'STRUCT' | 'TABLE' | 'THEN' | 'TIMESTAMP' | 'TINYINT' | 'TRUE' | 'UNION' | 'VALUES' | 'VARCHAR' | 'WHEN' | 'WHERE' | 'WITH' | 'ROLE'
  | 'AVG' | 'CAST' | 'COUNT' | 'MAX' | 'MIN' | 'STDDEV_POP' | 'STDDEV_SAMP' | 'SUM' | 'VARIANCE' | 'VAR_POP' | 'VAR_SAMP'
  | '<hive>COLLECT_SET' | '<hive>COLLECT_LIST' | '<hive>CORR' | '<hive>COVAR_POP' | '<hive>COVAR_SAMP' | '<hive>DAY' | '<hive>DAYOFWEEK' | '<hive>HISTOGRAM_NUMERIC' | '<hive>HOUR' | '<hive>MINUTE' | '<hive>MONTH' | '<hive>NTILE' | '<hive>PERCENTILE' | '<hive>PERCENTILE_APPROX' | '<hive>QUARTER' | '<hive>SECOND' | '<hive>WEEK' | '<hive>YEAR'
@@ -2758,17 +2758,17 @@ Joins
    }
  | Joins JoinType OptionalImpalaBroadcastOrShuffle TablePrimary OptionalJoinCondition
    {
-     if ($4 && $4.valueExpression) {
-       $$ = $4.valueExpression;
+     if ($5 && $5.valueExpression) {
+       $$ = $5.valueExpression;
      } else {
        $$ = {};
      }
      $$.joinType = $1;
-     if ($4.noJoinCondition) {
+     if ($5.noJoinCondition) {
        $$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() }
      }
-     if ($4.suggestKeywords) {
-       $$.suggestKeywords = $4.suggestKeywords;
+     if ($5.suggestKeywords) {
+       $$.suggestKeywords = $5.suggestKeywords;
      }
      if (parser.yy.latestTablePrimaries.length > 0) {
        parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true;
@@ -2902,8 +2902,11 @@ JoinCondition_EDIT
  ;
 
 TablePrimary
- : TableOrQueryName OptionalTableSample OptionalCorrelationName
+ : TableOrQueryName OptionalHiveTableSample OptionalCorrelationName OptionalImpalaTableSample
    {
+     $$ = {
+       primary: $1
+     }
      if ($1.identifierChain) {
        if ($3) {
          $1.alias = $3.alias
@@ -2911,29 +2914,57 @@ TablePrimary
        }
        parser.addTablePrimary($1);
      }
-     // Right-to-left for cursor after TablePrimary
-     $$.suggestKeywords = parser.getKeywordsForOptionalsLR([$3, $2], [{ value: 'AS', weight: 1 }, { value: 'TABLESAMPLE', weight: 2 }], [true, parser.isHive()]);
+     var keywords = [];
+     if ($4 && $4.suggestKeywords) {
+       keywords = $4.suggestKeywords;
+     } else {
+       // Right-to-left for cursor after TablePrimary
+       keywords = parser.getKeywordsForOptionalsLR([$4, $3, $2], [{ value: 'TABLESAMPLE', weight: 1 }, { value: 'AS', weight: 2 }, { value: 'TABLESAMPLE', weight: 3 }], [parser.isImpala(), true, parser.isHive()]);
+     }
+     if (keywords.length > 0) {
+       $$.suggestKeywords = keywords;
+     }
    }
- | DerivedTable OptionalCorrelationName
+ | DerivedTable OptionalCorrelationName OptionalImpalaTableSample
    {
+     $$ = {
+       primary: $1
+     };
+
      if ($2) {
-       $1.alias = $2.alias;
+       $$.primary.alias = $2.alias;
        parser.addTablePrimary({ subQueryAlias: $2.alias });
        parser.addSubqueryAliasLocation($2.location, $2.alias, $1.identifierChain);
+     }
+
+     var keywords = [];
+     if ($3 && $3.suggestKeywords) {
+       keywords = $3.suggestKeywords;
      } else {
-       $$.suggestKeywords = [{ value: 'AS', weight: 1 }];
+       keywords = parser.getKeywordsForOptionalsLR([$3, $2], [{ value: 'TABLESAMPLE', weight: 1 }, { value: 'AS', weight: 2 }], [parser.isImpala(), true]);
+     }
+     if (keywords.length > 0) {
+       $$.suggestKeywords = keywords;
      }
    }
  ;
 
 TablePrimary_EDIT
- : TableOrQueryName_EDIT OptionalTableSample OptionalCorrelationName
+ : TableOrQueryName_EDIT OptionalHiveTableSample OptionalCorrelationName OptionalImpalaTableSample
+   {
+     if ($3) {
+       parser.addTableAliasLocation($3.location, $3.alias, $1.identifierChain);
+     }
+   }
+ | TableOrQueryName OptionalHiveTableSample_EDIT OptionalCorrelationName OptionalImpalaTableSample
    {
      if ($3) {
+       $1.alias = $3.alias;
        parser.addTableAliasLocation($3.location, $3.alias, $1.identifierChain);
      }
+     parser.addTablePrimary($1);
    }
- | TableOrQueryName OptionalTableSample_EDIT OptionalCorrelationName
+ | TableOrQueryName OptionalHiveTableSample OptionalCorrelationName OptionalImpalaTableSample_EDIT
    {
      if ($3) {
        $1.alias = $3.alias;
@@ -2941,14 +2972,14 @@ TablePrimary_EDIT
      }
      parser.addTablePrimary($1);
    }
- | DerivedTable_EDIT OptionalCorrelationName
+ | DerivedTable_EDIT OptionalCorrelationName OptionalImpalaTableSample
    {
      if ($2) {
        parser.addTablePrimary({ subQueryAlias: $2.alias });
        parser.addSubqueryAliasLocation($2.location, $2.alias);
      }
    }
- | DerivedTable OptionalCorrelationName_EDIT
+ | DerivedTable OptionalCorrelationName_EDIT OptionalImpalaTableSample
  ;
 
 TableOrQueryName
@@ -2967,12 +2998,12 @@ DerivedTable_EDIT
  : TableSubQuery_EDIT
  ;
 
-OptionalTableSample
+OptionalHiveTableSample
  :
  | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' '<hive>OUT' '<hive>OF' 'UNSIGNED_INTEGER' OptionalOnColumn ')'
  ;
 
-OptionalTableSample_EDIT
+OptionalHiveTableSample_EDIT
  : '<hive>TABLESAMPLE' '(' AnyCursor RightParenthesisOrError
    {
      parser.suggestKeywords(['BUCKET']);
@@ -2994,6 +3025,19 @@ OptionalTableSample_EDIT
  | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' '<hive>OUT' '<hive>OF' 'UNSIGNED_INTEGER' OptionalOnColumn_EDIT RightParenthesisOrError
  ;
 
+OptionalImpalaTableSample
+ :
+ | '<impala>TABLESAMPLE' '<impala>SYSTEM' '(' 'UNSIGNED_INTEGER' ')'                                                  --> { suggestKeywords: ['REPEATABLE'] }
+ | '<impala>TABLESAMPLE' '<impala>SYSTEM' '(' 'UNSIGNED_INTEGER' ')' '<impala>REPEATABLE' '(' 'UNSIGNED_INTEGER' ')'
+ ;
+
+OptionalImpalaTableSample_EDIT
+ : '<impala>TABLESAMPLE' 'CURSOR'
+   {
+     parser.suggestKeywords(['SYSTEM()']);
+   }
+ ;
+
 OptionalOnColumn
  :
  | 'ON' ValueExpression

+ 176 - 92
desktop/core/src/desktop/static/desktop/js/autocomplete/spec/sqlSpecSelect.js

@@ -3307,7 +3307,7 @@
             suggestFilters: { prefix: 'WHERE', tables: [{ identifierChain: [{ name: 'testTableA' }], alias: 'tta' }, { identifierChain: [{ name: 'testTableB' }] }] },
             suggestGroupBys: { prefix: 'GROUP BY', tables: [{ identifierChain: [{ name: 'testTableA' }], alias: 'tta' }, { identifierChain: [{ name: 'testTableB' }] }] },
             suggestOrderBys: { prefix: 'ORDER BY', tables: [{ identifierChain: [{ name: 'testTableA' }], alias: 'tta' }, { identifierChain: [{ name: 'testTableB' }] }] },
-            suggestKeywords: ['AS', 'WHERE', 'GROUP BY', 'HAVING', 'ORDER BY', 'LIMIT', 'OFFSET', 'UNION', 'ANTI JOIN', 'FULL JOIN', 'FULL OUTER JOIN', 'INNER JOIN', 'JOIN', 'LEFT ANTI JOIN', 'LEFT INNER JOIN', 'LEFT JOIN', 'LEFT OUTER JOIN', 'LEFT SEMI JOIN', 'OUTER JOIN', 'RIGHT ANTI JOIN', 'RIGHT INNER JOIN', 'RIGHT JOIN', 'RIGHT OUTER JOIN', 'RIGHT SEMI JOIN', 'SEMI JOIN']
+            suggestKeywords: ['AS', 'WHERE', 'GROUP BY', 'HAVING', 'ORDER BY', 'LIMIT', 'OFFSET', 'UNION', 'TABLESAMPLE', 'ANTI JOIN', 'FULL JOIN', 'FULL OUTER JOIN', 'INNER JOIN', 'JOIN', 'LEFT ANTI JOIN', 'LEFT INNER JOIN', 'LEFT JOIN', 'LEFT OUTER JOIN', 'LEFT SEMI JOIN', 'OUTER JOIN', 'RIGHT ANTI JOIN', 'RIGHT INNER JOIN', 'RIGHT JOIN', 'RIGHT OUTER JOIN', 'RIGHT SEMI JOIN', 'SEMI JOIN']
           }
         });
       });
@@ -5863,111 +5863,195 @@
     });
 
     describe('TABLESAMPLE', function () {
-      it('should handle "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 32 ON baa) baa JOIN bla;|', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 32 ON baa) baa JOIN bla;',
-          afterCursor: '',
-          dialect: 'hive',
-          noErrors: true,
-          containsKeywords: ['SELECT'],
-          expectedResult: {
-            lowerCase: false
-          }
+      describe('Impala specific', function () {
+        it('should handle "select distinct x from sample_demo tablesample system(50);|"', function (){
+          assertAutoComplete({
+            beforeCursor: 'select distinct x from sample_demo tablesample system(50);',
+            afterCursor: '',
+            dialect: 'impala',
+            noErrors: true,
+            containsKeywords: ['SELECT'],
+            expectedResult: {
+              lowerCase: true
+            }
+          });
         });
-      });
 
-      it('should suggest keywords for "SELECT * FROM boo |', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo ',
-          afterCursor: '',
-          dialect: 'hive',
-          noErrors: true,
-          containsKeywords: ['TABLESAMPLE', 'AS'],
-          expectedResult: {
-            lowerCase: false,
-            suggestJoins: { prependJoin: true, tables: [{ identifierChain: [{ name: 'boo' }] }] },
-            suggestFilters: { prefix: 'WHERE', tables: [{ identifierChain: [{ name: 'boo' }] }] },
-            suggestGroupBys: { prefix: 'GROUP BY', tables: [{ identifierChain: [{ name: 'boo' }] }] },
-            suggestOrderBys: { prefix: 'ORDER BY', tables: [{ identifierChain: [{ name: 'boo' }] }] }
-          }
+        it('should handle "select distinct sd.x from sample_demo as sd tablesample system(50) repeatable (12345);|"', function (){
+          assertAutoComplete({
+            beforeCursor: 'select distinct sd.x from sample_demo as sd tablesample system(50) repeatable (12345);',
+            afterCursor: '',
+            dialect: 'impala',
+            noErrors: true,
+            containsKeywords: ['SELECT'],
+            expectedResult: {
+              lowerCase: true
+            }
+          });
         });
-      });
 
-      it('should suggest keywords for "SELECT * FROM boo |, baa', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo ',
-          afterCursor: ', baa',
-          dialect: 'hive',
-          containsKeywords: ['TABLESAMPLE', 'AS'],
-          expectedResult: {
-            lowerCase: false,
-            suggestJoins: { prependJoin: true, tables: [{ identifierChain: [{ name: 'boo' }] }] },
-            suggestFilters: { prefix: 'WHERE', tables: [{ identifierChain: [{ name: 'boo' }] }] },
-            suggestGroupBys: { prefix: 'GROUP BY', tables: [{ identifierChain: [{ name: 'boo' }] }] },
-            suggestOrderBys: { prefix: 'ORDER BY', tables: [{ identifierChain: [{ name: 'boo' }] }] }
-          }
+        it('should suggest keywords for "SELECT * FROM boo |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo ',
+            afterCursor: '',
+            dialect: 'impala',
+            noErrors: true,
+            containsKeywords: ['TABLESAMPLE', 'AS'],
+            doesNotContainKeywords: ['REPEATABLE'],
+            expectedResult: {
+              lowerCase: false,
+              suggestJoins: {prependJoin: true, tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestFilters: {prefix: 'WHERE', tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestGroupBys: {prefix: 'GROUP BY', tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestOrderBys: {prefix: 'ORDER BY', tables: [{identifierChain: [{name: 'boo'}]}]}
+            }
+          });
         });
-      });
 
-      it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (|', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo TABLESAMPLE (',
-          afterCursor: '',
-          dialect: 'hive',
-          expectedResult: {
-            lowerCase: false,
-            suggestKeywords: ['BUCKET']
-          }
+        it('should suggest keywords for "SELECT * FROM boo as b |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo as b ',
+            afterCursor: '',
+            dialect: 'impala',
+            noErrors: true,
+            containsKeywords: ['TABLESAMPLE'],
+            doesNotContainKeywords: ['AS'],
+            expectedResult: {
+              lowerCase: false,
+              suggestJoins: {prependJoin: true, tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]},
+              suggestFilters: {prefix: 'WHERE', tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]},
+              suggestGroupBys: {prefix: 'GROUP BY', tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]},
+              suggestOrderBys: {prefix: 'ORDER BY', tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]}
+            }
+          });
         });
-      });
 
-      it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 |', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 ',
-          afterCursor: '',
-          dialect: 'hive',
-          expectedResult: {
-            lowerCase: false,
-            suggestKeywords: ['OUT OF']
-          }
+        it('should suggest keywords for "SELECT * FROM boo as b TABLESAMPLE SYSTEM(50) |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo as b TABLESAMPLE SYSTEM(50) ',
+            afterCursor: '',
+            dialect: 'impala',
+            noErrors: true,
+            containsKeywords: ['REPEATABLE'],
+            doesNotContainKeywords: ['TABLESAMPLE'],
+            expectedResult: {
+              lowerCase: false,
+              suggestJoins: {prependJoin: true, tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]},
+              suggestFilters: {prefix: 'WHERE', tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]},
+              suggestGroupBys: {prefix: 'GROUP BY', tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]},
+              suggestOrderBys: {prefix: 'ORDER BY', tables: [{identifierChain: [{name: 'boo'}], alias: 'b'}]}
+            }
+          });
         });
       });
 
-      it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT |', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT ',
-          afterCursor: '',
-          dialect: 'hive',
-          expectedResult: {
-            lowerCase: false,
-            suggestKeywords: ['OF']
-          }
+      describe('Hive specific', function () {
+        it('should handle "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 32 ON baa) baa JOIN bla;|"', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 32 ON baa) baa JOIN bla;',
+            afterCursor: '',
+            dialect: 'hive',
+            noErrors: true,
+            containsKeywords: ['SELECT'],
+            expectedResult: {
+              lowerCase: false
+            }
+          });
         });
-      });
 
-      it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 |', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 ',
-          afterCursor: '',
-          dialect: 'hive',
-          expectedResult: {
-            lowerCase: false,
-            suggestKeywords: ['ON']
-          }
+        it('should suggest keywords for "SELECT * FROM boo |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo ',
+            afterCursor: '',
+            dialect: 'hive',
+            noErrors: true,
+            containsKeywords: ['TABLESAMPLE', 'AS'],
+            expectedResult: {
+              lowerCase: false,
+              suggestJoins: {prependJoin: true, tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestFilters: {prefix: 'WHERE', tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestGroupBys: {prefix: 'GROUP BY', tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestOrderBys: {prefix: 'ORDER BY', tables: [{identifierChain: [{name: 'boo'}]}]}
+            }
+          });
         });
-      });
 
-      it('should suggest columns for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 ON |', function () {
-        assertAutoComplete({
-          beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 ON ',
-          afterCursor: '',
-          dialect: 'hive',
-          containsKeywords: ['CASE'],
-          expectedResult: {
-            lowerCase: false,
-            suggestFunctions: {},
-            suggestColumns: { tables: [{ identifierChain: [{ name: 'boo' }] }] }
-          }
+        it('should suggest keywords for "SELECT * FROM boo |, baa', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo ',
+            afterCursor: ', baa',
+            dialect: 'hive',
+            containsKeywords: ['TABLESAMPLE', 'AS'],
+            expectedResult: {
+              lowerCase: false,
+              suggestJoins: {prependJoin: true, tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestFilters: {prefix: 'WHERE', tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestGroupBys: {prefix: 'GROUP BY', tables: [{identifierChain: [{name: 'boo'}]}]},
+              suggestOrderBys: {prefix: 'ORDER BY', tables: [{identifierChain: [{name: 'boo'}]}]}
+            }
+          });
+        });
+
+        it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (|', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo TABLESAMPLE (',
+            afterCursor: '',
+            dialect: 'hive',
+            expectedResult: {
+              lowerCase: false,
+              suggestKeywords: ['BUCKET']
+            }
+          });
+        });
+
+        it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 ',
+            afterCursor: '',
+            dialect: 'hive',
+            expectedResult: {
+              lowerCase: false,
+              suggestKeywords: ['OUT OF']
+            }
+          });
+        });
+
+        it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT ',
+            afterCursor: '',
+            dialect: 'hive',
+            expectedResult: {
+              lowerCase: false,
+              suggestKeywords: ['OF']
+            }
+          });
+        });
+
+        it('should suggest keywords for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 ',
+            afterCursor: '',
+            dialect: 'hive',
+            expectedResult: {
+              lowerCase: false,
+              suggestKeywords: ['ON']
+            }
+          });
+        });
+
+        it('should suggest columns for "SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 ON |', function () {
+          assertAutoComplete({
+            beforeCursor: 'SELECT * FROM boo TABLESAMPLE (BUCKET 1 OUT OF 16 ON ',
+            afterCursor: '',
+            dialect: 'hive',
+            containsKeywords: ['CASE'],
+            expectedResult: {
+              lowerCase: false,
+              suggestFunctions: {},
+              suggestColumns: {tables: [{identifierChain: [{name: 'boo'}]}]}
+            }
+          });
         });
       });
     });
@@ -6889,7 +6973,7 @@
             expectedResult: {
               lowerCase: false,
               suggestJoins: { prependJoin: true, tables: [{ identifierChain: [{ name: 'table1' }], alias: 't1' }] },
-              suggestKeywords: ['ANTI', 'CROSS', 'FULL', 'FULL OUTER', 'INNER', 'LEFT', 'LEFT ANTI', 'LEFT INNER', 'LEFT OUTER', 'LEFT SEMI', 'OUTER', 'RIGHT', 'RIGHT ANTI', 'RIGHT INNER', 'RIGHT OUTER', 'RIGHT SEMI', 'SEMI']
+              suggestKeywords: ['TABLESAMPLE', 'ANTI', 'CROSS', 'FULL', 'FULL OUTER', 'INNER', 'LEFT', 'LEFT ANTI', 'LEFT INNER', 'LEFT OUTER', 'LEFT SEMI', 'OUTER', 'RIGHT', 'RIGHT ANTI', 'RIGHT INNER', 'RIGHT OUTER', 'RIGHT SEMI', 'SEMI']
             }
           });
         });

Plik diff jest za duży
+ 0 - 0
desktop/core/src/desktop/static/desktop/js/autocomplete/sqlAutocompleteParser.js


Plik diff jest za duży
+ 0 - 0
desktop/core/src/desktop/static/desktop/js/autocomplete/sqlSyntaxParser.js


+ 2 - 2
desktop/core/src/desktop/static/desktop/js/sqlUtils.js

@@ -41,8 +41,8 @@ var SqlUtils = (function () {
     ESCAPED: true, EXISTS: true, EXPLAIN: true, EXTERNAL: true, FALSE: true, FIELDS: true, FILEFORMAT: true, FINALIZE_FN: true, FIRST: true, FLOAT: true, FORMAT: true, FORMATTED: true, FROM: true, FULL: true, FUNCTION: true, FUNCTIONS: true, GROUP: true, HAVING: true, IF: true, ILIKE: true, IN: true, INCREMENTAL: true,
     INIT_FN: true, INNER: true, INPATH: true, INSERT: true, INT: true, INTEGER: true, INTERMEDIATE: true, INTERVAL: true, INTO: true, INVALIDATE: true, IS: true, JOIN: true, KEY: true, KUDU: true, LAST: true, LEFT: true, LIKE: true, LIMIT: true, LINES: true, LOAD: true, LOCATION: true, MAP: true, MERGE_FN: true, METADATA: true,
     NOT: true, NULL: true, NULLS: true, OFFSET: true, ON: true, OR: true, ORDER: true, OUTER: true, OVERWRITE: true, PARQUET: true, PARQUETFILE: true, PARTITION: true, PARTITIONED: true, PARTITIONS: true, PREPARE_FN: true, PRIMARY: true, PRODUCED: true, PURGE: true, RCFILE: true, REAL: true, REFRESH: true, REGEXP: true, RENAME: true,
-    REPLACE: true, RETURNS: true, RIGHT: true, RLIKE: true, ROW: true, SCHEMA: true, SCHEMAS: true, SELECT: true, SEMI: true, SEQUENCEFILE: true, SERDEPROPERTIES: true, SERIALIZE_FN: true, SET: true, SHOW: true, SMALLINT: true, SORT: true, STATS: true, STORED: true, STRAIGHT_JOIN: true, STRING: true, STRUCT: true, SYMBOL: true, TABLE: true,
-    TABLES: true, TBLPROPERTIES: true, TERMINATED: true, TEXTFILE: true, THEN: true, TIMESTAMP: true, TINYINT: true, TO: true, TRUE: true, UNCACHED: true, UNION: true, UPDATE_FN: true, UPSERT: true, USE: true, USING: true, VALUES: true, VIEW: true, WHEN: true, WHERE: true, WITH: true
+    REPEATABLE: true, REPLACE: true, RETURNS: true, RIGHT: true, RLIKE: true, ROW: true, SCHEMA: true, SCHEMAS: true, SELECT: true, SEMI: true, SEQUENCEFILE: true, SERDEPROPERTIES: true, SERIALIZE_FN: true, SET: true, SHOW: true, SMALLINT: true, SORT: true, STATS: true, STORED: true, STRAIGHT_JOIN: true, STRING: true, STRUCT: true, SYMBOL: true, TABLE: true,
+    TABLES: true, TABLESAMPLE: true, TBLPROPERTIES: true, TERMINATED: true, TEXTFILE: true, THEN: true, TIMESTAMP: true, TINYINT: true, TO: true, TRUE: true, UNCACHED: true, UNION: true, UPDATE_FN: true, UPSERT: true, USE: true, USING: true, VALUES: true, VIEW: true, WHEN: true, WHERE: true, WITH: true
   };
 
   return {

+ 1 - 1
tools/ace-editor/lib/ace/mode/impala_highlight_rules.js

@@ -25,7 +25,7 @@ define(function (require, exports, module) {
     // regexps are ordered -> the first match is used
 
     var keywords = (
-        "ADD|AGGREGATE|ALL|ALTER|ANALYTIC|AND|ANTI|API_VERSION|AS|ASC|AVRO|BETWEEN|BINARY|BLOCK_SIZE|BY|CACHED|CASCADE|CASE|CAST|CHANGE|CLASS|CLOSE_FN|COLUMN|COLUMNS|COMMENT|COMPRESSION|COMPUTE|CREATE|CROSS|CURRENT|DATA|DATABASE|DATABASES|DATE|DATETIME|DEFAULT|DELETE|DELIMITED|DESC|DESCRIBE|DISTINCT|DIV|DROP|ELSE|ENCODING|END|ESCAPED|EXISTS|EXPLAIN|EXTENDED|EXTERNAL|FIELDS|FILEFORMAT|FINALIZE_FN|FIRST|FOLLOWING|FOR|FORMAT|FORMATTED|FROM|FULL|FUNCTION|FUNCTIONS|GRANT|GROUP|HASH|HAVING|IF|ILIKE|IN|INCREMENTAL|INIT_FN|INNER|INPATH|IREGEXP|INSERT|INTEGER|INTERMEDIATE|INTERVAL|INTO|INVALIDATE|IS|JOIN|KEY|LAST|LEFT|LIKE|LIMIT|LINES|LOAD|LOCATION|MERGE_FN|METADATA|NOT|NULLS|OFFSET|ON|OR|ORDER|OUTER|OVER|OVERWRITE|PARQUET|PARTITION|PARTITIONED|PARTITIONS|PRECEDING|PREPARE_FN|PRIMARY|PRODUCED|PURGE|RANGE|RECOVER|REFRESH|REGEXP|RENAME|RESTRICT|REPLACE|REPLICATION|RETURNS|REVOKE|RIGHT|RLIKE|ROLE|ROLES|ROW|ROWS|SCHEMA|SCHEMAS|SELECT|SEMI|SERDEPROPERTIES|SERIALIZE_FN|SET|SHOW|SORT|STATS|STORED|STRAIGHT_JOIN|SYMBOL|TABLE|TABLES|TBLPROPERTIES|TERMINATED|THEN|TO|UNBOUNDED|UNCACHED|UNION|UPDATE|UPDATE_FN|UPSERT|USE|USING|VALUES|VIEW|WHEN|WHERE|WITH"
+        "ADD|AGGREGATE|ALL|ALTER|ANALYTIC|AND|ANTI|API_VERSION|AS|ASC|AVRO|BETWEEN|BINARY|BLOCK_SIZE|BY|CACHED|CASCADE|CASE|CAST|CHANGE|CLASS|CLOSE_FN|COLUMN|COLUMNS|COMMENT|COMPRESSION|COMPUTE|CREATE|CROSS|CURRENT|DATA|DATABASE|DATABASES|DATE|DATETIME|DEFAULT|DELETE|DELIMITED|DESC|DESCRIBE|DISTINCT|DIV|DROP|ELSE|ENCODING|END|ESCAPED|EXISTS|EXPLAIN|EXTENDED|EXTERNAL|FIELDS|FILEFORMAT|FINALIZE_FN|FIRST|FOLLOWING|FOR|FORMAT|FORMATTED|FROM|FULL|FUNCTION|FUNCTIONS|GRANT|GROUP|HASH|HAVING|IF|ILIKE|IN|INCREMENTAL|INIT_FN|INNER|INPATH|IREGEXP|INSERT|INTEGER|INTERMEDIATE|INTERVAL|INTO|INVALIDATE|IS|JOIN|KEY|LAST|LEFT|LIKE|LIMIT|LINES|LOAD|LOCATION|MERGE_FN|METADATA|NOT|NULLS|OFFSET|ON|OR|ORDER|OUTER|OVER|OVERWRITE|PARQUET|PARTITION|PARTITIONED|PARTITIONS|PRECEDING|PREPARE_FN|PRIMARY|PRODUCED|PURGE|RANGE|RECOVER|REFRESH|REGEXP|RENAME|RESTRICT|REPEATABLE|REPLACE|REPLICATION|RETURNS|REVOKE|RIGHT|RLIKE|ROLE|ROLES|ROW|ROWS|SCHEMA|SCHEMAS|SELECT|SEMI|SERDEPROPERTIES|SERIALIZE_FN|SET|SHOW|SORT|STATS|STORED|STRAIGHT_JOIN|SYMBOL|TABLE|TABLES|TABLESAMPLE|TBLPROPERTIES|TERMINATED|THEN|TO|UNBOUNDED|UNCACHED|UNION|UPDATE|UPDATE_FN|UPSERT|USE|USING|VALUES|VIEW|WHEN|WHERE|WITH"
     );
 
     var builtinConstants = (

Niektóre pliki nie zostały wyświetlone z powodu dużej ilości zmienionych plików