Realtime Compute for Apache Flink:Consultas

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 '}'

Identificadores

Las reglas de identificadores de Flink SQL difieren de Java en un aspecto importante: se permiten caracteres no alfanuméricos. En todos los demás aspectos, las reglas son las mismas que en Java:

• Las definiciones de identificadores distinguen entre mayúsculas y minúsculas, independientemente de si el identificador está encerrado entre comillas inversas.

• La coincidencia de identificadores distingue entre mayúsculas y minúsculas.

Ejemplo con un identificador no alfanumérico:

SELECT a AS `my field` FROM t

Constantes de cadena

Las constantes de cadena deben usar comillas simples ('), no comillas dobles (").

SELECT 'Hello World'

Para escapar una comilla simple dentro de una cadena, duplíquela:

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

Consultas compatibles

La siguiente tabla enumera todas las consultas compatibles con Apache Flink 1.15. Para consultar la referencia de una versión diferente de Flink, cambie de versión en el sitio web de Apache Flink.

Ejecución de consultas

En modo streaming, los flujos de entrada se dividen en dos categorías:

• Los flujos sin actualizaciones contienen únicamente eventos de tipo INSERT.

• Los flujos con actualizaciones contienen otros tipos de eventos. Los orígenes de captura de datos de cambio (CDC) producen flujos con actualizaciones. Ciertas operaciones de Flink, como la agregación de grupo y Top-N, también generan eventos de actualización internamente.

La mayoría de las operaciones que producen eventos de actualización dependen de operadores con estado, los cuales utilizan estado gestionado para rastrear las actualizaciones. Sin embargo, no todos los operadores con estado aceptan flujos con actualizaciones como entrada. Por ejemplo, la agregación Over y el Interval Join no admiten flujos con actualizaciones como entrada.

La siguiente tabla describe las características de ejecución de cada consulta compatible. Esta información aplica a Ververica Runtime (VVR) 6.0.X y versiones posteriores.