class CDBSet : public CRecordset
{
public:
CDBSet(CDatabase* pDatabase = NULL);
DECLARE_DYNAMIC(CDBSet)

// Field/Param Data
//{{AFX_FIELD(CDBSet, CRecordset)
longm_ProductID;
CStringm_ProductName;
longm_SupplierID;
longm_CategoryID;
CStringm_QuantityPerUnit;
CStringm_UnitPrice;
intm_UnitsInStock;
CStringm_UnitsOnOrder;
intm_ReorderLevel;
BOOLm_Discontinued;
//}}AFX_FIELD

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CDBSet)
public:
virtual CString GetDefaultConnect();// Default connection string
virtual CString GetDefaultSQL(); // default SQL for Recordset
virtual void DoFieldExchange(CFieldExchange* pFX);// RFX support
//}}AFX_VIRTUAL

// Implementation
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif

};

// Field/Param Data
//{{AFX_FIELD(CDBSet, CRecordset)
longm_ProductID;
CStringm_ProductName;
longm_SupplierID;
longm_CategoryID;
CStringm_QuantityPerUnit;
CStringm_UnitPrice;
intm_UnitsInStock;
CStringm_UnitsOnOrder;
intm_ReorderLevel;
BOOLm_Discontinued;
//}}AFX_FIELD

CDBSet::CDBSet(CDatabase* pdb)
: CRecordset(pdb)
{
//{{AFX_FIELD_INIT(CDBSet)
m_ProductID = 0;
m_ProductName = _T("");
m_SupplierID = 0;
m_CategoryID = 0;
m_QuantityPerUnit = _T("");
m_UnitPrice = _T("");
m_UnitsInStock = 0;
m_UnitsOnOrder = _T("");
m_ReorderLevel = 0;
m_Discontinued = FALSE;
m_nFields = 10;
//}}AFX_FIELD_INIT
m_nDefaultType = snapshot;       //  here
}

virtual CString GetDefaultConnect();// Default connection string

CString CDBSet::GetDefaultConnect()
{
return _T("ODBC;DSN=Gestion de stock");
}

#include "DBSet.h"


class CDBDoc : public CDocument
{
protected: // create from serialization only
CDBDoc();
DECLARE_DYNCREATE(CDBDoc)

// Attributes
public:
CDBSet m_dBSet;

//...
};

CDBSet(CDatabase* pDatabase = NULL);

CString CDBSet::GetDefaultConnect()
{
return _T("ODBC;DSN=Gestion de stock;UID=Gabrielly;PWD=Angel");
}

return _T("ODBC;");

virtual CString GetDefaultSQL(); // default SQL for Recordset

CString CDBSet::GetDefaultSQL()
{
return _T("[Product]");    // équivalent à SELECT * FROM Product
}

CString CMyRecordset::GetDefaultSQL()
{
return _T("[Table1], [Table2]");    // équivalent à SELECT * FROM Table1, Table2  
}

void CDBSet::DoFieldExchange(CFieldExchange* pFX)
{
//{{AFX_FIELD_MAP(CDBSet)
pFX->SetFieldType(CFieldExchange::outputColumn);
RFX_Long(pFX, _T("[ProductID]"), m_ProductID);
RFX_Text(pFX, _T("[ProductName]"), m_ProductName);
RFX_Long(pFX, _T("[SupplierID]"), m_SupplierID);
RFX_Long(pFX, _T("[CategoryID]"), m_CategoryID);
RFX_Text(pFX, _T("[QuantityPerUnit]"), m_QuantityPerUnit);
RFX_Text(pFX, _T("[UnitPrice]"), m_UnitPrice);
RFX_Int(pFX, _T("[UnitsInStock]"), m_UnitsInStock);
RFX_Text(pFX, _T("[UnitsOnOrder]"), m_UnitsOnOrder);
RFX_Int(pFX, _T("[ReorderLevel]"), m_ReorderLevel);
RFX_Bool(pFX, _T("[Discontinued]"), m_Discontinued);
//}}AFX_FIELD_MAP
}

class CDBSet;

