Tous les produits
Search
Centre de documentation

Hologres:Path analysis functions

Dernière mise à jour :Aug 11, 2026

Hologres propose un ensemble de fonctions d'analyse de parcours, notamment des fonctions de détail de parcours et des fonctions d'analyse de parcours. Ces fonctions traitent efficacement les tâches de calcul de parcours, déterminent les détails des parcours et analysent les résultats. Utilisez les données enregistrées pour générer un diagramme de Sankey afin de comprendre et visualiser des informations de parcours complexes. Cette rubrique décrit l'utilisation des fonctions de détail de parcours et d'analyse de parcours.

Contexte

L'analyse de parcours enregistre la distribution des parcours utilisateurs et la séquence des actions au sein de chaque session lorsque les utilisateurs interagissent avec votre produit ou fonctionnalité. Elle génère un diagramme de Sankey intuitif illustrant le comportement des utilisateurs. Le diagramme de Sankey affiche chaque nœud clé du flux utilisateur ainsi que le trafic entre ces nœuds, permettant une analyse métier granulaire. L'analyse de parcours vous permet de comprendre clairement l'engagement des utilisateurs envers chaque fonctionnalité clé de votre produit. Vos équipes opérationnelles et produit peuvent ainsi optimiser les stratégies commerciales et faire évoluer le produit, stimulant ainsi la croissance de l'activité. Hologres prend en charge une fonction de détail de parcours pour le calcul détaillé des parcours et une fonction d'analyse de parcours pour l'analyse des résultats. La sortie peut servir directement à créer un diagramme de Sankey.

Le haut de l'interface du diagramme de Sankey d'analyse de parcours contient un sélecteur de fuseau horaire, un sélecteur de plage de temps, des paramètres pour le nombre maximal de nœuds par couche et un bouton Export. Le diagramme de Sankey commence par un événement initial (tel que $AppStart) et affiche progressivement les actions utilisateur suivantes (comme $AppEnd, AppPageview, Search, CheckIn et AllPayments). Chaque nœud indique le nom de l'événement et son nombre de déclenchements, tandis que la largeur du flux entre les nœuds reflète le volume de trafic.

Remarques sur l'utilisation

  • Les fonctions d'analyse de parcours sont disponibles dans Hologres V2.2 et versions ultérieures. Si votre instance est en version V2.1 ou antérieure, contactez le support technique Hologres pour mettre à niveau votre instance.

  • Pour utiliser les fonctions d'analyse de parcours, créez une extension. Par défaut, l'extension est chargée dans le schéma public et ne peut pas être chargée dans d'autres schémas.

     --Create the extension.
    CREATE extension flow_analysis;
    Remarque

    Une extension est définie au niveau de la base de données et ne doit être créée qu'une seule fois par base de données.

Fonctions de détail de parcours

Fonction de détail de parcours (path_analysis_detail)

