Identification des séquences de lignes qui correspondent à un modèle¶

Configuration des données pour cet exemple¶

Pour configurer les données utilisées dans cet exemple, exécutez les instructions SQL suivantes :

create table stock_price_history (company TEXT, price_date DATE, price INT);

Copy

insert into stock_price_history values
    ('ABCD', '2020-10-01', 50),
    ('XYZ' , '2020-10-01', 89),
    ('ABCD', '2020-10-02', 36),
    ('XYZ' , '2020-10-02', 24),
    ('ABCD', '2020-10-03', 39),
    ('XYZ' , '2020-10-03', 37),
    ('ABCD', '2020-10-04', 42),
    ('XYZ' , '2020-10-04', 63),
    ('ABCD', '2020-10-05', 30),
    ('XYZ' , '2020-10-05', 65),
    ('ABCD', '2020-10-06', 47),
    ('XYZ' , '2020-10-06', 56),
    ('ABCD', '2020-10-07', 71),
    ('XYZ' , '2020-10-07', 50),
    ('ABCD', '2020-10-08', 80),
    ('XYZ' , '2020-10-08', 54),
    ('ABCD', '2020-10-09', 75),
    ('XYZ' , '2020-10-09', 30),
    ('ABCD', '2020-10-10', 63),
    ('XYZ' , '2020-10-10', 32);

Copy

Étape 1 : Spécifier l’ordre et le regroupement des lignes¶

La première étape de l’identification d’une séquence de lignes consiste à définir le regroupement et l’ordre de tri des lignes que vous souhaitez rechercher. Exemple de recherche d’un modèle en « V » dans le cours de l’action d’une société :

• Les lignes doivent être regroupées par entreprise, car vous souhaitez trouver une tendance dans le prix d’une entreprise donnée.

• Dans chaque groupe de lignes (les prix pour une société donnée), les lignes doivent être triées par date dans l’ordre croissant.

Dans une clause MATCH_RECOGNIZE , vous utilisez les sous-clauses PARTITION BY et ORDER BY pour spécifier le regroupement et l’ordre des lignes. Par exemple :

MATCH_RECOGNIZE(
  PARTITION BY company
  ORDER BY price_date
  ...
)

Copy

Étape 2 : définition du modèle à mettre en correspondance¶

Ensuite, déterminez le modèle qui correspond à la séquence de lignes que vous voulez trouver.

Pour spécifier ce modèle, vous utilisez quelque chose de similaire à une expression régulière. Dans les expressions régulières, vous utilisez une combinaison de littéraux et de métacaractères pour spécifier un modèle à mettre en correspondance dans une chaîne.

Par exemple, pour trouver une séquence de caractères qui comprend :

• tout caractère unique, suivi de

• une ou plusieurs lettres majuscules, suivies de

• une ou plusieurs lettres minuscules

vous pouvez utiliser l’expression régulière suivante, compatible avec Perl :

.[A-Z]+[a-z]+

où :

• . correspond à n’importe quel caractère unique.

• [A-Z]+ correspond à une ou plusieurs lettres majuscules.

• [a-z]+ correspond à une ou plusieurs lettres minuscules.

+ est un quantificateur qui spécifie qu’un ou plusieurs des caractères précédents doivent correspondre.

Par exemple, l’expression régulière ci-dessus correspond à des séquences de caractères comme :

• 1Stock

• @SFComputing

• %Fn

Dans une clause MATCH_RECOGNIZE , vous utilisez une expression similaire pour spécifier le modèle des lignes à mettre en correspondance. Dans ce cas, trouver des lignes qui correspondent à un modèle « V » implique de trouver une séquence de lignes qui comprend :

• la ligne précédant la baisse du prix de l’action, suivie de

• une ou plusieurs lignes où le prix de l’action diminue, suivies de

• une ou plusieurs lignes où le prix de l’action augmente

Vous pouvez exprimer cela comme le modèle de ligne suivant :

row_before_decrease row_with_price_decrease+ row_with_price_increase+

Les modèles de lignes sont constitués de variables de modèle, de quantificateurs (qui sont similaires à ceux utilisés dans les expressions régulières), et d’opérateurs. Une variable de modèle définit une expression qui est évaluée par rapport à une ligne.

Dans ce modèle de ligne :

• row_before_decrease, row_with_price_decrease, et row_with_price_increase sont des variables de modèle. Les expressions pour ces variables de modèle doivent être évaluées à :

  • n’importe quelle ligne (la ligne avant la baisse du prix de l’action)

  • une ligne où le prix de l’action diminue

  • une ligne où le prix de l’action augmente

  row_before_decrease est similaire à . dans une expression régulière. Dans l’expression régulière suivante, . correspond à tout caractère unique qui apparaît avant la première lettre majuscule du modèle.

  .[A-Z]+[a-z]+
  

  Copy

  De même, dans le modèle de ligne, row_before_decrease correspond à toute ligne unique qui apparaît avant la première ligne avec une baisse de prix.

• Les quantificateurs + après row_with_price_decrease et row_with_price_increase spécifient qu’une ou plusieurs lignes de chacun de ces éléments doivent correspondre.

Dans une clause MATCH_RECOGNIZE , vous utilisez la sous-clause PATTERN pour spécifier le modèle de ligne à mettre en correspondance :

MATCH_RECOGNIZE(
  ...
  PATTERN(row_before_decrease row_with_price_decrease+ row_with_price_increase+)
  ...
)

Pour spécifier les expressions des variables de modèles, vous utilisez la sous-clause DEFINE :

MATCH_RECOGNIZE(
  ...
  DEFINE
    row_with_price_decrease AS price < LAG(price)
    row_with_price_increase AS price > LAG(price)
  ...
)

Copy

où :

• row_before_decrease n’a pas besoin d’être défini ici car il doit être évalué à n’importe quelle ligne.

• row_with_price_decrease est définie comme une expression pour une ligne avec une baisse de prix.

• row_with_price_increase est définie comme l’expression d’une ligne avec une augmentation de prix.

Pour comparer les prix de différentes lignes, les définitions de ces variables utilisent la fonction de navigation LAG() pour spécifier le prix de la ligne précédente.

