Realtime Compute for Apache Flink:Requêtes

query:
    values
  | WITH withItem [ , withItem ]* query
  | {
        select
      | selectWithoutFrom
      | query UNION [ ALL ] query
      | query EXCEPT query
      | query INTERSECT query
    }
    [ ORDER BY orderItem [, orderItem ]* ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start { ROW | ROWS } ]
    [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY]

withItem:
    name
    [ '(' column [, column ]* ')' ]
    AS '(' query ')'

orderItem:
    expression [ ASC | DESC ]

select:
    SELECT [ ALL | DISTINCT ]
    { * | projectItem [, projectItem ]* }
    FROM tableExpression
    [ WHERE booleanExpression ]
    [ GROUP BY { groupItem [, groupItem ]* } ]
    [ HAVING booleanExpression ]
    [ WINDOW windowName AS windowSpec [, windowName AS windowSpec ]* ]

selectWithoutFrom:
    SELECT [ ALL | DISTINCT ]
    { * | projectItem [, projectItem ]* }

projectItem:
    expression [ [ AS ] columnAlias ]
  | tableAlias . *

tableExpression:
    tableReference [, tableReference ]*
  | tableExpression [ NATURAL ] [ LEFT | RIGHT | FULL ] JOIN tableExpression [ joinCondition ]

joinCondition:
    ON booleanExpression
  | USING '(' column [, column ]* ')'

tableReference:
    tablePrimary
    [ matchRecognize ]
    [ [ AS ] alias [ '(' columnAlias [, columnAlias ]* ')' ] ]

tablePrimary:
    [ TABLE ] tablePath [ dynamicTableOptions ] [systemTimePeriod] [[AS] correlationName]
  | LATERAL TABLE '(' functionName '(' expression [, expression ]* ')' ')'
  | [ LATERAL ] '(' query ')'
  | UNNEST '(' expression ')'

tablePath:
    [ [ catalogName . ] databaseName . ] tableName

systemTimePeriod:
    FOR SYSTEM_TIME AS OF dateTimeExpression

dynamicTableOptions:
    /*+ OPTIONS(key=val [, key=val]*) */

key:
    stringLiteral

val:
    stringLiteral

values:
    VALUES expression [, expression ]*

groupItem:
    expression
  | '(' ')'
  | '(' expression [, expression ]* ')'
  | CUBE '(' expression [, expression ]* ')'
  | ROLLUP '(' expression [, expression ]* ')'
  | GROUPING SETS '(' groupItem [, groupItem ]* ')'

windowRef:
    windowName
  | windowSpec

windowSpec:
    [ windowName ]
    '('
    [ ORDER BY orderItem [, orderItem ]* ]
    [ PARTITION BY expression [, expression ]* ]
    [
        RANGE numericOrIntervalExpression {PRECEDING}
      | ROWS numericExpression {PRECEDING}
    ]
    ')'

matchRecognize:
    MATCH_RECOGNIZE '('
    [ PARTITION BY expression [, expression ]* ]
    [ ORDER BY orderItem [, orderItem ]* ]
    [ MEASURES measureColumn [, measureColumn ]* ]
    [ ONE ROW PER MATCH ]
    [ AFTER MATCH
      ( SKIP TO NEXT ROW
      | SKIP PAST LAST ROW
      | SKIP TO FIRST variable
      | SKIP TO LAST variable
      | SKIP TO variable )
    ]
    PATTERN '(' pattern ')'
    [ WITHIN intervalLiteral ]
    DEFINE variable AS condition [, variable AS condition ]*
    ')'

measureColumn:
    expression AS alias

pattern:
    patternTerm [ '|' patternTerm ]*

patternTerm:
    patternFactor [ patternFactor ]*

patternFactor:
    variable [ patternQuantifier ]

patternQuantifier:
    '*'
  | '*?'
  | '+'
  | '+?'
  | '?'
  | '??'
  | '{' { [ minRepeat ], [ maxRepeat ] } '}' ['?']
  | '{' repeat '}'

Identifiants

Les règles d'identification SQL de Flink diffèrent de Java sur un point important : les caractères non alphanumériques sont autorisés. À tous autres égards, les règles sont identiques à celles de Java :

• La définition des identifiants respecte la casse, qu'ils soient ou non entourés d'accent grave.

• La correspondance des identifiants respecte la casse.

Exemple avec un identifiant contenant des caractères non alphanumériques :

SELECT a AS `my field` FROM t

Constantes de chaîne

Les constantes de chaîne doivent utiliser des guillemets simples ('), et non des guillemets doubles (").

SELECT 'Hello World'

Pour échapper un guillemet simple au sein d'une chaîne, doublez-le :

Flink SQL> SELECT 'Hello World', 'It''s me';
+-------------+---------+
|      EXPR$0 |  EXPR$1 |
+-------------+---------+
| Hello World | It's me |
+-------------+---------+
1 row in set

Requêtes prises en charge

Le tableau suivant répertorie toutes les requêtes prises en charge par Apache Flink 1.15. Pour consulter la référence d'une autre version de Flink, changez de version sur le site Web d'Apache Flink.

Exécution des requêtes

En mode streaming, les flux d'entrée se divisent en deux catégories :

• Les flux sans mise à jour contiennent uniquement des événements de type INSERT.

• Les flux de mise à jour contiennent d'autres types d'événements. Les sources de capture des données modifiées (CDC) produisent des flux de mise à jour. Certaines opérations Flink, telles que l'agrégation de groupe et Top-N, génèrent également des événements de mise à jour en interne.

La plupart des opérations qui produisent des événements de mise à jour s'appuient sur des opérateurs avec état, qui utilisent un état géré pour suivre les mises à jour. Toutefois, tous les opérateurs avec état n'acceptent pas les flux de mise à jour en entrée. Par exemple, l'agrégation Over et la jointure d'intervalle ne prennent pas en charge les flux de mise à jour en entrée.

Le tableau suivant décrit les caractéristiques d'exécution de chaque requête prise en charge. Ces informations s'appliquent à Ververica Runtime (VVR) 6.0.X et versions ultérieures.