La fonction path_analysis_detail analyse les données d'événements spécifiées et les présente sous forme d'une structure de parcours détaillée. La sortie est un tableau sérialisé contenant des informations complètes, y compris la séquence complète du parcours, les relations parent-enfant entre les nœuds du parcours et la durée de chaque étape.

  • Syntaxe

    path_analysis_detail(
      event, 
    	event_time, 
    	start_event, 
    	session_interval_sec, 
    	path_depth, 
    	path_offset, 
    	is_reverse,
    split_session_by_event)
  • Paramètres

    Parameter

    Type

    Description

    event

    text (data)

    Événement à analyser.

    event_time

    timestamp, timestamptz, bigint (data)

    Horodatage de chaque événement.

    start_event

    text (literal)

    Événement de début ou de fin spécifié.

    session_interval_sec

    bigint (literal)

    Intervalle de session en secondes (s).

    Si le temps entre deux événements adjacents dans une session dépasse l'intervalle de session spécifié, le système divise la session en deux. Par exemple, si vous définissez l'intervalle sur 30 s et que le temps entre deux événements est supérieur à 30 s, les événements sont considérés comme faisant partie de deux sessions différentes.

    path_depth

    bigint (literal)

    Nombre d'événements à récupérer dans la séquence, à partir de l'événement de début ou de fin spécifié.

    path_offset

    bigint (literal)

    Décalage de l'événement par rapport à l'événement de début ou de fin. Une valeur de 0 signifie qu'il n'y a pas de décalage.

    Par exemple, pour une série d'événements a, b et c, si a est l'événement de début et que le décalage est de 1, la correspondance commence à partir de l'événement b.

    is_reverse

    bool (literal)

    Ordre de sortie de la série d'événements. Valeurs possibles :

    • false : Spécifie un événement de début. La série d'événements est renvoyée dans l'ordre chronologique.

    • true : Spécifie un événement de fin. La série d'événements est renvoyée dans l'ordre chronologique inverse.

    split_session_by_event

    bool (literal)

    Méthode de division des sessions. Valeurs possibles :

    • true : Une nouvelle session démarre chaque fois que l'événement de début ou de fin spécifié est rencontré dans la série d'événements.

    • false (par défaut) : Les sessions sont divisées uniquement en fonction de la valeur du paramètre session_interval_sec.

      Remarque

      Si session_interval_sec est défini sur -1, les sessions sont divisées par événement plutôt que par temps.

    Par exemple, si un parcours tel que abcabc...abc est répété 10 fois au sein de la même session, le mécanisme de correspondance de la fonction n'enregistre qu'une seule conversion. Pour traiter chaque répétition du parcours comme une nouvelle session et calculer chaque conversion indépendamment, définissez ce paramètre sur true. Cela permet d'enregistrer et de compter séparément chaque nouvelle opération.

  • Valeur de retour

    path_analysis_detail : Renvoie une valeur du type de données text. Exemple : {"",\x01a\x01b<,\x01b\x01c<,""}.

    Remarque

    Pour lire le résultat, utilisez une fonction d'analyse de parcours correspondante.

**Fonction pad_funnel**

La fonction pad_funnel récupère les informations de sous-parcours pour une combinaison spécifique d'événements.

  • Syntaxe

    pad_funnel(path_analysis_detail(), target_path)
  • Paramètres

    |
    **Parameter**
    |
    **Type**
    |
    **Description**
    | | --- | --- | --- | |
    path_analysis_detail()
    |
    text (data)
    |
    Résultat renvoyé par la fonction `path_analysis_detail`.
    | |
    target_path
    |
    text (literal)
    |
    Série d'événements spécifiée.
    |

















  • Valeur de retour

    pad_funnel : Renvoie une valeur text. Exemple : text []{"",\x01a\x01b<,\x01b\x01c<,""}.

    Remarque

    Pour lire le résultat, utilisez une fonction d'analyse de parcours correspondante.

Fonctions d'analyse de parcours

Fonction pad_full_path

La fonction pad_full_path analyse le résultat de path_analysis_detail en chemins parents, sous-chemins et durée de chaque étape.

  • Syntaxe

    pad_full_path(path_analysis_detail())
  • Paramètres

    path_analysis_detail() : Résultat renvoyé par la fonction path_analysis_detail.

  • Valeur de retour

    • La fonction pad_full_path renvoie le contenu suivant.

      pad_sub_path_left(unnested_pad_result)
      pad_sub_path_right(unnested_pad_result)
      pad_sub_index_left(unnested_pad_result)
      pad_sub_index_right(unnested_pad_result)
      pad_sub_cost(unnested_pad_result)
      pad_sub_session(unnested_pad_result)
    • Le tableau suivant décrit les paramètres de retour.

      |
      **Function**
      |
      **Type**
      |
      **Description**
      | | --- | --- | --- | |
      pad_sub_path_left
      |
      text
      |
      Événement de début du sous-chemin.
      | |
      pad_sub_path_right
      |
      text
      |
      Événement de fin du sous-chemin.
      | |
      pad_sub_index_left
      |
      bigint
      |
      Index de l'événement de début du sous-chemin dans le chemin complet de la session.
      | |
      pad_sub_index_right
      |
      bigint
      |
      Index de l'événement de fin du sous-chemin dans le chemin complet de la session.
      | |
      pad_sub_cost
      |
      bigint
      |
      Durée de transition pour le sous-chemin, en secondes (s).
      | |
      pad_sub_session
      |
      bigint
      |
      Index de la session valide à laquelle appartient le sous-chemin.
      |









































Fonction pad_session_path_array