Le modèle de ligne correspond à deux séquences de lignes, comme illustré ci-dessous :

Pour la première séquence de lignes correspondantes :

• row_before_decrease correspond à la ligne avec le prix de l’action 50.

• row_with_price_decrease correspond à la ligne suivante avec le prix de l’action 36.

• row_with_price_increase correspond aux deux lignes suivantes avec les prix des actions 39 et 42.

Pour la deuxième séquence de lignes correspondantes :

• row_before_decrease correspond à la ligne avec le prix de l’action 42. (Il s’agit de la même ligne qui se trouve à la fin de la première séquence de lignes correspondante).

• row_with_price_decrease correspond à la ligne suivante avec le prix de l’action 30.

• row_with_price_increase correspond aux deux lignes suivantes avec les prix des actions 47, 71, et 80.

Étape 3 : spécification des lignes à retourner¶

MATCH_RECOGNIZE peut soit retourner :

• une seule ligne qui résume chaque séquence correspondante, ou

• chaque ligne de chaque séquence correspondante

Dans cet exemple, vous voulez renvoyer un résumé de chaque séquence correspondante. Utilisez la sous-clause ONE ROW PER MATCH pour spécifier qu’une ligne doit être retournée pour chaque séquence correspondante.

MATCH_RECOGNIZE(
  ...
  ONE ROW PER MATCH
  ...
)

Étape 4 : spécification des mesures à sélectionner¶

Lorsque vous utilisez ONE ROW PER MATCH, MATCH_RECOGNIZE ne renvoie aucune des colonnes de la table (à l’exception de la colonne spécifiée par PARTITION BY), même si MATCH_RECOGNIZE se trouve dans une instruction SELECT *. Pour spécifier les données à renvoyer par cette instruction, vous devez définir des mesures. Les mesures sont des colonnes de données supplémentaires qui sont calculées pour chaque séquence de lignes correspondante (par exemple, la date de début de la séquence, la date de fin de la séquence, le nombre de jours dans la séquence, etc.)

Utilisez la sous-clause MEASURES pour spécifier ces colonnes supplémentaires à retourner dans la sortie. Le format général pour définir une mesure est le suivant :

<expression> AS <column_name>

où :

• expression spécifie l’information sur la séquence que vous voulez retourner. Pour l’expression, vous pouvez utiliser des fonctions avec les colonnes de la table et les variables de modèle que vous avez définies précédemment.

• column_name spécifie le nom de la colonne qui sera retournée dans la sortie.

Pour cet exemple, vous pouvez définir les mesures suivantes :

• Un numéro qui identifie la séquence (la première séquence correspondante, la seconde séquence correspondante, etc.)

  Pour cette mesure, utilisez la fonction MATCH_NUMBER() , qui renvoie le numéro de la correspondance. Les numéros commencent par 1 pour la première correspondance pour une partition de lignes. S’il y a plusieurs partitions, le numéro commence par 1 pour chaque partition.

• La veille du jour où le prix de l’action a baissé.

  Pour cette mesure, utilisez la fonction FIRST() , qui renvoie la valeur de l’expression pour la première ligne de la séquence correspondante. Dans cet exemple, FIRST(price_date) renvoie la valeur de la colonne price_date de la première ligne de chaque séquence correspondante, qui correspond à la date précédant la baisse du cours de l’action.

• Le dernier jour où le prix de l’action a augmenté.

  Pour cette mesure, utilisez la fonction LAST() , qui renvoie la valeur de l’expression pour la dernière ligne de la séquence correspondante.

• Le nombre de jours du modèle en « V ».

  Pour cette mesure, utilisez COUNT(*). Comme vous spécifiez COUNT(*) dans la définition d’une mesure, l’astérisque (*) indique que vous voulez compter toutes les lignes d’une séquence correspondante (et non toutes les lignes de la table).

• Le nombre de jours où le stock a diminué.

  Pour cette mesure, utilisez COUNT(row_with_price_decrease.*). La période suivie d’un astérisque (.*) indique que vous voulez compter toutes les lignes d’une séquence correspondante qui correspondent à la variable de modèle row_with_price_decrease.

• Le nombre de jours où le stock a augmenté.

  Pour cette mesure, utilisez COUNT(row_with_price_increase.*).

Voici la sous-clause MEASURES qui définit les mesures ci-dessus :

MATCH_RECOGNIZE(
  ...
  MEASURES
    MATCH_NUMBER() AS match_number,
    FIRST(price_date) AS start_date,
    LAST(price_date) AS end_date,
    COUNT(*) AS num_matching_rows,
    COUNT(row_with_price_decrease.*) AS num_decreases,
    COUNT(row_with_price_increase.*) AS num_increases
  ...
)

La figure suivante montre un exemple de sortie avec les mesures sélectionnées :

+---------+--------------+------------+------------+-------------------+---------------+---------------+
| COMPANY | MATCH_NUMBER | START_DATE | END_DATE   | NUM_MATCHING_ROWS | NUM_DECREASES | NUM_INCREASES |
|---------+--------------+------------+------------+-------------------+---------------+---------------|
| ABCD    |            1 | 2020-10-01 | 2020-10-04 |                 4 |             1 |             2 |
| ABCD    |            2 | 2020-10-04 | 2020-10-08 |                 5 |             1 |             3 |
+---------+--------------+------------+------------+-------------------+---------------+---------------+

Comme mentionné précédemment, la sortie inclut la colonne company car la clause PARTITION BY spécifie cette colonne.

Étape 5 : spécification du moment où poursuivre la recherche de la correspondance suivante¶

Après avoir trouvé une séquence de lignes correspondante, MATCH_RECOGNIZE continue de rechercher la séquence correspondante suivante. Vous pouvez spécifier où MATCH_RECOGNIZE doit commencer à chercher la séquence correspondante suivante.

Comme le montre l’illustration des séquences correspondantes, une ligne peut faire partie de plus d’une séquence correspondante. Dans cet exemple, la ligne pour 2020-10-04 fait partie de deux modèles en « V ».

Dans cet exemple, pour trouver la séquence correspondante suivante, vous pouvez commencer par une ligne où le prix a augmenté. Pour spécifier ceci dans la clause MATCH_RECOGNIZE , utilisez AFTER MATCH SKIP :

