Optimisation de mon code SVP ?

Le
Pascal
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un mot
de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela traine
et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];", ,
dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 2
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Christian Hugoud
Le #15353231
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres et
plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------



Pascal
Le #15353211
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud"
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot & "];",
, dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------







Christian Hugoud
Le #15353201
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.

"Pascal"
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" news:
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament que
pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------










Pascal
Le #15353191
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des fois
que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal



"Christian Hugoud"
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec des
long, toujours.

"Pascal"
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" news:
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne scrutes
plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8 lettres
et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour un
mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------














Christian Hugoud
Le #15353181
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...

Peut être le InsStr est long ?

"Pascal"
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal



"Christian Hugoud" news:
Oui, mais il faut que microprocesseur convertisse ton byte en long, dans
tous les cas. Il semblerait que ce soit plus rapide de travailler avec
des long, toujours.

"Pascal"
Hello Christian
merci pour ta réponse
mais Dim LongueurMOt ne dépasse JAMAIS 15 donc byte est bien approprié!
pour MotAnalyser j'aurai pu y penser, bien vu
merci à toi
Pascal

"Christian Hugoud" news:
Hi,

D'abord : Dim longueurMot As Byte devient Dim longueurMot As Long

Dim MotAnalyser as string

Ensuite :


For f = 0 To Me.LstMotAnalyser.ListCount - 1
MotAnalyser = UCase(LstMotAnalyser.List(f)) 'tu ne
scrutes plus la liste à chaque boucle
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0
Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If

rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
rs.MoveFirst
Next f

Essaies déjà cela...

Christian

"Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code
sachant que LstMotAnalyser est variable 18.000 pour un mot de 8
lettres et plus au dessus
et que le champ à vérifier de la base Access en contient 18.059(pour
un mot de 8 lettres) et 20.000 pour un mot de 10 lettres
cela ne pose pas trop de problème tant que longueurMot = 6, a 8 cela
traine et pour un mot de 10, je peux partir faire mes courses!
j'avais penser à une requête ACCESS, mais ne connait pas suffisament
que pour mettre en place!
si KKun a une idée, voir une très bonne!, serai sympa de m'éclairer
bien à tous
Pascal


'-------------------------------------------------------------------------------------------
'défini le dico à ouvrir
Dim longueurMot As Byte
'prend la longueur du mot
longueurMot = Len(LstMotAnalyser.List(0))
'ouvre la base Access et la table coorespondante
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

'compare les mots avec le Dico
' ouverture d 'une requête sur la table
Set rs = db.OpenRecordset("select*from[" & longueurMot &
"];", , dbForwardOnly)

For f = 0 To Me.LstMotAnalyser.ListCount - 1
Do While Not rs.EOF
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then
LstMotCompatible.AddItem LstMotAnalyser.List(f)
End If
'passe au suivant
rs.MoveNext
LstMotAnalyser.ListIndex = f
Loop
'repositionne l'index sur le premier
rs.MoveFirst
Next f
'referme la requete proprement
rs.Close
End Sub
'-------------------------------------------------------------------------------------------

















Pascal
Le #15353171
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?

Après, je n'ennuie plus personne avec cela!

Bien à toi
Pascal


"Christian Hugoud" %
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...

Peut être le InsStr est long ?

"Pascal"
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal




Pascal
Le #15353161
Re, Re, Re
ai pu encore gagner environ 6,2 secondes en déplacant
LstMotAnalyser.ListIndex = f qui était mal placé
je l'ai mis après le loop.....
mais toujours pas suffisant pour des mots supérieur à 7 lettres, GRRRRRRRR

Bat
Pascal

"Pascal"
hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes
sur l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans
la base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?

Après, je n'ennuie plus personne avec cela!

Bien à toi
Pascal


"Christian Hugoud" news: %
Je ne pense pas car en fait, tu vas juste récupérer l'accès au pointeur.
Faut essayer...

Peut être le InsStr est long ?