La fonction pad_session_path_array extrait la série d'événements pour un ID de session spécifié sous forme de tableau.

  • Syntaxe

    pad_session_path_array(path_analysis_detail(), session_idx)
  • Paramètres

    • path_analysis_detail() : Résultat renvoyé par la fonction path_analysis_detail.

    • session_idx : Index de session spécifié.

  • Valeur de retour

    Renvoie des données de type tableau.

Exemples

Préparation des données

--Create the extension if it does not already exist.
CREATE extension flow_analysis;
--Prepare the data.
CREATE TABLE path_demo( 
    uid text,
    event text,
    event_time timestamptz
);
INSERT INTO path_demo VALUES
('1','Register','2023-11-24 16:01:23+08'),
('1','Log on','2023-11-24 16:02:10+08'),
('1','Browse','2023-11-24 16:02:15+08'),
('1','View live streams','2023-11-24 16:03:10+08'),
('1','Browse','2023-11-24 16:03:15+08'),
('1','Add to favorites','2023-11-24 16:04:20+08'),
('1','Browse','2023-11-24 16:07:21+08'),
('1','Purchase','2023-11-24 16:08:23+08'),
('1','Exit','2023-11-24 16:09:05+08'),
('2','Log on','2023-11-24 16:10:23+08'),
('2','Purchase','2023-11-24 16:12:23+08'),
('3','Log on','2023-11-24 16:02:23+08'),
('3','Browse','2023-11-24 16:02:23+08'),
('3','Add to favorites','2023-11-24 16:03:53+08'),
('3','View live streams','2023-11-24 16:04:53+08'),
('4','Log on','2023-11-24 16:02:23+08'),
('4','Browse','2023-11-24 16:03:53+08'),
('4','Purchase','2023-11-24 16:04:23+08'),
('4','View live streams','2023-11-24 16:05:53+08'),
('4','Cancel the order','2023-11-24 16:06:53+08');

Exemple 1 : Enregistrement de tous les chemins d'événements

  • Division des sessions par temps.

    --Split by time: Specify 'Log on' as the start event, set the session interval to 180 s, and set the matching sequence length to 7. Then, use the pad_full_path function to decode the results.
    SELECT uid, pad_full_path(path_analysis_detail(event, event_time, 'Log on', 180, 7, 0, false)) AS ret FROM path_demo GROUP BY uid;

    Le résultat suivant est renvoyé.

     uid |                        ret
    -----+---------------------------------------------------
     3   | {Log on->Add to favorites->View live streams}
     4   | {Log on->Browse->Purchase->View live streams->Cancel the order}
     1   | {Log on->Browse->View live streams->Browse->Add to favorites}
     2   | {Log on->Purchase}
    (4 rows)
  • Division des sessions par temps et par événement.

    --Split by time and event: Specify 'Browse' as the start event, set the interval to 180 s, and set the sequence length to 7. Then, use the pad_full_path function to decode the results.
    SELECT uid, pad_full_path(path_analysis_detail(event, event_time, 'Browse', 180, 7, 0, false,TRUE)) AS ret FROM path_demo GROUP BY uid;

    Le résultat suivant est renvoyé.

     uid |                            ret
    -----+-----------------------------------------------------------
     1   | {Browse->View live streams,Browse->Add to favorites,Browse->Purchase->Exit}
     2   | {}
     4   | {Browse->Purchase->View live streams->Cancel the order}
     3   | {Browse->Log on->Add to favorites->View live streams}

Exemple 2 : Développement du résultat de parcours

--Expand the paths.
SELECT uid, unnest(pad_full_path(path_analysis_detail(event, event_time, 'Log on', 180, 7, 0, false))) AS ret FROM path_demo GROUP BY uid;
Remarque

Pour plus d'informations sur la fonction UNNEST, consultez la clause UNNEST.

Le résultat suivant est renvoyé.

 uid |                       ret
-----+-------------------------------------------------
 3   | Log on->Add to favorites->View live streams
 1   | Log on->Browse->View live streams->Browse->Add to favorites
 2   | Log on->Purchase
 4   | Log on->Browse->Purchase->View live streams->Cancel the order
(4 rows)

Exemple 3 : Développement des détails des sous-chemins

--Expand the subpaths.
SELECT
    uid,
    pad_sub_session (ret) AS session_id,
    pad_sub_path_left (ret) AS sub_path_left,
    pad_sub_path_right (ret) AS sub_path_right,
    pad_sub_index_left (ret) AS sub_index_left,
    pad_sub_index_right (ret) AS sub_index_right,
    pad_sub_cost (ret) AS sub_cost