MATCH_RECOGNIZE(
  ...
  AFTER MATCH SKIP TO LAST row_with_price_increase
  ...
)

où TO LAST row_with_price_increase indique que vous voulez commencer la recherche à la dernière ligne où le prix a augmenté.

Utilisation de quantificateurs avec des variables de modèle¶

Dans la sous-clause PATTERN, vous utilisez une expression régulière pour spécifier un modèle de lignes à mettre en correspondance. Vous utilisez des variables de modèle pour identifier les lignes de la séquence qui répondent à des conditions spécifiques.

Si vous devez faire correspondre plusieurs lignes qui répondent à une condition spécifique, vous pouvez utiliser un quantificateur, comme vous le feriez dans une expression régulière.

Par exemple, vous pouvez utiliser le quantificateur + pour spécifier que le modèle doit inclure une ou plusieurs lignes dans lesquelles le prix de l’action diminue de 10 %, suivies d’une ou plusieurs lignes dans lesquelles le prix de l’action augmente de 5 % :

pattern (decreased_10_percent+ increased_05_percent+)
define
    decreased_10_percent as lag(price) * 0.90 >= price,
    increased_05_percent as lag(price) * 1.05 <= price

Mise en correspondance des modèles par rapport au début ou à la fin d’une partition¶

Pour trouver une séquence de lignes relative au début ou à la fin d’une partition, vous pouvez utiliser les métacaractères ^ et $ dans la sous-clause PATTERN . Ces métacaractères dans un modèle de ligne ont une fonction similaire à celle des mêmes métacaractères dans une expression régulière:

• ^ représente le début d’une partition.

• $ représente la fin d’une partition.

Le modèle suivant correspond à une action dont le prix est supérieur à 75,00 au début de la partition :

PATTERN (^ GT75)
DEFINE
    GT75 AS price > 75.00

Notez que ^ et $ spécifient des positions et ne représentent pas les lignes à ces positions (tout comme ^ et $ dans une expression régulière spécifient la position et non les caractères à ces positions). Dans PATTERN (^ GT75), la première ligne (pas la deuxième) doit avoir un prix supérieur à 75,00. Dans PATTERN (GT75 $), la dernière ligne (et non l’avant-dernière ligne) doit être supérieure à 75.

Voici un exemple complet avec ^. Notez que bien que l’action XYZ ait un prix supérieur à 60,00 dans plus d’une ligne de cette partition, seule la ligne au début de la partition est considérée comme une correspondance.

SELECT *
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #"
           ALL ROWS PER MATCH
           PATTERN (^ GT60)
           DEFINE
               GT60 AS price > 60.00
           )
    ORDER BY "Match #", "Match Sequence #";
+---------+------------+-------+---------+------------------+
| COMPANY | PRICE_DATE | PRICE | Match # | Match Sequence # |
|---------+------------+-------+---------+------------------|
| XYZ     | 2020-10-01 |    89 |       1 |                1 |
+---------+------------+-------+---------+------------------+

Copy

Voici un exemple complet avec $. Notez que bien que l’action ABCD ait un prix supérieur à 50,00 dans plus d’une ligne de cette partition, seule la ligne à la fin de la partition est considérée comme une correspondance.

SELECT *
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #"
           ALL ROWS PER MATCH
           PATTERN (GT50 $)
           DEFINE
               GT50 AS price > 50.00
           )
    ORDER BY "Match #", "Match Sequence #";
+---------+------------+-------+---------+------------------+
| COMPANY | PRICE_DATE | PRICE | Match # | Match Sequence # |
|---------+------------+-------+---------+------------------|
| ABCD    | 2020-10-10 |    63 |       1 |                1 |
+---------+------------+-------+---------+------------------+

Copy

Génération d’une ligne pour chaque correspondance et génération de toutes les lignes pour chaque correspondance¶

Lorsque MATCH_RECOGNIZE trouve une correspondance, la sortie peut être soit une ligne de résumé pour l’ensemble de la correspondance, soit une ligne pour chaque point de données du modèle.

• ALL ROWS PER MATCH spécifie que la sortie inclut toutes les lignes de la correspondance.

• ONE ROW PER MATCH spécifie que la sortie inclut une seule ligne pour chaque correspondance dans chaque partition.

  La clause de projection de l’instruction SELECT ne peut utiliser que la sortie de l’instruction MATCH_RECOGNIZE. En fait, cela signifie que l’instruction SELECT ne peut utiliser que les colonnes des sous-clauses suivantes de MATCH_RECOGNIZE :

  • La sous-clause PARTITION BY .

    Toutes les lignes d’une correspondance proviennent de la même partition, et ont donc la même valeur pour les expressions de la sous-clause PARTITION BY .

  • La clause MEASURES .

    Lorsque vous utilisez MATCH_RECOGNIZE ... ONE ROW PER MATCH , la sous-clause MEASURES génère non seulement des expressions qui renvoient la même valeur pour toutes les lignes de la correspondance (par exemple, MATCH_NUMBER()), mais aussi des expressions qui peuvent renvoyer des valeurs différentes pour différentes lignes de la correspondance (par exemple, MATCH_SEQUENCE_NUMBER()). Si vous utilisez des expressions qui peuvent renvoyer des valeurs différentes pour différentes lignes de la correspondance, la sortie n’est pas déterministe.

  Si vous êtes familier avec les fonctions agrégées et GROUP BY , l’analogie suivante pourrait vous aider à comprendre ONE ROW PER MATCH :

  • La clause PARTITION BY de MATCH_RECOGNIZE regroupe les données de la même manière que GROUP BY regroupe les données dans un SELECT.

  • La clause MEASURES dans MATCH_RECOGNIZE ... ONE ROW PER MATCH autorise les fonctions d’agrégation, telles que COUNT(), qui renvoient la même valeur pour chaque ligne de la correspondance, comme le fait MATCH_NUMBER() .

  Si vous utilisez uniquement des fonctions d’agrégation et des expressions qui renvoient la même valeur pour chaque ligne de la correspondance, alors ... ONE ROW PER MATCH se comporte de la même manière que GROUP BY et les fonctions d’agrégation.