"Pascal"
Ah bon! je ne savais pas cela
merci pour l'info!
pour motanalyser, je gagne un petit peu en vitesse même en ajoutant:
If InStr(1, rs.Fields(1).Value, MotAnalyser ) > 0 Then
LstMotCompatible.AddItem MotAnalyser <--------
mais pas suffisament pour un mot de 10 ou 15 lettres.
j'avais penser, (dis-moi si c'est une erreur)
plustôt que d'ouvrir chaque fois la table appropriée, n'en faire qu'une
seule avec l'inconvenient qu'elle sera plus importante à parcourir. Des
fois que l'on gagnerai en vitesse ouverture/fermeture table?

Bien à toi
Pascal







François Picalausa
Le #15353151
On Oct 9, 1:06 pm, "Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code


<snip>
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then


<snip>


Hello,

Je n'ai pas suivi l'entièreté de la discussion, mais néanmoins, je
pense que l'article suivant de la faq pourait t'être utile:
http://faq.vb.free.fr/index.php?question7

François Picalausa
Pascal
Le #15353141
merci, je planche la dessus
B à Toi
Pascal

"François Picalausa"
On Oct 9, 1:06 pm, "Pascal"
Bien le bonjour,
je cherche à optimiser cette partie de mon code


<snip>
If InStr(1, rs.Fields(1).Value,
UCase(LstMotAnalyser.List(f))) > 0 Then


<snip>


Hello,

Je n'ai pas suivi l'entièreté de la discussion, mais néanmoins, je
pense que l'article suivant de la faq pourait t'être utile:
http://faq.vb.free.fr/index.php?question7

François Picalausa
Serial # 19781010
Le #15353101
On Tue, 9 Oct 2007 20:22:29 +0200, "Pascal" wrote:

hello,
oui, InsStr est de type Variant (long)
le fait de passer de byte à Long, je gagne effectivement 4/10 secondes sur
l'ensemble(test fait sur mot de 8 lettres)
Autre idée: du fait d'une base ACCESS, je pourrai créer une requête dans la
base et faire appel à celle-ci à partir de VB6! mais comment ajouter le
résultat de ma requête dans un ListView?



J'inclurais la sélection dans la requête (pas la peine de ramener
toute la table pour chaque mot cherché). Il faudrait aussi indexer le
champ recherché dans chaque table de la base Access. Quelque chose
comme ça en supposant que le champ sur lequel porte la recherche soit
nommé "mot" :


Sub Main()

Dim db As DataBase
Dim sMotFind As String
Dim f As Long
Dim sSql As String
Dim longueurMot As Long
Dim rs As RecordSet

longueurMot = Len(LstMotAnalyser.List(0))
Set db = DAO.Workspaces(0).OpenDatabase(MA_BASE_ACCESS, False,
False)

For f = 0 To LstMotAnalyser.ListCount - 1
sMotFind = LstMotAnalyser.List(f)
sMotFind = Replace(sMotFind, "'", "''")
sSql ="select mot from [" & longueurMot & "] where mot like '" &
sMotFind & "*';"
Set rs = db.OpenRecordset(sSql,dbForwardOnly)
RstToList rs, LstMotCompatible
Next f

rs.Close
Set rs = Nothing
db.Close
Set db = Nothing

End Sub

Private Function RstToList(rs As RecordSet, lst As ListBox)

Do While Not rs.EOF
lst.AddItem rs.Filed("mot")
rs.MoveNext
Loop

End Function


Ceci dit, j'ai l'impression que tu cherches un mot de n lettres dans
une table ne contenant que des mots de n lettres. Auquel cas la clause
where pourrait même se simplifier en "where mot ='" & sMotFind & "';"
(ce qui serait plus rapide et plus besoin de parcourir le recordset
dans ce cas : s'il est vide le mot n'existe pas, sinon il existe et on
l'ajoute à la liste). D'autre part, on pourrait aussi grouper
plusieurs critères dans chaque requête.
Publicité
Poster une réponse
Anonyme