Catégories :

Syntaxe de requête

ASOF JOIN

This topic describes how to use the ASOF JOIN construct in the FROM clause. An ASOF JOIN operation combines rows from two tables based on timestamp values that closely follow each other, precede each other, or match exactly. For a conceptual explanation of ASOF joins, see Joining Time-Series Data.

Voir également JOIN, qui couvre la syntaxe d’autres types de jointures standard, telles que les jointures internes et externes.

Syntaxe

La syntaxe suivante de la clause FROM est spécifique à ASOF JOIN :

SELECT ...
FROM <left_table> ASOF JOIN <right_table>
  MATCH_CONDITION (<left_table.timecol> <comparison_operator> <right_table.timecol>)
  [ ON <table.col> = <table.col> [ AND ... ] ]
Copy
SELECT ...

La liste SELECT peut sélectionner toutes les colonnes des deux tables. Lorsqu’il n’y a pas de correspondance pour une ligne dans la table de gauche, les colonnes de la table de droite sont complétées par des valeurs nulles.

FROM

La première table (ou table de gauche) de la clause FROM est supposée contenir des enregistrements qui suivent (dans le temps), précèdent ou sont exactement synchronisés avec les enregistrements de la deuxième table (ou table de droite).

Outre les tables et les vues ordinaires, toute référence d’objet peut être utilisée dans un ASOF JOIN. Voir FROM.

ASOF JOIN peut être utilisé dans la plupart des contextes où les jointures sont prises en charge. Voir Notes sur l’utilisation pour certaines restrictions.

MATCH_CONDITION (left_table.timecol comparison_operator right_table.timecol)

Cette condition désigne les colonnes d’horodatage spécifiques de chaque table qui seront comparées.

  • L’ordre des tables est important dans la condition. La table de gauche doit être nommée en premier.

  • Les parenthèses sont obligatoires.

  • L’opérateur de comparaison doit être l’un des suivants : >=, <=, >, <. L’opérateur égal (=) n’est pas pris en charge.

  • Les types de données suivants sont pris en charge : DATE, TIME, DATETIME, TIMESTAMP, TIMESTAMP_LTZ, TIMESTAMP_NTZ, TIMESTAMP_TZ.

  • Vous pouvez également utiliser des colonnes NUMBER dans la condition de correspondance. Par exemple, vous pouvez avoir NUMBER colonnes qui contiennent des horodatages UNIX (qui définissent le nombre de secondes qui se sont écoulées depuis le 1er janvier, 1970).

  • The data types of the two matched columns do not have to be exactly the same, but they must be compatible.

ON table.col = table.col [ AND ... ]

The optional ON clause defines one or more equality conditions on columns in the two tables, for the purpose of logically grouping the results of the query.

  • The comparison operator must be the equal sign (=).

  • La clause ON ne peut pas contenir de disjonctions (conditions liées à OR). Les conditions liées à AND sont prises en charge.

  • Chaque côté d’une condition doit faire référence à une seule des deux tables de la jointure. Toutefois, l’ordre des références de la table n’a pas d’importance.

  • Each ON condition may be enclosed in parentheses, but they are not required.

See also More Details on Join Behavior.