La valeur par défaut est ONE ROW PER MATCH.

Les exemples suivants montrent la différence de sorties entre ONE ROW PER MATCH et ALL ROWS PER MATCH. Ces deux exemples de code sont presque identiques, à l’exception de la clause ...ROW(S) PER MATCH . (Dans un usage typique, une instruction SQL avec ONE ROW PER MATCH a des sous-clauses MEASURES différentes de celles d’une instruction SQL avec ALL ROWS PER MATCH).

SELECT *
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #",
               COUNT(*) AS "Num Rows In Match"
           ALL ROWS PER MATCH
           PATTERN (LESS_THAN_45 UP UP)
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               UP AS price > LAG(price)
           )
    WHERE company = 'ABCD'
    ORDER BY "Match #", "Match Sequence #";
+---------+------------+-------+---------+------------------+-------------------+
| COMPANY | PRICE_DATE | PRICE | Match # | Match Sequence # | Num Rows In Match |
|---------+------------+-------+---------+------------------+-------------------|
| ABCD    | 2020-10-02 |    36 |       1 |                1 |                 1 |
| ABCD    | 2020-10-03 |    39 |       1 |                2 |                 2 |
| ABCD    | 2020-10-04 |    42 |       1 |                3 |                 3 |
| ABCD    | 2020-10-05 |    30 |       2 |                1 |                 1 |
| ABCD    | 2020-10-06 |    47 |       2 |                2 |                 2 |
| ABCD    | 2020-10-07 |    71 |       2 |                3 |                 3 |
+---------+------------+-------+---------+------------------+-------------------+

-- As you can see, the MATCH_SEQUENCE_NUMBER isn't useful when using
-- "ONE ROW PER MATCH". But the COUNT(*), which wasn't very useful in
-- "ALL ROWS PER MATCH", is useful here.
SELECT *
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #",
               COUNT(*) AS "Num Rows In Match"
           ONE ROW PER MATCH
           PATTERN (LESS_THAN_45 UP UP)
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               UP AS price > LAG(price)
           )
    WHERE company = 'ABCD'
    ORDER BY "Match #", "Match Sequence #";
+---------+---------+------------------+-------------------+
| COMPANY | Match # | Match Sequence # | Num Rows In Match |
|---------+---------+------------------+-------------------|
| ABCD    |       1 |                3 |                 3 |
| ABCD    |       2 |                3 |                 3 |
+---------+---------+------------------+-------------------+

Exclusion de lignes de la sortie¶

Pour certaines requêtes, vous pouvez souhaiter n’inclure qu’une partie du modèle dans la sortie. Par exemple, vous pouvez rechercher des modèles dans lesquels les actions ont augmenté plusieurs jours de suite, mais n’afficher que les pics et quelques informations sommaires (par exemple, le nombre de jours de hausse des prix avant chaque pic).

Vous pouvez utiliser une syntaxe d’exclusion dans le modèle pour indiquer à MATCH_RECOGNIZE de rechercher une variable particulière du modèle mais de ne pas l’inclure dans la sortie. Pour inclure une variable de modèle dans le modèle à rechercher, mais pas dans la sortie, utilisez la notation {- <variable_de_modèle> -} .

Voici un exemple simple qui montre la différence entre l’utilisation de la syntaxe d’exclusion et sa non-utilisation. Cet exemple contient deux requêtes, chacune recherchant un prix d’action qui a commencé à moins de 45 $, puis qui a diminué, puis qui a augmenté. La première requête n’utilise pas la syntaxe d’exclusion, et montre donc toutes les lignes. La deuxième requête utilise la syntaxe d’exclusion et ne montre pas le jour où le prix de l’action a baissé.

SELECT company, price_date, price
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           ALL ROWS PER MATCH
           PATTERN (LESS_THAN_45 DECREASED_10_PERCENT INCREASED_05_PERCENT)
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               DECREASED_10_PERCENT AS LAG(price) * 0.90 >= price,
               INCREASED_05_PERCENT AS LAG(price) * 1.05 <= price
           )
    ORDER BY price_date;
+---------+------------+-------+
| COMPANY | PRICE_DATE | PRICE |
|---------+------------+-------|
| ABCD    | 2020-10-04 |    42 |
| ABCD    | 2020-10-05 |    30 |
| ABCD    | 2020-10-06 |    47 |
+---------+------------+-------+

Copy

SELECT company, price_date, price
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           ALL ROWS PER MATCH
           PATTERN (LESS_THAN_45 {- DECREASED_10_PERCENT -} INCREASED_05_PERCENT)
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               DECREASED_10_PERCENT AS LAG(price) * 0.90 >= price,
               INCREASED_05_PERCENT AS LAG(price) * 1.05 <= price
           )
    ORDER BY price_date;
+---------+------------+-------+
| COMPANY | PRICE_DATE | PRICE |
|---------+------------+-------|
| ABCD    | 2020-10-04 |    42 |
| ABCD    | 2020-10-06 |    47 |
+---------+------------+-------+

Copy

L’exemple suivant est plus réaliste. Il recherche les modèles dans lesquels le cours d’une action a augmenté un ou plusieurs jours de suite, puis a baissé un ou plusieurs jours de suite. Comme la sortie peut être très importante, on utilise l’exclusion pour ne montrer que le premier jour de hausse de l’action (si elle a augmenté plus d’un jour de suite) et que le premier jour de baisse (si elle a baissé plus d’un jour de suite). Le modèle est présenté ci-dessous :

PATTERN(LESS_THAN_45 UP {- UP* -} DOWN {- DOWN* -})

Ce modèle recherche les événements suivants dans l’ordre :

• Un prix de départ inférieur à 45.

• Une augmentation (UP) , éventuellement suivie immédiatement par d’autres qui ne sont pas incluses dans la sortie.

• Une diminution (DOWN), éventuellement suivie immédiatement par d’autres qui ne sont pas incluses dans la sortie.

Voici le code et la sortie pour les versions du modèle précédent sans exclusion et avec exclusion :

SELECT company, price_date, price
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           ALL ROWS PER MATCH
           PATTERN ( LESS_THAN_45 UP UP* DOWN DOWN* )
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               UP   AS price > LAG(price),
               DOWN AS price < LAG(price)
           )
    WHERE company = 'XYZ'
    ORDER BY price_date;