class CDBView : public CRecordView
{
protected: // create from serialization only
CDBView();
DECLARE_DYNCREATE(CDBView)

public:
//{{AFX_DATA(CDBView)
enum{ IDD = IDD_DB_FORM };
CDBSet* m_pSet;
// NOTE: the ClassWizard will add data members here
//}}AFX_DATA

// Attributes
public:
CDBDoc* GetDocument();

// Operations
public:

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CDBView)
public:
virtual CRecordset* OnGetRecordset();
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
virtual void OnInitialUpdate(); // called first time after construct
virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);
//}}AFX_VIRTUAL

// Implementation
public:
virtual ~CDBView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif

protected:

// Generated message map functions
protected:
//{{AFX_MSG(CDBView)
// NOTE - the ClassWizard will add and remove member functions here.
//    DO NOT EDIT what you see in these blocks of generated code !
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};

class CDBSet;

class CDBView : public CRecordView
{
protected: // create from serialization only
CDBView();
DECLARE_DYNCREATE(CDBView)

public:
//{{AFX_DATA(CDBView)
enum{ IDD = IDD_DB_FORM };
CDBSet* m_pSet;
// NOTE: the ClassWizard will add data members here
//}}AFX_DATA

//...
};

void CDBView::DoDataExchange(CDataExchange* pDX)
{
CRecordView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDBView)
DDX_FieldText(pDX, IDC_CATEGORYID, m_pSet->m_CategoryID, m_pSet);
DDX_FieldText(pDX, IDC_PRODUCTID, m_pSet->m_ProductID, m_pSet);
DDX_FieldText(pDX, IDC_PRODUCTNAME, m_pSet->m_ProductName, m_pSet);
DDX_FieldText(pDX, IDC_UNITPRICE, m_pSet->m_UnitPrice, m_pSet);
DDX_FieldText(pDX, IDC_UNITSINSTOCK, m_pSet->m_UnitsInStock, m_pSet);
DDX_FieldText(pDX, IDC_UNITSONORDER, m_pSet->m_UnitsOnOrder, m_pSet);
//}}AFX_DATA_MAP
}

CDBOrderView::~CDBOrderView()
{
//if (m_pSet)
//delete m_pSet;
}

void CDBView::OnInitialUpdate()
{
      // On récupère le jeu de lignes déjà construit 
     // et connecté à la base de données

     m_pSet = &GetDocument()->m_dBSet;
     CRecordView::OnInitialUpdate();
     GetParentFrame()->RecalcLayout();
     ResizeParentToFit();
}

void CDBView::OnInitialUpdate()
{
m_pSet = &GetDocument()->m_dBSet;
m_pSet->m_strSort = "[ProductID]";// trie suivant la colonne ProductID de la table Product
CRecordView::OnInitialUpdate();
GetParentFrame()->RecalcLayout();
ResizeParentToFit();
}

m_strSort = "[ProductID], [ProductName]"

BOOL CEnrollDoc::RemoveStudent( CString strStudentID )
{
    // la fonction recoit l'ID de l'étudiant à supprimer

    if ( !m_dbStudentReg.BeginTrans( ) ) // On démarre la transaction
        return FALSE;

    // Je constuis le recordset associé à une table qui reprend tous les cours des étudiants
    CEnrollmentSet rsEnrollmentSet(&m_dbStudentReg);

    // je prépare le filtre 
    rsEnrollmentSet.m_strFilter = "StudentID = " + strStudentID;

    // j'exécute la requête suivant le filtre. Le recordset est modifiable
    // Cette requête me donne tous les cours associés à cet étudiant
    if ( !rsEnrollmentSet.Open(CRecordset::dynaset) )
        return FALSE;

    // Je construis le recordset associé à une table qui reprend tous les étudiants enrollés
    CStudentSet rsStudentSet(&m_dbStudentReg);
    
    // je prépare le filtre
    rsStudentSet.m_strFilter = "StudentID = " + strStudentID;
    
    // j'exécute la requête suivant le filtre. Le recordset est modifiable
    // Cette requête me donne en principe un seul enregistrement qui reprend
    // les informations de l'étudiant à supprimer
    if ( !rsStudentSet.Open(CRecordset::dynaset) )
        return FALSE;

    TRY  // Biensûr un bloc try-catch est nécessaire pour les exceptions éventuelles
    {
        while ( !rsEnrollmentSet.IsEOF( ) ) // je défile en avant
        {
            rsEnrollmentSet.Delete( );
            rsEnrollmentSet.MoveNext( );
        } 
        // je viens de supprimer tous les cours relatifs à l'étudiant
        // Je supprime également l'étudiant de la table des étudiants enrollés
        rsStudentSet.Delete( );
        
        // enfin je valide toutes les opérations effectués pour affecter la source de données
        m_dbStudentReg.CommitTrans();
        // après le commit,
        // j'aurais pu appeler CDatabase::GetCursorCommitBehavior()
        // pour tester l'effet de la transaction sur mes recordsets
    }

    CATCH_ALL(e)
    {
        // tiens!!! j'ai échoué. 
        // Je supprime donc la transaction
        m_dbStudentReg.Rollback();
        // après le rollback,
        // j'aurais pu appeler CDatabase::GetCursorRollbackBehavior()
        // pour tester l'effet de la transaction sur mes recordsets
        return FALSE;
    }
    END_CATCH_ALL

    rsEnrollmentSet.Close();  // bon je ferme mes recordset
    rsStudentSet.Close();  // le destructeur pouvait fair ça à ma place

    return TRUE;
}