Usage Notes

  • Si aucune correspondance n’est trouvée dans la table de droite pour une ligne donnée, le résultat est complété par des valeurs nulles pour les colonnes sélectionnées dans la table de droite. (Les jointuresASOF sont similaires aux jointures externes gauches à cet égard).

  • Si vous utilisez des colonnes TIME dans la condition de correspondance (par opposition à l’un des types d’horodatage), vous devrez peut-être définir le paramètre TIME_OUTPUT_FORMAT afin de voir les valeurs TIME exactes qui sont comparées lorsque vous regardez les résultats de la requête ASOF JOIN. Par défaut, l’affichage d’une colonne TIME tronque les millisecondes. Voir Colonnes TIME dans la condition de correspondance.

  • More than one ASOF join can be used in the same query as long as all of the syntax rules are followed for each join. Each join must be immediately followed by its own MATCH_CONDITION. You cannot apply a single MATCH_CONDITION to multiple ASOF joins. See Multiple ASOF Joins in a Query.

  • Les jointures ASOF ne sont pas prises en charge pour les jointures avec des fonctions de table LATERAL ou des vues en ligne LATERAL. Pour plus d’informations sur les jonctions latérales, voir Lateral Join.

  • Une jointure ASOF avec une autoréférence n’est pas autorisée dans une expression de table commune RECURSIVE (CTE). Pour plus d’informations sur CTEs, voir WITH.

  • The EXPLAIN output for ASOF JOIN queries identifies the ON conditions and the MATCH_CONDITION. For example, in text or tabular format, you will see this kind of output above the table scans in the plan:

    ->ASOF Join  joinKey: (S.LOCATION = R.LOCATION) AND (S.STATE = R.STATE),
    matchCondition: (S.OBSERVED >= R.OBSERVED)

  • Query profiles also clearly identify the ASOF JOIN operation in the plan. In this example, you can see that the table scan reads 22M rows from the left table, which are all preserved by the join. The profile also shows the match condition for the join.

Profil de requête qui montre des analyses de table alimentant en lignes l'opérateur ASOF JOIN situé au-dessus.

More Details on Join Behavior

The optional ON conditions for ASOF JOIN provide a way of grouping or partitioning table rows before the final matching rows are singled out by the required match condition. If you want the rows from the joined tables to be grouped on one or more dimensions that the tables share (stock symbol, location, city, state, company name, etc.), use an ON condition. If you do not use an ON condition, each row from the left table may be matched (by time) with any row from the right table in the final result set.

Here is an abstract example. Tables left_table and right_table have values A, B, etc. in column c1, and values 1, 2, etc. in column c2. Column c3 is a TIME column, and c4 is a numeric value (column of interest).

SELECT * FROM left_table ORDER BY c1, c2;
Copy
+----+----+----------+------+
| C1 | C2 | C3       |   C4 |
|----+----+----------+------|
| A  |  1 | 09:15:00 | 3.21 |
| A  |  2 | 09:16:00 | 3.22 |
| B  |  1 | 09:17:00 | 3.23 |
| B  |  2 | 09:18:00 | 4.23 |
+----+----+----------+------+

SELECT * FROM right_table ORDER BY c1, c2;
Copy
+----+----+----------+------+
| C1 | C2 | C3       |   C4 |
|----+----+----------+------|
| A  |  1 | 09:14:00 | 3.19 |
| B  |  1 | 09:16:00 | 3.04 |
+----+----+----------+------+

Si c1 et c2 sont toutes deux des colonnes de condition ON dans la requête, une ligne de la table de gauche ne correspond à une ligne de la table de droite que si A et 1, A et 2, B et 1, ou B et 2 se trouvent dans les deux tables. Si aucune correspondance n’est trouvée pour ces valeurs, les colonnes de la table de droite sont complétées par des valeurs nulles.

SELECT *
  FROM left_table l ASOF JOIN right_table r
    MATCH_CONDITION(l.c3>=r.c3)
    ON(l.c1=r.c1 and l.c2=r.c2)
  ORDER BY l.c1, l.c2;
Copy
+----+----+----------+------+------+------+----------+------+
| C1 | C2 | C3       |   C4 | C1   | C2   | C3       |   C4 |
|----+----+----------+------+------+------+----------+------|
| A  |  1 | 09:15:00 | 3.21 | A    |  1   | 09:14:00 | 3.19 |
| A  |  2 | 09:16:00 | 3.22 | NULL | NULL | NULL     | NULL |
| B  |  1 | 09:17:00 | 3.23 | B    |  1   | 09:16:00 | 3.04 |
| B  |  2 | 09:18:00 | 4.23 | NULL | NULL | NULL     | NULL |
+----+----+----------+------+------+------+----------+------+

Si les conditions ON sont supprimées, toute combinaison de valeurs dans c1 et c2 peut être prise en compte dans le résultat final. Seule la condition de correspondance détermine les résultats.