+---------+------------+-------+
| COMPANY | PRICE_DATE | PRICE |
|---------+------------+-------|
| XYZ     | 2020-10-02 |    24 |
| XYZ     | 2020-10-03 |    37 |
| XYZ     | 2020-10-04 |    63 |
| XYZ     | 2020-10-05 |    65 |
| XYZ     | 2020-10-06 |    56 |
| XYZ     | 2020-10-07 |    50 |
+---------+------------+-------+

Copy

SELECT company, price_date, price
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           ALL ROWS PER MATCH
           PATTERN ( {- LESS_THAN_45 -}  UP  {- UP* -}  DOWN  {- DOWN* -} )
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               UP   AS price > LAG(price),
               DOWN AS price < LAG(price)
           )
    WHERE company = 'XYZ'
    ORDER BY price_date;
+---------+------------+-------+
| COMPANY | PRICE_DATE | PRICE |
|---------+------------+-------|
| XYZ     | 2020-10-03 |    37 |
+---------+------------+-------+

Copy

Informations de base sur les correspondances¶

Dans de nombreux cas, vous souhaitez que votre requête affiche non seulement les informations de la table qui contient les données, mais aussi les informations sur les modèles qui ont été trouvés. Lorsque vous voulez des informations sur les correspondances elles-mêmes, vous les spécifiez dans la clause MEASURES .

La clause MEASURES peut inclure les fonctions suivantes, qui sont spécifiques à MATCH_RECOGNIZE :

• MATCH_NUMBER() : chaque fois qu’une correspondance est trouvée, on lui attribue un numéro de correspondance séquentiel, en commençant par un. Cette fonction renvoie ce numéro de correspondance.

• MATCH_SEQUENCE_NUMBER() : parce qu’un modèle implique généralement plus d’un point de données, vous pourriez vouloir savoir quel point de données est associé à chaque valeur de la table. Cette fonction renvoie le numéro séquentiel du point de données dans la correspondance.

• CLASSIFIER() : le classificateur est le nom de la variable de modèle à laquelle la ligne correspond.

La requête ci-dessous comprend une clause MEASURES avec le numéro de correspondance, le numéro de séquence de correspondance et le classificateur.

SELECT company, price_date, price,
       "Match #", "Match Sequence #", "Symbol Matched"
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #",
               CLASSIFIER AS "Symbol Matched"
           ALL ROWS PER MATCH
           PATTERN (LESS_THAN_45 DECREASED_10_PERCENT INCREASED_05_PERCENT)
           DEFINE
               LESS_THAN_45 AS price < 45.00,
               DECREASED_10_PERCENT AS LAG(price) * 0.90 >= price,
               INCREASED_05_PERCENT AS LAG(price) * 1.05 <= price
           )
    ORDER BY company, "Match #", "Match Sequence #";
+---------+------------+-------+---------+------------------+----------------------+
| COMPANY | PRICE_DATE | PRICE | Match # | Match Sequence # | Symbol Matched       |
|---------+------------+-------+---------+------------------+----------------------|
| ABCD    | 2020-10-04 |    42 |       1 |                1 | LESS_THAN_45         |
| ABCD    | 2020-10-05 |    30 |       1 |                2 | DECREASED_10_PERCENT |
| ABCD    | 2020-10-06 |    47 |       1 |                3 | INCREASED_05_PERCENT |
+---------+------------+-------+---------+------------------+----------------------+

Copy

La sous-clause MEASURES peut produire beaucoup plus d’informations que cela. Pour plus de détails, voir la documentation de référence MATCH_RECOGNIZE.

Fenêtres, cadres de fenêtre et fonctions de navigation¶

La clause MATCH_RECOGNIZE opère sur une « fenêtre » de lignes. Si MATCH_RECOGNIZE contient une sous-clause PARTITION , alors chaque partition est une fenêtre. S’il n’y a pas de sous-clause PARTITION , alors l’entrée entière est une fenêtre.

La sous-clause PATTERN de MATCH_RECOGNIZE spécifie les symboles dans l’ordre de gauche à droite. Par exemple :

PATTERN (START DOWN UP)

Si vous vous représentez les données comme une séquence de lignes en ordre croissant de gauche à droite, vous pouvez considérer que MATCH_RECOGNIZE se déplace vers la droite (par exemple, de la date la plus ancienne à la date la plus récente dans l’exemple du cours de l’action), en recherchant un modèle dans les lignes à l’intérieur de chaque fenêtre.

MATCH_RECOGNIZE commence par la première ligne de la fenêtre et vérifie si cette ligne et les lignes suivantes correspondent au modèle.

Dans le cas le plus simple, après avoir déterminé s’il y a une correspondance de modèle à partir de la première ligne de la fenêtre, MATCH_RECOGNIZE se déplace d’une ligne vers la droite et répète le processus, en vérifiant si la 2e ligne est le début d’une occurrence du modèle. MATCH_RECOGNIZE continue à se déplacer vers la droite jusqu’à atteindre la fin de la fenêtre.

(MATCH_RECOGNIZE peut se déplacer vers la droite de plus d’une ligne. Par exemple, vous pouvez dire à MATCH_RECOGNIZE de commencer à rechercher le modèle suivant après la fin du modèle actuel).

Vous pouvez vous représenter cela comme s’il y avait un « cadre » se déplaçant vers la droite à l’intérieur de la fenêtre. Le bord gauche de ce cadre se trouve à la première ligne de l’ensemble des lignes pour lequel une correspondance est en cours de vérification. Le bord droit du cadre n’est pas défini tant qu’une correspondance n’est pas trouvée ; une fois qu’une correspondance est trouvée, le bord droit du cadre est la dernière ligne de la correspondance. Par exemple, si le modèle de recherche est pattern (start down up), la ligne qui correspond à up est la dernière ligne avant le bord droit du cadre.

(Si aucune correspondance n’est trouvée, alors le bord droit du cadre n’est jamais défini et n’est jamais référencé).

Dans les cas simples, vous pouvez imaginer un cadre de fenêtre coulissant comme illustré ci-dessous :

