Jeu d'enregistrements : liaison dynamique de colonnes de données (ODBC)
Mise à jour : novembre 2007
Cette rubrique s'applique aux classes ODBC MFC.
Les jeux d'enregistrements gèrent la liaison des colonnes de table que vous spécifiez au moment du design ; cependant, dans certains cas, il se peut que vous souhaitiez lier des colonnes dont vous n'aviez pas connaissance à ce moment-là. Cette rubrique explique :
dans quels cas vous pourriez vouloir lier dynamiquement des colonnes à un jeu d'enregistrements ;
comment lier dynamiquement des colonnes lors de l'exécution.
.gif "Remarque") Remarque : |
|---|
Cette rubrique s'applique aux objets dérivés de CRecordset dans lesquels l'extraction de lignes en bloc n'a pas été implémentée. Les techniques présentées sont généralement déconseillées si vous utilisez l'extraction de lignes en bloc. Pour plus d'informations sur l'extraction de lignes en bloc, consultez Jeu d'enregistrements : extraction globale d'enregistrements (ODBC). |
Cas de liaison dynamique de colonnes
Au moment du design, l'Assistant Création d'applications MFC ou l'Assistant Consommateur ODBC MFC (depuis l'Assistant Ajouter une classe) crée des classes de jeu d'enregistrements à partir des tables et colonnes connues de votre source de données. Les bases de données peuvent avoir été modifiées entre le moment où vous les avez conçues et celui où l'application utilise leurs tables et les colonnes au moment de l'exécution. Il se peut que vous-même ou un autre utilisateur ait ajouté ou supprimé la table ou les colonnes sur lesquelles le jeu d'enregistrements de l'application s'appuie. Ce problème ne concerne pas nécessairement toutes les applications accédant aux données, mais si tel est le cas, comment pouvez-vous faire face à ces modifications du schéma de la base de données autrement qu'au moyen d'une nouvelle création et d'une nouvelle compilation ? L'objectif de la présente rubrique est de répondre à cette question.
Elle décrit le cas le plus fréquent où vous pourriez lier des colonnes dynamiquement : après avoir commencé avec un jeu d'enregistrements fondé sur un schéma de base de données connu, vous souhaitez gérer des colonnes supplémentaires à l'exécution. La rubrique présume que les colonnes supplémentaires correspondent aux membres de données de type champ CString (le cas le plus fréquent), même si l'article contient des suggestions destinées à vous permettre de gérer d'autres types de données.
Avec quelques lignes de code supplémentaires, vous pouvez :
déterminer les colonnes disponibles à l'exécution ;
lier dynamiquement de nouvelles colonnes au jeu d'enregistrements lors de l'exécution.
Le jeu d'enregistrements contient toujours les membres de données des colonnes dont vous connaissiez l'existence au moment du design. Il contient aussi quelques lignes de code supplémentaires qui déterminent dynamiquement si de nouvelles colonnes ont été ajoutées à la base de données cible et, si tel est le cas, lie ces nouvelles colonnes au stockage alloué dynamiquement (plutôt qu'aux membres de données du jeu d'enregistrements).
Cette rubrique ne traite aucun autre cas de liaison dynamique, comme les tables ou colonnes supprimées. Pour gérer de tels cas, vous devez utiliser les appels d'API ODBC d'une façon plus directe. Pour plus d'informations, consultez le guide ODBC SDK Programmer's Reference sur le CD-ROM MSDN Library.
Liaison dynamique de colonnes
Pour lier des colonnes de manière dynamique, vous devez connaître (ou être en mesure de déterminer) les noms des colonnes supplémentaires. Vous devez aussi allouer un espace de stockage pour les membres de données additionnels de type champ et indiquer le nombre de colonnes ajoutées.
La discussion ci-après fait état de deux jeux d'enregistrements différents. Le premier correspond au jeu d'enregistrements principal qui sélectionne les enregistrements de la table cible. Le second est un jeu d'enregistrements particulier destiné à obtenir les informations sur les colonnes de la table cible.
Processus général
Au niveau le plus général, utilisez la procédure suivante :
Construisez l'objet recordset principal.
Le cas échéant, passez un pointeur à l'objet ouvert CDatabase ou soyez à même de fournir des informations de connexion au jeu d'enregistrements des colonnes d'une façon ou d'une autre.
Utilisez la procédure permettant d'ajouter dynamiquement des colonnes.
Consultez à cette fin la procédure décrite dans « Ajout de colonnes » (voir plus bas).
Ouvrez le jeu d'enregistrements principal.
Le jeu d'enregistrements sélectionne les enregistrements et utilise RFX pour lier à la fois les colonnes statiques (celles qui sont mappées aux membres de données de type champ de recordset) et les colonnes dynamiques (mappées à l'espace de stockage supplémentaire que vous avez alloué).
Ajout de colonnes
La liaison dynamique des colonnes ajoutées à l'exécution nécessite les étapes suivantes :
Déterminez à l'exécution les colonnes qui figurent dans la table cible. Extraire de ces informations la liste des colonnes ayant été ajoutées à la table depuis que la classe de jeu d'enregistrements a été conçue.
Une bonne solution consiste à utiliser une classe de jeu d'enregistrements de colonnes conçue pour interroger la source de données sur les informations de colonnes de la table cible (nom de colonne et type de données, par exemple).
Prévoyez le stockage destiné aux nouveaux membres de données de type champ. Comme la classe de jeu d'enregistrements principale ne possède pas de membres de données de type champ pour les colonnes inconnues, vous devez définir un emplacement pour stocker les noms, les résultats et, éventuellement, les informations sur les types de données (si les colonnes ont des types de données différents).
Une solution consiste à créer une ou plusieurs listes dynamiques, une première pour les nouveaux noms de colonnes, une deuxième pour les résultats et une troisième pour les types de données (si nécessaire). Ces listes, particulièrement celle des valeurs des résultats, fournissent les informations et le stockage nécessaire à la liaison. La figure ci-après illustre la création de ces listes.
Création des listes de colonnes pour la liaison dynamique
.gif)
Ajoutez un appel de fonctions RFX dans la fonction DoFieldExchange du jeu d'enregistrements principal pour chaque colonne ajoutée. Ces appels RFX effectuent le travail d'extraction d'un enregistrement, colonnes supplémentaires incluses, et de liaison des colonnes aux membres de données du jeu d'enregistrements ou à l'espace de stockage réservé dynamiquement à leur attention.
Une solution consiste à ajouter une boucle à la fonction DoFieldExchange du jeu d'enregistrements principal : la boucle s'applique à la liste des nouvelles colonnes et appelle la fonction RFX appropriée pour chaque colonne de la liste. À chaque appel de fonction RFX, passez un nom de colonne de la liste des noms de colonnes et un emplacement de stockage dans le membre correspondant de la liste des valeurs de résultats.
Listes des colonnes
Les quatre listes que vous devez utiliser sont affichées dans le tableau suivant.
Current-Table-Columns (liste 1 de l'illustration)
Liste des colonnes figurant dans la table de la source de données. Cette liste peut correspondre à la liste des colonnes actuellement liées du jeu d'enregistrements.Bound-Recordset-Columns (liste 2 de l'illustration)
Liste des colonnes liées du jeu d'enregistrements. Ces colonnes disposent déjà d'instructions RFX dans la fonction DoFieldExchange.Columns-To-Bind-Dynamically (liste 3 de l'illustration)
Liste des colonnes figurant dans la table mais non dans le jeu d'enregistrements. Ces colonnes sont celles que vous devez lier dynamiquement.Dynamic-Column-Values (liste 4 de l'illustration)
Liste contenant le stockage pour les valeurs récupérées des colonnes que vous liez dynamiquement. Les éléments de cette liste correspondent, un à un, à celles de la liste Columns-to-Bind-Dynamically.
Création des listes
La stratégie générale définie, vous pouvez maintenant vous consacrer aux détails. Les procédures décrites dans le reste de la rubrique vous expliquent comment créer les listes affichées dans Listes des colonnes. Les procédures vous aident à :
déterminer les noms de colonnes ne figurant pas dans le jeu d'enregistrements ;
réserver l'espace de stockage dynamique pour les colonnes nouvellement ajoutées à la table ;
ajouter dynamiquement les appels RFX pour les nouvelles colonnes.
Détermination des colonnes de tables ne figurant pas dans le jeu d'enregistrements
Construisez une liste (Bound-Recordset-Columns, comme dans la liste 2 de l'illustration) qui contient la liste des colonnes déjà liées dans votre jeu d'enregistrements principal. Puis, construisez une liste (Columns-to-Bind-Dynamically, dérivée de Current-Table-Columns et de Bound-Recordset-Columns) qui contient les noms de colonnes figurant dans la table de la source de données mais non dans votre jeu d'enregistrements principal.
Pour déterminer les noms des colonnes ne figurant pas dans le jeu d'enregistrements (Columns-to-Bind-Dynamically)
Construisez la liste (Bound-Recordset-Columns) des colonnes déjà liées dans votre jeu d'enregistrements principal.
Une solution consiste à créer Bound-Recordset-Columns au moment du design. Vous pouvez examiner visuellement les appels de fonction RFX dans la fonction DoFieldExchange du jeu d'enregistrements pour obtenir ces noms. Puis, configurez votre liste sous forme de tableau initialisé à l'aide des noms.
Par exemple, l'illustration montre Bound-Recordset-Columns (liste 2) avec trois éléments. Bound-Recordset-Columns ne contient pas la colonne Phone illustrée dans Current-Table-Columns (liste 1).
Comparez Current-Table-Columns et Bound-Recordset-Columns pour construire la liste (Columns-to-Bind-Dynamically) des colonnes non déjà liées dans votre jeu d'enregistrements principal.
Une solution consiste à définir une boucle sur la liste des colonnes de la table à l'exécution (Current-Table-Columns) et parallèlement sur celle des colonnes déjà liées dans le jeu d'enregistrements (Bound-Recordset-Columns). Dans la liste Columns-to-Bind-Dynamically, placez les noms de Current-Table-Columns qui ne figurent pas dans Bound-Recordset-Columns.
Par exemple, l'illustration montre Columns-to-Bind-Dynamically (liste 3) avec un seul élément : la colonne Phone trouvée dans Current-Table-Columns (liste 1), mais non dans Bound-Recordset-Columns (liste 2).
Construisez la liste Dynamic-Column-Values (comme dans la liste 4 de l'illustration) dans laquelle sont stockées les valeurs des données correspondant à chaque nom de colonne stocké dans la liste des colonnes à lier dynamiquement (Columns-to-Bind-Dynamically).
Les éléments de cette liste jouent le rôle de nouveaux membres de données de type champ de recordset. Il s'agit des emplacements de stockage auxquels les colonnes dynamiques sont liées. Pour une description des listes, consultez Listes des colonnes.
Stockage des nouvelles colonnes
Ensuite, définissez les emplacements de stockage des colonnes à lier dynamiquement. L'idée est de fournir un élément de liste dans lequel stocker chaque valeur de colonne. Ces emplacements de stockage sont parallèles aux variables membres du jeu d'enregistrements, lesquelles stockent les colonnes liées normalement.
Pour fournir un stockage dynamique aux nouvelles colonnes (Dynamic-Column-Values)
Construisez Dynamic-Column-Values en parallèle à Columns-to-Bind-Dynamically, pour contenir la valeur des données de chaque colonne.
Par exemple, l'illustration montre Dynamic-Column-Values (liste 4) avec un seul élément : un objet CString contenant le numéro de téléphone de l'enregistrement courant (555-1212).
Dans le cas le plus courant, Dynamic-Column-Values possède des éléments du type CString. Si vous gérez des colonnes ayant des types de données différents, vous aurez besoin d'une liste qui puisse contenir des éléments d'une grande diversité de types.
Le résultat des procédures précédentes se compose de deux listes : Columns-to-Bind-Dynamically contient les noms des colonnes et Dynamic-Column-Values contient les valeurs des colonnes de l'enregistrement courant.
| Conseil : |
|---|
Si les nouvelles colonnes n'ont pas toutes le même type de données, il se peut que vouliez disposer d'une liste parallèle supplémentaire, contenant les éléments qui définissent d'une façon ou une autre le type de chaque élément correspondant dans la liste des colonnes. (À cette fin, vous pouvez utiliser les valeurs AFX_RFX_BOOL, AFX_RFX_BYTE, etc., si vous le souhaitez. Ces constantes sont définies dans AFXDB.H.) Choisissez un type de liste fondé sur la façon dont vous représentez les types de données des colonnes. |
Ajout d'appels RFX pour lier les colonnes
Enfin, organisez le déroulement de la liaison dynamique en plaçant les appels RFX des nouvelles colonnes dans la fonction DoFieldExchange.
Pour ajouter dynamiquement les appels RFX des nouvelles colonnes
- Dans la fonction membre DoFieldExchange de votre jeu d'enregistrements principal, ajoutez le code de la boucle sur la liste des nouvelles colonnes (Columns-to-Bind-Dynamically). Dans chaque boucle, extrayez un nom de colonne de Columns-to-Bind-Dynamically et la valeur résultat de la colonne depuis Dynamic-Column-Values. Passez ces éléments à l'appel de fonction RFX approprié au type de données de la colonne. Pour une description des listes, consultez Listes des colonnes.
Généralement, dans les appels de la fonction RFX_Text vous extrayez les objets CString à partir des listes, comme dans les lignes de code suivantes, où Columns-to-Bind-Dynamically est une liste CStringList du nom de m_listName et Dynamic-Column-Values une liste CStringList du nom de m_listValue :
RFX_Text( pFX,
m_listName.GetNext( posName ),
m_listValue.GetNext( posValue ));
Pour plus d'informations sur les fonctions RFX, consultez Macros and Globals dans Class Library Reference.
| Conseil : |
|---|
Si les nouvelles colonnes ont des types de données différents, utilisez une instruction switch dans la boucle afin d'appeler la fonction RFX appropriée pour chaque type. |
Quand l'infrastructure appelle DoFieldExchange durant le processus Open pour lier les colonnes au jeu d'enregistrements, les appels RFX des colonnes statiques lient ces colonnes. Puis, la boucle appelle plusieurs fois les fonctions RFX pour les colonnes dynamiques.
Voir aussi
Concepts
Jeu d'enregistrements : utilisation d'éléments de données volumineux (ODBC)