FROM (
    SELECT
        uid,
        unnest( path_analysis_detail (event, event_time, 'Log on', 180, 7, 0, FALSE)) AS ret
    FROM
        path_demo 
    GROUP BY
        uid) a ;

Le résultat suivant est renvoyé.

  uid | session_id | sub_path_left | sub_path_right | sub_index_left | sub_index_right | sub_cost
-----+------------+---------------+----------------+----------------+-----------------+----------
 1   |          0 |               | Log on         |             -1 |               0 |        0
 1   |          0 | Log on        | Browse         |              0 |               1 |        5
 1   |          0 | Browse        | View live streams      |              1 |               2 |       55
 1   |          0 | View live streams     | Browse         |              2 |               3 |        5
 1   |          0 | Browse        | Add to favorites         |              3 |               4 |       65
 2   |          0 |               | Log on         |             -1 |               0 |        0
 2   |          0 | Log on        | Purchase         |              0 |               1 |      120
 3   |          0 |               | Log on         |             -1 |               0 |        0
 3   |          0 | Log on        | Add to favorites         |              0 |               1 |       90
 3   |          0 | Add to favorites        | View live streams      |              1 |               2 |       60
 4   |          0 |               | Log on         |             -1 |               0 |        0
 4   |          0 | Log on        | Browse         |              0 |               1 |       90
 4   |          0 | Browse        | Purchase         |              1 |               2 |       30
 4   |          0 | Purchase        | View live streams      |              2 |               3 |       90
 4   |          0 | View live streams     | Cancel the order   |              3 |               4 |       60
(15 rows)

Exemple 4 : Obtention de la série d'événements de session

SELECT
    uid,
    pad_session_path_array (path_analysis_detail (event, event_time, 'Log on', 180, 7, 0,FALSE), 0) AS ret
FROM
    path_demo
GROUP BY
    uid;

Le résultat suivant est renvoyé.

 uid |                      ret
-----+-----------------------------------------------
 1   | {Log on,Browse,View live streams,Browse,Add to favorites}
 2   | {Log on,Purchase}
 3   | {Log on,Add to favorites,View live streams}
 4   | {Log on,Browse,Purchase,View live streams,Cancel the order}
(4 rows)

Exemple 5 : Calcul du PV et de l'UV des sous-chemins

--Calculate the page view (PV) and unique visitor (UV) for each subpath without deduplication. If you need to deduplicate the results, you can perform deduplication on the uid.
SELECT
    sub_index,
    sub_path_left,
    sub_path_right,
    count(uid)
FROM (
    SELECT
        uid,
        pad_sub_path_left (ret) AS sub_path_left,
        pad_sub_path_right (ret) AS sub_path_right,
        pad_sub_index_right (ret) AS sub_index
    FROM (
        SELECT
            uid,
            unnest(path_analysis_detail (event, event_time, 'Log on', 180, 7, 0, FALSE)) AS ret
        FROM
            path_demo
        GROUP BY
            uid) a) a
GROUP BY
    sub_index,
    sub_path_left,
    sub_path_right
ORDER BY
    sub_index,
    sub_path_left,
    sub_path_right;

Le résultat suivant est renvoyé.

 sub_index | sub_path_left | sub_path_right | count
-----------+---------------+----------------+-------
         0 |               | Log on         |     4
         1 | Log on        | Add to favorites         |     1
         1 | Log on        | Browse         |     2
         1 | Log on        | Purchase         |     1
         2 | Add to favorites        | View live streams      |     1
         2 | Browse        | View live streams      |     1
         2 | Browse        | Purchase         |     1
         3 | View live streams     | Browse         |     1
         3 | Purchase        | View live streams      |     1
         4 | Browse        | Add to favorites         |     1
         4 | View live streams     | Cancel the order   |     1
(11 rows)

Exemple 6 : Calcul de la durée moyenne des sous-chemins

--Calculate the average duration for each subpath.
SELECT
    sub_path_left,
    sub_path_right,
    avg(sub_cost)
FROM (
    SELECT
        uid,
        pad_sub_path_left (ret) AS sub_path_left,
        pad_sub_path_right (ret) AS sub_path_right,
        pad_sub_cost (ret) AS sub_cost
    FROM (
        SELECT
            uid,
            unnest(path_analysis_detail (event, event_time, 'Log on', 180, 7, 0, FALSE)) AS ret
        FROM
            path_demo
        GROUP BY
            uid) a) a