Vous avez déjà vu les fonctions de navigation telles que LAG() utilisées dans des expressions de la sous-clause DEFINE (par exemple DEFINE down_10_percent as LAG(price) * 0.9 >= price). La requête suivante montre que les fonctions de navigation peuvent également être utilisées dans la sous-clause MEASURES . Dans cet exemple, les fonctions de navigation indiquent les bords (et donc la taille) du cadre de la fenêtre qui contient la correspondance actuelle.

Chaque ligne de sortie de cette requête comprend les valeurs des fonctions de navigation LAG(), LEAD(), FIRST() et LAST() pour cette ligne. La taille du cadre de la fenêtre est le nombre de lignes entre FIRST() et LAST(), y compris la première et la dernière ligne elles-mêmes.

Les clauses DEFINE et PATTERN de la requête ci-dessous sélectionnent des groupes de trois lignes (1-3 octobre, 2-4 octobre, 3-5 octobre, etc.)

SELECT company, price_date,
       "First(price_date)", "Lag(price_date)", "Lead(price_date)", "Last(price_date)",
       "Match#", "MatchSeq#", "Classifier"
    FROM stock_price_history
        MATCH_RECOGNIZE (
            PARTITION BY company
            ORDER BY price_date
            MEASURES
                -- Show the "edges" of the "window frame".
                FIRST(price_date) AS "First(price_date)",
                LAG(price_date) AS "Lag(price_date)",
                LEAD(price_date) AS "Lead(price_date)",
                LAST(price_date) AS "Last(price_date)",
                MATCH_NUMBER() AS "Match#",
                MATCH_SEQUENCE_NUMBER() AS "MatchSeq#",
                CLASSIFIER AS "Classifier"
            ALL ROWS PER MATCH
            AFTER MATCH SKIP TO NEXT ROW
            PATTERN (CURRENT_ROW T2 T3)
            DEFINE
                CURRENT_ROW AS TRUE,
                T2 AS TRUE,
                T3 AS TRUE
            )
    ORDER BY company, "Match#", "MatchSeq#"
    ;
+---------+------------+-------------------+-----------------+------------------+------------------+--------+-----------+-------------+
| COMPANY | PRICE_DATE | First(price_date) | Lag(price_date) | Lead(price_date) | Last(price_date) | Match# | MatchSeq# | Classifier  |
|---------+------------+-------------------+-----------------+------------------+------------------+--------+-----------+-------------|
| ABCD    | 2020-10-01 | 2020-10-01        | NULL            | 2020-10-02       | 2020-10-01       |      1 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-02 | 2020-10-01        | 2020-10-01      | 2020-10-03       | 2020-10-02       |      1 |         2 | T2          |
| ABCD    | 2020-10-03 | 2020-10-01        | 2020-10-02      | NULL             | 2020-10-03       |      1 |         3 | T3          |
| ABCD    | 2020-10-02 | 2020-10-02        | NULL            | 2020-10-03       | 2020-10-02       |      2 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-03 | 2020-10-02        | 2020-10-02      | 2020-10-04       | 2020-10-03       |      2 |         2 | T2          |
| ABCD    | 2020-10-04 | 2020-10-02        | 2020-10-03      | NULL             | 2020-10-04       |      2 |         3 | T3          |
| ABCD    | 2020-10-03 | 2020-10-03        | NULL            | 2020-10-04       | 2020-10-03       |      3 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-04 | 2020-10-03        | 2020-10-03      | 2020-10-05       | 2020-10-04       |      3 |         2 | T2          |
| ABCD    | 2020-10-05 | 2020-10-03        | 2020-10-04      | NULL             | 2020-10-05       |      3 |         3 | T3          |
| ABCD    | 2020-10-04 | 2020-10-04        | NULL            | 2020-10-05       | 2020-10-04       |      4 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-05 | 2020-10-04        | 2020-10-04      | 2020-10-06       | 2020-10-05       |      4 |         2 | T2          |
| ABCD    | 2020-10-06 | 2020-10-04        | 2020-10-05      | NULL             | 2020-10-06       |      4 |         3 | T3          |
| ABCD    | 2020-10-05 | 2020-10-05        | NULL            | 2020-10-06       | 2020-10-05       |      5 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-06 | 2020-10-05        | 2020-10-05      | 2020-10-07       | 2020-10-06       |      5 |         2 | T2          |
| ABCD    | 2020-10-07 | 2020-10-05        | 2020-10-06      | NULL             | 2020-10-07       |      5 |         3 | T3          |
| ABCD    | 2020-10-06 | 2020-10-06        | NULL            | 2020-10-07       | 2020-10-06       |      6 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-07 | 2020-10-06        | 2020-10-06      | 2020-10-08       | 2020-10-07       |      6 |         2 | T2          |
| ABCD    | 2020-10-08 | 2020-10-06        | 2020-10-07      | NULL             | 2020-10-08       |      6 |         3 | T3          |
| ABCD    | 2020-10-07 | 2020-10-07        | NULL            | 2020-10-08       | 2020-10-07       |      7 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-08 | 2020-10-07        | 2020-10-07      | 2020-10-09       | 2020-10-08       |      7 |         2 | T2          |
| ABCD    | 2020-10-09 | 2020-10-07        | 2020-10-08      | NULL             | 2020-10-09       |      7 |         3 | T3          |
| ABCD    | 2020-10-08 | 2020-10-08        | NULL            | 2020-10-09       | 2020-10-08       |      8 |         1 | CURRENT_ROW |
| ABCD    | 2020-10-09 | 2020-10-08        | 2020-10-08      | 2020-10-10       | 2020-10-09       |      8 |         2 | T2          |
| ABCD    | 2020-10-10 | 2020-10-08        | 2020-10-09      | NULL             | 2020-10-10       |      8 |         3 | T3          |
| XYZ     | 2020-10-01 | 2020-10-01        | NULL            | 2020-10-02       | 2020-10-01       |      1 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-02 | 2020-10-01        | 2020-10-01      | 2020-10-03       | 2020-10-02       |      1 |         2 | T2          |
| XYZ     | 2020-10-03 | 2020-10-01        | 2020-10-02      | NULL             | 2020-10-03       |      1 |         3 | T3          |
| XYZ     | 2020-10-02 | 2020-10-02        | NULL            | 2020-10-03       | 2020-10-02       |      2 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-03 | 2020-10-02        | 2020-10-02      | 2020-10-04       | 2020-10-03       |      2 |         2 | T2          |
| XYZ     | 2020-10-04 | 2020-10-02        | 2020-10-03      | NULL             | 2020-10-04       |      2 |         3 | T3          |
| XYZ     | 2020-10-03 | 2020-10-03        | NULL            | 2020-10-04       | 2020-10-03       |      3 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-04 | 2020-10-03        | 2020-10-03      | 2020-10-05       | 2020-10-04       |      3 |         2 | T2          |
| XYZ     | 2020-10-05 | 2020-10-03        | 2020-10-04      | NULL             | 2020-10-05       |      3 |         3 | T3          |
| XYZ     | 2020-10-04 | 2020-10-04        | NULL            | 2020-10-05       | 2020-10-04       |      4 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-05 | 2020-10-04        | 2020-10-04      | 2020-10-06       | 2020-10-05       |      4 |         2 | T2          |
| XYZ     | 2020-10-06 | 2020-10-04        | 2020-10-05      | NULL             | 2020-10-06       |      4 |         3 | T3          |
| XYZ     | 2020-10-05 | 2020-10-05        | NULL            | 2020-10-06       | 2020-10-05       |      5 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-06 | 2020-10-05        | 2020-10-05      | 2020-10-07       | 2020-10-06       |      5 |         2 | T2          |
| XYZ     | 2020-10-07 | 2020-10-05        | 2020-10-06      | NULL             | 2020-10-07       |      5 |         3 | T3          |
| XYZ     | 2020-10-06 | 2020-10-06        | NULL            | 2020-10-07       | 2020-10-06       |      6 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-07 | 2020-10-06        | 2020-10-06      | 2020-10-08       | 2020-10-07       |      6 |         2 | T2          |
| XYZ     | 2020-10-08 | 2020-10-06        | 2020-10-07      | NULL             | 2020-10-08       |      6 |         3 | T3          |
| XYZ     | 2020-10-07 | 2020-10-07        | NULL            | 2020-10-08       | 2020-10-07       |      7 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-08 | 2020-10-07        | 2020-10-07      | 2020-10-09       | 2020-10-08       |      7 |         2 | T2          |
| XYZ     | 2020-10-09 | 2020-10-07        | 2020-10-08      | NULL             | 2020-10-09       |      7 |         3 | T3          |
| XYZ     | 2020-10-08 | 2020-10-08        | NULL            | 2020-10-09       | 2020-10-08       |      8 |         1 | CURRENT_ROW |
| XYZ     | 2020-10-09 | 2020-10-08        | 2020-10-08      | 2020-10-10       | 2020-10-09       |      8 |         2 | T2          |
| XYZ     | 2020-10-10 | 2020-10-08        | 2020-10-09      | NULL             | 2020-10-10       |      8 |         3 | T3          |
+---------+------------+-------------------+-----------------+------------------+------------------+--------+-----------+-------------+

