Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui
retournent le résultat à l'écran, en utilisant une requête dont le contenu
va dépendre de leur choix. Pour cela, j'utilise la méthode suivante :
================================================================
SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres"
Set Q = Db.QueryDefs("Marequete")
Q.SQL = SQL
Q.Close
"MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes
variables.
Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons
et des entêtes.
Mais pour cela, il faudrait que je puisse modifier dynamiquement mon
formulaire (puisque je ne sais pas à priori combien je vais avoir de
contrôle à faire afficher), en fonction de la liste des champs contenus dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au
format MDE, qui interdisent la création de formulaire.
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
Raymond [mvp]
Bonsoir.
Tu trouveras un exemple de base sur : http://access.seneque.free.fr/bases_exemples.htm N° 2
ce exemple exporte une requête dynamique mais affiche aussi la requête. tu devrais trouver des idées pour ton cas.
-- @+ Raymond Access MVP http://access.seneque.free.fr/ http://access2003.free.fr/ http://users.skynet.be/mpfa/ pour une meilleure efficacité de tes interventions sur MPFA
"Didier Fanget" a écrit dans le message de news:ZEMyb.55695$
Bonjour,
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui retournent le résultat à l'écran, en utilisant une requête dont le contenu va dépendre de leur choix. Pour cela, j'utilise la méthode suivante :
=============================================================== > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres"
Set Q = Db.QueryDefs("Marequete") Q.SQL = SQL Q.Close
DoCmd.OpenQuery "Marequete", acViewNormal =============================================================== > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes variables.
Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons
et des entêtes. Mais pour cela, il faudrait que je puisse modifier dynamiquement mon formulaire (puisque je ne sais pas à priori combien je vais avoir de contrôle à faire afficher), en fonction de la liste des champs contenus dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au format MDE, qui interdisent la création de formulaire.
Existe-t-il une solution à mon problème ?
Merci pour vos suggestions.
Bonsoir.
Tu trouveras un exemple de base sur :
http://access.seneque.free.fr/bases_exemples.htm N° 2
ce exemple exporte une requête dynamique mais affiche aussi la requête. tu
devrais trouver des idées pour ton cas.
--
@+
Raymond Access MVP
http://access.seneque.free.fr/
http://access2003.free.fr/
http://users.skynet.be/mpfa/ pour une meilleure
efficacité de tes interventions sur MPFA
"Didier Fanget" <didier.fanget@chello.fr> a écrit dans le message de
news:ZEMyb.55695$361.30591@news.chello.at...
Bonjour,
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui
retournent le résultat à l'écran, en utilisant une requête dont le contenu
va dépendre de leur choix. Pour cela, j'utilise la méthode suivante :
=============================================================== > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres"
Set Q = Db.QueryDefs("Marequete")
Q.SQL = SQL
Q.Close
DoCmd.OpenQuery "Marequete", acViewNormal
=============================================================== >
"MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce
qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes
variables.
Le "OpenQuery" est bien, mais je voudrais rendre la chose plus
ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des
boutons
et des entêtes.
Mais pour cela, il faudrait que je puisse modifier dynamiquement mon
formulaire (puisque je ne sais pas à priori combien je vais avoir de
contrôle à faire afficher), en fonction de la liste des champs contenus
dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au
format MDE, qui interdisent la création de formulaire.
Tu trouveras un exemple de base sur : http://access.seneque.free.fr/bases_exemples.htm N° 2
ce exemple exporte une requête dynamique mais affiche aussi la requête. tu devrais trouver des idées pour ton cas.
-- @+ Raymond Access MVP http://access.seneque.free.fr/ http://access2003.free.fr/ http://users.skynet.be/mpfa/ pour une meilleure efficacité de tes interventions sur MPFA
"Didier Fanget" a écrit dans le message de news:ZEMyb.55695$
Bonjour,
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui retournent le résultat à l'écran, en utilisant une requête dont le contenu va dépendre de leur choix. Pour cela, j'utilise la méthode suivante :
=============================================================== > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres"
Set Q = Db.QueryDefs("Marequete") Q.SQL = SQL Q.Close
DoCmd.OpenQuery "Marequete", acViewNormal =============================================================== > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes variables.
Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons
et des entêtes. Mais pour cela, il faudrait que je puisse modifier dynamiquement mon formulaire (puisque je ne sais pas à priori combien je vais avoir de contrôle à faire afficher), en fonction de la liste des champs contenus dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au format MDE, qui interdisent la création de formulaire.
Existe-t-il une solution à mon problème ?
Merci pour vos suggestions.
3stone
Salut,
"Didier Fanget"
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui retournent le résultat à l'écran, en utilisant une requête dont le contenu va dépendre de leur choix. Pour cela, j'utilise la méthode suivante : =============================================================== > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres" Set Q = Db.QueryDefs("Marequete") Q.SQL = SQL Q.Close DoCmd.OpenQuery "Marequete", acViewNormal =============================================================== > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui fait que je me retrouve avec une extraction ayant un nombre de colonnes variables. Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique, en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons et des entêtes. Mais pour cela, il faudrait que je puisse modifier dynamiquement mon formulaire (puisque je ne sais pas à priori combien je vais avoir de contrôle à faire afficher), en fonction de la liste des champs contenus dans la requête. Et cela n'est pas faisable, car je distribue des fichiers au format MDE, qui interdisent la création de formulaire.
Ayant le même besoin, il y a... un temps... j'avais fait ceci. Un sous formulaire avec une "série" de contrôles indépendants, numérotés de T0 à Tn , le tout présenté en "feuille de données". Il serait bon, par prudence, de limiter le nombre de champs dans la requête.
Code exécuté au chargement...
Dim intIndex As Integer Dim rst As Dao.Recordset Dim db As Dao.Database
Set db = CurrentDb Set rst = db.OpenRecordset("QryTemp")
With rst For intIndex = 0 To .Fields.Count - 1 Me.Controls("T" & intIndex).ControlSource = .Fields(intIndex).Name Next End With
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
Salut,
"Didier Fanget"
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui
retournent le résultat à l'écran, en utilisant une requête dont le contenu
va dépendre de leur choix. Pour cela, j'utilise la méthode suivante :
=============================================================== > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres"
Set Q = Db.QueryDefs("Marequete")
Q.SQL = SQL
Q.Close
DoCmd.OpenQuery "Marequete", acViewNormal
=============================================================== > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes
variables.
Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons
et des entêtes.
Mais pour cela, il faudrait que je puisse modifier dynamiquement mon
formulaire (puisque je ne sais pas à priori combien je vais avoir de
contrôle à faire afficher), en fonction de la liste des champs contenus dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au
format MDE, qui interdisent la création de formulaire.
Ayant le même besoin, il y a... un temps... j'avais fait ceci.
Un sous formulaire avec une "série" de contrôles indépendants,
numérotés de T0 à Tn , le tout présenté en "feuille de données".
Il serait bon, par prudence, de limiter le nombre de champs dans la requête.
Code exécuté au chargement...
Dim intIndex As Integer
Dim rst As Dao.Recordset
Dim db As Dao.Database
Set db = CurrentDb
Set rst = db.OpenRecordset("QryTemp")
With rst
For intIndex = 0 To .Fields.Count - 1
Me.Controls("T" & intIndex).ControlSource = .Fields(intIndex).Name
Next
End With
--
A+
Pierre (3stone) Access MVP
--------------------------------------
Une pour tous, tous pour une ;-)
http://users.skynet.be/mpfa/charte.htm
--------------------------------------
--
A+
Pierre (3stone) Access MVP
--------------------------------------
Une pour tous, tous pour une ;-)
http://users.skynet.be/mpfa/charte.htm
--------------------------------------
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui retournent le résultat à l'écran, en utilisant une requête dont le contenu va dépendre de leur choix. Pour cela, j'utilise la méthode suivante : =============================================================== > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres" Set Q = Db.QueryDefs("Marequete") Q.SQL = SQL Q.Close DoCmd.OpenQuery "Marequete", acViewNormal =============================================================== > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui fait que je me retrouve avec une extraction ayant un nombre de colonnes variables. Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique, en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons et des entêtes. Mais pour cela, il faudrait que je puisse modifier dynamiquement mon formulaire (puisque je ne sais pas à priori combien je vais avoir de contrôle à faire afficher), en fonction de la liste des champs contenus dans la requête. Et cela n'est pas faisable, car je distribue des fichiers au format MDE, qui interdisent la création de formulaire.
Ayant le même besoin, il y a... un temps... j'avais fait ceci. Un sous formulaire avec une "série" de contrôles indépendants, numérotés de T0 à Tn , le tout présenté en "feuille de données". Il serait bon, par prudence, de limiter le nombre de champs dans la requête.
Code exécuté au chargement...
Dim intIndex As Integer Dim rst As Dao.Recordset Dim db As Dao.Database
Set db = CurrentDb Set rst = db.OpenRecordset("QryTemp")
With rst For intIndex = 0 To .Fields.Count - 1 Me.Controls("T" & intIndex).ControlSource = .Fields(intIndex).Name Next End With
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
Didier Fanget
Oui, merci, c'est ce que je me suis résolu à faire. Mais il aurait été bien qu'il y ait une méthode plus intégrée.
A+
"3stone" a écrit dans le message de news: 3fcbc0e8$0$2871$
Salut,
"Didier Fanget"
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui
retournent le résultat à l'écran, en utilisant une requête dont le contenu
va dépendre de leur choix. Pour cela, j'utilise la méthode suivante : =============================================================== > > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres" Set Q = Db.QueryDefs("Marequete") Q.SQL = SQL Q.Close DoCmd.OpenQuery "Marequete", acViewNormal =============================================================== > > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes variables. Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons
et des entêtes. Mais pour cela, il faudrait que je puisse modifier dynamiquement mon formulaire (puisque je ne sais pas à priori combien je vais avoir de contrôle à faire afficher), en fonction de la liste des champs contenus dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au format MDE, qui interdisent la création de formulaire.
Ayant le même besoin, il y a... un temps... j'avais fait ceci. Un sous formulaire avec une "série" de contrôles indépendants, numérotés de T0 à Tn , le tout présenté en "feuille de données". Il serait bon, par prudence, de limiter le nombre de champs dans la requête.
Code exécuté au chargement...
Dim intIndex As Integer Dim rst As Dao.Recordset Dim db As Dao.Database
Set db = CurrentDb Set rst = db.OpenRecordset("QryTemp")
With rst For intIndex = 0 To .Fields.Count - 1 Me.Controls("T" & intIndex).ControlSource = .Fields(intIndex).Name Next End With
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
Oui, merci, c'est ce que je me suis résolu à faire.
Mais il aurait été bien qu'il y ait une méthode plus intégrée.
A+
"3stone" <3stone@skynet.be> a écrit dans le message de news:
3fcbc0e8$0$2871$ba620e4c@reader1.news.skynet.be...
Salut,
"Didier Fanget"
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées,
qui
retournent le résultat à l'écran, en utilisant une requête dont le
contenu
va dépendre de leur choix. Pour cela, j'utilise la méthode suivante :
=============================================================== > > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres"
Set Q = Db.QueryDefs("Marequete")
Q.SQL = SQL
Q.Close
DoCmd.OpenQuery "Marequete", acViewNormal
=============================================================== > > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce
qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes
variables.
Le "OpenQuery" est bien, mais je voudrais rendre la chose plus
ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des
boutons
et des entêtes.
Mais pour cela, il faudrait que je puisse modifier dynamiquement mon
formulaire (puisque je ne sais pas à priori combien je vais avoir de
contrôle à faire afficher), en fonction de la liste des champs contenus
dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au
format MDE, qui interdisent la création de formulaire.
Ayant le même besoin, il y a... un temps... j'avais fait ceci.
Un sous formulaire avec une "série" de contrôles indépendants,
numérotés de T0 à Tn , le tout présenté en "feuille de données".
Il serait bon, par prudence, de limiter le nombre de champs dans la
requête.
Code exécuté au chargement...
Dim intIndex As Integer
Dim rst As Dao.Recordset
Dim db As Dao.Database
Set db = CurrentDb
Set rst = db.OpenRecordset("QryTemp")
With rst
For intIndex = 0 To .Fields.Count - 1
Me.Controls("T" & intIndex).ControlSource = .Fields(intIndex).Name
Next
End With
--
A+
Pierre (3stone) Access MVP
--------------------------------------
Une pour tous, tous pour une ;-)
http://users.skynet.be/mpfa/charte.htm
--------------------------------------
--
A+
Pierre (3stone) Access MVP
--------------------------------------
Une pour tous, tous pour une ;-)
http://users.skynet.be/mpfa/charte.htm
--------------------------------------
Oui, merci, c'est ce que je me suis résolu à faire. Mais il aurait été bien qu'il y ait une méthode plus intégrée.
A+
"3stone" a écrit dans le message de news: 3fcbc0e8$0$2871$
Salut,
"Didier Fanget"
Mes utilisateurs peuvent actuellement créer des requêtes paramétrées, qui
retournent le résultat à l'écran, en utilisant une requête dont le contenu
va dépendre de leur choix. Pour cela, j'utilise la méthode suivante : =============================================================== > > SQL = "SELECT MesChamps FROM MesTables WHERE MesCriteres" Set Q = Db.QueryDefs("Marequete") Q.SQL = SQL Q.Close DoCmd.OpenQuery "Marequete", acViewNormal =============================================================== > > "MesChamps" et "MesTables" peuvent varier, en fonction de leur choix, ce qui
fait que je me retrouve avec une extraction ayant un nombre de colonnes variables. Le "OpenQuery" est bien, mais je voudrais rendre la chose plus ergonomique,
en insérant le tout dans un formulaire, afin de pouvoir ajouter des boutons
et des entêtes. Mais pour cela, il faudrait que je puisse modifier dynamiquement mon formulaire (puisque je ne sais pas à priori combien je vais avoir de contrôle à faire afficher), en fonction de la liste des champs contenus dans
la requête. Et cela n'est pas faisable, car je distribue des fichiers au format MDE, qui interdisent la création de formulaire.
Ayant le même besoin, il y a... un temps... j'avais fait ceci. Un sous formulaire avec une "série" de contrôles indépendants, numérotés de T0 à Tn , le tout présenté en "feuille de données". Il serait bon, par prudence, de limiter le nombre de champs dans la requête.
Code exécuté au chargement...
Dim intIndex As Integer Dim rst As Dao.Recordset Dim db As Dao.Database
Set db = CurrentDb Set rst = db.OpenRecordset("QryTemp")
With rst For intIndex = 0 To .Fields.Count - 1 Me.Controls("T" & intIndex).ControlSource = .Fields(intIndex).Name Next End With
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
-- A+ Pierre (3stone) Access MVP -------------------------------------- Une pour tous, tous pour une ;-) http://users.skynet.be/mpfa/charte.htm --------------------------------------
