Discussion :

[jimmo]

Bonjour,

Je cherche à obtenir les chiffres d'affaires annuel de mes ventes.
Là ou je sèche, c'est que mon exercice comptable n'est pas du 01/01 au 31/12 mais du 01/09 au 31/08

Du 01/01 au 31/12 j'utiliserai le code ci-dessous

Code sql :

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

SELECT YEAR(date_vente) as An, SUM(total_ht_vente) as Total FROM clients__vente GROUP BY YEAR(date_vente) ORDER BY YEAR(date_vente) DESC

Mais dans mon cas, comment le réaliser?

Une idée svp ?

[darkstar123456]

Bonjour,

Grâce à l'utilisation de BETWEEN :

Code sql :

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

SELECT SUM(total_ht_vente) as Total FROM clients__vente WHERE date_vente BETWEEN '2018-09-01' AND '2019-08-31';

Il est aussi possible d'écrire WHERE date_vente >= '2018-09-01' AND date_vente <= '2019-08-31'

[jimmo]

Bonjour Darkstar,

J'avais pensé à cela, mais j'ai besoin de récupérer le chiffre d'affaire des années passées également.

Code :

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

1
2
3
4
5
 
01/09/2018 au 31/08/2019 : 20000€
01/09/2017 au 31/08/2018 : 20000€
01/09/2016 au 31/08/2017 : 20000€
etc...

Et la je sèche complètement.

[darkstar123456]

A mon avis, en imbriquant des requêtes il devrait y avoir moyen mais c'est illisible et donc un peu dégueulasse ^^

Personnellement, je commencerais par faire un SELECT MIN(date_vente) FROM clients__vente histoire de connaître la date la plus ancienne.
Une fois que c'est fait, faire une boucle en PHP de la date maximum (date('Y')) et ensuite boucler de la date max jusqu'à la min (quelque chose comme : for($i = date('Y'); $i >= $date_min; $i--)) et là, dans chaque boucle, tu peux construire les dates et faire le SELECT avec BETWEEN en remplaçant les dates par celles construites

EDIT :
Voilà un bout de code plus précis. Attention, l'exécution des requêtes se fait suivant ce que tu utilises (mysqli, PDO, ou autre)

Code php :

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
// On imagine qu'on a un classe qui gère la DB
$db = new ClassQuiGereLesConnexionsDB();
// On récupère la date minimale
$sql = "SELECT MIN(date_vente) AS min_date_vente FROM clients__vente";
$min_date_vente = $db->query($sql)->get_row()->min_date_vente;
$min_year = date('Y', strtotime($min_date_vente));
// On va boucler de maintenant à la plus petite année
$montants = [];
for ($i = date('Y'); $i >= $min_year; $i--) {
    $sql = "SELECT SUM(total_ht_vente) as Total FROM clients__vente WHERE date_vente BETWEEN '2018-09-01' AND '2019-08-31';";
    $sqlData = [
        ($i - 1) . '-09-01',
        $i . '-08-31',
    ];
    // On exécute notre requête préparée, avec les dates correctes
    $total_ht_vente = $db->exec($db->prepare($sql, $sqlData))->get_row()->Total;
    // On ajoute tout dans $montants, comme ça on garde l'interval aussi :)
    $montants[] = [
        'total' => $total_ht_vente,
        'interval' => $sqlData,
    ];
 
}
// Affichage des résultats
echo PHP_EOL . '<pre>$montants: ' . print_r($montants, true) . '</pre>' . PHP_EOL;

[jimmo]

J'avais pensé effectivement à boucler sur la requête SELECT.
Mais je me demandais s'il n'existait pas une autre possibilité "plus propre".
J'avais pensé que peut être il existait quelque chose du style GROUP BY (date_range).

[darkstar123456]

Il vaut souvent mieux faire plein de petites requêtes plutôt que des gros JOIN ou des requêtes imbriquées

[rawsrc]

@darkstar123456

t'es sûr de toi parce que j'aurais plutôt tendance à largement privilégier les gros JOIN sur les colonnes indexées afin de déporter au maximum la charge de travail sur le moteur de la base de données qui est hyper optimisé de ce côté...

[Invité]

Bonjour,

Normalement, les dates de l'exercice comptable (du 01/09 au 31/08) sont fixée dès le départ, et ne changent plus.

Une autre solution est de :

• créer une colonne "annee_compta" dans la table "clients__vente".
• écrire un script PHP qui va effectuer un UPDATE de toute la table, afin d'ajouter l'année compta qui convient à chaque ligne
• écrire un script PHP qui déterminera l'année compta pour chaque nouvel INSERT dans la table

Ce qui, au final, simplifie grandement la requête des totaux, qui devrait ressembler à :

Code sql :

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