SELECT *
  FROM left_table l ASOF JOIN right_table r
    MATCH_CONDITION(l.c3>=r.c3)
  ORDER BY l.c1, l.c2;
Copy
+----+----+----------+------+----+----+----------+------+
| C1 | C2 | C3       |   C4 | C1 | C2 | C3       |   C4 |
|----+----+----------+------+----+----+----------+------|
| A  |  1 | 09:15:00 | 3.21 | A  |  1 | 09:14:00 | 3.19 |
| A  |  2 | 09:16:00 | 3.22 | B  |  1 | 09:16:00 | 3.04 |
| B  |  1 | 09:17:00 | 3.23 | B  |  1 | 09:16:00 | 3.04 |
| B  |  2 | 09:18:00 | 4.23 | B  |  1 | 09:16:00 | 3.04 |
+----+----+----------+------+----+----+----------+------+

Using ASOF and MATCH_CONDITION as Object Names and Aliases

This feature introduces two new keywords: ASOF and MATCH_CONDITION. The use of these keywords in SELECT command syntax is restricted:

  • Si une instruction SELECT utilise ASOF ou MATCH_CONDITION comme nom d’une table, d’une vue ou d’une vue en ligne, vous devez l’identifier comme suit :

    • Si l’objet a été créé avec des guillemets doubles dans le nom, utilisez le même nom entre guillemets doubles.

    • Si l’objet a été créé sans guillemets doubles dans le nom, utilisez des guillemets doubles et des lettres majuscules.

    Par exemple, les instructions suivantes ne sont plus autorisées et renvoient des erreurs :

    SELECT * FROM asof;

WITH match_condition AS (SELECT * FROM T1) SELECT * FROM match_condition;
    Copy

    Si vous avez créé les objets avec des guillemets doubles, corrigez le problème en utilisant des guillemets doubles :

    SELECT * FROM "asof";

WITH "match_condition" AS (SELECT * FROM T1) SELECT * FROM "match_condition";
    Copy

    Si vous avez créé les objets sans guillemets doubles, corrigez le problème en utilisant des guillemets doubles et des lettres majuscules :

    SELECT * FROM "ASOF";

WITH "MATCH_CONDITION" AS (SELECT * FROM T1) SELECT * FROM "MATCH_CONDITION";
    Copy

  • Si une instruction SELECT utilise ASOF ou MATCH_CONDITION comme alias, vous devez utiliser AS avant l’alias ou mettre l’alias entre guillemets doubles. Par exemple, les instructions suivantes ne sont plus autorisées et renvoient des erreurs :

    SELECT * FROM t1 asof;

SELECT * FROM t2 match_condition;
    Copy

    Réglez le problème de l’une des manières suivantes :

    SELECT * FROM t1 AS asof;

SELECT * FROM t1 "asof";

SELECT * FROM t2 AS match_condition;

SELECT * FROM t2 "match_condition";
    Copy

Exemples

The following examples demonstrate the expected behavior of ASOF JOIN queries.

Join with Match and ON Conditions

The following example is described under Conceptual Example of an ASOF JOIN Query.

SELECT t.stock_symbol, t.trade_time, t.quantity, q.quote_time, q.price
  FROM trades t ASOF JOIN quotes q
    MATCH_CONDITION(t.trade_time >= quote_time)
    ON t.stock_symbol=q.stock_symbol
  ORDER BY t.stock_symbol;
Copy
+--------------+-------------------------+----------+-------------------------+--------------+
| STOCK_SYMBOL | TRADE_TIME              | QUANTITY | QUOTE_TIME              |        PRICE |
|--------------+-------------------------+----------+-------------------------+--------------|
| AAPL         | 2023-10-01 09:00:05.000 |     2000 | 2023-10-01 09:00:03.000 | 139.00000000 |
| SNOW         | 2023-10-01 09:00:05.000 |     1000 | 2023-10-01 09:00:02.000 | 163.00000000 |
| SNOW         | 2023-10-01 09:00:10.000 |     1500 | 2023-10-01 09:00:08.000 | 165.00000000 |
+--------------+-------------------------+----------+-------------------------+--------------+