La sortie de cette requête montre également que les fonctions LAG() et LEAD() renvoient NULL pour les expressions qui tentent de référencer des lignes en dehors du groupe de correspondance (c’est-à-dire en dehors du cadre de la fenêtre).

Les règles relatives aux fonctions de navigation dans les clauses DEFINE sont légèrement différentes des règles relatives aux fonctions de navigation dans les clauses MEASURES . Par exemple, la fonction PREV() est disponible dans la clause MEASURES mais ne l’est pas actuellement dans la clause DEFINE. Au lieu de cela, vous pouvez utiliser LAG() dans la clause DEFINE. La documentation de référence pour MATCH_RECOGNIZE affiche la règle correspondante pour chaque fonction de navigation.

La sous-clause MEASURES peut également inclure les éléments suivants :

• Fonctions d’agrégation. Par exemple, si le modèle peut correspondre à un nombre variable de lignes (par exemple, parce qu’il correspond à 1 ou à un plus grand nombre de cours boursiers en baisse), vous voudrez peut-être connaître le nombre total de lignes dans la correspondance ; vous pouvez afficher cette information en utilisant COUNT(*).

• Expressions générales qui opèrent sur les valeurs de chaque ligne de la correspondance. Il peut s’agir d’expressions mathématiques, d’expressions logiques, etc. Par exemple, vous pouvez examiner les valeurs de la ligne et imprimer des descripteurs de texte tels que « ABOVE AVERAGE ».

  N’oubliez pas que si vous regroupez des lignes (ONE ROW PER MATCH), et si une colonne a des valeurs différentes pour différentes lignes du groupe, la valeur sélectionnée pour cette colonne pour cette correspondance est non déterministe, et les expressions basées sur cette valeur sont également susceptibles d’être non déterministes.

Pour plus d’informations sur la sous-clause MEASURES , voir la documentation de référence pour MATCH_RECOGNIZE.

Corrélation et causalité¶

La corrélation ne garantit pas la causalité. MATCH_RECOGNIZE peut renvoyer des « faux positifs » (cas où vous voyez un modèle, mais il s’agit juste d’une coïncidence).

La mise en correspondance de modèles peut également donner lieu à des « faux négatifs » (cas où il existe un modèle dans le monde réel, mais où ce modèle n’apparaît pas dans l’échantillon de données).

Dans la plupart des cas, trouver une correspondance (par exemple, trouver un modèle qui suggère une fraude à l’assurance) n’est que la première étape d’une analyse.

Les facteurs suivants augmentent généralement le nombre de faux positifs :

• De grands ensembles de données.

• Recherche d’un grand nombre de modèles.

• Recherche de modèles courts ou simples.

Les facteurs suivants augmentent généralement le nombre de faux négatifs.

• Petits ensembles de données.

• Ne pas rechercher tous les modèles pertinents possibles.

• Une recherche de modèles plus complexes que nécessaire.

Modèles insensibles à l’ordre¶