1
2
3
4
5
SELECT 
	DISTINCT CV.annee_compta as An, 
	(SELECT SUM(CV2.total_ht_vente FROM clients__vente CV2 WHERE CV2.annee_compta = CV.annee_compta) as Total
FROM clients__vente CV
ORDER BY CV.annee_compta DESC

N.B. J'ajoute que le chiffre d'affaire des années passées est aussi censé être fixe et inchangé !
Par conséquent, on doit pouvoir :

• créer une table "chiffres_affaire_compta" (id_ca, annee_compta, montat_ht_ca)
• les "années passées" y seraient listées
• seule l'"année en cours" serait "en cours" (à actualiser en fin d'année comptable)

Mais bon, ce ne sont que des réflexions perso "à chaud"...
Il existe certainement une méthode rodée qui a fait ses preuves.

[darkstar123456]

@rawsrc Hmmm il faudrait que je sois plus clair dans mon explication ! C'est comme pour tout, y'a des nuances ^^

Déjà, si tu as des OR dans ta requête, vaut mieux pas utiliser de JOIN =) bon, sauf si tu t'attends pas à avoir beaucoup de données dans tes tables évidemment ^^

Chaque JOIN créée une table temporaire, donc si tu travailles sur des tables qui contiennent beaucoup de données et qu'il faut beaucoup croiser (beaucoup de JOIN), il vaut clairement mieux faire beaucoup de "petites requêtes" car tu vas te retrouver avec une table temporaire ENORME

Perso, j'ai travaillé sur des tables avec une douzaine de millions de lignes donc tu ne fais pas n'importe quoi là-dedans.
Malheureusement pour moi, certaines requêtes m'obligeaient à cumuler des JOIN et des OR... du coup, la seule solution était le cache mais en tout cas, tu vois direct que c'est ça qui foutait la merde.
Toutes mes requêtes allaient super vites malgré le nombre de lignes en DB mais dès l'ajout de ces règles (suivant ce que le user avait choisi en front) ça devenait super lent

Après, si je parlais de ça, c'est que j'ai l'impression que les gens se disent que c'est mal de faire plein de petites requêtes mais pas vraiment.
Si tu fais 10 requêtes de 0.01s, ça ne fait jamais que 0.1s de prise alors qu'une requête avec des JOIN et des OR peut potentiellement prendre plus de temps.


EDIT : Je n'ai pas vraiment de sources pour étayer mon propos. Je tiens ça en partie de mon expérience et de notre admin sys du boulot =D

[jimmo]

C'est animé, c'est cool
J'ai tenté la proposition de Jreaux62 en omettant la colonne "annee_compta" car tout mon code php et sql est réalisé et que j'aimerai éviter d'apporter des modifications.

Code sql :

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

1
2
3
SELECT DISTINCT YEAR(CV.date_vente) as An, 
(SELECT SUM(CV2.total_ht_vente) FROM clients__vente CV2 WHERE YEAR(CV2.date_vente) = An) as Total 
FROM clients__vente CV

Le résultat est là, par contre, ça prend énormément de temps.
Pour traiter 10 000 lignes, ça a pris 50 secondes.

[darkstar123456]

Si ta colonne CV.date_vente n'est pas de type DATETIME mais un simple DATE, essaye de rajouter un INDEX dessus pour accélérer la requête (s'il n'y en a pas).
S'il y a déjà un INDEX, je t'invite à séparer les requêtes car les requêtes imbriquées créées, elles aussi, des tables temporaires.

[Invité]

Une variante de la proposition de darkstar123456 :

// 1- On récupère toutes les ANNEES

Code :

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

$sql_annees = "SELECT DISTINCT(YEAR(date_vente)) AS annee FROM clients__vente ORDER BY annee DESC";

// 2- On boucle sur les années

Code :

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

1
2
3
4
5
6
7
$montants = [];
foreach( ..... as $annee_compta ) {
    // Total pour cette année
    $sql = "SELECT SUM(total_ht_vente) as Total FROM clients__vente WHERE date_vente BETWEEN '".($annee_compta-1)."-09-01' AND '".$annee_compta."-08-31';";
...
    $montants[$annee_compta] = $row['Total'];
}

N.B. Pour participer au débat...
Je suis plutôt d'accord avec darkstar123456 : si une seule requête commence à devenir trop complexe, je préfère passer par plusieurs petites, plus simples.

En l'occurrence, il ne suffit pas de mettre "simplement" des JOIN, mais des IF ou CASE * dans la requête SQL:

• en fonction de la date date_vente, l'année compta pour cette ligne sera YEAR(date_vente) ou (YEAR(date_vente)+1) !

* Et là, je suis largué, car je ne suis pas "admin BDD".

[jimmo]

Ça se fait d'ajouter un INDEX à une colonne DATE ? Je pensais que DATE était naturellement indexé de par sa nature...
Je vais surement finir par boucler les requêtes SQL effectivement...

[darkstar123456]

Alors je me trompe peut-être car je ne suis pas sûr à 100% mais il me semble que c'est le type TIMESTAMP qui a une particularité.
Les champs DATE et DATETIME ne sont pas indexés, et il est déconseillé d'indexer des champs DATETIME car ça créé plus d'index que de résultats xD

[jimmo]

Merci pour les renseignements. Je vais partir sur une boucle avec un index sur la colonne date.
Merci à tous.