Partager via

Simplification de l'accès aux données à l'aide d'attributs de base de données

  • Article

Cette rubrique illustre l’utilisation d’attributs de base de données pour simplifier les opérations de base de données.

La méthode de base pour accéder aux informations à partir d’une base de données consiste à créer une classe de commande (ou table) et une classe d’enregistrement utilisateur pour une table particulière de la base de données. Les attributs de base de données simplifient certaines déclarations de modèle que vous deviez effectuer précédemment.

Pour illustrer l’utilisation des attributs de base de données, les sections suivantes présentent deux déclarations de classe de table et d’enregistrement utilisateur équivalentes : la première utilise des attributs et le second utilise des modèles OLE DB. Ce code de déclaration est généralement placé dans un fichier d’en-tête nommé pour la table ou l’objet de commande, par exemple, Authors.h.

En comparant les deux fichiers, vous pouvez voir combien il est plus simple d’utiliser des attributs. Parmi les différences sont les suivantes :

  • À l’aide d’attributs, vous n’avez qu’à déclarer une seule classe : CAuthors, tandis qu’avec les modèles, vous devez déclarer deux : CAuthorsNoAttrAccessor et CAuthorsNoAttr.

  • L’appel db_source dans la version attribuée équivaut à l’appel OpenDataSource() dans la déclaration de modèle.

  • L’appel db_table dans la version attribuée équivaut à la déclaration de modèle suivante :

    class CAuthorsNoAttr : public CTable<CAccessor<CAuthorsNoAttrAccessor>>

  • Les db_column appels dans la version attribuée sont équivalents à la carte de colonnes (voir BEGIN_COLUMN_MAP ... END_COLUMN_MAP) dans la déclaration de modèle.

Les attributs injectent une déclaration de classe d’enregistrement utilisateur pour vous. La classe d’enregistrement utilisateur est égale à CAuthorsNoAttrAccessor celle de la déclaration de modèle. Si votre classe de table est CAuthors, la classe d’enregistrement utilisateur injectée est nommée CAuthorsAccessoret vous ne pouvez afficher sa déclaration que dans le code injecté. Pour plus d’informations, consultez « Classes d’enregistrements utilisateur injectés par attribut » dans les enregistrements utilisateur.

Dans l’attribut et le code basé sur un modèle, vous devez définir les propriétés de l’ensemble de lignes à l’aide CDBPropSet::AddPropertyde .

Pour plus d’informations sur les attributs abordés dans cette rubrique, consultez attributs de consommateur OLE DB.

Remarque

Les instructions suivantes include sont requises pour compiler les exemples ci-dessous :

#include <atlbase.h>
#include <atlplus.h>
#include <atldbcli.h>

Déclaration de table et d’accesseur à l’aide d’attributs

Le code suivant appelle db_source et db_table sur la classe de table. db_source spécifie la source de données et la connexion à utiliser. db_table injecte le code de modèle approprié pour déclarer une classe de table. db_column spécifiez la carte de colonnes et injectez la déclaration d’accesseur. Vous pouvez utiliser des attributs de consommateur OLE DB dans n’importe quel projet qui prend en charge ATL.

Voici la déclaration de table et d’accesseur à l’aide d’attributs :

//////////////////////////////////////////////////////////////////////
// Table and accessor declaration using attributes
// authors.h
//////////////////////////////////////////////////////////////////////

// Table class declaration
// (Note that you must provide your own connection string for db_source.)
[
   db_source(L"your connection string"),
   db_table("Authors")
]
class CAuthors
{
public:
   DBSTATUS m_dwAuIDStatus;
   DBSTATUS m_dwAuthorStatus;
   DBSTATUS m_dwYearBornStatus;
   DBLENGTH m_dwAuIDLength;
   DBLENGTH m_dwAuthorLength;
   DBLENGTH m_dwYearBornLength;
   [db_column("1", status = "m_dwAuIDStatus", length = "m_dwAuIDLength")] LONG m_AuID;
   [db_column("2", status = "m_dwAuthorStatus", length = "m_dwAuthorLength")] TCHAR m_Author[51];
   [db_column("3", status = "m_dwYearBornStatus", length = "m_dwYearBornLength")] SHORT m_YearBorn;
   void GetRowsetProperties(CDBPropSet* pPropSet)
   {
      pPropSet->AddProperty(DBPROP_CANFETCHBACKWARDS, true);
      pPropSet->AddProperty(DBPROP_CANSCROLLBACKWARDS, true);
      pPropSet->AddProperty(DBPROP_IRowsetChange, true);
   }
};

