Discussion :

[panthere noire]

Je tente de faire ma requête , mai il y a pas moins de 500'000 ligne. évidement tout est aux format texte. après 30 minute .. j'ai finalement laisser tomber.

La question, le processeur n'est exploiter qu'a 17% , le disque ne sature pas donc je comprend pas d'ou viens le problèmes.

il y a peut être un paramètre qui lui permettrai d'utiliser aux mieux le cpu ?

c'est coder en C#

Code :

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

1
2
3
4
5
6
7
8
 
"SELECT * FROM T_FileTriDifference t1 WHERE EXISTS ( " +
                    "SELECT * FROM T_Fichier t2 WHERE " +
                    "t1.id <> t2.id AND " +
                    "t1.fullpath = t2.fullpath AND " +
                    "t1.sizefile = t2.sizefile AND " +
                    "t1.sha256 <> t2.sha256 GROUP BY " +
                    "sha256 )";

la table a 500'000 ligne environ
Merci d'avance

[acaumes]

Bonjour

1/ 17% de CPU cela dépend de ton nombre de cœurs. SQLITE ne fonctionne qu'en monothread.

2/ A quoi sert le group by dans ta requête?

3/ Select * dans la deuxième requête serait AMHA bien mieux remplacé par 1 ou NULL ou n'importe quoi sauf une étoile...