//...
if( !rsStudent.Open( ) )  // Est-il ouvert?
    return FALSE;

// Ok, je prépare à nouveau mes trie et mes filtres.
// rsStudent.Open(); // non non non, le recordset est déjà ouvert!!!
rsStudent.Requery(); // c'est comme ça qu'on relance une nouvelle fois
//...

//...
rsStudent.SetLockingMode(CRecordset::optimistic);  // je choisit ce mode de vérouillage car je suis optimiste 
rsStudent.Edit();   // le vérouillage n'a pas encore commencé

// j'édite mes quelques champs 
rsStudent.m_strStreet = strNewStreet;
rsStudent.m_strCity = strNewCity;
rsStudent.m_strState = strNewState;
rsStudent.m_strPostalCode = strNewPostalCode;

if( !rsStudent.Update() )  // bon, je vérouille pour garantir que je suis seul à modifier cet enregistrement
{
    AfxMessageBox( "Impossible de mettre à jours." );
    return FALSE;
}
// le vérouillage est libéré après l'appel à Update. 
// d'autres utilisateurs peuvent maintenant modifier cet enregistrement.

//...
rsStudent.SetLockingMode(CRecordset::pessimistic);  // je suis vraiment pessimiste!!!
rsStudent.Edit();   // je préfère commencer le vérouillage ici

// j'édite mes quelques champs 
rsStudent.m_strStreet = strNewStreet;
rsStudent.m_strCity = strNewCity;
rsStudent.m_strState = strNewState;
rsStudent.m_strPostalCode = strNewPostalCode;
//Hé oui, jusqu'à Update je suis vraiment le seul utilisateur à modifier cet enregistrement
if( !rsStudent.Update() )
{
    AfxMessageBox( "Impossible de mettre à jours." );
    return FALSE;
}
// le vérouillage est libéré après l'appel à Update. 
// d'autres utilisateurs peuvent maintenant modifier cet enregistrement.
// Excusez-moi les autres users si les appels entre Edit et Update me prennent 5 secondes de temps processeur.
// Car je suis vraiment pessimiste et je veux que personne n'y accède pendant que je modifie.

if( !rsStudent.Open( ) )  // Est-il ouvert?
    return FALSE;

if( !rsStudent.CanUpdate() )  //Puisse-je modifier? 
    return FALSE;

rsStudent.SetAbsolutePosition(3);   // j'accède à l'enregistrement à supprimer
rsStudent.Delete();  // je le détruit

if(rsStudent.IsDelete()) // Est-il vraiment détruit?  
   rsStudent.MoveNext();  // bon, je me positionne sur l'enregistrement suivant

if( !rsStudent.Open( ) )  // Est-il ouvert?
    return FALSE;

if( !rsStudent.CanUpdate() )  //Puisse-je modifier? 
    return FALSE;

rsStudent.SetAbsolutePosition(3);   // j'accède à l'enregistrement à mettre à jours
rsStudent.Edit( );   // bon, je prépare le tampon d'édition