The ON condition groups the matched rows by their stock symbols.

NULL-Padded Results

As a follow-up to the previous example, insert a new row into the trades table with a date that is a day earlier than the existing rows in both trades and quotes:

INSERT INTO trades VALUES('SNOW','2023-09-30 12:02:55.000',3000);
Copy
+-------------------------+
| number of rows inserted |
|-------------------------|
|                       1 |
+-------------------------+

Exécutez à nouveau le premier exemple de requête. Notez que la requête renvoie quatre lignes, mais que la nouvelle ligne est remplacée par une ligne nulle. Aucune ligne de la table quotes ne répond à la condition de correspondance. Les colonnes de trades sont renvoyées et les colonnes correspondantes de quotes sont complétées par des valeurs nulles.

SELECT t.stock_symbol, t.trade_time, t.quantity, q.quote_time, q.price
  FROM trades t ASOF JOIN quotes q
    MATCH_CONDITION(t.trade_time >= quote_time)
    ON t.stock_symbol=q.stock_symbol
  ORDER BY t.stock_symbol;
Copy
+--------------+-------------------------+----------+-------------------------+--------------+
| STOCK_SYMBOL | TRADE_TIME              | QUANTITY | QUOTE_TIME              |        PRICE |
|--------------+-------------------------+----------+-------------------------+--------------|
| AAPL         | 2023-10-01 09:00:05.000 |     2000 | 2023-10-01 09:00:03.000 | 139.00000000 |
| SNOW         | 2023-09-30 12:02:55.000 |     3000 | NULL                    |         NULL |
| SNOW         | 2023-10-01 09:00:05.000 |     1000 | 2023-10-01 09:00:02.000 | 163.00000000 |
| SNOW         | 2023-10-01 09:00:10.000 |     1500 | 2023-10-01 09:00:08.000 | 165.00000000 |
+--------------+-------------------------+----------+-------------------------+--------------+

Using a Different Comparison Operator in the Match Condition

Dans le prolongement de l’exemple précédent, les résultats de la requête changent à nouveau lorsque l’opérateur de comparaison dans la condition de correspondance est modifié. La requête suivante spécifie l’opérateur <= (au lieu de >=) :

SELECT t.stock_symbol, t.trade_time, t.quantity, q.quote_time, q.price
  FROM trades t ASOF JOIN quotes q
    MATCH_CONDITION(t.trade_time <= quote_time)
    ON t.stock_symbol=q.stock_symbol
  ORDER BY t.stock_symbol;
Copy
+--------------+-------------------------+----------+-------------------------+--------------+
| STOCK_SYMBOL | TRADE_TIME              | QUANTITY | QUOTE_TIME              |        PRICE |
|--------------+-------------------------+----------+-------------------------+--------------|
| AAPL         | 2023-10-01 09:00:05.000 |     2000 | 2023-10-01 09:00:07.000 | 142.00000000 |
| SNOW         | 2023-10-01 09:00:10.000 |     1500 | NULL                    |         NULL |
| SNOW         | 2023-10-01 09:00:05.000 |     1000 | 2023-10-01 09:00:07.000 | 166.00000000 |
| SNOW         | 2023-09-30 12:02:55.000 |     3000 | 2023-10-01 09:00:01.000 | 166.00000000 |
+--------------+-------------------------+----------+-------------------------+--------------+

Voir aussi Opérateurs de comparaison Inférieur à et Supérieur à.

Inner Join to a Third Table

The following example adds a third companies table to the join in order to pick the company name for each stock symbol. You can use a regular INNER JOIN with an ON condition (or some other standard join syntax) to add the third table. However, note that USING(stock_symbol) would not work here because the reference to stock_symbol would be ambiguous.

SELECT t.stock_symbol, c.company_name, t.trade_time, t.quantity, q.quote_time, q.price
  FROM trades t ASOF JOIN quotes q
    MATCH_CONDITION(t.trade_time >= quote_time)
    ON t.stock_symbol=q.stock_symbol
    INNER JOIN companies c ON c.stock_symbol=t.stock_symbol
  ORDER BY t.stock_symbol;