Bien que la plupart des correspondances de modèles exigent que les données soient dans l’ordre (par exemple, classées par heure), il existe des exceptions. Par exemple, si une personne commet une fraude à l’assurance à la fois lors d’un accident de voiture et lors d’un cambriolage, l’ordre dans lequel les fraudes se produisent importe peu.

Si le modèle que vous recherchez n’est pas sensible à l’ordre, vous pouvez utiliser des opérateurs tels que « alternative » (|) et PERMUTE pour rendre vos recherches moins sensibles à l’ordre.

Trouver des augmentations de prix sur plusieurs jours¶

La requête suivante trouve tous les modèles dans lesquels le prix de la société ABCD a augmenté deux jours de suite :

SELECT *
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #"
           ALL ROWS PER MATCH
           PATTERN (MINIMUM_37 UP UP)
           DEFINE
               MINIMUM_37 AS price >= 37.00,
               UP AS price > LAG(price)
           )
    ORDER BY company, "Match #", "Match Sequence #";
+---------+------------+-------+---------+------------------+
| COMPANY | PRICE_DATE | PRICE | Match # | Match Sequence # |
|---------+------------+-------+---------+------------------|
| ABCD    | 2020-10-06 |    47 |       1 |                1 |
| ABCD    | 2020-10-07 |    71 |       1 |                2 |
| ABCD    | 2020-10-08 |    80 |       1 |                3 |
| XYZ     | 2020-10-03 |    37 |       1 |                1 |
| XYZ     | 2020-10-04 |    63 |       1 |                2 |
| XYZ     | 2020-10-05 |    65 |       1 |                3 |
+---------+------------+-------+---------+------------------+

Copy

Démontrer l’option SKIP TO NEXT ROW¶

Cet exemple illustre l’option SKIP TO NEXT ROW . Cette requête recherche les courbes en W dans le graphique de chaque entreprise. Les correspondances peuvent se chevaucher.

select * from stock_price_history match_recognize(
    partition by company
    order by price_date
    measures
        match_number() as "MATCH_NUMBER",
        first(price_date) as "START",
        last(price_date) as "END",
        count(*) as "PRICE_COUNT"
    after match skip to next row
    pattern(ANY_ROW DOWN+ UP+ DOWN+ UP+)
    define
        ANY_ROW AS TRUE,
        UP as price > lag(price),
        DOWN as price < lag(price)
)
order by company, match_number;
+---------+--------------+------------+------------+-------------+
| COMPANY | MATCH_NUMBER | START      | END        | PRICE_COUNT |
|---------+--------------+------------+------------+-------------|
| ABCD    |            1 | 2020-10-01 | 2020-10-08 |           8 |
| XYZ     |            1 | 2020-10-01 | 2020-10-08 |           8 |
| XYZ     |            2 | 2020-10-05 | 2020-10-10 |           6 |
| XYZ     |            3 | 2020-10-06 | 2020-10-10 |           5 |
+---------+--------------+------------+------------+-------------+

Copy

Recherche de modèles dans des lignes non adjacentes¶

Dans certaines situations, vous pouvez rechercher des modèles dans des lignes non contiguës. Par exemple, si vous analysez des fichiers journaux, vous pouvez rechercher tous les modèles dans lesquels une erreur fatale a été précédée d’une séquence particulière d’avertissements. Il se peut qu’il n’existe pas de moyen naturel de partitionner et de trier les lignes de manière à ce que tous les messages pertinents (lignes) se trouvent dans une seule fenêtre et soient adjacents. Dans cette situation, vous pouvez avoir besoin d’un modèle qui recherche des événements particuliers, mais qui n’exige pas que les événements soient contigus dans les données.

Vous trouverez ci-dessous un exemple de clauses DEFINE et PATTERN qui reconnaissent des lignes contiguës ou non contiguës correspondant au modèle. Le symbole ANY_ROW est défini comme TRUE (il correspond donc à n’importe quelle ligne). Le * après chaque occurrence de ANY_ROW indique d’autoriser 0 ou plus d’occurrences de ANY_ROW entre le premier avertissement et le deuxième avertissement, et entre le deuxième avertissement et le message d’erreur fatale. Ainsi, le modèle complet indique qu’il faut rechercher WARNING1, suivi d’un nombre quelconque de lignes, puis de WARNING2, suivi d’un nombre quelconque de lignes, puis de FATAL_ERROR. Pour omettre les lignes non pertinentes de la sortie, la requête utilise la syntaxe exclusion ({- et -}).

MATCH_RECOGNIZE (
    ...
    ORDER BY log_message_timestamp
    ...
    ALL ROWS PER MATCH
    PATTERN ( WARNING1  {- ANY_ROW* -}  WARNING2  {- ANY_ROW* -}  FATAL_ERROR )
    DEFINE
        ANY_ROW AS TRUE,
        WARNING1 AS SUBSTR(log_message, 1, 42) = 'WARNING: Available memory is less than 10%',
        WARNING2 AS SUBSTR(log_message, 1, 41) = 'WARNING: Available memory is less than 5%',
        FATAL_ERROR AS SUBSTR(log_message, 1, 11) = 'FATAL ERROR'
    )
...

Erreurs lors de l’utilisation de ONE ROW PER MATCH et de la spécification de colonnes dans la clause de sélection¶

La clause ONE ROW PER MATCH agit de la même manière qu’une fonction d’agrégation. Cela limite les colonnes de sortie que vous pouvez utiliser. Par exemple, si vous utilisez ONE ROW PER MATCH et que chaque correspondance contient trois lignes avec des dates différentes, vous ne pouvez pas spécifier la colonne date comme colonne de sortie dans la clause SELECT car aucune date n’est correcte pour les trois lignes.

Résultats inattendus¶

• Vérifiez les erreurs typographiques dans les clauses PATTERN et DEFINE .

  Si le nom d’une variable de modèle utilisée dans la clause PATTERN n’est pas défini dans la clause DEFINE (par exemple parce que le nom est mal saisi dans la clause PATTERN ou DEFINE), aucune erreur n’est signalée. Au lieu de cela, le nom de la variable de modèle est simplement supposé être vrai pour chaque ligne.

• Examinez la clause SKIP pour vous assurer qu’elle est appropriée, par exemple pour inclure ou exclure les modèles qui se chevauchent.