// j'édite mes quelques champs 
rsStudent.m_strStreet = strNewStreet;
rsStudent.m_strCity = strNewCity;
rsStudent.m_strState = strNewState;
rsStudent.m_strPostalCode = strNewPostalCode;

if( !rsStudent.Update() )  // je n'oublie de mettre à jours. C'est la validation
{
    AfxMessageBox( "Impossible de mettre à jours." );
    return FALSE;
}

if( !rsStudent.Open( ) )  // Est-il ouvert?
    return FALSE;

if( !rsStudent.CanAppend() )  //Puisse-je ajouter? 
    return FALSE;  

rsStudent.AddNew();   // bon, je prépare le tampon d'édition

// j'édite mes quelques champs       
rsStudent.m_strName = strName;
rsStudent.m_strCity = strCity;
rsStudent.m_strStreet = strStreet;

if( !rsStudent.Update( ) )  // je n'oublie de mettre à jours. C'est la validation
{
    AfxMessageBox( "Impossible de mettre à jours" );
    return FALSE;
}

if( !rsStudentSet.Open() )  // rsStudentSet est de type CStudentSet dérivée de CRecordset
    return FALSE;

if( !rsStudentSet.CanUpdate() ) // vérifie s'il est modifiable
{
    AfxMessageBox( "Impossible de mettre à jours le recordset." );
    return;
}

if( !rsStudentSet.CanAppend() )  // vérifie s'il permet l'ajout d'enregistrement
{
    AfxMessageBox("Impossible d'ajouter des enregistrements");
    return;
}

class CStudentSet : public CRecordset
{
    // Field Data
    CString m_strFirstName;
    CString m_strLastName;
    long m_StudentID;
    CString m_strGradYear;

    // Param Data
    CString m_strGradYrParam; 
    long m_StudebtIDParam;   
};

CStudentSet::CStudentSet(CDatabase* pdb)
   : CRecordset(pdb)
{ 
    // Field Data
    m_strFirstName = _T("");
    m_strLastName = _T("");
    m_StudentID = 0;
    m_strGradYear = _T("");
    m_nFields = 4;

    // Param Data
    m_strGradYrParam = _T("");
    m_StudentIDParam = 0;
    m_nParams = 2;
}

void CStudentSet::DoFieldExchange(CFieldExchange* pFX)
{
    // Field Data
    pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_Text(pFX, _T("[FirstName]"), m_strFirstName);
    RFX_Text(pFX, _T("[LastName]"), m_strLastName);
    RFX_Long(pFX, _T("[StudentID]"), m_StudentID);
    RFX_Text(pFX, _T("[GradYear]"), m_strGradYear);

    // Param Data
    // l'ordre des appels RFX_() sur les paramètres est important!!!
    pFX->SetFieldType(CFieldExchange::param);
    RFX_Text(pFX, _T("[GradYear]"), m_strGradYrParam);  // 1 ier paramètre
    RFX_Long(pFX, _T("[StudentID]"), m_StudentIDParam); // 2 ième paramètre
}

CString CStudentSet::GetDefaultSQL()
{
    return _T("[Student]");  // la requête SELECT par défaut de la table Student
}

CDatabase mydb;

