Discussion :

[Calimero90]

Bonjour,

Je commence à être un peu moins débutant en MySQL et je commence à faire un peu plus attention à la façon dont je fais les choses :

J'ai une table qui contient ceci (des datas HIght value, LOw value selon un DatetTime) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
mysql> select dt, hi, lo from mytable where dt >='2022-10-03 09:20:00'  limit 20;
+---------------------+--------+--------+
| dt                  | hi     | lo     |
+---------------------+--------+--------+
| 2022-10-03 09:21:00 | 4.1200 | 4.1180 |
| 2022-10-03 09:24:00 | 4.1080 | 4.1040 |
| 2022-10-03 09:25:00 | 4.1040 | 4.1000 |
| 2022-10-03 09:26:00 | 4.0960 | 4.0940 |
| 2022-10-03 09:28:00 | 4.0940 | 4.0920 |
| 2022-10-03 09:29:00 | 4.0980 | 4.0940 |
| 2022-10-03 09:31:00 | 4.1020 | 4.0980 |
| 2022-10-03 09:32:00 | 4.1000 | 4.1000 |
| 2022-10-03 09:33:00 | 4.0940 | 4.0940 |
| 2022-10-03 09:36:00 | 4.0720 | 4.0720 |
| 2022-10-03 09:37:00 | 4.0600 | 4.0500 |
| 2022-10-03 09:39:00 | 4.0620 | 4.0560 |
| 2022-10-03 09:42:00 | 4.0660 | 4.0580 |
| 2022-10-03 09:47:00 | 4.0620 | 4.0620 |
| 2022-10-03 09:48:00 | 4.0620 | 4.0620 |
| 2022-10-03 09:50:00 | 4.0580 | 4.0580 |
| 2022-10-03 09:51:00 | 4.0580 | 4.0580 |
| 2022-10-03 09:52:00 | 4.0560 | 4.0540 |
| 2022-10-03 09:53:00 | 4.0460 | 4.0460 |
| 2022-10-03 09:55:00 | 4.0420 | 4.0360 |
+---------------------+--------+--------+
20 rows in set (0,00 sec)

Je souhaite obtenir, en MySQL (car j’apprends un peu), pour chaque lignes la différance (rdif) entre le ‘hi’ de la ligne et le ‘lo’ d’il y à 10 minute.

J’y arrive comme ceci :
(Je sais, les ‘as’ sont facultatif, mais ca permet de mieux comprendre)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
mysql> select dt as rdt, hi as rhi, (select lo from mytable where dt = rdt-interval 10 minute) as rlo, (hi-(select rlo)) as rdif from mytable where dt >= '2022-10-03 09:20:00'  limit 20;
+---------------------+--------+--------+---------+
| rdt                 | rhi    | rlo    | rdif    |
+---------------------+--------+--------+---------+
| 2022-10-03 09:21:00 | 4.1200 | 3.9900 |  0.1300 |
| 2022-10-03 09:24:00 | 4.1080 | 4.0180 |  0.0900 |
| 2022-10-03 09:25:00 | 4.1040 | 4.0500 |  0.0540 |
| 2022-10-03 09:26:00 | 4.0960 | 4.0800 |  0.0160 |
| 2022-10-03 09:28:00 | 4.0940 |   NULL |    NULL |
| 2022-10-03 09:29:00 | 4.0980 |   NULL |    NULL |
| 2022-10-03 09:31:00 | 4.1020 | 4.1180 | -0.0160 |
| 2022-10-03 09:32:00 | 4.1000 |   NULL |    NULL |
| 2022-10-03 09:33:00 | 4.0940 |   NULL |    NULL |
| 2022-10-03 09:36:00 | 4.0720 | 4.0940 | -0.0220 |
| 2022-10-03 09:37:00 | 4.0600 |   NULL |    NULL |
| 2022-10-03 09:39:00 | 4.0620 | 4.0940 | -0.0320 |
| 2022-10-03 09:42:00 | 4.0660 | 4.1000 | -0.0340 |
| 2022-10-03 09:47:00 | 4.0620 | 4.0500 |  0.0120 |
| 2022-10-03 09:48:00 | 4.0620 |   NULL |    NULL |
| 2022-10-03 09:50:00 | 4.0580 |   NULL |    NULL |
| 2022-10-03 09:51:00 | 4.0580 |   NULL |    NULL |
| 2022-10-03 09:52:00 | 4.0560 | 4.0580 | -0.0020 |
| 2022-10-03 09:53:00 | 4.0460 |   NULL |    NULL |
| 2022-10-03 09:55:00 | 4.0420 |   NULL |    NULL |
+---------------------+--------+--------+---------+
20 rows in set (0,00 sec)

Les ‘NULL’ c’est normal car il n’y à pas toujours la minute antérieur qui correspond (en plus ca m’arrange dans ce cas)

Mais je me pose des questions :

