Formulaire d'accès à l'exécution d'une requête et afficher les résultats

Sur la base des réponses, je suppose que je n'ai pas compris la question. On dirait que l'OP a un DML requête (ou "requête de l'action" dans les conditions d'Accès) qui modifie les données et veut afficher les résultats dans une forme. L'actuel réponses expliquer comment afficher les résultats, mais pas la façon d'exécuter la requête.

Donc, voici une réponse basée sur mon interprétation de la question.

Tout d'abord, créez un processus continu ou formulaire de feuille de données qui est liée aux résultats.

C'est la partie facile. Le "dur" de la partie est de l'exécution de SQL pour faire les mises à jour dont les résultats, vous allez à l'écran. Vous ne donnez pas n'importe quel contexte pour lequel vous êtes le lancement de ce, ni comment vous déterminer les enregistrements particuliers pour la mise à jour, donc je vais vous donner deux assez générique réponses.

La méthode 1. créer une macro avec deux parties:

1. la première commande est OpenQuery et que vous souhaitez fournir le nom de votre requête enregistrée comme argument.

2. la deuxième commande est OpenForm qui ouvre le formulaire que vous avez créé pour afficher les résultats.

Maintenant, je n'ai pas fourni toute méthode d'exécution de la macro, mais c'est parce que vous n'avez pas à fournir de tout contexte.

La méthode 2. sur une forme à partir de laquelle il convient d'initier ce processus:

1. créer un système comand bouton.

2. utiliser l'événement OnClick pour effectuer l'action souhaitée.

   un. utiliser la macro que vous avez écrit avec la Méthode 1 comme argument pour l'événement OnClick du bouton de commande.

   b. écrire du code VBA pour accomplir les deux tâches:

   CurrentDB.Execute "MySaveQueryThatUpdatesData", dbFailOneError
   DoCmd.OpenForm "MyFormThatDisplaysTheResults"

Mais c'est vraiment la mendicité questions, comme cela est plutôt carrément élémentaire. La partie la plus difficile de ce genre de chose arrive lorsque votre SQL de mise à jour est sur un sous-ensemble d'enregistrements et que vous avez besoin pour afficher uniquement les sous-ensemble d'enregistrements.

Il est très probable que votre requête d'origine, sera saisi pour le contexte d'origine. Dire, par exemple, que vous souhaitez lancer, l'ensemble du processus à partir d'un formulaire qui affiche les Entreprises et SQL fonctionne sur les Employés de l'Entreprise. Dans ce cas, vous souhaitez une mise à jour de la table Employés limitée à l'Entreprise que vous êtes en train de visualiser. Il y a deux façons de le faire:

1. utiliser une référence à la CompanyID dans la forme de la Société dans la clause where de votre enregistrés QueryDef:

   UPDATE Employees
   SET [blah, blah, blah]
   WHERE Employees.CompanyID = Forms!Company!CompanyID

2. au lieu d'utiliser une version sauvegardée de l'objet QueryDef programmés pour exiger que votre Entreprise soit ouverte pour que cela fonctionne, écrire du SQL à la volée dans le code de votre bouton de commande:

   Dim strSQL As String
   strSQL = "UPDATE Employees "
   strSQL = strSQL & "SET [blah, blah, blah] "
   strSQL = strSQL & "WHERE Employees.CompanyID = "
   strSQL = strSQL & Me!CompanyID
   CurrentDB.Execute strSQL, dbFailOneError

Maintenant, pour la deuxième partie, vous devez ouvrir le formulaire de résultats à afficher uniquement les enregistrements qui ont été mis à jour. Cela signifie que vous souhaitez que le formulaire ouvert avec la même clause where comme a été utilisé pour la mise à jour. Il existe deux méthodes pour cela, aussi.

1. la première est très semblable à la première méthode pour effectuer la mise à jour, c'est à dire, de brancher la référence à la forme de la Société dans la clause where de votre formulaire de résultats source (Recordsource) de la clause where. Donc, la Source de votre formulaire de résultats devrait ressembler à ceci:

   SELECT Employees.*
   FROM Employees
   WHERE Employees.CompanyID = Forms!Company!CompanyID

   Vous devez alors ouvrir le formulaire de résultats de la même façon qu'à l'origine, a déclaré:

   DoCmd.OpenForm "MyFormThatDisplaysTheResults"

2. la deuxième approche permet d'éviter de brancher la Source de votre formulaire de résultats pour exiger de la Société, le formulaire doit être ouvert, et au lieu de cela, vous venez d'approvisionnement de la clause where (sans le mot-clé where) dans le paramètre approprié de la OpenForm commande:

   DoCmd.OpenForm "MyFormThatDisplaysTheResults", , , "[CompanyID] = " & Me!CompanyID

   Cet apprentissage est l'un des plus puissant et facile aspects de l'utilisation de l'Accès, puisque vous pouvez créer un formulaire qui renvoie tous les enregistrements dans une table, et ensuite ouvrir ce formulaire et afficher des sous-ensembles de données en fournissant à la appropriée dans les cas OÙ le paramètre dans le OpenForm de commande. Gardez à l'esprit que l'Accès applique de manière très efficace, qui est, il n'a pas ouvert la forment et se chargent de l'ensemble du jeu d'enregistrements et d'appliquer ensuite la OÙ argument, mais s'applique à la OÙ des paramètres de la source avant tous les enregistrements sont chargés dans le formulaire.

Maintenant, un examen de ce qui est la meilleure façon de se sortir de toutes les alternatives:

Je voudrais écrire du SQL à la volée pour la mise à jour et l'utilisation de la OÙ le paramètre de la OpenForm commande pour faire le filtrage. Ainsi, dans une de mes applications, le code de l'événement OnClick de votre bouton de commande sur la forme de la Société devrait ressembler à ceci:

  Dim strSQL As String

  strSQL = "UPDATE Employees "
  strSQL = strSQL & "SET [blah, blah, blah] "
  strSQL = strSQL & "WHERE Employees.CompanyID = "
  strSQL = strSQL & Me!CompanyID
  CurrentDB.Execute strSQL, dbFailOneError
  DoCmd.OpenForm "MyFormThatDisplaysTheResults", , , "[CompanyID] = " & Me!CompanyID

Maintenant, en raison de l'argument dbFailOnError pour CurrentDB.Exécuter, vous auriez besoin d'un gestionnaire d'erreur. Et si vous voulez savoir combien de dossiers où ils ont changé, vous devez utiliser un objet de base de données autre que CurrentDB, donc plus probable, je ferais comme ceci:

On Error GoTo errHandler
  Dim strSQL As String
  Dim db As DAO.Database

  strSQL = "UPDATE Employees "
  strSQL = strSQL & "SET [blah, blah, blah] "
  strSQL = strSQL & "WHERE Employees.CompanyID = "
  strSQL = strSQL & Me!CompanyID
  Set db = CurrentDB
  db.Execute strSQL, dbFailOneError
  Debug.Print "Updated " & db.RecordsAffect & " Employee records."
  DoCmd.OpenForm "MyFormThatDisplaysTheResults", , , "[CompanyID] = " & Me!CompanyID

exitRoutine:
  Set db = Nothing
  Exit Sub

errHandler:
  MsgBox Err.Number & ": " & Err.Description, _
    vbExclamation, "Error in Forms!Company!cmdMyButton.OnClick()"
  Resume exitRoutine

Ma raison pour la construction du SQL à la volée dans le OnClick du bouton de commande de l'événement est de sorte qu'il est très facile d'ajouter en plus des critères devraient-ils devenir nécessaire. Je tiens à éviter de surcharger mon enregistré QueryDefs avec dépendances sur les objets de l'INTERFACE utilisateur, donc j'ai tendance à écrire de SQL comme ça à la volée dans l'endroit où il est utilisé.

Certaines personnes craignent que cela dégrade les performances, car à la volée SQL n'est pas optimisé par votre moteur de base de données de l'optimiseur de requête. Cela peut ou peut ne pas être vrai. Beaucoup de serveur de base de données des moteurs de cache optimisation des plans de à la volée des commandes SQL, et à cause de la Jet/ACE traite une commande SQL comme ceci et les mains vers le serveur, il est susceptible d'être envoyé en tant que générique de la procédure stockée. À cause de cela, un serveur SQL Server cache de plan de requête et être en mesure de ré-utiliser chaque fois que vous exécutez la à la volée SQL, même si à chaque fois il a un autre CompanyID valeur.

Avec un Jet/ACE back-end, il n'y a pas de mise en cache comme ça, mais la différence de temps d'exécution entre l'optimisation et unoptimized SQL va être très faible dans tous les cas où vous n'êtes pas d'exploitation sur de très grands ensembles de données. Et même la mise à jour, disons, 1000 dossiers des employés n'est pas quelque chose qui compte comme un grand jeu de données pour Jet/ACE. Donc, je pense qu'il y a rarement assez de performances, de l'écriture SQL à la volée pour justifier de le déplacer vers une version sauvegardée de l'objet QueryDef. Cependant, au cas par cas, je pourrais très bien choisir de le faire-ce n'est pas mon premier choix.

La plus importante objection, cependant, c'est que vous aurez un tas de chaînes SQL parsemé tout au long de votre code, et cela peut devenir un entretien cauchemar. Je ne sais pas quoi dire à ce sujet, sauf qu'il y a des façons de le gérer que de telles que vous éliminer autant de répétitions que possible, soit par l'enregistrement d'une base de SÉLECTIONNER une requête query as a enregistré QueryDef et l'utilisation de tels que le SQL que vous construisez dans le code est unique uniquement les parties spécifiques à l'action, dans ce cas particulier, ou à l'aide de constantes définies dans votre code qui maintiennent la base SQL que vous utilisez (par exemple que vous n'avez qu'à changer la définition de la constante de changer les résultats partout où il est utilisé).

Qui est assez faible, mais avec l'Accès, je ne vois pas d'alternative. Si vous enregistrez chaque instruction SQL d'un objet QueryDef vous vous retrouvez avec un autre type de ingérable mess avec le trop grand nombre de requêtes enregistrées, chacune légèrement différente de l'autre, et il peut être tout aussi redondants que SQL répété dans le code.

Mais c'est un autre problème, et je ne devrais pas faire cela plus longtemps en essayant de le résoudre ici!