champs1 champs2
123 a
123 a
123 b
124 c
126 d
126 d
126 d
127 d
127 d
127 e
127 e
je souhaite repere les valeurs du champs1 ayant + d'une
valeur differente ds le champs2
soit 123 et 127
je sais faire avec 2 requetes "superposees"
la premiere avec select distinct
la deuxieme avec select count group by sur cette premiere
mais existe un "2 en 1" ?
autre question j'ai entendu dire que ce n'etait pas tres
sain de faire des requetes "superposees". il y aurait des
limites internes (memoire ?) qui, au dela d'une certaine
taille, provoqueraient des resultats erronnes. cela est il
exact ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Gilles
Bonjour, Laurent
-----Message d'origine----- Bsr j'ai une table a peu pres comme suit champs1 champs2 123 a ... 127 e
je souhaite repere les valeurs du champs1 ayant + d'une valeur differente ds le champs2 soit 123 et 127 je sais faire avec 2 requetes "superposees" la premiere avec select distinct la deuxieme avec select count group by sur cette premiere mais existe un "2 en 1" ? autre question j'ai entendu dire que ce n'etait pas tres sain de faire des requetes "superposees". il y aurait des limites internes (memoire ?) qui, au dela d'une certaine taille, provoqueraient des resultats erronnes. cela est il exact ?
Merci
Pour faire cela en une seule requête, esssaye ceci:
SELECT champs1, Count(champs2) AS CompteDechamps2 FROM TaTable GROUP BY champs1 HAVING (((Count(champs2))>1));
Concernant les limites d'Access, consulte l'aide et cherche "caractéristiques". En Access 2002, le nombre de requêtes imbriquées est limité à 50 (il y a de la marge). Néanmoins, je pense que le temps d'exécution d'une requête imbriquée sera toujours plus long que celui d'une requête simple. En multi-utilisateur, les données peuvent donc avoir changé entre le moment où la requête est lancée et celui où le résultat s'affiche.
Bonne continuation Gilles
Bonjour, Laurent
-----Message d'origine-----
Bsr
j'ai une table a peu pres comme suit
champs1 champs2
123 a
...
127 e
je souhaite repere les valeurs du champs1 ayant + d'une
valeur differente ds le champs2
soit 123 et 127
je sais faire avec 2 requetes "superposees"
la premiere avec select distinct
la deuxieme avec select count group by sur cette premiere
mais existe un "2 en 1" ?
autre question j'ai entendu dire que ce n'etait pas tres
sain de faire des requetes "superposees". il y aurait des
limites internes (memoire ?) qui, au dela d'une certaine
taille, provoqueraient des resultats erronnes.
cela est il exact ?
Merci
Pour faire cela en une seule requête, esssaye ceci:
SELECT champs1, Count(champs2) AS CompteDechamps2
FROM TaTable
GROUP BY champs1
HAVING (((Count(champs2))>1));
Concernant les limites d'Access, consulte l'aide et
cherche "caractéristiques". En Access 2002, le nombre de
requêtes imbriquées est limité à 50 (il y a de la marge).
Néanmoins, je pense que le temps d'exécution d'une requête
imbriquée sera toujours plus long que celui d'une requête
simple. En multi-utilisateur, les données peuvent donc
avoir changé entre le moment où la requête est lancée et
celui où le résultat s'affiche.
-----Message d'origine----- Bsr j'ai une table a peu pres comme suit champs1 champs2 123 a ... 127 e
je souhaite repere les valeurs du champs1 ayant + d'une valeur differente ds le champs2 soit 123 et 127 je sais faire avec 2 requetes "superposees" la premiere avec select distinct la deuxieme avec select count group by sur cette premiere mais existe un "2 en 1" ? autre question j'ai entendu dire que ce n'etait pas tres sain de faire des requetes "superposees". il y aurait des limites internes (memoire ?) qui, au dela d'une certaine taille, provoqueraient des resultats erronnes. cela est il exact ?
Merci
Pour faire cela en une seule requête, esssaye ceci:
SELECT champs1, Count(champs2) AS CompteDechamps2 FROM TaTable GROUP BY champs1 HAVING (((Count(champs2))>1));
Concernant les limites d'Access, consulte l'aide et cherche "caractéristiques". En Access 2002, le nombre de requêtes imbriquées est limité à 50 (il y a de la marge). Néanmoins, je pense que le temps d'exécution d'une requête imbriquée sera toujours plus long que celui d'une requête simple. En multi-utilisateur, les données peuvent donc avoir changé entre le moment où la requête est lancée et celui où le résultat s'affiche.
Bonne continuation Gilles
laurent m
compte tenu de test commentaire je pense que je vais conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon probleme:
pour 123 a 123 a 124 a 124 b elle donnera 123 2 124 2
alors que je souhaite n'obtenir que 124 2. c'est pour cela que je commence avec un select distinct: ce qui m'interesse c'est de connaitre les occurrences du champs 1 ayant 2 champs 2 DIFFERENTS
Merci tout de meme.
-----Message d'origine----- Bonjour, Laurent
-----Message d'origine----- Bsr j'ai une table a peu pres comme suit champs1 champs2 123 a ... 127 e
je souhaite repere les valeurs du champs1 ayant + d'une valeur differente ds le champs2 soit 123 et 127 je sais faire avec 2 requetes "superposees" la premiere avec select distinct la deuxieme avec select count group by sur cette premiere mais existe un "2 en 1" ? autre question j'ai entendu dire que ce n'etait pas tres sain de faire des requetes "superposees". il y aurait des
limites internes (memoire ?) qui, au dela d'une certaine taille, provoqueraient des resultats erronnes. cela est il exact ?
Merci
Pour faire cela en une seule requête, esssaye ceci:
SELECT champs1, Count(champs2) AS CompteDechamps2 FROM TaTable GROUP BY champs1 HAVING (((Count(champs2))>1));
Concernant les limites d'Access, consulte l'aide et cherche "caractéristiques". En Access 2002, le nombre de requêtes imbriquées est limité à 50 (il y a de la marge). Néanmoins, je pense que le temps d'exécution d'une requête
imbriquée sera toujours plus long que celui d'une requête simple. En multi-utilisateur, les données peuvent donc avoir changé entre le moment où la requête est lancée et celui où le résultat s'affiche.
Bonne continuation Gilles .
compte tenu de test commentaire je pense que je vais
conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon
probleme:
pour
123 a
123 a
124 a
124 b
elle donnera
123 2
124 2
alors que je souhaite n'obtenir que 124 2. c'est pour cela
que je commence avec un select distinct: ce qui
m'interesse c'est de connaitre les occurrences du champs 1
ayant 2 champs 2 DIFFERENTS
Merci tout de meme.
-----Message d'origine-----
Bonjour, Laurent
-----Message d'origine-----
Bsr
j'ai une table a peu pres comme suit
champs1 champs2
123 a
...
127 e
je souhaite repere les valeurs du champs1 ayant + d'une
valeur differente ds le champs2
soit 123 et 127
je sais faire avec 2 requetes "superposees"
la premiere avec select distinct
la deuxieme avec select count group by sur cette premiere
mais existe un "2 en 1" ?
autre question j'ai entendu dire que ce n'etait pas tres
sain de faire des requetes "superposees". il y aurait
des
limites internes (memoire ?) qui, au dela d'une certaine
taille, provoqueraient des resultats erronnes.
cela est il exact ?
Merci
Pour faire cela en une seule requête, esssaye ceci:
SELECT champs1, Count(champs2) AS CompteDechamps2
FROM TaTable
GROUP BY champs1
HAVING (((Count(champs2))>1));
Concernant les limites d'Access, consulte l'aide et
cherche "caractéristiques". En Access 2002, le nombre de
requêtes imbriquées est limité à 50 (il y a de la marge).
Néanmoins, je pense que le temps d'exécution d'une
requête
imbriquée sera toujours plus long que celui d'une requête
simple. En multi-utilisateur, les données peuvent donc
avoir changé entre le moment où la requête est lancée et
celui où le résultat s'affiche.
compte tenu de test commentaire je pense que je vais conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon probleme:
pour 123 a 123 a 124 a 124 b elle donnera 123 2 124 2
alors que je souhaite n'obtenir que 124 2. c'est pour cela que je commence avec un select distinct: ce qui m'interesse c'est de connaitre les occurrences du champs 1 ayant 2 champs 2 DIFFERENTS
Merci tout de meme.
-----Message d'origine----- Bonjour, Laurent
-----Message d'origine----- Bsr j'ai une table a peu pres comme suit champs1 champs2 123 a ... 127 e
je souhaite repere les valeurs du champs1 ayant + d'une valeur differente ds le champs2 soit 123 et 127 je sais faire avec 2 requetes "superposees" la premiere avec select distinct la deuxieme avec select count group by sur cette premiere mais existe un "2 en 1" ? autre question j'ai entendu dire que ce n'etait pas tres sain de faire des requetes "superposees". il y aurait des
limites internes (memoire ?) qui, au dela d'une certaine taille, provoqueraient des resultats erronnes. cela est il exact ?
Merci
Pour faire cela en une seule requête, esssaye ceci:
SELECT champs1, Count(champs2) AS CompteDechamps2 FROM TaTable GROUP BY champs1 HAVING (((Count(champs2))>1));
Concernant les limites d'Access, consulte l'aide et cherche "caractéristiques". En Access 2002, le nombre de requêtes imbriquées est limité à 50 (il y a de la marge). Néanmoins, je pense que le temps d'exécution d'une requête
imbriquée sera toujours plus long que celui d'une requête simple. En multi-utilisateur, les données peuvent donc avoir changé entre le moment où la requête est lancée et celui où le résultat s'affiche.
Bonne continuation Gilles .
Gilles
Bonjour, Laurent
-----Message d'origine----- compte tenu de test commentaire je pense que je vais conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon probleme:
pour 123 a 123 a 124 a 124 b elle donnera 123 2 124 2
Merci tout de meme.
Effectivement, ma requête ne fait que répertorier les valeurs de Champs1 qui apparaissent plusieurs fois dans la table. Désolé pour cette réponse erronée...
Pour connaître les Champs1 associés à des Champs2 ayant des valeurs différentes, il faut plutôt faire une jointure sur la table et son "double" et n'afficher que les Champs1 pour lesquels Champs2 est différent entre les deux tables. Cela donne:
SELECT TaTable.Champs1 FROM TaTable INNER JOIN TaTable AS TaTable_1 ON TaTable.Champs1 = TaTable_1.Champs1 WHERE (((TaTable.Champs2)<>[TaTable_1].[Champs2])) GROUP BY TaTable.Champs1;
Je ne sais pas si tu as bien compris quand je parle de requêtes imbriquées, alors je détaille.
(Je ne connais pas tout du fonctionnement interne d'Access et du moteur Jet, alors, si je dis des bêtises, merci aux contributeurs plus avisés d'apporter les corrections nécessaires!)
Il s'agit de requêtes faisant appel à d'autres, autrement dit, c'est la méthode que tu utilises. Avant de résoudre la requête finale, Access doit résoudre toutes les requêtes appelées par celle-ci et toutes les autres contenues dans les sous-requêtes. C'est pour cela qu'il me semble que le temps d'exécution de ces requêtes devrait être plus long que pour des requêtes simples. Ce temps grandit encore selon la complexité de chaque requête, le nombre d'enregistrements, l'indexation des tables, selon que la base est ou non en réseau et/ou en multi-utilisateur... Pour toutes ces raisons, je pense qu'il est préférable de limiter l'utilisation des requêtes imbriquées ou, au moins, de limiter le niveau d'imbrication.
J'espère avoir été clair et excuse-moi encore pour ma réponse erronée.
Bonne continuation Gilles
Bonjour, Laurent
-----Message d'origine-----
compte tenu de test commentaire je pense que je vais
conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon
probleme:
pour
123 a
123 a
124 a
124 b
elle donnera
123 2
124 2
Merci tout de meme.
Effectivement, ma requête ne fait que répertorier les
valeurs de Champs1 qui apparaissent plusieurs fois dans la
table. Désolé pour cette réponse erronée...
Pour connaître les Champs1 associés à des Champs2 ayant
des valeurs différentes, il faut plutôt faire une jointure
sur la table et son "double" et n'afficher que les Champs1
pour lesquels Champs2 est différent entre les deux tables.
Cela donne:
SELECT TaTable.Champs1
FROM TaTable INNER JOIN TaTable AS TaTable_1 ON
TaTable.Champs1 = TaTable_1.Champs1
WHERE (((TaTable.Champs2)<>[TaTable_1].[Champs2]))
GROUP BY TaTable.Champs1;
Je ne sais pas si tu as bien compris quand je parle de
requêtes imbriquées, alors je détaille.
(Je ne connais pas tout du fonctionnement interne d'Access
et du moteur Jet, alors, si je dis des bêtises, merci aux
contributeurs plus avisés d'apporter les corrections
nécessaires!)
Il s'agit de requêtes faisant appel à d'autres, autrement
dit, c'est la méthode que tu utilises.
Avant de résoudre la requête finale, Access doit résoudre
toutes les requêtes appelées par celle-ci et toutes les
autres contenues dans les sous-requêtes. C'est pour cela
qu'il me semble que le temps d'exécution de ces requêtes
devrait être plus long que pour des requêtes simples. Ce
temps grandit encore selon la complexité de chaque
requête, le nombre d'enregistrements, l'indexation des
tables, selon que la base est ou non en réseau et/ou en
multi-utilisateur...
Pour toutes ces raisons, je pense qu'il est préférable de
limiter l'utilisation des requêtes imbriquées ou, au
moins, de limiter le niveau d'imbrication.
J'espère avoir été clair et excuse-moi encore pour ma
réponse erronée.
-----Message d'origine----- compte tenu de test commentaire je pense que je vais conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon probleme:
pour 123 a 123 a 124 a 124 b elle donnera 123 2 124 2
Merci tout de meme.
Effectivement, ma requête ne fait que répertorier les valeurs de Champs1 qui apparaissent plusieurs fois dans la table. Désolé pour cette réponse erronée...
Pour connaître les Champs1 associés à des Champs2 ayant des valeurs différentes, il faut plutôt faire une jointure sur la table et son "double" et n'afficher que les Champs1 pour lesquels Champs2 est différent entre les deux tables. Cela donne:
SELECT TaTable.Champs1 FROM TaTable INNER JOIN TaTable AS TaTable_1 ON TaTable.Champs1 = TaTable_1.Champs1 WHERE (((TaTable.Champs2)<>[TaTable_1].[Champs2])) GROUP BY TaTable.Champs1;
Je ne sais pas si tu as bien compris quand je parle de requêtes imbriquées, alors je détaille.
(Je ne connais pas tout du fonctionnement interne d'Access et du moteur Jet, alors, si je dis des bêtises, merci aux contributeurs plus avisés d'apporter les corrections nécessaires!)
Il s'agit de requêtes faisant appel à d'autres, autrement dit, c'est la méthode que tu utilises. Avant de résoudre la requête finale, Access doit résoudre toutes les requêtes appelées par celle-ci et toutes les autres contenues dans les sous-requêtes. C'est pour cela qu'il me semble que le temps d'exécution de ces requêtes devrait être plus long que pour des requêtes simples. Ce temps grandit encore selon la complexité de chaque requête, le nombre d'enregistrements, l'indexation des tables, selon que la base est ou non en réseau et/ou en multi-utilisateur... Pour toutes ces raisons, je pense qu'il est préférable de limiter l'utilisation des requêtes imbriquées ou, au moins, de limiter le niveau d'imbrication.
J'espère avoir été clair et excuse-moi encore pour ma réponse erronée.
Bonne continuation Gilles
Laurent m
C'est parfait desormais. merci
-----Message d'origine----- Bonjour, Laurent
-----Message d'origine----- compte tenu de test commentaire je pense que je vais conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon
probleme:
pour 123 a 123 a 124 a 124 b elle donnera 123 2 124 2
Merci tout de meme.
Effectivement, ma requête ne fait que répertorier les valeurs de Champs1 qui apparaissent plusieurs fois dans la
table. Désolé pour cette réponse erronée...
Pour connaître les Champs1 associés à des Champs2 ayant des valeurs différentes, il faut plutôt faire une jointure
sur la table et son "double" et n'afficher que les Champs1
pour lesquels Champs2 est différent entre les deux tables.
Cela donne:
SELECT TaTable.Champs1 FROM TaTable INNER JOIN TaTable AS TaTable_1 ON TaTable.Champs1 = TaTable_1.Champs1 WHERE (((TaTable.Champs2)<>[TaTable_1].[Champs2])) GROUP BY TaTable.Champs1;
Je ne sais pas si tu as bien compris quand je parle de requêtes imbriquées, alors je détaille.
(Je ne connais pas tout du fonctionnement interne d'Access
et du moteur Jet, alors, si je dis des bêtises, merci aux contributeurs plus avisés d'apporter les corrections nécessaires!)
Il s'agit de requêtes faisant appel à d'autres, autrement dit, c'est la méthode que tu utilises. Avant de résoudre la requête finale, Access doit résoudre toutes les requêtes appelées par celle-ci et toutes les autres contenues dans les sous-requêtes. C'est pour cela qu'il me semble que le temps d'exécution de ces requêtes devrait être plus long que pour des requêtes simples. Ce temps grandit encore selon la complexité de chaque requête, le nombre d'enregistrements, l'indexation des tables, selon que la base est ou non en réseau et/ou en multi-utilisateur... Pour toutes ces raisons, je pense qu'il est préférable de limiter l'utilisation des requêtes imbriquées ou, au moins, de limiter le niveau d'imbrication.
J'espère avoir été clair et excuse-moi encore pour ma réponse erronée.
Bonne continuation Gilles .
C'est parfait desormais.
merci
-----Message d'origine-----
Bonjour, Laurent
-----Message d'origine-----
compte tenu de test commentaire je pense que je vais
conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond
mon
probleme:
pour
123 a
123 a
124 a
124 b
elle donnera
123 2
124 2
Merci tout de meme.
Effectivement, ma requête ne fait que répertorier les
valeurs de Champs1 qui apparaissent plusieurs fois dans
la
table. Désolé pour cette réponse erronée...
Pour connaître les Champs1 associés à des Champs2 ayant
des valeurs différentes, il faut plutôt faire une
jointure
sur la table et son "double" et n'afficher que les
Champs1
pour lesquels Champs2 est différent entre les deux
tables.
Cela donne:
SELECT TaTable.Champs1
FROM TaTable INNER JOIN TaTable AS TaTable_1 ON
TaTable.Champs1 = TaTable_1.Champs1
WHERE (((TaTable.Champs2)<>[TaTable_1].[Champs2]))
GROUP BY TaTable.Champs1;
Je ne sais pas si tu as bien compris quand je parle de
requêtes imbriquées, alors je détaille.
(Je ne connais pas tout du fonctionnement interne
d'Access
et du moteur Jet, alors, si je dis des bêtises, merci aux
contributeurs plus avisés d'apporter les corrections
nécessaires!)
Il s'agit de requêtes faisant appel à d'autres, autrement
dit, c'est la méthode que tu utilises.
Avant de résoudre la requête finale, Access doit résoudre
toutes les requêtes appelées par celle-ci et toutes les
autres contenues dans les sous-requêtes. C'est pour cela
qu'il me semble que le temps d'exécution de ces requêtes
devrait être plus long que pour des requêtes simples. Ce
temps grandit encore selon la complexité de chaque
requête, le nombre d'enregistrements, l'indexation des
tables, selon que la base est ou non en réseau et/ou en
multi-utilisateur...
Pour toutes ces raisons, je pense qu'il est préférable de
limiter l'utilisation des requêtes imbriquées ou, au
moins, de limiter le niveau d'imbrication.
J'espère avoir été clair et excuse-moi encore pour ma
réponse erronée.
-----Message d'origine----- compte tenu de test commentaire je pense que je vais conserver la meme approche en 2 requetes.
j'ai aussi l'impression que ta solution ne correspond mon
probleme:
pour 123 a 123 a 124 a 124 b elle donnera 123 2 124 2
Merci tout de meme.
Effectivement, ma requête ne fait que répertorier les valeurs de Champs1 qui apparaissent plusieurs fois dans la
table. Désolé pour cette réponse erronée...
Pour connaître les Champs1 associés à des Champs2 ayant des valeurs différentes, il faut plutôt faire une jointure
sur la table et son "double" et n'afficher que les Champs1
pour lesquels Champs2 est différent entre les deux tables.
Cela donne:
SELECT TaTable.Champs1 FROM TaTable INNER JOIN TaTable AS TaTable_1 ON TaTable.Champs1 = TaTable_1.Champs1 WHERE (((TaTable.Champs2)<>[TaTable_1].[Champs2])) GROUP BY TaTable.Champs1;
Je ne sais pas si tu as bien compris quand je parle de requêtes imbriquées, alors je détaille.
(Je ne connais pas tout du fonctionnement interne d'Access
et du moteur Jet, alors, si je dis des bêtises, merci aux contributeurs plus avisés d'apporter les corrections nécessaires!)
Il s'agit de requêtes faisant appel à d'autres, autrement dit, c'est la méthode que tu utilises. Avant de résoudre la requête finale, Access doit résoudre toutes les requêtes appelées par celle-ci et toutes les autres contenues dans les sous-requêtes. C'est pour cela qu'il me semble que le temps d'exécution de ces requêtes devrait être plus long que pour des requêtes simples. Ce temps grandit encore selon la complexité de chaque requête, le nombre d'enregistrements, l'indexation des tables, selon que la base est ou non en réseau et/ou en multi-utilisateur... Pour toutes ces raisons, je pense qu'il est préférable de limiter l'utilisation des requêtes imbriquées ou, au moins, de limiter le niveau d'imbrication.
J'espère avoir été clair et excuse-moi encore pour ma réponse erronée.