1)
Dans « (hi-(select rlo)) as rdif » pourquoi je ne peu pas simplement utiliser ‘rlo’ (il faut un ajouter le select) ?
(Même si vous répondez à la question ci-dessous, merci quand même de répondre à celle-ci)

2)
Comment éviter le double select-from dans la table ? (c’est ça une sous requête ?)
Il doit y avoir mieux… Que proposer vous ?

3)
J’envisage ensuite d’autre opérations, dans ce style, plus ou moins simples mais compliquées pour moi en MySQL. (calculs plus des update de colonnes..., pas nécessairement des sélections à afficher...)
Ai-je meilleur temps de lire/écrire simplement la table et de coder ces calculs dans mon appli en nodejs (que je maitrise : J’apprends un peu MySQL, ok, mais je veux quand même avancer…)
(Quant serait-il du temps d’exécution ?)

Merci !

[al1_24]

Bonjour,

1) Comme la colonne rlo est calculée dans la clause SELECT, l'analyse syntaxique ne la trouve pas dans un premier temps. C'est une manière de forcer l'interpréteur à revenir une seconde fois sur les références pour la trouver. Pas certain que cela fonctionne pour un autre SGBD que MySQL.

2) Il y a en effet une manière plus simple d'écrire la requête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
select  cur.dt  as rdt
    ,   cur.hi  as rhi
    ,   pre.lo  as rlo
    ,   cur.hi  -  pre.lo as rdif 
from    mytable as cur
    left join
        mytable as pre
        on  pre.dt  = cur.dt - interval 10 minute 
where   cur.dt >= '2022-10-03 09:20:00'  
limit   20
;

Les sous-requêtes scalaires (utilisées dans la clause SELECT pour retourner une seule colonne) sont rarement performantes et on a beaucoup plus intérêt à effectuer des jointures dans la clause FROM. D'autant plus lorsqu'on a besoin des valeurs liées dans plusieurs colonnes.

NB : j'ai utilisé une jointure externe de manière que la requête retourne une ligne même si la mesure précédente n'existe pas.

[al1_24]

Je sais, les ‘as’ sont facultatif, mais ca permet de mieux comprendre

En effet. Et plus une requête est lisible donc compréhensible, plus elle est maintenable.

Ai-je meilleur temps de lire/écrire simplement la table et de coder ces calculs dans mon appli en nodejs (que je maitrise : J’apprends un peu MySQL, ok, mais je veux quand même avancer…)
(Quant serait-il du temps d’exécution ?)

On a toujours intérêt à faire effectuer le maximum de travail par le SGBD :
Cela présente de nombreux avantages :

• Limiter le nombre d'allers-retours entre la base de données et l'application.
• Limiter le nombre de colonnes retournées aux seules nécessaires à l'application (et non toutes celles qui pourraient entrer dans le calcul)
• Si le calcul doit être effectué en consultant plusieurs tables, s'assurer qu'il n'y ait aucun risque qu'une valeur dans l'une des tables soit modifiée entre le début et la fin des multiples récupérations de données.
• Dans une mise à jour, s'assurer que toutes les modifications sont enregistrées en une seule transaction même si elles concernent plusieurs tables.
• ...

[Calimero90]

Ces jointures me semblaient compliquées, je les avais remisées de côté, pour quand je serais plus grand...
Je m'y suis enfin attardé et c'est finalement assez simple en fait, comme toujours quand on a compris...
Je suis un peu plus grand maintenant !

Merci!

[al1_24]

Un peu de lecture si tu veux encore grandir ou raviver tes souvenirs :
SELECT les expressions - FROM les tables - WHERE un filtre - ORDER BY tri - Fonctions SQL - NULL les absents - CASE le branchement
Les jointures - operateur JOIN - NATURAL, INNER, OUTER, CROSS, UNION - équi, non équi, inéqui et théta jointures - Arbre de jointure
Formez des sous ensembles avec GROUP BY - Agrégez avec SUM, COUNT, MAX, MIN, AVG... - Filtrer les agrégats - opérez des ensembles avec UNION, INTERSECT et EXCEPT
Imbriquez vos SELECT - structurez votre code - corrélez vos sous requêtes - utilisez IN, SOME, ANY, ALL, MATCH, UNIQUE, EXISTS
Les expressions de table (CTE : Common Table Expression) - Requête ancre et requête d'itération - Requêtes de parcours d'arbres - Requêtes de parcours de graphes - Requêtes de parcours de liste : découper une chaîne, concaténez une liste
Analysez vos données avec les fonctions analytiques et de classement et la clause WINDOW. RANK, ROW_NUMBER, NTILE, LEAD, LAG, FIRST_VALUE, LAST_VALUE....
Insérez avec INSERT - Supprimez avec DELETE - modifiez avec UPDATE - jouez avec NULL et DEFAULT
Démultipliez vos requêtes avec les fonctions du langage SQL.