4/ Il y a des instructions EXPLAIN Dans SQLITE (cela te permettra de voir si il faut mettre des index (a mon avis au moins sur Id) et probablement sur les colonnes de test.

5/ Et comme ceci c'est mieux?

Code :

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

1
2
3
4
SELECT t1.* FROM T_FileTriDifference t1 join T_Fichier t2 on 
                                          t1.fullpath = t2.fullpath AND  
                                          t1.sizefile = t2.sizefile
     WHERE   t1.id <> t2.id AND t1.sha256 <> t2.sha256

6/ J'ai déjà utilisé des tables de plus de 20 millions de lignes avec SQLITE et les temps de réponse n'étaient pas si mauvais mais il faut mettre les bons index.

[panthere noire]

1.- Merci si je comprend bien c est 1 seul core ... j'en dispose 4

2.- group by ser a regrouper ce qui est a trier

3.- Le problème c' est que la comparaison ce fera de toute manière sur le texte chemin et la somme sha256sum.
l'id serai plus rapide si j'arrive a trouver une solution en la matière

4.- EXPLAIN je connait pas je vais me renseigner sur la question merci d'avoir souligner le sujet.

5.- Non le tri obtenu est pas bon, il en ressort que si 1 élément est différent tous ce qui est différent est afficher.

c'est pas très claire mai un exemple

mon tris donne:

Code :

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

1
2
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
28 : C:\Users\erox\Documents\Light\out : f665fd555885f929c33b7bba16d38b70e89d1e8387f92be8e6063a324600968e

le tien donne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
1 : C:\Users\erox\Documents\Light\out : 100000000000000000000000
28 : C:\Users\erox\Documents\Light\out : f665fd555885f929c33b7bba16d38b70e89d1e8387f92be8e6063a324600968e

Merci pour ta réponse et tes précisions

[acaumes]

2.- group by ser a regrouper ce qui est a trier

3.- Le problème c' est que la comparaison ce fera de toute manière sur le texte chemin et la somme sha256sum.
l'id serai plus rapide si j'arrive a trouver une solution en la matière

5.- Non le tri obtenu est pas bon, il en ressort que si 1 élément est différent tous ce qui est différent est afficher.

2/ Non Group by sert à regrouper des information quand il y a des fonctions de regroupement sinon il ne sert à rien!

3/ Le EXIST vérifie que la requête interne renvoie au moins une ligne quel que soit ce que tu as dans le select! donc tu mets ce que tu veux mais pas une étoile!

5/ Donc tu as plusieurs lignes dans T2 pour une ligne dans T1 qui ont le même fullpath et le même sizefile!

[escartefigue]

Bonjour,

3/ Le EXIST vérifie que la requête interne renvoie au moins une ligne quel que soit ce que tu as dans le select! donc tu mets ce que tu veux mais pas une étoile!

D'une façon générale, SELECT * est à proscrire en effet, mais, dans le cas particulier d'un test d'existence avec EXISTS, ça ne change rien aux performances : le résultat est ici un simple booléen vrai/faux.
Par contre, le SELECT * de la requête principale peut avantageusement être remplacé par la liste des colonnes utiles.
Et effectivement, faire un regroupement dans la requête corrélée qui fait ce test d'existence est inutile et pénalise les performances, à supprimer donc.

[panthere noire]

Merci a vous deux pour vos réponse, j'en ai donc tenu compte, j'ai donc tenter simplement ceci:

Code :

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

1
2
3
4
5
6
7
 
"SELECT * FROM T_FileTriDifference t1 WHERE  ( " +
                     "SELECT t1.id FROM T_Fichier  t2 WHERE " +
                     "t1.id <> t2.id AND " +
                     "t1.fullpath = t2.fullpath AND " +
                     "t1.sizefile = t2.sizefile AND " +
                     "t1.sha256 <> t2.sha256 ) ";

Mai c'est toujours sans résulta après 5 minute ...

mai pour l'utilisation du cpu et du disque sa me surprend toujours, une curieuse sensation qu'il n'exploite pas la puissance de la machine de manière appropriée.

[escartefigue]

Cette syntaxe est invalide, ça ne peut pas être cette requête qui tourne, elle doit planter dès son lancement

[acaumes]

Mais c'est toujours sans résultat après 5 minutes ...

Bon, ta requête est peut être bonne (en enlevant les plus et les quotes) mais tu ne nous dis pas:

* Quel outil utilises tu pour la passer à SQLITE.

* Quel est le SQL de création de tes tables?

* Quels sont les index que tu as positionné sur ta table.

* As tu regardé le résultat de EXPLAIN?

Vu de mon côté avec le peu d'informations disponibles je dirai qu'il te faut au moins un index sur fullpath et sizefile dans les deux tables si tu veux avoir des délais raisonnables

Cordialement

[panthere noire]

Pour EXPLAIN j'ai regarder mai curieusement cela ne me retourne rien.

Quel outil utilises tu pour la passer à SQLITE

je code en C# j'utilise les paquet nuget a c'est effet , je me demande d'Alleur si le problème ne viens pas de là.

les paquet suivant:

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
 
Get-Package
 
Id                                  Versions                                 ProjectName                                                              
--                                  --------                                 -----------                                                              
EntityFramework                     {6.4.4}                                  Database                                                                 
Microsoft.Data.Sqlite               {5.0.0}                                  Database                                                                 
Microsoft.Data.Sqlite.Core          {5.0.0}                                  Database                                                                 
SQLitePCLRaw.bundle_e_sqlite3       {2.0.4}                                  Database                                                                 
SQLitePCLRaw.core                   {2.0.4}                                  Database                                                                 
SQLitePCLRaw.lib.e_sqlite3          {2.0.4}                                  Database                                                                 
SQLitePCLRaw.provider.dynamic_cdecl {2.0.4}                                  Database                                                                 
Stub.System.Data.SQLite.Core.Net... {1.0.113.3}                              Database                                                                 
System.Buffers                      {4.5.1}                                  Database                                                                 
System.Data.SQLite                  {1.0.113.6}                              Database                                                                 
System.Data.SQLite.Core             {1.0.113.6}                              Database                                                                 
System.Data.SQLite.EF6              {1.0.113.0}                              Database                                                                 
System.Data.SQLite.Linq             {1.0.113.0}                              Database                                                                 
System.Memory                       {4.5.4}                                  Database                                                                 
System.Numerics.Vectors             {4.5.0}                                  Database                                                                 
System.Runtime.CompilerServices.... {4.7.1}                                  Database

pour la création de la table:

Code :

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

1
2
 
"CREATE TABLE IF NOT EXISTS T_Fichier ( "subkey INTEGER NOT NULL, id INTEGER PRIMARY KEY,  fullpath TEXT T NULL, sizefile INTEGER NOT NULL, sha256 TEXT NOT NULL ");"

As tu regardé le résultat de EXPLAIN?

Oui, mai aucun résultat en retour.
Soit la lib ne prend par en charge, soit c est moi qui m'y prend mal comme c est nouveau je cherche a comprendre d'ou viens le problème.

si vous pouvez me donner la syntaxe voulue, car d'après la documentation il s'agirai de:

Code :

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

EXPLAIN QUERY PLAN

trouver ici (non officiel) https://sql.sh/cours/explain

Je précise il n'y a qu'une seul table. l'intérêt d'en avoir 2 compliquerai encore plus le problème
il n'y a aucune contrainte sur cette table. bref c est basique.

désoler pour les + c'est un oubli de ma par de ne pas l'avoir préciser, cela concatène la chaine et permet donc d'indenter le code. la string est enfermer par les "double quotes"

merci pour votre patience.

[acaumes]

Bon je ne connais pas vraiment c# mais un peu mieux SQLITE...

La syntaxe la plus intéressante :

Code :

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

1
2
3
4
5
6
7
EXPLAIN QUERY PLAN 
  SELECT * FROM T_FileTriDifference t1 WHERE  ( 
                     SELECT t1.id FROM T_Fichier  t2 WHERE 
                     t1.id <> t2.id AND 
                     t1.fullpath = t2.fullpath AND 
                     t1.sizefile = t2.sizefile AND 
                     t1.sha256 <> t2.sha256 ) ;

Si dans tes résultats tu vois ceci

SCAN TABLE T_FileTriDifference AS t1

tu es dans les choux car SQLITE va lire toute la table!

L'autre te donne les codes de la machine virtuelle...

[escartefigue]

SELECT * FROM T_FileTriDifference t1 WHERE (SELECT ... ça ne choque personne

[panthere noire]

pour moi qui débute, j'avoue que non

[acaumes]

Il manque le EXIST

[panthere noire]

Pour ce qui est du retour de "EXPLAIN QUERY PLAN"

je suis seulement parvenu à obtenir "init" .... je pense que cette lib ne supporte ce type d'instruction.

[acaumes]

Bon.

Va sur le site SQLITE et dans la zone des téléchargements télécharges les outils (sqlite-tools-XXX...) selon ton environnement.

Utilises le programme sqlite3 (il s'agit d'un programme en ligne de commandes que tu fermes avec ".quit") avec ta base de données en argument de lancement pour regarder ce que donne un explain avec la requête

Code :

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

1
2
3
4
5
6
7
 EXPLAIN QUERY PLAN
  SELECT * FROM T_FileTriDifference t1 WHERE  EXISTS(
                     SELECT t2.id FROM T_Fichier  t2 WHERE
                     t1.id <> t2.id AND
                     t1.fullpath = t2.fullpath AND
                     t1.sizefile = t2.sizefile AND
                     t1.sha256 <> t2.sha256 ) ;

Accessoirement la requête sans le EXIST fonctionne sur SQLITE... Il transforme le résultat en booléen avec les effets de bord que l'on peut imaginer (0 faux différent de 0 vrai...)

Cordialement

[panthere noire]

Merci pour ta réponse: voici le résulta.

Code :

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

1
2
3
4
QUERY PLAN
|--SCAN TABLE T_FileTriDifference AS t1
`--CORRELATED SCALAR SUBQUERY 1
   `--SCAN TABLE T_Fichier AS t2

Donc c'est ma requête qui tourne "pas rond" donc je fait quoi ?

je peux peut être revoir la structure et séparer les champs/table si cela peux changer le problème ?

Merci pour votre patience , et précision

[escartefigue]

Il est fort probable qu'aucun index soit éligible, d'où les deux tablescan (parcours séquentiel de toute la table)
Le premier est inévitable sur ce type de requête
Le deuxième par contre pourrait éventuellement être évité sous réserve d'avoir un critère de jointure indexable, mais le premier critère est WHERE t1.id <> t2.id AND et le quatrième est and t1.sha256 <> t2.sha256.
Or, l'opérateur <> n'est pas indexable.

Reste donc à savoir s'il existe des index éligibles pour les autres critères ? Il semble que non, on ne pourra en être certains qu'après avoir la description des index.

Merci donc de communiquer la description des tables et index, c'est requis pour une demande d'optimisation !

[acaumes]

Donc tu n'as aucun index!
Pour aller un peu plus vite, il t faut au moins créer celui ci :

Code :

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

1
2
3
4
CREATE INDEX [IDX_T_FICHIER_1]
ON [T_Fichier](
[fullpath] ASC,
[sizefile] ASC);

Cordialement

[escartefigue]

Tu vas un peu vite en besogne acaumes : créer un index n'aura d'intérêt que si ces colonnes présentent un nombre de valeurs distinctes significatif.
Si l'une et/ou l'autre de ces colonnes n'ont par exemple que 5 ou 6 valeurs différentes, alors l'index ne sera pas utilisé en lecture et pénalisera les modifications (INSERT, DELETE et UPDATE)

Avant de créer des index, il faut donc vérifier les statistiques sur ces deux colonnes

[acaumes]

oui c'est vrai mais comme il semble que la base contient des noms de fichiers et des tailles, j'en ai déduit (peut un peu vite) qu'un index pouvait être discriminant...

Cordialement