Copy
+--------------+---------------+-------------------------+----------+-------------------------+--------------+
| STOCK_SYMBOL | COMPANY_NAME  | TRADE_TIME              | QUANTITY | QUOTE_TIME              |        PRICE |
|--------------+---------------+-------------------------+----------+-------------------------+--------------|
| AAPL         | Apple Inc     | 2023-10-01 09:00:05.000 |     2000 | 2023-10-01 09:00:03.000 | 139.00000000 |
| SNOW         | Snowflake Inc | 2023-09-30 12:02:55.000 |     3000 | NULL                    |         NULL |
| SNOW         | Snowflake Inc | 2023-10-01 09:00:05.000 |     1000 | 2023-10-01 09:00:02.000 | 163.00000000 |
| SNOW         | Snowflake Inc | 2023-10-01 09:00:10.000 |     1500 | 2023-10-01 09:00:08.000 | 165.00000000 |
+--------------+---------------+-------------------------+----------+-------------------------+--------------+

Numbers as Timestamps

L’exemple suivant montre que la condition de correspondance peut comparer des valeurs numériques. Dans ce cas, les tables ont des valeurs d’horodatage UNIX stockées dans les colonnes (38,0) NUMBER. 1696150805 est équivalent à 2023-10-30 10:20:05.000 (trois secondes plus tard que 1696150802).

SELECT * FROM trades_unixtime;
Copy
+--------------+------------+----------+--------------+
| STOCK_SYMBOL | TRADE_TIME | QUANTITY |        PRICE |
|--------------+------------+----------+--------------|
| SNOW         | 1696150805 |      100 | 165.33300000 |
+--------------+------------+----------+--------------+

SELECT * FROM quotes_unixtime;
Copy
+--------------+------------+----------+--------------+--------------+
| STOCK_SYMBOL | QUOTE_TIME | QUANTITY |          BID |          ASK |
|--------------+------------+----------+--------------+--------------|
| SNOW         | 1696150802 |      100 | 166.00000000 | 165.00000000 |
+--------------+------------+----------+--------------+--------------+

SELECT *
  FROM trades_unixtime tu
    ASOF JOIN quotes_unixtime qu
    MATCH_CONDITION(tu.trade_time>=qu.quote_time);
Copy
+--------------+------------+----------+--------------+--------------+------------+----------+--------------+--------------+
| STOCK_SYMBOL | TRADE_TIME | QUANTITY |        PRICE | STOCK_SYMBOL | QUOTE_TIME | QUANTITY |          BID |          ASK |
|--------------+------------+----------+--------------+--------------+------------+----------+--------------+--------------|
| SNOW         | 1696150805 |      100 | 165.33300000 | SNOW         | 1696150802 |      100 | 166.00000000 | 165.00000000 |
+--------------+------------+----------+--------------+--------------+------------+----------+--------------+--------------+

TIME Columns in the Match Condition

The following example joins two tables that contain weather observations. The observations in both tables are recorded into TIME columns. All the TIME values appear to be exactly the same in this result set (14:42:59).

SELECT * FROM preciptime p ASOF JOIN snowtime s MATCH_CONDITION(p.observed>=s.observed);
Copy
+----------+----------+-------+-------------+----------+-----------+-------+-------------+
| OBSERVED | LOCATION | STATE | OBSERVATION | OBSERVED | LOCATION  | STATE | OBSERVATION |
|----------+----------+-------+-------------+----------+-----------+-------+-------------|
| 14:42:59 | Oakhurst | CA    |        0.50 | NULL     | NULL      | NULL  |        NULL |
| 14:42:59 | Ahwahnee | CA    |        0.90 | 14:42:59 | Fish Camp | CA    |        3.20 |
+----------+----------+-------+-------------+----------+-----------+-------+-------------+

To return a more precise display of TIME values, including milliseconds, run the following ALTER SESSION command, then run the join query again:

ALTER SESSION SET TIME_OUTPUT_FORMAT = 'HH24:MI:SS.FF3';
Copy
+----------------------------------+
| status                           |
|----------------------------------|
| Statement executed successfully. |
+----------------------------------+

SELECT * FROM preciptime p ASOF JOIN snowtime s MATCH_CONDITION(p.observed>=s.observed);
Copy
+--------------+----------+-------+-------------+--------------+-----------+-------+-------------+
| OBSERVED     | LOCATION | STATE | OBSERVATION | OBSERVED     | LOCATION  | STATE | OBSERVATION |
|--------------+----------+-------+-------------+--------------+-----------+-------+-------------|
| 14:42:59.001 | Oakhurst | CA    |        0.50 | NULL         | NULL      | NULL  |        NULL |
| 14:42:59.230 | Ahwahnee | CA    |        0.90 | 14:42:59.199 | Fish Camp | CA    |        3.20 |
+--------------+----------+-------+-------------+--------------+-----------+-------+-------------+

Multiple ASOF Joins in a Query

L’exemple suivant montre comment connecter une séquence de deux ou plusieurs jointures ASOF dans un seul bloc de requête. Les trois tables (snowtime, raintime, preciptime) contiennent toutes des observations météorologiques qui ont été enregistrées dans des lieux et à des moments précis. La colonne qui nous intéresse est la colonne observation. Les lignes sont regroupées logiquement par état.

ALTER SESSION SET TIME_OUTPUT_FORMAT = 'HH24:MI:SS.FF3';

SELECT *
  FROM snowtime s
    ASOF JOIN raintime r
      MATCH_CONDITION(s.observed>=r.observed)
      ON s.state=r.state
    ASOF JOIN preciptime p
      MATCH_CONDITION(s.observed>=p.observed)
      ON s.state=p.state
  ORDER BY s.observed;
Copy
+--------------+------------+-------+-------------+--------------+----------+-------+-------------+--------------+----------+-------+-------------+
| OBSERVED     | LOCATION   | STATE | OBSERVATION | OBSERVED     | LOCATION | STATE | OBSERVATION | OBSERVED     | LOCATION | STATE | OBSERVATION |
|--------------+------------+-------+-------------+--------------+----------+-------+-------------+--------------+----------+-------+-------------|
| 14:42:44.435 | Reno       | NV    |        3.00 | 14:42:44.435 | Reno     | NV    |        0.00 | 14:42:44.435 | Reno     | NV    |        0.01 |
| 14:42:45.000 | Bozeman    | MT    |        1.80 | NULL         | NULL     | NULL  |        NULL | 14:40:34.000 | Bozeman  | MT    |        1.11 |
| 14:42:59.199 | Fish Camp  | CA    |        3.20 | 14:42:59.001 | Oakhurst | CA    |        0.50 | 14:42:59.001 | Oakhurst | CA    |        0.51 |
| 14:43:01.000 | Lake Tahoe | CA    |        4.20 | 14:42:59.230 | Ahwahnee | CA    |        0.90 | 14:42:59.230 | Ahwahnee | CA    |        0.91 |
+--------------+------------+-------+-------------+--------------+----------+-------+-------------+--------------+----------+-------+-------------+

Less Than and Greater Than Comparison Operators

Dans le prolongement de l’exemple précédent, deux jointures ASOF sont spécifiées, mais cette fois, la première condition de correspondance utilise l’opérateur > et la seconde l’opérateur <. Le résultat est une ligne unique qui renvoie les données des trois tables et trois lignes qui renvoient les données de deux des tables. De nombreuses colonnes du jeu de résultats sont complétées par des valeurs nulles.

Logiquement, la requête ne trouve qu’une seule ligne où l’heure observée dans la table snowtime est postérieure à l’heure observée dans la table raintime mais antérieure à l’heure observée dans la table preciptime.

SELECT *
  FROM snowtime s
    ASOF JOIN raintime r
      MATCH_CONDITION(s.observed>r.observed)
      ON s.state=r.state
    ASOF JOIN preciptime p
      MATCH_CONDITION(s.observed<p.observed)
      ON s.state=p.state
    ORDER BY s.observed;