GROUP BY
    sub_path_left,
    sub_path_right
ORDER BY
    sub_path_left,
    sub_path_right;

Le résultat suivant est renvoyé.

 sub_path_left | sub_path_right |    avg
---------------+----------------+------------
 Add to favorites        | View live streams      |  60.000000
 Browse        | Add to favorites         |  65.000000
 Browse        | View live streams      |  55.000000
 Browse        | Purchase         |  30.000000
 Log on        | Add to favorites         |  90.000000
 Log on        | Browse         |  47.500000
 Log on        | Purchase         | 120.000000
 View live streams     | Cancel the order   |  60.000000
 View live streams     | Browse         |   5.000000
 Purchase        | View live streams      |  90.000000
               | Log on         |   0.000000
(11 rows)

Exemple 7 : Association des chemins de session aux détails des sous-chemins

--Associate session paths with subpaths.
select
    uid,
    pad_sub_session(item) as session_id,
    full_path [pad_sub_session(item)+1] as full_path,
    pad_sub_path_left(item) as sub_path_left,
    pad_sub_path_right(item) as sub_path_right,
    pad_sub_index_right(item) as sub_idx,
    pad_sub_cost(item) as sub_cost
from
    (
        select
            uid,
            unnest(ret) as item,
            pad_full_path(ret) as full_path
        from
            (
                select
                    uid,
                    path_analysis_detail(event, event_time, 'Log on', 180, 7, 0, false) as ret
                from
                    path_demo
                group by
                    uid
            ) a
    ) a;

Le résultat suivant est renvoyé.

uid | session_id |                    full_path                    | sub_path_left | sub_path_right | sub_idx | sub_cost
-----+------------+-------------------------------------------------+---------------+----------------+---------+----------
 3   |          0 | Log on->Add to favorites->View live streams                       |               | Log on         |       0 |        0
 3   |          0 | Log on->Add to favorites->View live streams                       | Log on        | Add to favorites         |       1 |       90
 3   |          0 | Log on->Add to favorites->View live streams                       | Add to favorites        | View live streams      |       2 |       60
 1   |          0 | Log on->Browse->View live streams->Browse->Add to favorites       |               | Log on         |       0 |        0
 1   |          0 | Log on->Browse->View live streams->Browse->Add to favorites       | Log on        | Browse         |       1 |        5
 1   |          0 | Log on->Browse->View live streams->Browse->Add to favorites       | Browse        | View live streams      |       2 |       55
 1   |          0 | Log on->Browse->View live streams->Browse->Add to favorites       | View live streams     | Browse         |       3 |        5
 1   |          0 | Log on->Browse->View live streams->Browse->Add to favorites       | Browse        | Add to favorites         |       4 |       65
 2   |          0 | Log on->Purchase                                  |               | Log on         |       0 |        0
 2   |          0 | Log on->Purchase                                  | Log on        | Purchase         |       1 |      120
 4   |          0 | Log on->Browse->Purchase->View live streams->Cancel the order |               | Log on         |       0 |        0
 4   |          0 | Log on->Browse->Purchase->View live streams->Cancel the order | Log on        | Browse         |       1 |       90
 4   |          0 | Log on->Browse->Purchase->View live streams->Cancel the order | Browse        | Purchase         |       2 |       30
 4   |          0 | Log on->Browse->Purchase->View live streams->Cancel the order | Purchase        | View live streams      |       3 |       90
 4   |          0 | Log on->Browse->Purchase->View live streams->Cancel the order | View live streams     | Cancel the order   |       4 |       60
(15 rows)

Exemple 8 : Affichage des détails partiels du chemin

--View conversion details for a specific path ('Log on' to 'Purchase') using the pad_funnel function.
SELECT uid, pad_full_path(pad_funnel(path_analysis_detail(event, event_time, 'Log on', 180, 7, 0, false), array['Log on', 'Purchase'])) AS ret FROM path_demo GROUP BY uid;

Le résultat suivant est renvoyé.

 uid |       ret
-----+------------------
 3   | {Log on}
 4   | {Log on->Purchase}
 1   | {Log on}
 2   | {Log on->Purchase}
(4 rows)