Bojour,
je voudrais savoir si sur access on pouvait rechercher un mot dans une table
entiere
(non pour un seul champs mais pour tous les champs de cette table)
exemple: table client avec les champs suivant
id nom adresse cp ville
01 toto rue fr 75000 paris
02 tata rue de 75000 paris
03 titi toto 75000 paris
04 tutu rue 75000 tokkkkk
j'aimerais obtenir toutes les enregistrement qui présentent le mot "to"
le résultat serait donc :
id nom adresse cp ville
01 toto rue fr 75000 paris
03 titi toto 75000 paris
04 tutu rue 75000 tokkkkk
.../... parti trop vite ! Et la fonction comme cà : Function Kumquat(strNomTable As String, strCle As String, _ lngRang As String) As String
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
yannick
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde , je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé. vois tu pourquoi cette différence?
Cordialement
Yannick
..../... parti trop vite ! Et la fonction comme cà : Function Kumquat(strNomTable As String, strCle As String, _ lngRang As String) As String
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas
c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat.
Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les
fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
..../...
parti trop vite !
Et la fonction comme cà :
Function Kumquat(strNomTable As String, strCle As String, _
lngRang As String) As String
--
A+
Eric
http://www.mpfa.info/
Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde , je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé. vois tu pourquoi cette différence?
Cordialement
Yannick
..../... parti trop vite ! Et la fonction comme cà : Function Kumquat(strNomTable As String, strCle As String, _ lngRang As String) As String
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà expérimenté ce problème. La solution que j'avais trouvée et qui permettait d'obtenir un résultat beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*" UNION SELECT * FROM LaTable WHERE Adresse= "*to*" UNION SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de savoir ce que vont devenir tes 12 secondes avec cette méthode.....
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"yannick" a écrit dans le message de news:
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà
expérimenté ce problème.
La solution que j'avais trouvée et qui permettait d'obtenir un résultat
beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*"
UNION
SELECT * FROM LaTable WHERE Adresse= "*to*"
UNION
SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de
savoir ce que vont devenir tes 12 secondes avec cette méthode.....
--
A+
Arnaud
-----------------------------------------------------
Tout ce qu'il faut savoir est sur http://www.mpfa.info
-----------------------------------------------------
"yannick" <yannick@discussions.microsoft.com> a écrit dans le message de
news:83EF241C-2EE4-4869-9168-CC91B24F6E50@microsoft.com...
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas
c'est que lorque j'utilse les fonctions le resultat s'execute en 12
seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1
seconde
j'ai le résultat.
Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les
fonctions pour les rappeler pour d'autres formulaires mais la je suis
coincé.
Pour les problèmes de performances d'une requete SQL, j'avais déjà expérimenté ce problème. La solution que j'avais trouvée et qui permettait d'obtenir un résultat beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*" UNION SELECT * FROM LaTable WHERE Adresse= "*to*" UNION SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de savoir ce que vont devenir tes 12 secondes avec cette méthode.....
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"yannick" a écrit dans le message de news:
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
yannick
Avec la solution que tu m'as donne (avec le Having) en concatenant ou le Or de Eric c'est hyper rapide, mais Eric ma suggerer une autre methode au lieu de saisir tout mes champs qui celle avec une fonction globale, elle fonctionne mais elle met 12 seconde. Pourtant je ne vois pas la difference, a mon avis ça doit etre la maniere de lecture des enregistrements en memoire 12 secondes en faisant cela: SELECT * FROM client WHERE (((Kumquat1("client","N°client",[N°client])) Like [test]));
Function Kumquat1(strNomTable As String, strCle As String, _ lngRang As String) As String
Dim rst As DAO.Recordset, f As DAO.Field, newf As String Set rst = CurrentDb.OpenRecordset( _ "Select * from [" & strNomTable & "] Where [" _ & strCle & "]='" & lngRang & "'")
For Each f In rst.Fields newf = newf & " " & f.Value Next f Kumquat1 = newf rst.Close Set rst = Nothing End Function Bizzare, bizzare @+
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà expérimenté ce problème. La solution que j'avais trouvée et qui permettait d'obtenir un résultat beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*" UNION SELECT * FROM LaTable WHERE Adresse= "*to*" UNION SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de savoir ce que vont devenir tes 12 secondes avec cette méthode.....
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"yannick" a écrit dans le message de news:
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
Avec la solution que tu m'as donne (avec le Having) en concatenant ou le Or
de Eric c'est hyper rapide, mais Eric ma suggerer une autre methode au lieu
de saisir tout mes champs qui celle avec une fonction globale, elle
fonctionne mais elle met 12 seconde.
Pourtant je ne vois pas la difference, a mon avis ça doit etre la maniere de
lecture des enregistrements en memoire
12 secondes en faisant cela:
SELECT *
FROM client
WHERE (((Kumquat1("client","N°client",[N°client])) Like [test]));
Function Kumquat1(strNomTable As String, strCle As String, _
lngRang As String) As String
Dim rst As DAO.Recordset, f As DAO.Field, newf As String
Set rst = CurrentDb.OpenRecordset( _
"Select * from [" & strNomTable & "] Where [" _
& strCle & "]='" & lngRang & "'")
For Each f In rst.Fields
newf = newf & " " & f.Value
Next f
Kumquat1 = newf
rst.Close
Set rst = Nothing
End Function
Bizzare, bizzare
@+
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà
expérimenté ce problème.
La solution que j'avais trouvée et qui permettait d'obtenir un résultat
beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*"
UNION
SELECT * FROM LaTable WHERE Adresse= "*to*"
UNION
SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de
savoir ce que vont devenir tes 12 secondes avec cette méthode.....
--
A+
Arnaud
-----------------------------------------------------
Tout ce qu'il faut savoir est sur http://www.mpfa.info
-----------------------------------------------------
"yannick" <yannick@discussions.microsoft.com> a écrit dans le message de
news:83EF241C-2EE4-4869-9168-CC91B24F6E50@microsoft.com...
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas
c'est que lorque j'utilse les fonctions le resultat s'execute en 12
seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1
seconde
j'ai le résultat.
Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les
fonctions pour les rappeler pour d'autres formulaires mais la je suis
coincé.
Avec la solution que tu m'as donne (avec le Having) en concatenant ou le Or de Eric c'est hyper rapide, mais Eric ma suggerer une autre methode au lieu de saisir tout mes champs qui celle avec une fonction globale, elle fonctionne mais elle met 12 seconde. Pourtant je ne vois pas la difference, a mon avis ça doit etre la maniere de lecture des enregistrements en memoire 12 secondes en faisant cela: SELECT * FROM client WHERE (((Kumquat1("client","N°client",[N°client])) Like [test]));
Function Kumquat1(strNomTable As String, strCle As String, _ lngRang As String) As String
Dim rst As DAO.Recordset, f As DAO.Field, newf As String Set rst = CurrentDb.OpenRecordset( _ "Select * from [" & strNomTable & "] Where [" _ & strCle & "]='" & lngRang & "'")
For Each f In rst.Fields newf = newf & " " & f.Value Next f Kumquat1 = newf rst.Close Set rst = Nothing End Function Bizzare, bizzare @+
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà expérimenté ce problème. La solution que j'avais trouvée et qui permettait d'obtenir un résultat beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*" UNION SELECT * FROM LaTable WHERE Adresse= "*to*" UNION SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de savoir ce que vont devenir tes 12 secondes avec cette méthode.....
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"yannick" a écrit dans le message de news:
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
yannick
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que les autres sauf pour la méthode d'Eric avec les fonctions globales Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà expérimenté ce problème. La solution que j'avais trouvée et qui permettait d'obtenir un résultat beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*" UNION SELECT * FROM LaTable WHERE Adresse= "*to*" UNION SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de savoir ce que vont devenir tes 12 secondes avec cette méthode.....
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"yannick" a écrit dans le message de news:
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que
les autres sauf pour la méthode d'Eric avec les fonctions globales
Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà
expérimenté ce problème.
La solution que j'avais trouvée et qui permettait d'obtenir un résultat
beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*"
UNION
SELECT * FROM LaTable WHERE Adresse= "*to*"
UNION
SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de
savoir ce que vont devenir tes 12 secondes avec cette méthode.....
--
A+
Arnaud
-----------------------------------------------------
Tout ce qu'il faut savoir est sur http://www.mpfa.info
-----------------------------------------------------
"yannick" <yannick@discussions.microsoft.com> a écrit dans le message de
news:83EF241C-2EE4-4869-9168-CC91B24F6E50@microsoft.com...
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas
c'est que lorque j'utilse les fonctions le resultat s'execute en 12
seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1
seconde
j'ai le résultat.
Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les
fonctions pour les rappeler pour d'autres formulaires mais la je suis
coincé.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que les autres sauf pour la méthode d'Eric avec les fonctions globales Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
Salut
Pour les problèmes de performances d'une requete SQL, j'avais déjà expérimenté ce problème. La solution que j'avais trouvée et qui permettait d'obtenir un résultat beaucoup plus rapidement consistait à bâtir ta requete comme ceci :
SELECT * FROM LaTable WHERE Nom= "*to*" UNION SELECT * FROM LaTable WHERE Adresse= "*to*" UNION SELECT * FROM LaTable WHERE Ville= "*to*";
Attention : cette requête n'est plus modifiable....mais je serais curieux de savoir ce que vont devenir tes 12 secondes avec cette méthode.....
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"yannick" a écrit dans le message de news:
j'ai essayer avec de l'apha cela fonctionne mais ce que je ne comprend pas c'est que lorque j'utilse les fonctions le resultat s'execute en 12 seconde ,
je n'ai plus la main alorsque si je ne passe pas par celles-ci en 1 seconde
j'ai le résultat. Surprenant. C'est bizzare. J'aurais bien voulu pourtant utilser les fonctions pour les rappeler pour d'autres formulaires mais la je suis coincé.
vois tu pourquoi cette différence?
Cordialement
Yannick
Eric
Bonsoir,
Normal que ça soit plus long puisque pour chaque enregistrement du jeu j'ouvre un recordset sur la même table pour concaténer les valeurs, le referme et enfin passe la chaine à la fonction. Donc, si ton jeu contient 21000 enregistrements, la fonction ouvre en plus 21000 recordset d'un enregistrement. Par contre, je ne pensais pas arriver à un temps aussi pénalisant voire médiocre. Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que les autres sauf pour la méthode d'Eric avec les fonctions globales Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Bonsoir,
Normal que ça soit plus long puisque pour chaque enregistrement du jeu
j'ouvre un recordset sur la même table pour concaténer les valeurs, le
referme et enfin passe la chaine à la fonction. Donc, si ton jeu
contient 21000 enregistrements, la fonction ouvre en plus 21000
recordset d'un enregistrement. Par contre, je ne pensais pas arriver à
un temps aussi pénalisant voire médiocre.
Mon idée initiale était de ne pas avoir à faire la concaténation à la
main dans le générateur de requête.
Ma fonction doit être mal faite ---> A la poubelle.
Arnaud t'a proposé 2 solutions qui font leurs preuves.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que
les autres sauf pour la méthode d'Eric avec les fonctions globales
Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
--
A+
Eric
http://www.mpfa.info/
Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Normal que ça soit plus long puisque pour chaque enregistrement du jeu j'ouvre un recordset sur la même table pour concaténer les valeurs, le referme et enfin passe la chaine à la fonction. Donc, si ton jeu contient 21000 enregistrements, la fonction ouvre en plus 21000 recordset d'un enregistrement. Par contre, je ne pensais pas arriver à un temps aussi pénalisant voire médiocre. Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que les autres sauf pour la méthode d'Eric avec les fonctions globales Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
yannick
Bonjour et Merci pour tous j'utilise la methode du having de Arnaud sinon la tienne avec le Or tourne aussi vite, sinon pour ta fonction c'etait bien pensé pourtant.
Bon dimanche
@+
Yannick
Bonsoir,
Normal que ça soit plus long puisque pour chaque enregistrement du jeu j'ouvre un recordset sur la même table pour concaténer les valeurs, le referme et enfin passe la chaine à la fonction. Donc, si ton jeu contient 21000 enregistrements, la fonction ouvre en plus 21000 recordset d'un enregistrement. Par contre, je ne pensais pas arriver à un temps aussi pénalisant voire médiocre. Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que les autres sauf pour la méthode d'Eric avec les fonctions globales Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Bonjour et Merci pour tous
j'utilise la methode du having de Arnaud sinon la tienne avec le Or tourne
aussi vite, sinon pour ta fonction c'etait bien pensé pourtant.
Bon dimanche
@+
Yannick
Bonsoir,
Normal que ça soit plus long puisque pour chaque enregistrement du jeu
j'ouvre un recordset sur la même table pour concaténer les valeurs, le
referme et enfin passe la chaine à la fonction. Donc, si ton jeu
contient 21000 enregistrements, la fonction ouvre en plus 21000
recordset d'un enregistrement. Par contre, je ne pensais pas arriver à
un temps aussi pénalisant voire médiocre.
Mon idée initiale était de ne pas avoir à faire la concaténation à la
main dans le générateur de requête.
Ma fonction doit être mal faite ---> A la poubelle.
Arnaud t'a proposé 2 solutions qui font leurs preuves.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que
les autres sauf pour la méthode d'Eric avec les fonctions globales
Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
--
A+
Eric
http://www.mpfa.info/
Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Bonjour et Merci pour tous j'utilise la methode du having de Arnaud sinon la tienne avec le Or tourne aussi vite, sinon pour ta fonction c'etait bien pensé pourtant.
Bon dimanche
@+
Yannick
Bonsoir,
Normal que ça soit plus long puisque pour chaque enregistrement du jeu j'ouvre un recordset sur la même table pour concaténer les valeurs, le referme et enfin passe la chaine à la fonction. Donc, si ton jeu contient 21000 enregistrements, la fonction ouvre en plus 21000 recordset d'un enregistrement. Par contre, je ne pensais pas arriver à un temps aussi pénalisant voire médiocre. Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
j'ajoute j'ai essayé avec les requetes union, elles sont aussi rapides que les autres sauf pour la méthode d'Eric avec les fonctions globales Je suis donc obliger de le faire pour tous mes champs manuelement.
Donc la méthode avec les fonctions globales est à revoir
Bonne soirée et je remercie.
@+
Yannick
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Salut Eric,
"Eric" a écrit dans le message de news:
Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
une 3ème solution idée comme ça qui permettrait de combiner les deux méthodes.
Le code SQL serait de la forme : "select * from latable where " & fConcatChamps(latable) & " like '*to*'"
L'idée serait de créer une fonction qui liste et concatène tous les champs de latable elle retournerait donc tout simplement champ1&champ2&champ3......&champ999
ensuite, on rajoute un paramètre pour le critère, on currentdb.exécute ça et c'est automatique sans ouvrir de recordset à chaque fois ;-)))
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
Salut Eric,
"Eric" <f_framZZ@hotmail.com> a écrit dans le message de
news:uIbqUru8FHA.1000@tk2msftngp13.phx.gbl...
Mon idée initiale était de ne pas avoir à faire la concaténation à la
main dans le générateur de requête.
Ma fonction doit être mal faite ---> A la poubelle.
Arnaud t'a proposé 2 solutions qui font leurs preuves.
une 3ème solution idée comme ça qui permettrait de combiner les deux
méthodes.
Le code SQL serait de la forme :
"select * from latable where " & fConcatChamps(latable) & " like '*to*'"
L'idée serait de créer une fonction qui liste et concatène tous les champs
de latable
elle retournerait donc tout simplement champ1&champ2&champ3......&champ999
ensuite, on rajoute un paramètre pour le critère, on currentdb.exécute ça et
c'est automatique sans ouvrir de recordset à chaque fois ;-)))
--
A+
Arnaud
-----------------------------------------------------
Tout ce qu'il faut savoir est sur http://www.mpfa.info
-----------------------------------------------------
Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
une 3ème solution idée comme ça qui permettrait de combiner les deux méthodes.
Le code SQL serait de la forme : "select * from latable where " & fConcatChamps(latable) & " like '*to*'"
L'idée serait de créer une fonction qui liste et concatène tous les champs de latable elle retournerait donc tout simplement champ1&champ2&champ3......&champ999
ensuite, on rajoute un paramètre pour le critère, on currentdb.exécute ça et c'est automatique sans ouvrir de recordset à chaque fois ;-)))
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
Eric
Bonjour Arnaud,
Oui, j' y avais pensé mais je ne sais pas comment faire évaluer dans la requête la chaine concaténée. Même avec Eval() je n'y suis pas arrivé dans le générateur de requêtes. Toutefois j'ai contourné le problème de la manière suivante:
Une fonction qui : 1 - concatène les champs de la table passée en paramètre et qui demande les caracères à comparer. 2 - Création d'une requête temporaire qui est ouverte ( ;-) ) 3 - Affichage des résultats 4 - Suppression de la query temporaire.
Cette fonction est appelée sur le clic d'un bouton de formulaire (inconvénient éventuel mais on court-circuite le générateur). Ca donne le code ci-dessous mais à parfaire évidemment.
Il faudrait que Yannick teste pour donner une évaluation des temps de réponse par rapport aux autres méthodes.
Function fConcatChamps(UneTable As String) Dim t As DAO.TableDef, f As DAO.Field Dim qry As DAO.QueryDef, reponse As String Dim strsql As String For i = 0 To CurrentDb.TableDefs(UneTable).Fields.Count - 1 LesChamps = LesChamps & "[" & _ CurrentDb.TableDefs(UneTable).Fields(i).Name & "] & " Next i reponse = InputBox("Caractère(s) cherché(s)") strsql = "select * from " & UneTable & _ " where " & Left(LesChamps, Len(LesChamps) - 3) & _ " like '*" & Trim(reponse) & "*'" Set qry = CurrentDb.CreateQueryDef("tmp", strsql) DoCmd.OpenQuery "tmp" CurrentDb.QueryDefs.Delete "tmp" Set qry = Nothing End Function
Sur l'évènement clic d'un bouton de formulaire : Private Sub Commande0_Click() Dim reponse As String, msg As String msg = "Nom de la table où" & _ vbCrLf & "s'effectue la recherche ?" reponse = InputBox(msg) If Len(reponse) = 0 Then MsgBox " Action interrompue", vbInformation Else reponse = Trim(reponse) fConcatChamps (reponse) End If End Sub
Salut Eric,
"Eric" a écrit dans le message de news:
Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
une 3ème solution idée comme ça qui permettrait de combiner les deux méthodes.
Le code SQL serait de la forme : "select * from latable where " & fConcatChamps(latable) & " like '*to*'"
L'idée serait de créer une fonction qui liste et concatène tous les champs de latable elle retournerait donc tout simplement champ1&champ2&champ3......&champ999
ensuite, on rajoute un paramètre pour le critère, on currentdb.exécute ça et c'est automatique sans ouvrir de recordset à chaque fois ;-)))
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Bonjour Arnaud,
Oui, j' y avais pensé mais je ne sais pas comment faire évaluer dans la
requête la chaine concaténée. Même avec Eval() je n'y suis pas arrivé
dans le générateur de requêtes.
Toutefois j'ai contourné le problème de la manière suivante:
Une fonction qui :
1 - concatène les champs de la table passée en paramètre et qui demande
les caracères à comparer.
2 - Création d'une requête temporaire qui est ouverte ( ;-) )
3 - Affichage des résultats
4 - Suppression de la query temporaire.
Cette fonction est appelée sur le clic d'un bouton de formulaire
(inconvénient éventuel mais on court-circuite le générateur). Ca donne
le code ci-dessous mais à parfaire évidemment.
Il faudrait que Yannick teste pour donner une évaluation des temps de
réponse par rapport aux autres méthodes.
Function fConcatChamps(UneTable As String)
Dim t As DAO.TableDef, f As DAO.Field
Dim qry As DAO.QueryDef, reponse As String
Dim strsql As String
For i = 0 To CurrentDb.TableDefs(UneTable).Fields.Count - 1
LesChamps = LesChamps & "[" & _
CurrentDb.TableDefs(UneTable).Fields(i).Name & "] & "
Next i
reponse = InputBox("Caractère(s) cherché(s)")
strsql = "select * from " & UneTable & _
" where " & Left(LesChamps, Len(LesChamps) - 3) & _
" like '*" & Trim(reponse) & "*'"
Set qry = CurrentDb.CreateQueryDef("tmp", strsql)
DoCmd.OpenQuery "tmp"
CurrentDb.QueryDefs.Delete "tmp"
Set qry = Nothing
End Function
Sur l'évènement clic d'un bouton de formulaire :
Private Sub Commande0_Click()
Dim reponse As String, msg As String
msg = "Nom de la table où" & _
vbCrLf & "s'effectue la recherche ?"
reponse = InputBox(msg)
If Len(reponse) = 0 Then
MsgBox " Action interrompue", vbInformation
Else
reponse = Trim(reponse)
fConcatChamps (reponse)
End If
End Sub
Salut Eric,
"Eric" <f_framZZ@hotmail.com> a écrit dans le message de
news:uIbqUru8FHA.1000@tk2msftngp13.phx.gbl...
Mon idée initiale était de ne pas avoir à faire la concaténation à la
main dans le générateur de requête.
Ma fonction doit être mal faite ---> A la poubelle.
Arnaud t'a proposé 2 solutions qui font leurs preuves.
une 3ème solution idée comme ça qui permettrait de combiner les deux
méthodes.
Le code SQL serait de la forme :
"select * from latable where " & fConcatChamps(latable) & " like '*to*'"
L'idée serait de créer une fonction qui liste et concatène tous les champs
de latable
elle retournerait donc tout simplement champ1&champ2&champ3......&champ999
ensuite, on rajoute un paramètre pour le critère, on currentdb.exécute ça et
c'est automatique sans ouvrir de recordset à chaque fois ;-)))
--
A+
Eric
http://www.mpfa.info/
Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Oui, j' y avais pensé mais je ne sais pas comment faire évaluer dans la requête la chaine concaténée. Même avec Eval() je n'y suis pas arrivé dans le générateur de requêtes. Toutefois j'ai contourné le problème de la manière suivante:
Une fonction qui : 1 - concatène les champs de la table passée en paramètre et qui demande les caracères à comparer. 2 - Création d'une requête temporaire qui est ouverte ( ;-) ) 3 - Affichage des résultats 4 - Suppression de la query temporaire.
Cette fonction est appelée sur le clic d'un bouton de formulaire (inconvénient éventuel mais on court-circuite le générateur). Ca donne le code ci-dessous mais à parfaire évidemment.
Il faudrait que Yannick teste pour donner une évaluation des temps de réponse par rapport aux autres méthodes.
Function fConcatChamps(UneTable As String) Dim t As DAO.TableDef, f As DAO.Field Dim qry As DAO.QueryDef, reponse As String Dim strsql As String For i = 0 To CurrentDb.TableDefs(UneTable).Fields.Count - 1 LesChamps = LesChamps & "[" & _ CurrentDb.TableDefs(UneTable).Fields(i).Name & "] & " Next i reponse = InputBox("Caractère(s) cherché(s)") strsql = "select * from " & UneTable & _ " where " & Left(LesChamps, Len(LesChamps) - 3) & _ " like '*" & Trim(reponse) & "*'" Set qry = CurrentDb.CreateQueryDef("tmp", strsql) DoCmd.OpenQuery "tmp" CurrentDb.QueryDefs.Delete "tmp" Set qry = Nothing End Function
Sur l'évènement clic d'un bouton de formulaire : Private Sub Commande0_Click() Dim reponse As String, msg As String msg = "Nom de la table où" & _ vbCrLf & "s'effectue la recherche ?" reponse = InputBox(msg) If Len(reponse) = 0 Then MsgBox " Action interrompue", vbInformation Else reponse = Trim(reponse) fConcatChamps (reponse) End If End Sub
Salut Eric,
"Eric" a écrit dans le message de news:
Mon idée initiale était de ne pas avoir à faire la concaténation à la main dans le générateur de requête. Ma fonction doit être mal faite ---> A la poubelle. Arnaud t'a proposé 2 solutions qui font leurs preuves.
une 3ème solution idée comme ça qui permettrait de combiner les deux méthodes.
Le code SQL serait de la forme : "select * from latable where " & fConcatChamps(latable) & " like '*to*'"
L'idée serait de créer une fonction qui liste et concatène tous les champs de latable elle retournerait donc tout simplement champ1&champ2&champ3......&champ999
ensuite, on rajoute un paramètre pour le critère, on currentdb.exécute ça et c'est automatique sans ouvrir de recordset à chaque fois ;-)))
-- A+ Eric http://www.mpfa.info/ Archives : http://groups.google.fr/group/microsoft.public.fr.access?hl=fr
Salut Eric
bien bien, et moi il faudra que je réinstalle office un de ces jours pour tester tout ça aussi ;-)
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
"Eric" a écrit dans le message de news:%
Bonjour Arnaud,
Function fConcatChamps(UneTable As String)
Salut Eric
bien bien, et moi il faudra que je réinstalle office un de ces jours pour
tester tout ça aussi ;-)
--
A+
Arnaud
-----------------------------------------------------
Tout ce qu'il faut savoir est sur http://www.mpfa.info
-----------------------------------------------------
"Eric" <f_framZZ@hotmail.com> a écrit dans le message de
news:%23tuRAv08FHA.3660@TK2MSFTNGP09.phx.gbl...
bien bien, et moi il faudra que je réinstalle office un de ces jours pour tester tout ça aussi ;-)
-- A+ Arnaud ----------------------------------------------------- Tout ce qu'il faut savoir est sur http://www.mpfa.info -----------------------------------------------------