Copy
+--------------+------------+-------+-------------+--------------+-----------+-------+-------------+--------------+----------+-------+-------------+
| OBSERVED     | LOCATION   | STATE | OBSERVATION | OBSERVED     | LOCATION  | STATE | OBSERVATION | OBSERVED     | LOCATION | STATE | OBSERVATION |
|--------------+------------+-------+-------------+--------------+-----------+-------+-------------+--------------+----------+-------+-------------|
| 14:42:44.435 | Reno       | NV    |        3.00 | 14:41:44.435 | Las Vegas | NV    |        0.00 | NULL         | NULL     | NULL  |        NULL |
| 14:42:45.000 | Bozeman    | MT    |        1.80 | NULL         | NULL      | NULL  |        NULL | NULL         | NULL     | NULL  |        NULL |
| 14:42:59.199 | Fish Camp  | CA    |        3.20 | 14:42:59.001 | Oakhurst  | CA    |        0.50 | 14:42:59.230 | Ahwahnee | CA    |        0.91 |
| 14:43:01.000 | Lake Tahoe | CA    |        4.20 | 14:42:59.230 | Ahwahnee  | CA    |        0.90 | NULL         | NULL     | NULL  |        NULL |
+--------------+------------+-------+-------------+--------------+-----------+-------+-------------+--------------+----------+-------+-------------+

Examples of Expected Error Cases

Les exemples suivants montrent des requêtes qui renvoient des erreurs de syntaxe attendues.

Après avoir déclaré que snowtime s est la table de gauche, vous ne pouvez pas commencer la condition de correspondance par une référence à la table de droite, preciptime p :

SELECT * FROM snowtime s ASOF JOIN preciptime p MATCH_CONDITION(p.observed>=s.observed);
Copy
010002 (42601): SQL compilation error:
MATCH_CONDITION clause is invalid: The left side allows only column references from the left side table, and the right side allows only column references from the right side table.

Seuls les opérateurs >=, <=, >, et < sont autorisés dans les conditions de correspondance :

SELECT * FROM preciptime p ASOF JOIN snowtime s MATCH_CONDITION(p.observed=s.observed);
Copy
010001 (42601): SQL compilation error:
MATCH_CONDITION clause is invalid: Only comparison operators '>=', '>', '<=' and '<' are allowed. Keywords such as AND and OR are not allowed.

La clause ON pour ASOF JOIN doit contenir des conditions d’égalité :

SELECT *
  FROM preciptime p ASOF JOIN snowtime s
  MATCH_CONDITION(p.observed>=s.observed)
  ON s.state>=p.state;
Copy
010010 (42601): SQL compilation error:
ON clause for ASOF JOIN must contain conjunctions of equality conditions only. Disjunctions are not allowed. Each side of an equality condition must only refer to either the left table or the right table. S.STATE >= P.STATE is invalid.

Une condition d’égalité de clause ON ne peut pas contenir de disjonctions :

SELECT *
  FROM preciptime p ASOF JOIN snowtime s
  MATCH_CONDITION(p.observed>=s.observed)
  ON s.state=p.state OR s.location=p.location;
Copy
010010 (42601): SQL compilation error:
ON clause for ASOF JOIN must contain conjunctions of equality conditions only. Disjunctions are not allowed. Each side of an equality condition must only refer to either the left table or the right table. (S.STATE = P.STATE) OR (S.LOCATION = P.LOCATION) is invalid.

Les jointures ASOF ne peuvent pas être utilisées avec les vues en ligne LATERAL :

SELECT t1.a "t1a", t2.a "t2a"
  FROM t1 ASOF JOIN
    LATERAL(SELECT a FROM t2 WHERE t1.b = t2.b) t2
    MATCH_CONDITION(t1.a >= t2.a)
  ORDER BY 1,2;
Copy
010004 (42601): SQL compilation error:
ASOF JOIN is not supported for joins with LATERAL table functions or LATERAL views.
Langage: Français