if( !mydb.OpenEx( _T( "ODBC;DSN=MYDATASOURCE;UID=JOES" ))
{
    AfxMessageBox("Impossible d'ouvrir la base de donnée");
    return;
}

CStudentSet rsStudents(mydb);
rsStudents.m_strFilter = "[GradYear] <= ? AND [StudentID] >= ? AND [StudentID] <= '1000'"; // je prépare le filtre

// Hééée!!! l'ordre des points d'interrogation est important
// je dois avoir 2 points d'interrogations car m_nParams = 2
// le premier est pour m_strGradYrParam et le deuxième pour m_StudentIDParam dans cet ordre définit dans DoFieldExchange!!!
// rsStudents.m_strFilter = "[StudentID] >= ? AND [StudentID] <= '1000' AND [GradYear] <= ?";  // very bad

rsStudent.m_strSort = "LastName DESC, FirstName DESC"; // je prépare le trie

// Cette fonction d'aide me donne l'année académique courante
CString strGradYear = GetCurrentAcademicYear(); 

// Cette fonction d'aide me donne un ID d'étudiant inférieure à 1000  
long StudentID = GetCurrentStudentID();

// j'initialise mes paramètres
rsStudents.m_strGradYrParam = strGradYear;
rsStudents.m_StudentIDParam = StudentID;

rsStudents.Open(); // j'ouvre le jeu

if(rsStudents.IsOpen())
{
    // bon il est ouvert je peux naviguer à travers les enregistrements
}

rsStudents.Close(); // bon, je préfère fermer explicitement 
mydb.Close(); // je ferme aussi la connexion

CStudentSet rsStudent( NULL );
// définit le trie 
rsStudent.m_strSort = "LastName DESC, FirstName DESC"; // good
// rsStudent.m_strSort = "ORDER BY LastName DESC, FirstName DESC"; // bad
// exécute la requête
rsStudent.Open();

class CCourse : public CRecordset
{
public:
   CCourse(CDatabase* pDatabase = NULL);
   ...
   CString m_strCourseID;
   CString m_strCourseTitle;
   CString m_strIDParam;
};

CCourse rsCourseSet( NULL );

rsCourseSet.m_strFilter = "CourseID = 'MATH101'"; // very good
// rsCourseSet.m_strFilter = "WHERE CourseID = 'MATH101'"; // very bad, pas de WHERE
// rsCourseSet.m_strFilter = "CourseID = MATH101"; // very bad, mais où sont les guillemets simples? 

rsCourseSet.Open( CRecordset::snapshot, NULL, CRecordset::readOnly );

if( !rsCourseSet.IsOpen() )
    return;

// Affiche tous les titres pour lequel CourseID = 'MATH101'
while ( !rsCourseSet.IsEOF( ) )
{
    CString strTitle = rsCourseSet.m_strCourseTitle; // j'obtient un titre
    TRACE("%s\n", (LPCTSTR) strTitle); 
    rsCourseSet.MoveNext( );
}

rsCourseSet.m_strFilter = "CourseID = ?";
rsCourseSet.m_strIDParam = "PROGRAMMATION"; // very good
// rsCourseSet.m_strIDParam = "'PROGRAMMATION'"; // very bad, pourquoi des guillemets simples?

// aller on refait la requête si m_strIDParam a été definit correctement (m_nParams et DoFieldExchange)
rsCourseSet.Requery(); 

// Réaffiche à nouveau tous les titres pour lequel CourseID = 'PROGRAMMATION'
while ( !rsCourseSet.IsEOF( ) )
{
    CString strTitle = rsCourseSet.m_strCourseTitle; // j'obtient un titre
    TRACE("%s\n", (LPCTSTR) strTitle); 
    rsCourseSet.MoveNext( );
}

CCustSet rsCustSet( NULL ); 
// ouvre le recordset;
rsCustSet.Open( CRecordset::snapshot, NULL, CRecordset::useBookmarks);  // utilise des signets

//...

CString strSaveRecord = rsCustSet.m_strData;

CDBVariant varRecordToReturnTo;

if(rsCustSet.CanBookmark())
   rsCustSet.GetBookmark( varRecordToReturnTo );// pour l'enregistrement courant on obtient un signet dans un CDBVariant

// lignes de code de défilement du recordset
//...

if(rsCustSet.CanBookmark())
   rsCustSet.SetBookmark( varRecordToReturnTo );  // à l'aide du signet j'atteint immédiatement mon enregistrement

if(strSaveRecord == rsCustSet.m_strData)
{
   AfxMessageBox("j'ai retrouvé ma position");
}

long nRows = 3; // je n'oublie pas de revenir au 3 ième enregistrement comme enregistrement courant 

// lignes de code de défilement du recordset
//...
rsCustSet.SetAbsolutePosition(nRows); // bon, je veux revenir au 3 ième enregistrement

CCustSet rsCustSet( NULL ); 
// ouvre le recordset; l'enregistrement courant est en première position 
rsCustSet.Open( );

// Suis-je avant le premier enregistrement?
if( rsCustSet.IsBOF( ) ) 
    return; // le recordset est vide
// je lis le champ Data du premier enregistrement    
Cstring strFirstData = rsCustSet.m_strData; 

if( !rsCustSet.CanScroll() )   // Puisse-je défiler?
   return;   // dommage!!!
   
// Scroll à la fin du recordset, jusqu'à se positionner au-delà du dernier enregistrement
while ( !rsCustSet.IsEOF( ) )
{
 // je lis le champ Data de l'enregistrement courant 
    CString strCurrentData = rsCustSet.m_strData;
    rsCustSet.MoveNext( );
}

// je move au dernier record
rsCustSet.MoveLast( );

// je lis le champ Data du dernier enregistrement
CString strLastData = rsCustSet.m_strData; 

// Scroll au début du recordset, jusqu'à se positionner avant le premier enregistrement
while( !rsCustSet.IsBOF( ) )
{
// je lis le champ Data de l'enregistrement courant
    CString strCurrentData = rsCustSet.m_strData; 
    rsCustSet.MovePrev( );
}

// je move vers le premier record
rsCustSet.MoveFirst( );
// je lis le champ Data du premier enregistrement  
strFirstData = rsCustSet.m_strData; 

// Construit un snapshot
CStudentSet rsStudent( NULL ); // construction implicite d'un CDatabase non connecté à une base de données
// définit les options d'ouverture
// utilise la chaîne de connexion par défaut de CRecordset::GetDefaultConnect
if(!rsStudent.Open(CRecordset::snapshot, NULL, CRecordset::readOnly))  
    return FALSE;
// Utilise le snapshot pour agir sur ses enregistrements...
// ...
rsStudent.Close();

class CCourse : public CRecordset
{
public:
   CCourse(CDatabase* pDatabase = NULL);
   ...
   CString m_strCourseID;
   CString m_strCourseTitle;
   CString m_strIDParam;
};

void CCourse::DoFieldExchange(CFieldExchange* pFX)
{
   pFX->SetFieldType(CFieldExchange::outputColumn);
   RFX_Text(pFX, "CourseID", m_strCourseID);
   RFX_Text(pFX, "CourseTitle", m_strCourseTitle);
}

CCourse::CCourse(CDatabase* pdb)
   : CRecordset(pdb)
{
   m_strCourseID = "";
   m_strCourseTitle = "";
   m_nFields = 2;  // absolument recommandé 
}

void CCourse::DoFieldExchange(CFieldExchange* pFX)
{
   pFX->SetFieldType(CFieldExchange::outputColumn);
   RFX_Text(pFX, "CourseID", m_strCourseID);
   RFX_Text(pFX, "CourseTitle", m_strCourseTitle);

   pFX->SetFieldType(CFieldExchange::param);
   RFX_Text(pFX, "CourseID", m_strIDParam);  // le second argument est ignoré
}

CCourse::CCourse(CDatabase* pdb)
   : CRecordset(pdb)
{
   m_strCourseID = "";
   m_strCourseTitle = "";
   m_nFields = 2;
   m_nParams = 1;  // absolument recommandé 
}

CDatabase mydb;

if( !mydb.OpenEx( _T( "ODBC;DSN=MYDATASOURCE;UID=JOES" ), 
CDatabase::openReadOnly)
{
    AfxMessageBox("Impossible d'ouvrir la base de donnée en lecture seule");
    return;
}
else
{
    AfxMessageBox("Test d'ouverture réussi");
    mydb.ExecuteSQL("CREATE TABLE OFFICES (OfficeID TEXT(4)" ", 
                         OfficeName TEXT(10))");
}

CRecorset r(&mydb);

//... utilisation

r.Close();  // Je ferme d'abord le recordset
mydb.Close();  // Je me déconnecte

// je me reconnecte à une autre source de données

if( !mydb.OpenEx( _T( "ODBC;DSN=SQLServer_Source;Trusted_Connection=Yes;" ),
 CDatabase::forceOdbcDialog)
{
    AfxMessageBox("Impossible d'ouvrir la base de donnée à l'aide de l'authentification Windows NT");
    return;
}
else
{
    AfxMessageBox("Test d'ouverture réussi");
}

// ...

CString CMyAppSet::GetDefaultConnect()
{
   // les utilisateurs seront forcés de sélectionner une source de données, 
   // et de rentrer un username et un password à travers une boîte de dialogue de connexion 
   return "ODBC;"; 
}

CString CMyAppSet::GetDefaultConnect()
{
   // les utilisateurs seront forcés de rentrer un username et un password
   // à travers une boîte de dialogue de connexion 
   // mydb est le nom de ma source de données
   return "ODBC;DSN=mydb;"; 
}

CString CMyAppSet::GetDefaultConnect()
{
   // les utilisateurs seront forcés de rentrer un password qui
   // correspond au username myuserid attendu à travers une boîte
   // de dialogue de connexion  
   return "ODBC;DSN=mydb;UID=myuserid;"; 
}

CString CMyAppSet::GetDefaultConnect()
{
   // la chaîne est codée en dure et la connexion est directe
   // Il convient d'éviter de coder de manière irréversible un mot de passe, 
   // ou de spécifier un mot de passe vide puisque cela compromet sérieusement la sécurité.
   return "ODBC;DSN=mydb;UID=sa;PWD=777;";
}

CString CApp1Set::GetDefaultConnect()
{
   // Cette chaîne de connexion spécifie une connexion approuvée 
   // (qui utilise la sécurité intégrée de Windows NT). 
   return "ODBC;DSN=afx;Trusted_Connection=Yes;";
}

CDBSet(CDatabase* pDatabase = NULL);  // pour notre CDBSet
CDBOrderSet(CDatabase* pDatabase = NULL); // pour notre CDBOrderSet

m_pSet->m_pDataBase = new CDatabase();  // m_pSet est un pointeur sur un CRecordset

void CDBOrderView::OnInitialUpdate()
{
BeginWaitCursor();

CDBDoc* pDoc = (CDBDoc*) GetDocument(); // Obtient le document
m_pSet = &pDoc->m_OrderSet;// Obtient le jeu de ligne associé

// Utilise la BD ouverte pour le jeu de lignes CDBSet
m_pSet->m_pDatabase = pDoc->m_dBSet.m_pDatabase; // Réutilisation de la connexion 

// Définit le code produit en cours comme paramètre
// Initialise le paramètre du filtre
m_pSet->m_ProductIDParam = pDoc->m_dBSet.m_ProductID; 

// Définit le filtre comme colonne code produit
m_pSet->m_strFilter = "[ProductID] = ? AND [Orders].[OrderID] = [Order Details].[OrderID]";

m_pSet->Open();   // Appel du membre CDBOrderSet::Open

if (m_pSet->IsOpen())
{
CString strTitle = "Nom de la table :";
// la chaîne est vide Pourquoi? Parce que nous avons 2 tables
CString strTable = m_pSet->GetTableName(); 
     // et donc 2 noms de tables

if (!strTable.IsEmpty())
strTitle += _T(":") + strTable;

GetDocument()->SetTitle(strTitle);
}
CRecordView::OnInitialUpdate();
EndWaitCursor();
}

class CDBOrderSet : public CRecordset
{
public:
CDBOrderSet(CDatabase* pDatabase = NULL);
DECLARE_DYNAMIC(CDBOrderSet)

// Field/Param Data
//{{AFX_FIELD(CDBOrderSet, CRecordset)
longm_OrderDetailID;
longm_OrderID; // champ de la table [Orders] attaché à la colonne [Orders].[OrderID]
longm_ProductID;
//... d'autres déclarations des colonnes
longm_OrderID2;// champ de la table [Order Detail] attaché à la colonne [Order Details].[OrderID]
//... d'autres déclarations des colonnes
//}}AFX_FIELD

long m_ProductIDParam;// définition du paramètre qui remplace le symbole ? dans le filtre
//...

CDBOrderSet::CDBOrderSet(CDatabase* pdb)
: CRecordset(pdb)
{
//{{AFX_FIELD_INIT(CDBOrderSet)
m_OrderDetailID = 0;
m_OrderID = 0;
m_ProductID = 0;
//... autres initialisations
m_OrderID2 = 0;
//... autres initialisations
m_nFields = 29;     //nombre de champs 
//}}AFX_FIELD_INIT

m_ProductIDParam = 0L;//initialisation du paramètre
m_nParams = 1;//nombre de paramètres
m_nDefaultType = snapshot; //type de jeu de lignes
}

void CDBOrderSet::DoFieldExchange(CFieldExchange* pFX)
{
//{{AFX_FIELD_MAP(CDBOrderSet)
pFX->SetFieldType(CFieldExchange::outputColumn);
RFX_Long(pFX, _T("[OrderDetailID]"), m_OrderDetailID);
RFX_Long(pFX, _T("[Order Details].[OrderID]"), m_OrderID);
RFX_Long(pFX, _T("[ProductID]"), m_ProductID);
//... autres définitions de mappage
RFX_Long(pFX, _T("[Orders].[OrderID]"), m_OrderID2);
//... autres définitions de mappage
//}}AFX_FIELD_MAP

//Définit le type de colonne comme paramètre
pFX->SetFieldType(CFieldExchange::param);// définit le mode des appels RFX_()suivants sur param
RFX_Long(pFX, _T("ParamProductID"), m_ProductIDParam);

}

m_pSet->m_strFilter = "[ProductID] = ? AND [Orders].[OrderID] = [Order Details].[OrderID]";

class CDBOrderSet : public CRecordset
{
public:
CDBOrderSet(CDatabase* pDatabase = NULL);
DECLARE_DYNAMIC(CDBOrderSet)

// Field/Param Data
//{{AFX_FIELD(CDBOrderSet, CRecordset)
longm_OrderDetailID;
longm_OrderID;
longm_ProductID;
CTimem_DateSold;
doublem_Quantity;
CStringm_UnitPrice;
doublem_Discount;
CStringm_SalePrice;
CStringm_SalesTax;
CStringm_LineTotal;
longm_OrderID2;
longm_CustomerID;
longm_EmployeeID;
CTimem_OrderDate;
CStringm_PurchaseOrderNumber;
CTimem_RequiredByDate;
CTimem_PromisedByDate;
CStringm_ShipName;
CStringm_ShipAddress;
CStringm_ShipCity;
CStringm_ShipState;
CStringm_ShipStateOrProvince;
CStringm_ShipPostalCode;
CStringm_ShipCountry;
CStringm_ShipPhoneNumber;
CTimem_ShipDate;
longm_ShippingMethodID;
CStringm_FreightCharge;
doublem_SalesTaxRate;
//}}AFX_FIELD
//...

#include "DBSet.h"
#include "DBOrderSet.h"

class CDBDoc : public CDocument
{
protected: // create from serialization only
CDBDoc();
DECLARE_DYNCREATE(CDBDoc)

// Attributes
public:
CDBSet m_dBSet;
CDBOrderSet m_OrderSet;
//...

CString CDatabase::GetDatabaseName() const

const CString& CRecordset::GetTableName() const

void CDBView::OnInitialUpdate()
{
m_pSet = &GetDocument()->m_dBSet;
// trie suivant la colonne ProductID de la table Product
m_pSet->m_strSort = "[ProductID]";
// ouverture du jeu de ligne
CRecordView::OnInitialUpdate();

if(m_pSet->IsOpen())
{
CString strTitle = m_pSet->m_pDatabase->GetDatabaseName();
CString strTable = m_pSet->GetTableName();

if(!strTable.IsEmpty())
strTitle += _T(":") + strTable;

GetDocument()->SetTitle(strTitle);
 }
             
  GetParentFrame()->RecalcLayout();
ResizeParentToFit();
}

void CDBView::OnInitialUpdate()
{
//...
m_pSet->m_strSort = "[ProductID]";// trie suivant la colonne ProductID de la table Product
CRecordView::OnInitialUpdate();// appel implicite de CRecordset::Open
//...
}

void CRecordView::OnInitialUpdate()
{
CRecordset* pRecordset = OnGetRecordset();
// recordset must be allocated already
ASSERT(pRecordset != NULL);

if (!pRecordset->IsOpen())
{
CWaitCursor wait;
   // ouverture du jeu de ligne par l'appel à OnInitialUpdate()
pRecordset->Open(); 
}
CFormView::OnInitialUpdate();
}