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;RemarqueUne 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.RemarqueSi
session_interval_secest 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...abcest 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 surtrue. 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<,""}.RemarquePour 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<,""}.RemarquePour 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_pathrenvoie 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;
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)