Déclaration de table et d’accesseur à l’aide de modèles

Voici la déclaration de table et d’accesseur à l’aide de modèles.

//////////////////////////////////////////////////////////////////////
// Table and user record class declaration using templates
// authors.h
//////////////////////////////////////////////////////////////////////

// User record class declaration
class CAuthorsNoAttrAccessor
{
public:
   DWORD m_dwAuIDStatus;
   DWORD m_dwAuthorStatus;
   DWORD m_dwYearBornStatus;
   DWORD m_dwAuIDLength;
   DWORD m_dwAuthorLength;
   DWORD m_dwYearBornLength;
   LONG m_AuID;
   TCHAR m_Author[51];
   SHORT m_YearBorn;
   void GetRowsetProperties(CDBPropSet* pPropSet)
   {
      pPropSet->AddProperty(DBPROP_CANFETCHBACKWARDS, true);
      pPropSet->AddProperty(DBPROP_CANSCROLLBACKWARDS, true);
      pPropSet->AddProperty(DBPROP_IRowsetChange, true);
   }
   HRESULT OpenDataSource()
   {
      CDataSource _db;

HRESULT hr;
      hr = _db.OpenFromInitializationString(L"your connection string");
      if (FAILED(hr))
      {
#ifdef _DEBUG
         AtlTraceErrorRecords(hr);
#endif
         return hr;
      }
      return m_session.Open(_db);
   }
   void CloseDataSource()
   {
      m_session.Close();
   }
   operator const CSession&()
   {
      return m_session;
   }
   CSession m_session;
   BEGIN_COLUMN_MAP(CAuthorsNoAttrAccessor)
      COLUMN_ENTRY_LENGTH_STATUS(1, m_AuID, m_dwAuIDLength, m_dwAuIDStatus)
      COLUMN_ENTRY_LENGTH_STATUS(2, m_Author, m_dwAuthorLength, m_dwAuthorStatus)
      COLUMN_ENTRY_LENGTH_STATUS(3, m_YearBorn, m_dwYearBornLength, m_dwYearBornStatus)
   END_COLUMN_MAP()
};
class CAuthorsNoAttr : public CTable<CAccessor<CAuthorsNoAttrAccessor>>
{
public:
   HRESULT OpenAll()
   {
HRESULT hr;
      hr = OpenDataSource();
      if (FAILED(hr))
         return hr;
      __if_exists(GetRowsetProperties)
      {
         CDBPropSet propset(DBPROPSET_ROWSET);
         __if_exists(HasBookmark)
         {
            propset.AddProperty(DBPROP_IRowsetLocate, true);
         }
         GetRowsetProperties(&propset);
         return OpenRowset(&propset);
      }
      __if_not_exists(GetRowsetProperties)
      {
         __if_exists(HasBookmark)
         {
            CDBPropSet propset(DBPROPSET_ROWSET);
            propset.AddProperty(DBPROP_IRowsetLocate, true);
            return OpenRowset(&propset);
         }
      }
      return OpenRowset();
   }
   HRESULT OpenRowset(DBPROPSET *pPropSet = NULL)
   {
HRESULT hr = Open(m_session, "Authors", pPropSet);
#ifdef _DEBUG
      if(FAILED(hr))
         AtlTraceErrorRecords(hr);
#endif
      return hr;
   }
   void CloseAll()
   {
      Close();
      CloseDataSource();
   }
};

Voir aussi

Attributs du consommateur OLE DB