Tasso di fidelizzazione è definito come il numero di clienti che continuano a utilizzare un prodotto/servizio. È difficile calcolare l'analisi della ritenzione di coorte. Ecco come calcolare il tasso di fidelizzazione in SQL per l'analisi della fidelizzazione dei clienti. Puoi usarlo per calcolare il tasso di ritenzione in MySQL, PostgreSQL, SQL Server e Oracle. Esamineremo anche la query SQL per la fidelizzazione dei clienti. Il tasso di fidelizzazione viene misurato come il numero di utenti di ritorno, a intervalli regolari, ad esempio ogni settimana o mese, raggruppati per settimana di registrazione.
Calcoleremo la fidelizzazione per coorte settimanale in SQL e ci ritroveremo con una tabella come quella di seguito, che mostra il numero di clienti che hanno effettuato nuovamente l'accesso dopo la prima registrazione alcune settimane fa, per ogni settimana di registrazione.
Come calcolare il tasso di conservazione in SQL?
Ecco i passaggi per calcolare il tasso di conservazione in SQL. Supponiamo che tu abbia la seguente tabella che memorizza user_id e login_date della visita di ogni utente.
mysql> create table login(login_date date,user_id int, id int not null auto_increment, primary key (id));
mysql> insert into login(login_date,user_id)
values('2020-01-01',10),('2020-01-02',12),('2020-01-03',15),
('2020-01-04',11),('2020-01-05',13),('2020-01-06',9),
('2020-01-07',21),('2020-01-08',10),('2020-01-09',10),
('2020-01-10',2),('2020-01-11',16),('2020-01-12',12),
('2020-01-13',10),('2020-01-14',18),('2020-01-15',15),
('2020-01-16',12),('2020-01-17',10),('2020-01-18',18),
('2020-01-19',14),('2020-01-20',16),('2020-01-21',12),
('2020-01-22',21),('2020-01-23',13),('2020-01-24',15),
('2020-01-25',20),('2020-01-26',14),('2020-01-27',16),
('2020-01-28',15),('2020-01-29',10),('2020-01-30',18);
mysql> select * from login;
+------------+---------+----+
| login_date | user_id | id |
+------------+---------+----+
| 2020-01-01 | 10 | 1 |
| 2020-01-02 | 12 | 2 |
| 2020-01-03 | 15 | 3 |
| 2020-01-04 | 11 | 4 |
| 2020-01-05 | 13 | 5 |
| 2020-01-06 | 9 | 6 |
| 2020-01-07 | 21 | 7 |
| 2020-01-08 | 10 | 8 |
| 2020-01-09 | 10 | 9 |
| 2020-01-10 | 2 | 10 |
| 2020-01-11 | 16 | 11 |
| 2020-01-12 | 12 | 12 |
| 2020-01-13 | 10 | 13 |
| 2020-01-14 | 18 | 14 |
| 2020-01-15 | 15 | 15 |
| 2020-01-16 | 12 | 16 |
| 2020-01-17 | 10 | 17 |
| 2020-01-18 | 18 | 18 |
| 2020-01-19 | 14 | 19 |
| 2020-01-20 | 16 | 20 |
| 2020-01-21 | 12 | 21 |
| 2020-01-22 | 21 | 22 |
| 2020-01-23 | 13 | 23 |
| 2020-01-24 | 15 | 24 |
| 2020-01-25 | 20 | 25 |
| 2020-01-26 | 14 | 26 |
| 2020-01-27 | 16 | 27 |
| 2020-01-28 | 15 | 28 |
| 2020-01-29 | 10 | 29 |
| 2020-01-30 | 18 | 30 |
+------------+---------+----+
Creeremo analisi di coorte settimanali. A seconda del tuo prodotto/servizio puoi cambiarlo in mensile/giornaliero.
Useremo MySQL per calcolare il tasso di ritenzione in SQL. Puoi anche calcolare il tasso di abbandono per PostgreSQL.
1. Visite al secchio per settimana
Per calcolare il tasso di conservazione in SQL, innanzitutto raggrupperemo ogni visita in base alla settimana di accesso.
mysql> SELECT
user_id,
week(login_date) AS login_week
FROM login
GROUP BY user_id,week(login_date);
+---------+------------+
| user_id | login_week |
+---------+------------+
| 2 | 1 |
| 9 | 1 |
| 10 | 0 |
| 10 | 1 |
| 10 | 2 |
| 10 | 4 |
| 11 | 0 |
| 12 | 0 |
| 12 | 2 |
| 12 | 3 |
| 13 | 1 |
| 13 | 3 |
| 14 | 3 |
| 14 | 4 |
| 15 | 0 |
| 15 | 2 |
| 15 | 3 |
| 15 | 4 |
| 16 | 1 |
| 16 | 3 |
| 16 | 4 |
| 18 | 2 |
| 18 | 4 |
| 20 | 3 |
| 21 | 1 |
| 21 | 3 |
+---------+------------+
Consulta anche Come calcolare gli utenti attivi settimanali (WAU) in MySQL.
2. Calcola la PRIMA SETTIMANA di accesso per ogni utente
Successivamente, per calcolare il tasso di conservazione in SQL, dobbiamo calcolare la prima settimana di accesso per ciascun utente. Useremo semplicemente la funzione MIN e GROUP BY per calcolare la prima settimana di accesso per ogni utente
mysql> SELECT
user_id,
min(week(login_date)) AS first_week
FROM login
GROUP BY user_id;
+---------+------------+
| user_id | first_week |
+---------+------------+
| 2 | 1 |
| 9 | 1 |
| 10 | 0 |
| 11 | 0 |
| 12 | 0 |
| 13 | 1 |
| 14 | 3 |
| 15 | 0 |
| 16 | 1 |
| 18 | 2 |
| 20 | 3 |
| 21 | 1 |
+---------+------------+
3. Unisci le 2 tabelle per login_week e first_week
Successivamente, otteniamo login_week e first_week fianco a fianco per ciascun utente utilizzando la query seguente, con un INNER JOIN, per calcolare il tasso di conservazione in SQL.
mysql> select a.user_id,a.login_week,b.first_week as first_week from
(SELECT
user_id,
week(login_date) AS login_week
FROM login
GROUP BY user_id,week(login_date)) a,
(SELECT
user_id,
min(week(login_date)) AS first_week
FROM login
GROUP BY user_id) b
where a.user_id=b.user_id;
+---------+------------+------------+
| user_id | login_week | first_week |
+---------+------------+------------+
| 2 | 1 | 1 |
| 9 | 1 | 1 |
| 10 | 0 | 0 |
| 10 | 1 | 0 |
| 10 | 2 | 0 |
| 10 | 4 | 0 |
| 11 | 0 | 0 |
| 12 | 0 | 0 |
| 12 | 2 | 0 |
| 12 | 3 | 0 |
| 13 | 1 | 1 |
| 13 | 3 | 1 |
| 14 | 3 | 3 |
| 14 | 4 | 3 |
| 15 | 0 | 0 |
| 15 | 2 | 0 |
| 15 | 3 | 0 |
| 15 | 4 | 0 |
| 16 | 1 | 1 |
| 16 | 3 | 1 |
| 16 | 4 | 1 |
| 18 | 2 | 2 |
| 18 | 4 | 2 |
| 20 | 3 | 3 |
| 21 | 1 | 1 |
| 21 | 3 | 1 |
+---------+------------+------------+
4. Calcola il numero della settimana
Da qui in poi, è facile calcolare il tasso di ritenzione in SQL. Successivamente, calcoliamo la differenza tra login_week e first_week per calcolare week_number (numero di settimana)
mysql> select a.user_id,a.login_week,b.first_week as first_week,
a.login_week-first_week as week_number from
(SELECT
user_id,
week(login_date) AS login_week
FROM login
GROUP BY user_id,week(login_date)) a,
(SELECT
user_id,
min(week(login_date)) AS first_week
FROM login
GROUP BY user_id) b
where a.user_id=b.user_id;
+---------+------------+------------+-------------+
| user_id | login_week | first_week | week_number |
+---------+------------+------------+-------------+
| 2 | 1 | 1 | 0 |
| 9 | 1 | 1 | 0 |
| 10 | 0 | 0 | 0 |
| 10 | 1 | 0 | 1 |
| 10 | 2 | 0 | 2 |
| 10 | 4 | 0 | 4 |
| 11 | 0 | 0 | 0 |
| 12 | 0 | 0 | 0 |
| 12 | 2 | 0 | 2 |
| 12 | 3 | 0 | 3 |
| 13 | 1 | 1 | 0 |
| 13 | 3 | 1 | 2 |
| 14 | 3 | 3 | 0 |
| 14 | 4 | 3 | 1 |
| 15 | 0 | 0 | 0 |
| 15 | 2 | 0 | 2 |
| 15 | 3 | 0 | 3 |
| 15 | 4 | 0 | 4 |
| 16 | 1 | 1 | 0 |
| 16 | 3 | 1 | 2 |
| 16 | 4 | 1 | 3 |
| 18 | 2 | 2 | 0 |
| 18 | 4 | 2 | 2 |
| 20 | 3 | 3 | 0 |
| 21 | 1 | 1 | 0 |
| 21 | 3 | 1 | 2 |
+---------+------------+------------+-------------+
5. Ruota il risultato
Infine, dobbiamo ruotare il risultato, calcolare il tasso di ritenzione in SQL e generare una tabella di coorte. Nella nostra tabella pivot, avremo una riga per ogni prima_settimana valore e una colonna per ogni numero_settimana contenente il numero di utenti che sono tornati dopo "n" settimane per utilizzare il tuo prodotto/servizio. Per questo, utilizziamo la seguente query.
mysql> select first_week,
SUM(CASE WHEN week_number = 0 THEN 1 ELSE 0 END) AS week_0,
SUM(CASE WHEN week_number = 1 THEN 1 ELSE 0 END) AS week_1,
SUM(CASE WHEN week_number = 2 THEN 1 ELSE 0 END) AS week_2,
SUM(CASE WHEN week_number = 3 THEN 1 ELSE 0 END) AS week_3,
SUM(CASE WHEN week_number = 4 THEN 1 ELSE 0 END) AS week_4,
SUM(CASE WHEN week_number = 5 THEN 1 ELSE 0 END) AS week_5,
SUM(CASE WHEN week_number = 6 THEN 1 ELSE 0 END) AS week_6,
SUM(CASE WHEN week_number = 7 THEN 1 ELSE 0 END) AS week_7,
SUM(CASE WHEN week_number = 8 THEN 1 ELSE 0 END) AS week_8,
SUM(CASE WHEN week_number = 9 THEN 1 ELSE 0 END) AS week_9
from (
select a.user_id,a.login_week,b.first_week as first_week,a.login_week-first_week as week_number from (SELECT
user_id,
week(login_date) AS login_week
FROM login
GROUP BY user_id,week(login_date)) a,(SELECT
user_id,
min(week(login_date)) AS first_week
FROM login
GROUP BY user_id) b
where a.user_id=b.user_id
) as with_week_number
group by first_week
order by first_week;
+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
| first_week | week_0 | week_1 | week_2 | week_3 | week_4 | week_5 | week_6 | week_7 | week_8 | week_9 |
+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
| 0 | 4 | 1 | 3 | 2 | 2 | 0 | 0 | 0 | 0 | 0 |
| 1 | 5 | 0 | 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
Ora sappiamo come calcolare il tasso di ritenzione in SQL. Puoi anche eseguire le query precedenti per calcolare il tasso di conservazione in MySQL, PostgreSQL.
Infine, puoi utilizzare uno strumento di visualizzazione dei dati per tracciare l'analisi della coorte di conservazione di cui sopra in una tabella. Ecco una tabella di conservazione della coorte creata utilizzando Ubiq.
A proposito, se vuoi creare tabelle pivot, grafici e dashboard dal database MySQL, puoi provare Ubiq. Offriamo una prova gratuita di 14 giorni.
