Programmation de données avec Microsoft Access 2010
Synthèse : découvrez comment développer du code d’accès aux données natif (C, C++, Java, VBA) ou géré (C#, Visual Basic.NET) avec Microsoft Office Access 2007 ou Microsoft Access 2010. Découvrez l’architecture Access, le moteur et les fournisseurs de données ACE, les plateformes 32 bits et 64 bits, ainsi que ce qu’il faut considérer lorsque vous choisissez une technologie d’accès aux données optimale pour votre projet de base de données nouvelle ou existante.
Dernière modification : vendredi 24 avril 2015
S’applique à : Access 2007 | Access 2010 | Office 2010
Dans cet article
Présentation
Architecture du moteur Microsoft Access
Présentation des technologies d’accès aux données
Données de performance
Utilisation de fournisseurs 32 bits et 64 bits ACE
Considérations pour le choix d’une technologie d’accès aux données
Méthodes obsolètes d’accès aux données
Conclusion
Applies to: Microsoft Access 2010 | Microsoft Office Access 2007
Date de publication : septembre 2010
Auteur : Aleksandar Jakšić, Microsoft Corporation
Contenu
Présentation
Architecture du moteur Microsoft Access
Présentation des technologies d’accès aux données
Données de performance
Utilisation de fournisseurs 32 bits et 64 bits ACE
Considérations pour le choix d’une technologie d’accès aux données
Méthodes obsolètes d’accès aux données
Conclusion
Présentation
Cet article technique explore les nombreux points de programmabilité d’accès aux données d’Access 2007 et d’Access 2010. Il présente le moteur Access, connu sous le nom de « Moteur de base de données Microsoft Access » (Moteur ACE). Si vous êtes développeur de base de données et que vous voulez en savoir plus sur les options disponibles lorsque vous développez une solution d’accès aux données pour des bases de données Access, cet article est écrit pour vous. Cet article ne contient pas des détails pour chacune des interfaces d’accès aux données mentionnées ici. Au lieu de cela, son objet est de vous donner une présentation de l’architecture du moteur ACE, de façon à vous permettre de mieux comprendre le modèle de programmation créé qui s’y exécute. L’exemple de code associé est écrit à la fois dans des langages natifs (C, C++, Java et VBA) et dans des langages .NET Framework (C# et Visual Basic.NET) ; il est destiné à vous aider à démarrer rapidement, même si vous n’avez jamais programmé dans certains de ces langages auparavant.
Cet article technique contient les réponses à des questions telles que les suivantes :
Mon application 32 bits existante va-t-elle fonctionner avec le logiciel 64 bits Access ?
Quel est généralement le moyen le plus rapide pour travailler par programmation avec les bases de données Access ?
Y a-t-il un moyen de se connecter au moteur ACE à l’aide du langage de programmation C (ANSI/ISO C) ou même Java ?
Puis-je utiliser mon code DAO (Data Access Object) MFC (Microsoft Foundation Classes) pour travailler avec des bases de données .accdb ?
Exemples de code
Cet article technique présente neufs programmes complets créés à l’aide de Microsoft Visual Studio 2008 et qui sont disponibles en téléchargement.
Chacun des exemples de code effectue le même algorithme d’accès aux données à l’aide de différents langages de programmation et de différentes technologies d’accès aux données, telles que DAO, OLE DB, ADO.NET, ADO, ODBC ou JDBC. Les sorties de console de chaque programme sont pratiquement identiques. Les exemples montrent les fonctionnalités centrales de programmation d’accès aux données, telles que la création d’une chaîne de connexion avec un mot de passe fort pour déchiffrer une base de données, la connexion à une base de données chiffrée, la création et l’exécution d’une requête SQL, l’utilisation d’un schéma et d’un jeu d’enregistrements ainsi que la récupération de données triées.
Le moteur Access ne faisant pas partie du système d’exploitation Windows, vous devez installer le moteur ACE et ses fournisseurs sur votre ordinateur local. Pour plus d’informations, voir Où puis-je obtenir le moteur ACE ?.
Cet article technique présente également des Données de performance pour tous les fournisseurs de données figurant dans les exemples de code.
À qui est destiné cet article ?
Le sujet des technologies d’accès aux données est étendu et, comme ce guide est destiné à une large audience de développeurs, tout développeur travaillant avec des données Access au niveau de la logique métier ou de l’application peut tirer parti de ces éléments. Cependant, cet article technique est écrit aussi dans l’idée d’atteindre les professionnels, les étudiants et les fans de l’informatique qui seraient d’une façon générale plus intéressés par la programmation de bases de données.
Il est supposé que vous êtes familier avec l’environnement Visual Studio, avec les bases de la programmation (la programmation structurée et .NET Framework) et que vous connaissez suffisamment les concepts des bases de données relationnelles et de SQL. Il est également supposé que vous êtes suffisamment familier avec la création de tables et de requêtes avec une des versions antérieures de Microsoft Access.
Notes
Quand Access est référencé dans ce document et non pas une version spécifique de Microsoft Access (telle que Microsoft Access 2003), il est supposé que les informations s’appliquent à la fois à Microsoft Office Access 2007 et à Microsoft Access 2010.
Architecture du moteur Microsoft Access
La figure 1 montre comment l’interface utilisateur d’Access et le moteur ACE forment un système de gestion de base de données complet.
Figure 1. Vue conceptuelle d’Access 2010
L’interface utilisateur d’Access est responsable de l’interface utilisateur et de tous les moyens par lesquels les utilisateurs affichent, éditent et utilisent des données à travers des formulaires, des rapports, des requêtes, des macros, des assistants, etc. De son côté, Microsoft Access Engine (le moteur ACE) fournit les services centraux de gestion de base de données tels que les suivants :
Stockage des données : stocker des données dans le système de fichiers.
Définition des données : créer, éditer ou supprimer des structures pour héberger des données, telles que les tables et les champs.
Intégrité des données : appliquer les règles relationnelles qui empêchent la corruption des données.
Manipulation des données : ajouter, éditer, supprimer ou trier des données existantes.
Récupération des données : récupérer des données dans le système à l’aide de SQL.
Chiffrement des données : protéger les données contre une utilisation non autorisée.
Partage des données : partager les données dans un environnement réseau multiutilisateur.
Publication de données : travailler dans un environnement Web client ou serveur.
Importation, exportation et liaison de données : travailler avec des données provenant de différentes sources.
Concernant l’accès aux données, vous pouvez voir Access comme étant la façon dont le moteur ACE est exposé visuellement aux utilisateurs.
Où puis-je obtenir le moteur ACE ?
Pour exécuter les exemples de code fournis dans cet article technique, vous devez disposer du moteur ACE sur votre ordinateur, ce qui signifie que vous devez installer un des produits Access 2010 (ou Office Access 2007) suivants :
Microsoft Access 2010 : disponible dans les éditions d’Office 2010 suivantes : Professionnel, Éducation, Professionnel Plus ou Microsoft Access autonome
Microsoft Access 2010 Runtime : disponible en téléchargement gratuit
Moteur de base de données Microsoft Access 2010 redistribuable
Notes
Les pilotes Microsoft Access Database Engine 2007 et 2010 sont disponibles pour permettre aux développeurs de solutions de créer des outils pour lire et écrire des fichiers Office, tels que des fichiers .accdb, .xlsx et .xlsb. Ceci permet à un créateur de solutions de disposer d’un serveur (tel que SQL) pour lire et écrire des formats de fichier Office sans devoir installer Office sur le serveur. Cependant, ce pilote ne dispose pas d’une licence pour être utilisé en tant que magasin de données autonome.
Qu’en est-il du moteur Microsoft JET ?
Avant Access 2007, Access utilisait le moteur Microsoft JET (Joint Engine Technology). Même si JET a généralement été vu comme faisant partie d’Access, le moteur JET était un produit distinct. Depuis la sortie de Microsoft Windows 2000, JET a été inclus dans le système d’exploitation Windows, puis distribué ou mis à jour avec les composants MDAC (Microsoft Data Access Components). Cependant, à la sortie d’Access 2007, le moteur JET a été abandonné et il n’est plus distribué avec MDAC. À la place, Access utilise maintenant un moteur ACE intégré et amélioré, dont le développement a commencé par une capture instantanée du code de base JET d’origine.
Le moteur ACE a une compatibilité descendante complète avec les versions antérieures du moteur JET et il peut donc lire et écrire les fichiers (.mdb) des versions antérieures d’Access. L’équipe Access possédant dorénavant le moteur, les développeurs sont assurés que leurs solutions Access non seulement continueront à fonctionner dans le futur mais aussi seront plus rapides, plus robustes et plus riches en fonctionnalités. Par exemple, avec l’édition d’Access 2010, entre autres améliorations, le moteur ACE a été mis à niveau pour prendre en charge les versions 64 bits et pour améliorer l’intégration avec les technologies liées à SharePoint et aux services Web en général. Microsoft considère Access en tant que plateforme pour les développeurs.
Présentation des technologies d’accès aux données
Microsoft offre plusieurs moyens pour travailler avec des bases de données Access. Les API et les couches d’accès aux données suivantes sont utilisées pour la programmation Access :
DAO (Data Access Objects)
OLE DB (Object Linking and Embedding, Database)
ADO.NET
Objets ADO (ActiveX Data Object)
ODBC (Open Database Connectivity)
Le moteur ACE implémente des fournisseurs pour les trois technologies mentionnées précédemment : DAO, OLE DB et ODBC. Le fournisseur ACE DAO, le fournisseur ACE OLE DB et le fournisseur ACE ODBC sont distribués avec le produit Access (excepté ADO, qui fait toujours partie de Microsoft Windows DAC). Beaucoup d’interfaces de programmation, de fournisseurs et d’infrastructures de niveau système pour l’accès aux données incluant ADO et ADO.NET s’appuient sur ces trois fournisseurs ACE. La figure 2 montre un diagramme représentant une vue d’ensemble des composants Access.
Figure 2. Architecture du moteur ACE dans l’environnement de programmation d’accès aux données
Cet article technique décrit les méthodes d’accès aux données figurant dans le tableau suivant.
Tableau 1. Méthodes d’accès aux données
Nom du fournisseur |
Méthode d’accès aux données |
Informations de connexion |
Langage(s) pris en charge |
---|---|---|---|
ACE DAO |
Exemple DAO direct |
Acedao.tlh (généré à partir de acedao.dll); acedao.dll |
C++ |
Exemple VBA DAO |
Set db = CurrentDb() S’exécute dans l’environnement VBE |
VBA |
|
ACE OLE DB |
Exemple ATL OLE DB |
Microsoft.ACE.OLEDB.12.0 <Atldbcli.h> et <Atldbsch.h>; Aceoledb.dll |
C++ |
ADO.NET |
Exemple C# ADO.NET |
Microsoft.ACE.OLEDB.12.0 avec System.Data.OleDb ; |
C# |
Exemple Visual Basic.NET ADO.NET Exemple Visual Basic.NET ADO.NET |
Microsoft.ACE.OLEDB.12.0 Importe System.Data.OleDb Importe System.Console |
Visual Basic.NET |
|
ADO |
Exemple ADO |
Msado15.tlh (généré à partir de Msado15.dll); Installé avec MDAC 2.8 ou Windows DAC 6.0. |
C++ |
ACE ODBC |
Exemple Direct ODBC |
Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=chemin d’accès au fichier mdb/accdb <Sqlext.h>; Aceodbc.dll; |
C/C++ |
Exemple MFC ODBC |
Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=chemin d’accès au fichier mdb/accdb <Afxdb.h>; Aceodbc.dll; |
C++ |
|
Exemple JDBC-ODBC |
jdbc:odbc:DRIVER=Microsoft Access Driver (*.mdb, *.accdb);DBQ= chemin d’accès au fichier mdb/accdb |
Java |
Pour plus d’informations et pour une liste des méthodes d’accès aux données qui sont obsolètes avec la version Access 2007, voir Méthodes obsolètes d’accès aux données.
DAO
À l’origine, DAO était la seule méthode d’accès aux données pour les développeurs Access.
Exemple DAO direct
Cette méthode d’accès offre la meilleure prise en charge pour les nouvelles fonctionnalités qui sont introduites avec Access 2007 car elle expose la plupart des fonctionnalités du moteur ACE. Direct DAO utilise Acedao.dll. Pour compiler ce code, utilisez la macro #import pour générer l’en-tête .tlh en spécifiant une directive similaire à celle qui figure dans l’exemple de code suivant.
#import <C:\\Program Files (x86)\\Common Files\\Microsoft Shared\\OFFICE14\\ACEDAO.dll> \
rename( "EOF", "AdoNSEOF" )
Selon que vous compilez le code sur un système d’exploitation 32 bits ou 64 bits, vous pouvez mettre à jour ce chemin d’accès pour supprimer la partie « (x86) ». Un moyen de vérifier cela est de contrôler une clé du Registre nommée Path de type REG_SZ sous l’un des chemins d’accès du Registre suivants :
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Access Connectivity Engine\InstallRoot
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Access Connectivity Engine\InstallRoot
La connexion s’effectuant directement au moteur, l’emplacement de la base de données seul est suffisant comme information de connexion.
_bstr_t bstrConnect = "C:\\Northwind.accdb";
L’exemple de code suivant obtient le schéma et les données.
Notes
Pour accéder aux exemples d’applications complets, téléchargez l’exemple de code.
// Create an instance of the engine
DAO::_DBEngine* pEngine = NULL;
// The CoCreateInstance helper function provides a convenient shortcut by connecting
// to the class object associated with the specified CLSID, creating an
// uninitialized instance, and releasing the class object.
hr = CoCreateInstance(
__uuidof(DAO::DBEngine),
NULL,
CLSCTX_ALL,
IID_IDispatch,
(LPVOID*)&pEngine);
if (SUCCEEDED(hr) && pEngine)
{
// COM errors are handled by C++ try/catch block
try
{
DAO::DatabasePtr pDbPtr = NULL;
pDbPtr = pEngine->OpenDatabase(bstrConnect, false, false, ";PWD=1L0v3Acce55;");
if (pDbPtr)
{
cout<<DAM<<": Successfully connected to database. Data source name:\n "
<<pDbPtr->GetName()<<endl;
// Prepare SQL query.
_bstr_t query = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
cout<<DAM<<": SQL query:\n "<<query<<endl;
// Run the query and create a record set
DAO::RecordsetPtr pRS = NULL;
pRS = pDbPtr->OpenRecordset(query, _variant_t(DAO::dbOpenDynaset));
if (pRS && 0 < pRS->RecordCount)
{
cout<<DAM<<": Retrieve schema info for the given result set: "<<endl;
DAO::FieldsPtr pFields = NULL;
pFields = pRS->GetFields();
if (pFields && pFields->Count > 0)
{
for (short column = 0; column < pFields->Count; column++)
{
cout<<" | "<<pFields->GetItem(column)->GetName();
}
cout<<endl;
}
else
{
cout<<DAM<<": Error: Number of fields in the result set is 0."<<endl;
}
cout<<DAM<<": Fetch the actual data: "<<endl;
// Loop through the rows in the result set
while (!pRS->AdoNSEOF)
{
for (short column = 0; column < pFields->Count; column++)
{
cout<<" | "<<_bstr_t(pFields->GetItem(column)->GetValue());
}
cout<<endl;
pRS->MoveNext();
}
cout<<DAM<<": Total Row Count: "<<pRS->RecordCount<<endl;
}
// Close record set and database
pRS->Close();
pDbPtr->Close();
pDbPtr = NULL;
}
else
{
cout<<DAM<<": Unable to connect to data source: "<<bstrConnect<<endl;
}
}
catch(_com_error& e)
{
cout<<DAM<<": _com_error: "<<e.ErrorMessage()<<endl;
}
pEngine->Release();
pEngine = NULL;
cout<<DAM<<": Cleanup. Done."<<endl;
}
else
{
cout<<DAM<<": Cannot instantiate DBEngine object."<<endl;
}
L’exemple suivant montre la sortie du programme.
Direct DAO: Successfully connected to database. Data source name:
C:\Northwind.accdb
Direct DAO: SQL query:
SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;
Direct DAO: Retrieve schema info for the given result set:
| Company | First Name
Direct DAO: Fetch the actual data:
| Company A | Anna
| Company AA | Karen
| Company B | Antonio
| Company BB | Amritansh
| Company C | Thomas
| Company CC | Soo Jung
| Company D | Christina
| Company E | Martin
| Company F | Francisco
| Company G | Ming-Yang
| Company H | Elizabeth
| Company I | Sven
| Company J | Roland
| Company K | Peter
| Company L | John
| Company M | Andre
| Company N | Carlos
| Company O | Helena
| Company P | Daniel
| Company Q | Jean Philippe
| Company R | Catherine
| Company S | Alexander
| Company T | George
| Company U | Bernard
| Company V | Luciana
| Company W | Michael
| Company X | Jonas
| Company Y | John
| Company Z | Run
Direct DAO: Total Row Count: 29
Direct DAO: Cleanup. Done.
Exemple VBA DAO
L’exemple de code suivant s’exécute dans l’environnement Access VBA/VBE, sur une base de données active.
Public Sub VBADAO()
Dim DAM As String
Dim db As DAO.Database
Dim rst As DAO.Recordset
Dim query As String
DAM = "VBA DAO"
' Open pointer to current database
Set db = CurrentDb()
Debug.Print DAM & ": Successfully connected to database. Data source name: " & _
vbNewLine & " " & db.Name
' Prepare SQL query
query = "SELECT Customers.[Company], Customers.[First Name] " & _
"FROM Customers " & _
"ORDER BY Customers.[Company] ASC"
Debug.Print DAM & ": SQL Query: " & _
vbNewLine & " " & query
' Run the query and create a record set
Set rst = db.OpenRecordset(query)
Debug.Print DAM & ": Retrieve schema info for the given result set: "
For i = 0 To rst.Fields.Count - 1
Debug.Print " | " & rst.Fields(i).Name
Next i
Debug.Print DAM & ": Fetch the actual data: "
Do While Not rst.EOF
Debug.Print " | " & rst![Company] & " | " & rst![First Name]
rst.MoveNext
Loop
Debug.Print DAM & ": Total Row Count: " & rst.RecordCount
Debug.Print DAM & ": Cleanup. Done. "
rst.Close
db.Close
End Sub
OLE DB
OLE DB est l’interface de programmation de niveau système de Microsoft pour accéder aux données. Il s’agit d’une spécification et non pas d’un ensemble de composants ou de fichiers. C’est la technologie sous-jacente pour ADO et une source de données pour ADO.NET. OLE DB spécifie un ensemble d’interfaces COM qui encapsule différents services de système de gestion de base de données destinés à servir des consommateurs. OLE DB est un standard ouvert pour accéder à toutes les sortes de données, y compris des bases de données Access. Il prend en charge des conditions requises en matière de développement, incluant la création de clients de bases de données frontales et d’objets métiers de niveau intermédiaire à l’aide de connexions directes à des données dans des bases de données relationnelles et dans d’autres stockages.
Exemple ATL OLE DB
Cet exemple utilise ATL (Active Template Library) en incluant <Atldbcli.h> et <Atldbsch.h>. Les informations de connexion utilisent le fournisseur de données Microsoft.ACE.OLEDB.12.0 implémenté dans Aceoledb.dll.
LPCOLESTR lpcOleConnect =
L"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\Northwind.accdb;Jet OLEDB:Database Password=1L0v3Acce55;";
L’exemple de code suivant obtient le schéma et les données.
// To initialize the connection to a database using an OLE DB provider,
// two ATL classes are needed: CDataSource and CSession;
CDataSource dbDataSource;
CSession dbSession;
// Uses the ATL string conversion macros to convert between character encodings
USES_CONVERSION;
// Open the connection and initialize the data source specified by the passed
// initialization string.
hr = dbDataSource.OpenFromInitializationString(lpcOleConnect);
if (FAILED(hr))
{
cout<<DAM<<": Unable to connect to data source "<<OLE2T(lpcOleConnect)<<endl;
}
else
{
hr = dbSession.Open(dbDataSource);
if (FAILED(hr))
{
cout<<DAM<<": Couldn't create session on data source "<<OLE2T(lpcOleConnect)<<endl;
}
else
{
CComVariant var;
hr = dbDataSource.GetProperty(DBPROPSET_DATASOURCEINFO, DBPROP_DATASOURCENAME, &var);
if (FAILED(hr) || (var.vt == VT_EMPTY))
{
cout<<DAM<<": No Data Source Name Specified."<<endl;
}
else
{
cout<<DAM<<": Successfully connected to database. Data source name:\n "
<<COLE2T(var.bstrVal)<<endl;
// Prepare SQL query.
LPCOLESTR query = L"SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
cout<<DAM<<": SQL query:\n "<<OLE2T(query)<<endl;
// Run the query and create a record set
CCommand<CDynamicStringAccessor> cmd;
hr = cmd.Open(dbSession, query);
DBORDINAL colCount = cmd.GetColumnCount();
if (SUCCEEDED(hr) && 0 < colCount)
{
cout<<DAM<<": Retrieve schema info for the given result set: "<<endl;
DBORDINAL cColumns;
DBCOLUMNINFO* rgInfo = NULL;
OLECHAR* pStringsBuffer = NULL;
cmd.GetColumnInfo(&cColumns, &rgInfo, &pStringsBuffer);
for (int col=0; col < (int)colCount; col++)
{
cout<<" | "<<OLE2T(rgInfo[col].pwszName);
}
cout<<endl;
cout<<DAM<<": Fetch the actual data: "<<endl;
int rowCount = 0;
CRowset<CDynamicStringAccessor>* pRS = (CRowset<CDynamicStringAccessor>*)&cmd;
// Loop through the rows in the result set
while (pRS->MoveNext() == S_OK)
{
for (int col=1; col <= (int)colCount; col++)
{
CHAR* szValue = cmd.GetString(col);
cout<<" | "<<szValue;
}
cout<<endl;
rowCount++;
}
cout<<DAM<<": Total Row Count: "<<rowCount<<endl;
}
else
{
cout<<DAM<<": Error: Number of fields in the result set is 0."<<endl;
}
}
}
}
dbDataSource.Close();
dbSession.Close();
cout<<DAM<<": Cleanup. Done."<<endl;
ADO.NET
ADO.NET offre un accès aux données uniforme et complet à différentes sources de données au sein de l’environnement (géré) .NET. ADO.NET utilise des fournisseurs gérés .NET qui à leur tour utilisent des API sous-jacentes, telles que OLE DB et ODBC. Cet article technique présente deux exemples ADO.NET (C# et Visual Basic.NET) utilisant chacun l’API OLE DB sous-jacente en tant que couche d’accès aux données.
Exemple C# ADO.NET
Ce qui suit est un exemple de code C# ADO.NET.
// Connection string for ADO.NET via OleDB
OleDbConnection cn =
new OleDbConnection("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\Northwind.accdb;Jet OLEDB:Database Password=1L0v3Acce55;");
// Prepare SQL query
string query = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
OleDbCommand cmd = new OleDbCommand(query, cn);
try
{
cn.Open();
Console.WriteLine("{0}: Successfully connected to database. Data source name:\n {1}",
DAM, cn.DataSource);
Console.WriteLine("{0}: SQL query:\n {1}", DAM, query);
// Run the query and create a record set
OleDbDataReader dr = cmd.ExecuteReader();
Console.WriteLine("{0}: Retrieve schema info for the given result set:", DAM);
for (int column = 0; column < dr.FieldCount; column++)
{
Console.Write(" | {0}", dr.GetName(column));
}
Console.WriteLine("\n{0}: Fetch the actual data: ", DAM);
int row = 0;
while (dr.Read())
{
Console.WriteLine(" | {0} | {1} ", dr.GetValue(0), dr.GetValue(1));
row++;
}
Console.WriteLine("{0}: Total Row Count: {1}", DAM, row);
dr.Close();
}
catch (OleDbException ex)
{
Console.WriteLine("{0}: OleDbException: Unable to connect or retrieve data from data source: {1}.",
DAM, ex.ToString());
}
catch (Exception ex)
{
Console.WriteLine("{0}: Exception: Unable to connect or retrieve data from data source: {1}.",
DAM, ex.ToString());
}
finally
{
cn.Close();
Console.WriteLine("{0}: Cleanup. Done.", DAM);
}
Exemple Visual Basic.NET ADO.NET
Ce qui suit est un exemple de code Visual Basic.NET ADO.NET.
' Connection string for ADO.NET via OleDB
Dim cn As OleDbConnection =
New OleDbConnection("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\Northwind.accdb;Jet OLEDB:Database Password=1L0v3Acce55;")
Dim cmd As OleDbCommand
Dim dr As OleDbDataReader
Try
cn.Open()
WriteLine(DAM + ": : Successfully connected to database. Data source name:" + ControlChars.Lf + " " + cn.DataSource)
' Prepare SQL query.
Dim query As String = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;"
WriteLine(DAM + ": SQL Query:" + ControlChars.Lf + " " + query)
' Run the query and create a record set
cmd = New OleDbCommand(query, cn)
dr = cmd.ExecuteReader
WriteLine(DAM + ": Retrieve schema info for the given result set: ")
Dim column, row As Integer
For column = 0 To dr.FieldCount - 1
Write(" | " + dr.GetName(column))
Next column
WriteLine(ControlChars.Lf + DAM + ": Fetch the actual data: ")
row = 0
While dr.Read()
WriteLine(" | " + dr(0) + " | " + dr(1))
row += 1
End While
WriteLine(DAM + ": Total Row Count: " + row.ToString())
dr.Close()
Catch ex As OleDbException
WriteLine(ControlChars.Lf + DAM + ": OleDbException: Unable to connect or retrieve data from data source: " + ex.Message())
Catch ex As Exception
WriteLine(ControlChars.Lf + DAM + ": Exception: Unable to connect or retrieve data from data source: " + ex.Message())
Finally
cn.Close()
WriteLine(DAM + ": Cleanup. Done.")
End Try
ADO
ADO (ActiveX Data Objects) fournit une interface de niveau application basée sur COM pour des fournisseurs de données OLE DB. Bien qu’il offre des performances diminuées par rapport à un codage direct OLE DB, ADO est simple à apprendre et à utiliser. ADO donne aux programmeurs C++ un accès aux interfaces OLE DB sous-jacentes. La plupart des développeurs ne sont généralement pas intéressés par un niveau de contrôle si bas, tel que la gestion des ressources mémoire et l’agrégation manuelle de composants, offert par OLE DB sur le processus d’accès aux données.
Au contraire de DAO, qui exposait les fonctionnalités d’un seul moteur de base de données, ADO utilise un modèle de programmation commun pour accéder à des données de façon universelle.
Exemple ADO
ADO utilise la bibliothèque Msado15.dll, qui est incluse avec MDAC 2.8 ou ultérieur. Pour compiler ce code, vous devez utiliser la macro #import pour générer l’en-tête .tlh en spécifiant une directive similaire à celle qui figure dans l’exemple de code suivant.
#import <C:\\Program Files\\Common Files\\System\\ado\\msado15.dll> \
rename( "EOF", "AdoNSEOF" )
Pour les informations de connexion, utilisez le fournisseur de données Microsoft.ACE.OLEDB.12.0 implémenté dans Aceoledb.dll.
_bstr_t bstrConnect =
"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\Northwind.accdb;Jet OLEDB:Database Password=1L0v3Acce55;";
L’exemple de code suivant obtient le schéma et les données.
// COM errors are handled by C++ try/catch block
try
{
ADODB::_ConnectionPtr pConn("ADODB.Connection");
hr = pConn->Open(bstrConnect, "admin", "", ADODB::adConnectUnspecified);
if (SUCCEEDED(hr))
{
cout<<DAM<<": Successfully connected to database. Data source name:\n "
<<pConn->GetConnectionString()<<endl;
// Prepare SQL query.
_bstr_t query = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
cout<<DAM<<": SQL query:\n "<<query<<endl;
// Run the query and create a record set
ADODB::_RecordsetPtr pRS("ADODB.Recordset");
hr = pRS->Open(query,
_variant_t((IDispatch *) pConn, true),
ADODB::adOpenUnspecified,
ADODB::adLockUnspecified,
ADODB::adCmdText);
if (SUCCEEDED(hr))
{
cout<<DAM<<": Retrieve schema info for the given result set: "<<endl;
ADODB::Fields* pFields = NULL;
hr = pRS->get_Fields(&pFields);
if (SUCCEEDED(hr) && pFields && pFields->GetCount() > 0)
{
for (long nIndex=0; nIndex < pFields->GetCount(); nIndex++)
{
cout<<" | "<<_bstr_t(pFields->GetItem(nIndex)->GetName());
}
cout<<endl;
}
else
{
cout<<DAM<<": Error: Number of fields in the result set is 0."<<endl;
}
cout<<DAM<<": Fetch the actual data: "<<endl;
int rowCount = 0;
while (!pRS->AdoNSEOF)
{
for (long nIndex=0; nIndex < pFields->GetCount(); nIndex++)
{
cout<<" | "<<_bstr_t(pFields->GetItem(nIndex)->GetValue());
}
cout<<endl;
pRS->MoveNext();
rowCount++;
}
cout<<DAM<<": Total Row Count: "<<rowCount<<endl;
}
pRS->Close();
pConn->Close();
cout<<DAM<<": Cleanup. Done."<<endl;
}
else
{
cout<<DAM<<": Unable to connect to data source: "<<bstrConnect<<endl;
}
}
catch(_com_error& e)
{
cout<<DAM<<": _com_error: "<<e.Description()<<endl;
}
ODBC
ODBC (Open Database Connectivity) est la plus ancienne des technologies Microsoft actuelles d’accès aux données et est conçue pour vous permettre de créer une base de code commune qui fournit un accès à différents magasins de données relationnels. Ses méthodes sont exposées dans une API traditionnelle, non orientée objet et semblable à du code C.
Exemple Direct ODBC
Cette méthode d’accès aux données est recommandée seulement pour la maintenance des applications existantes ou lorsque vous devez travailler avec ANSI/ISO C. L’exemple de code suivant montre les informations de connexion pour Direct ODBC, qui utilise le pilote {Microsoft Access Driver (*.mdb, *.accdb)} implémenté dans la bibliothèque Aceodbc.dll en incluant <Sqlext.h>.
SQLCHAR szDSN[256] =
"Driver={Microsoft Access Driver (*.mdb, *.accdb)};DSN='';DBQ=C:\\Northwind.accdb;PWD=1L0v3Acce55;";
L’exemple de code suivant obtient le schéma et les données.
HENV hEnv;
HDBC hDbc;
/* ODBC API return status */
SQLRETURN rc;
SQLSMALLINT iConnStrLength2Ptr;
SQLCHAR szConnStrOut[255];
SQLCHAR* query = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
SQLCHAR chval1[128], chval2[128], colName[128];
SQLINTEGER ret1, ret2;
/* Number of rows and columns in result set */
SQLINTEGER rowCount = 0;
SQLSMALLINT fieldCount = 0, column = 0;
HSTMT hStmt;
/* Allocate an environment handle */
rc = SQLAllocEnv(&hEnv);
/* Allocate a connection handle */
rc = SQLAllocConnect(hEnv, &hDbc);
/* Connect to the 'Northwind 2007.accdb' database */
rc = SQLDriverConnect(hDbc, NULL, szDSN, _countof(szDSN),
szConnStrOut, 255, &iConnStrLength2Ptr, SQL_DRIVER_NOPROMPT);
if (SQL_SUCCEEDED(rc))
{
printf("%s: Successfully connected to database. Data source name: \n %s\n",
DAM, szConnStrOut);
/* Prepare SQL query */
printf("%s: SQL query:\n %s\n", DAM, query);
rc = SQLAllocStmt(hDbc,&hStmt);
rc = SQLPrepare(hStmt, query, SQL_NTS);
/* Bind result set columns to the local buffers */
rc = SQLBindCol(hStmt, 1, SQL_C_CHAR, chval1, 128, &ret1);
rc = SQLBindCol(hStmt, 2, SQL_C_CHAR, chval2, 128, &ret2);
/* Run the query and create a record set */
rc = SQLExecute(hStmt);
if (SQL_SUCCEEDED(rc))
{
printf("%s: Retrieve schema info for the given result set:\n", DAM);
SQLNumResultCols(hStmt, &fieldCount);
if (fieldCount > 0)
{
for (column = 1; column <= fieldCount; column++)
{
SQLDescribeCol(hStmt, column,
colName, sizeof(colName), 0, 0, 0, 0, 0);
printf(" | %s", colName);
}
printf("\n");
}
else
{
printf("%s: Error: Number of fields in the result set is 0.\n", DAM);
}
printf("%s: Fetch the actual data:\n", DAM);
/* Loop through the rows in the result set */
rc = SQLFetch(hStmt);
while (SQL_SUCCEEDED(rc))
{
printf(" | %s | %s\n", chval1, chval2);
rc = SQLFetch(hStmt);
rowCount++;
};
printf("%s: Total Row Count: %d\n", DAM, rowCount);
rc = SQLFreeStmt(hStmt, SQL_DROP);
}
}
else
{
printf("%s: Couldn't connect to %s.\n", DAM, szDSN);
}
/* Disconnect and free up allocated handles */
SQLDisconnect(hDbc);
SQLFreeHandle(SQL_HANDLE_DBC, hDbc);
SQLFreeHandle(SQL_HANDLE_ENV, hEnv);
printf("%s: Cleanup. Done.\n", DAM);
Exemple MFC ODBC
L’exemple de code suivant montre les informations de connexion pour MFC ODBC, qui utilise le pilote {Microsoft Access Driver (*.mdb, *.accdb)} implémenté dans la bibliothèque Aceodbc.dll en incluant <Afxdb.h>.
LPCTSTR lpszConnect =
_T("Driver={Microsoft Access Driver (*.mdb, *.accdb)};DSN='';DBQ=C:\\Northwind.accdb;PWD=1L0v3Acce55;");
L’exemple de code suivant obtient le schéma et les données.
BOOL result = TRUE;
CDatabase db;
TRY
{
result = db.OpenEx(lpszConnect,
CDatabase::openReadOnly |
CDatabase::noOdbcDialog);
if (FALSE == result)
{
cout<<DAM<<": Unable to connect to data source "<<lpszConnect<<endl;
return result;
}
cout<<DAM<<": Successfully connected to database. Data source name:\n "
<<db.GetDatabaseName()<<endl;
// Prepare SQL query
LPCTSTR query = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
cout<<DAM<<": SQL query:\n "<<query<<endl;
// Run the query and create a record set
CRecordset rs(&db);
result = rs.Open(CRecordset::dynaset, query, CRecordset::none);
if (result == TRUE)
{
cout<<DAM<<": Retrieve schema info for the given result set: "<<endl;
CODBCFieldInfo fInfo;
short sFieldCount = rs.GetODBCFieldCount();
if (sFieldCount > 0)
{
for (short nIndex=0; nIndex < sFieldCount; nIndex++)
{
CODBCFieldInfo fInfo;
rs.GetODBCFieldInfo(nIndex, fInfo);
cout<<" | "<<fInfo.m_strName;
}
cout<<endl;
}
else
{
cout<<DAM<<": Error: Number of fields in the result set is 0."<<endl;
}
cout<<DAM<<": Fetch the actual data: "<<endl;
CDBVariant var;
CString value;
// Loop through the rows in the result set
int rowCount = 0;
while (!rs.IsEOF())
{
for (short nIndex=0; nIndex < sFieldCount; nIndex++)
{
rs.GetFieldValue(nIndex, var);
switch (var.m_dwType)
{
case DBVT_STRING:
value.Format("%s", var.m_pstring->GetBuffer(var.m_pstring->GetLength()));
break;
case DBVT_ASTRING:
value.Format("%s", var.m_pstringA->GetBuffer(var.m_pstringA->GetLength()));
break;
case DBVT_WSTRING:
value.Format("%s", var.m_pstringW->GetBuffer(var.m_pstringW->GetLength()));
break;
default:
value = "";
}
cout<<" | "<<value;
}
cout<<endl;
rowCount++;
rs.MoveNext();
}
cout<<DAM<<": Total Row Count: "<<rowCount<<endl;
}
}
CATCH_ALL(e)
{
TCHAR errMsg[255];
e->GetErrorMessage(errMsg, 255);
cout<<DAM<<": CException: "<<errMsg<<endl;
}
END_CATCH_ALL
db.Close();
cout<<DAM<<": Cleanup. Done."<<endl;
Exemple JDBC-ODBC
JDBC est une couche d’accès aux données qui permet à Java d’interagir avec une source de données sous-jacente. Un pont JDBC-ODBC est une implémentation de pilote de base de données qui s’appuie sur le pilote ODBC pour se connecter à une base de données Access. Le pilote convertit les appels de méthode JDBC en appels de fonction ODBC.
private static String strConnect =
"jdbc:odbc:DRIVER=Microsoft Access Driver (*.mdb, *.accdb);DBQ=C:\\Northwind.accdb;PWD=1L0v3Acce55;";
L’exemple de code Java suivant obtient le schéma et les données.
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con = DriverManager.getConnection(strConnect, "","");
if (null == con) {
System.out.println(DAM + "Unable to connect to data source " + strConnect);
return;
}
System.out.println(DAM + ": Successfully connected to database. Data source name:\n "
+ con.getMetaData().getURL());
// Prepare SQL query.
String query = "SELECT Customers.[Company], Customers.[First Name] FROM Customers ORDER BY Customers.[Company] ASC;";
System.out.println(DAM + ": SQL query:\n " + query);
// Run the query and create a record set
Statement stmt = con.createStatement();
stmt.execute(query);
ResultSet rs = stmt.getResultSet();
if (rs != null) {
System.out.println(DAM + ": Retrieve schema info for the given result set: ");
ResultSetMetaData rsmd = rs.getMetaData();
for (int i=1; i <= rsmd.getColumnCount(); i++) {
System.out.print(" | " + rsmd.getColumnName(i));
}
System.out.println("\n" + DAM + ": Fetch the actual data: ");
int rowCount = 0;
while (rs.next()) {
for (int i=1; i <= rsmd.getColumnCount(); i++) {
System.out.print(" | " + rs.getString(i));
}
System.out.println("");
rowCount++;
}
System.out.println(DAM + ": Total Row Count: " + rowCount);
}
stmt.close();
con.close();
} catch (Exception err) {
System.out.println(DAM + ": Exception: " + err.getMessage());
} finally {
System.out.println(DAM + ": Cleanup. Done.");
}
Données de performance
Les résultats en matière de performance ont été générés pour Access 2010 64 bits sur un système d’exploitation 64 bits exécutant Windows Server 2008 SP2, avec un processeur AMD 64 Athlon X2 Dual Core 4600+ 2,40 Ghz et 8 Go de RAM. Les programmes de point de référence n’ont pas généré de sortie vers l’interface utilisateur et n’ont pas utilisé de fonctionnalités nouvelles ou avancées du moteur ACE.
La figure 3 montre un graphique qui présente des données de performance.
Figure 3. Mesures de performance (en secondes)
Notes
Tous les programmes de point de référence ont été exécutés en tant qu’applications de console à l’exception du code VBA DAO qui a été exécuté à partir de l’environnement VBA/VBE. Cela signifie que le code VBA était le seul programme disposant du privilège de s’exécuter dans le même espace d’adresses que MSAccess.exe, ce qui a abouti a une réduction significative des opérations d’E/S disque et des défauts de page, améliorant ainsi la performance globale.
Utilisation de fournisseurs 32 bits et 64 bits ACE
Les fournisseurs ACE (ACE DAO, ACE OLE DB ou ACE ODBC) pour le produit Access 2007 sont disponibles seulement en version 32 bits. Les fournisseurs ACE pour le produit Access 2010 sont disponibles dans les éditions 32 bits et 64 bits.
Fondamentalement, il y a maintenant trois configurations possibles.
Solution 64 bits seulement (Access 64 bits, Windows 64 bits)
Pour implémenter une solution 64 bits, vous devez effectuer ce qui suit :
Déployer Access 2010 64 bits sur Windows 64 bits
Créer une application d’accès aux données 64 bits personnalisée
Solution 32 bits seulement (Access 32 bits, Windows 32 bits)
Si vous avez une application 32 bits et que vous voulez continuer à l’exécuter inchangée avec Access 2010, vous devez installer la version 32 bits d’Access 2010.
Access 2010 32 bits fonctionne exactement comme Access 2007 32 bits et aucune modification ne sera nécessaire pour que votre code VBA, vos compléments COM ou vos contrôles ActiveX continuent de fonctionner.
Solution WOW64 (Access 32 bits, Windows 64 bits)
La technologie WOW64 permet l’exécution d’applications 32 bits sur des plateformes Windows 64 bits. Il est possible d’installer Access 2010 32 bits sur Windows 64 bits. Dans ce cas, votre application de données doit être 32 bits pour pouvoir dialoguer avec les fournisseurs ACE. Il s’agit de l’installation par défaut sur les systèmes d’exploitation Windows 64 bits, qui permet la compatibilité avec les applications Office 32 bits.
Bien que les applications 32 bits puissent s’exécuter de façon transparente, le mélange de deux sortes de code au sein du même processus n’est pas pris en charge. Une application 64 bits ne peut pas établir de lien avec une bibliothèque système 32 bits (DLL) et, de façon similaire, une application 32 bits ne peut pas établir de lien avec une bibliothèque 64 bits.
Important
Vous recevrez des erreurs d’exécution si vous essayez d’exécuter votre code 32 bits existant avec Access 64 bits. Par exemple, l’erreur « Le fournisseur Microsoft.ACE.OLEDB.12.0 n’est pas inscrit sur l’ordinateur local » peut être provoquée par une non-correspondance de version entre votre application (code 32 bits) et un des fournisseurs ACE 64 bits qui ont été installés avec Microsoft Access 64 bits. Pour corriger ce problème, mettez à niveau votre code personnalisé vers une version 64 bits ou désinstallez Access 64 bits et remplacez-le par Access 32 bits.
Figure 4. Versions en correspondance entre les fournisseurs ACE et les applications
Installations côte à côte
Aucune prise en charge n’est fournie pour les installations côte à côte d’éditions 64 bits et 32 bits d’Office 2010. Ceci inclut Access.
Autres considérations
Avant de déployer Access 64 bits, déterminez s’il s’agit d’une option de déploiement appropriée pour votre environnement spécifique. Plusieurs facteurs peuvent affecter la compatibilité de votre solution Access 32 bits. Par exemple, si vous utilisez des bases de données dont le code source a été supprimé (telles que des fichiers .mde, .ade et .accde) ou si vous utilisez du code VBA dans des instructions Declare, des compléments COM ou des contrôles ActiveX, il peut être nécessaire de consacrer du temps de développement avant que ces fonctionnalités puissent fonctionner avec Access 64 bits. Une solution alternative pour résoudre ce problème peut être d’installer Access 32 bits sur Windows 32 bits ou Access 32 bits (WOW64) sur Windows 64 bits. Pour plus d’informations à ce sujet, voir Éditions 64 bits d’Office 2010.
Considérations pour le choix d’une technologie d’accès aux données
Si vous avez développé une solution qui fonctionne avec une base de données Access existante, vous pouvez continuer à utiliser la technologie actuelle d’accès aux données de l’application aussi longtemps qu’elle répond à vos besoins. La section Méthodes obsolètes d’accès aux données contient la liste des pilotes qui continuent de fournir une connectivité aux formats de fichier Access antérieurs. Notez bien que tous les nouveaux fournisseurs ACE offrent une compatibilité descendante complète.
Si vous prévoyez un cycle de vie long pour l’application, vous devez considérer plusieurs facteurs lors de l’analyse des conditions requises et de la conception. Voici quelques-uns des facteurs pouvant influencer votre décision d’utiliser le pilote d’accès aux données le plus approprié :
Langage/Plateforme. Êtes-vous limité dans l’implémentation de votre solution avec des langages natifs (C, C++, VBA) en comparaison avec des langages gérés (C#, Visual Basic.NET) ? Les langages gérés et leur infrastructure sous-jacente d’accès aux données (ADO.NET) offrent une implémentation plus facile, une meilleure interopérabilité des plateformes et un accès aux données modulable. Par exemple, si vous voulez une intégration poussée avec .NET Framework, XML, une solution requérant la logique métier déconnectée (présentation en mémoire des données relationnelles) ou des interfaces bien définies et adaptées avec un comportement, des performances et une sémantique prévisibles, le choix d’ADO.NET peut être parfait pour vous. Si par contre vous voulez la meilleure performance possible ou que vous êtes limité à l’utilisation d’un langage spécifique, vous pouvez considérer l’utilisation d’autres méthodes (Direct DAO, Direct OLE DB, etc.). Si vous voulez développer votre solution en C, votre choix peut être limité à l’approche de Direct ODBC. De la même façon, pour le développement Java, vous pouvez utiliser le pilote JDBC-ODBC.
Fonctionnalités. Si votre solution dépend exclusivement des bases de données Access et que cela ne changera pas, le pilote ACE DAO devrait être le choix naturel car il fournit les fonctionnalités les plus complètes. Sur le long terme, les technologies natives d’accès aux données réduisent généralement les temps de développement, simplifient le code et offrent de meilleures performances. Si vous devez disposer de fonctions avancées de manipulation de jeux d’enregistrements et que vous vous connectez à une source externe de données, envisagez l’utilisation d’ADO.NET (ou ADO) ou d’OLE DB. Seul le pilote ACE DAO offre la prise en charge complète des fonctionnalités antérieures, telles que les tables liées et les requêtes enregistrées, et des nouveaux types de données complexes qui sont introduits avec Access 2007. Le pilote ACE OLE DB offre une prise en charge limitée des données complexes. Par exemple, pour permettre une meilleure prise en charge des jeux de données complexes (pour récupérer des jeux d’enregistrements dans des jeux d’enregistrements), définissez le paramètre de connexion « JET OLE DB: Support Complex Data ». Sinon, par défaut, vous obtenez seulement des listes délimitées pour les champs complexes. ADO.NET, ADO et ACE ODBC obtiennent toujours des listes délimitées pour les champs complexes.
Sécurité. L’écriture de code de base de données sécurisé dans un environnement Web multi-utilisateur représente beaucoup plus que la création d’un mot de passe de chiffrement fort. Une application qui accède à une base de données a de nombreux points de défaillance potentiels qu’une personne malveillante peut exploiter pour récupérer, manipuler ou détruire des données sensibles. Il est par conséquent important de comprendre tous les aspects de la sécurité, depuis la modélisation des menaces lors de la phase de conception de votre application jusqu’à son déploiement final et sa maintenance courante. D’une façon générale, .NET Framework fournit un environnement plus facile à utiliser et bien intégré pour l’amélioration de la sécurité de votre application.
Performance. Même si ADO.NET et ADO sont rapides, ils insèrent une couche supplémentaire d’abstraction entre votre application et le fournisseur ACE OLE DB lorsqu’il fonctionne avec le moteur ACE. En général, les méthodes Direct DAO, OLE DB et ODBC sont plus rapides, en particulier pour les bases de données d’une taille plus importante. Si la performance est un problème et que vous prévoyez que la taille de votre base de données augmentera de façon significative avec le temps, vous pouvez écrire votre application en C++ en utilisant l’interface OLE DB ou DAO.
Maintenance. Pour développer des solutions simples, ADO.NET ou Direct DAO (et éventuellement ADO), voir les commentaires. Le choix de la technologie d’accès aux données OLE DB affecte le coût de maintenance à long terme de votre application. OLE DB est plus coûteux que DAO ou ADO.NET car la maintenance et l’amélioration de code COM complexe est plus difficile. Comme alternative à la méthode Direct OLE DB, vous pouvez utiliser l’approche ATL OLE DB (un exemple de code source est fourni) qui offre un bon niveau d’abstraction de la complexité COM sous-jacente.
Notes
Les fournisseurs Office Access 2007 ACE fonctionnent seulement avec du code client 32 bits. Les fournisseurs ACE Access 2010 prennent en charge le code 32 bits et le code 64 bits. Pour implémenter une solution 64 bits, vous-même et vos clients devez déployer un produit Access 2010 64 bits.
Méthodes obsolètes d’accès aux données
Le tableau 2 contient la liste des méthodes obsolètes d’accès aux données pour Access 2007. Ces méthodes ne sont pas prises en charge pour une utilisation avec des bases de données Access enregistrées dans le format de fichier .accdb et elles doivent être utilisées seulement pour la maintenance d’applications héritées.
Tableau 2. Méthodes obsolètes d’accès aux données
Nom du fournisseur |
Méthode d’accès aux données |
Informations de connexion et autres informations |
Langage(s) pris en charge |
---|---|---|---|
Fournisseur OLE DB JET4.0 |
OLE DB |
Microsoft.JET.OLEDB.4.0 <Atldbcli.h> |
C++ |
MFC DAO |
MFC DAO |
<Afxdao.h>; Installé avec MDAC ; classes MFC qui ont le préfixe CDao. Les classes MFC DAO offrent à l’utilisateur un moyen d’utiliser le moteur de base de données Microsoft JET hérité. Cependant, elles ne sont pas prises en charge au niveau d’Access 2007. DAO 3.6 est la version finale de cette technologie. Elle n’est pas disponible sur Windows 64 bits. Les Assistants Visual C++ .NET ne génèrent pas de code qui crée et ouvre automatiquement les jeux d’enregistrements. |
C++ |
Pilote Access ODBC 4.0 |
MFC ODBC |
Driver={Microsoft Access Driver (*.mdb)} ; DBQ=chemin d’accès du fichier mdb <Afxdb.h>; Odbcjt32.dll; |
C++ |
Conclusion
Cet article technique présente l’architecture de haut niveau de Microsoft Access, son moteur et ses fournisseurs de données ACE. Il explore les différentes technologies d’accès aux données qui sont à votre disposition pour la programmation d’Access, que vous développiez du code natif ou géré, 32 bits ou 64 bits. En utilisant des technologies d’accès aux données telles que DAO, OLE DB, ADO.NET, ADO, ODBC ou JDBC, vous pouvez continuer à créer des solutions Access personnalisées, même pour les scénarios les plus complexes et les plus exigeants. D’une façon générale, en tant que fournisseur par défaut pour le moteur ACE, le pilote ACE DAO fournit l’interface native la plus complète avec les bases de données Access, et ADO.NET est une bonne alternative pour les langages .NET. Non seulement chacun d’eux s’intègre bien avec le moteur ACE, mais ils fournissent aussi un environnement stable et de compatibilité descendante avec les formats de fichiers hérités.