ODBC操作数据库

 

        ODBC是微软公司开放服务结构中有关数据库的一个组成部分，它建立了一组规范，并提供了一组对数据库访问的标准API（应用程序编程接口）。这些API利用SQL来完成其大部分任务。ODBC本身也提供了对SQL语言的支持，用户可以直接将SQL语句送给ODBC。一个基于ODBC的应用程序对数据库的操作不依赖任何DBMS，不直接与DBMS打交道，所有的数据库操作由对应的DBMS的ODBC驱动程序完成。也就是说，不论是FoxPro、Access还是Oracle数据库，均可用ODBC API进行访问。由此可见，ODBC的最大优点是能以统一的方式处理所有的数据库。MFC提供的ODBC类对较复杂的ODBC API进行了封装，提供了简化的调用接口，从而大大方便了数据库应用程序的开发。程序员不必了解ODBC API和SQL的具体细节，利用ODBC类即可完成对数据库的大部分操作。为了说明如何通过ODBC类操作数据库，本实例给出一个数据库的应用实例，它实现了对数据库中的课程表的浏览、编辑、修改、添加等基本操作。需要注意的是，在编译运行该程序时，请先注册代码中的数据源，并将该数据源命名为"Student Regritration"。程序编译运行后的界面效果如图一所示：

　　一、实现方法

　　一个完整的ODBC由下列几个部件组成：（1）应用程序(Application)；（2）ODBC管理器(Administrator)，该程序位于Windows 95控制面板(Control Panel)的32位ODBC内，其主要任务是管理安装的ODBC驱动程序和管理数据源；（3）驱动程序管理器(Driver Manager)，驱动程序管理器包含在ODBC32.DLL中，对用户是透明的。其任务是管理ODBC驱动程序，是ODBC中最重要的部件（4）ODBC API；（5）ODBC 驱动程序，是一些DLL，提供了ODBC和数据库之间的接口；（6）数据源。数据源包含了数据库位置和数据库类型等信息，实际上是一种数据连接的抽象。各部件之间的关系如图2所示：

图二、ODBC部件关系图

　　应用程序要访问一个数据库，首先必须用ODBC管理器注册一个数据源（或动态注册一个数据源），管理器根据数据源提供的数据库位置、数据库类型及ODBC驱动程序等信息，建立起ODBC与具体数据库的联系。这样，只要应用程序将数据源名提供给ODBC，ODBC就能建立起与相应数据库的连接。

　　在ODBC中，ODBC API不能直接访问数据库，必须通过驱动程序管理器与数据库交换信息。驱动程序管理器负责将应用程序对ODBC API的调用传递给正确的驱动程序，而驱动程序在执行完相应的操作后，将结果通过驱动程序管理器返回给应用程序。

　　MFC的ODBC类主要包括：（1）CDatabase类，主要功能是建立与数据源的连接。（2）CRecordset类，该类代表从数据源选择的一组记录（记录集），程序可以选择数据源中的某个表作为一个记录集，也可以通过对表的查询得到记录集，还可以合并同一数据源中多个表的列到一个记录集中，通过该类可对记录集中的记录进行滚动、修改、增加和删除等操作。（3）CRecordView类，提供了一个表单视图与某个记录集直接相连，利用对话框数据交换机制(DDX)在记录集与表单视图的控件之间传输数据。该类支持对记录的浏览和更新，在撤销时会自动关闭与之相联系的记录集。（4）CFieldExchange类：支持记录字段数据交换（DFX），即记录集字段数据成员与相应的数据库的表的字段之间的数据交换。该类的功能与CDataExchange类的对话框数据交换功能类似。（5）CDBException类，代表ODBC类产生的异常。

　1、CDatabase类

　　概括地讲，CDatabase针对某个数据库，它负责连接数据源；CRecordset针对数据源中的记录集，它负责对记录的操作；CRecordView负责界面，而CFieldExchange负责CRecordset与数据源的数据交换。

　　要建立与数据源的连接，首先应构造一个CDatabase对象，然后再调用CDatabase的Open（）成员函数。Open（）函数负责建立连接，其函数原型为：

virtual BOOL Open( LPCTSTR lpszDSN, BOOL bExclusive = FALSE, BOOL bReadOnly =
FALSE, LPCTSTR lpszConnect = "ODBC;", BOOL bUseCursorLib = TRUE );

        函数中参数lpszDSN指定了数据源名（构造数据源的方法将在后面介绍），在lpszConnect参数中也可包括数据源名，此时lpszDSN必需为NULL，若在函数中未提供数据源名且使lpszDSN为NULL，则会显示一个数据源对话框，用户可以在该对话框中选择一个数据源。参数bExclusive说明是否独占数据源，由于目前版本的类库还不支持独占方式，故该参数的值应该是FALSE，这说明数据源是被共享的。参数bReadOnly若为TRUE则对数据源的连接是只读的。参数lpszConnect指定了一个连接字符串，连接字符串中可以包括数据源名、用户帐号(ID)和口令等信息，字符串中的＂ODBC＂表示要连接到一个ODBC数据源上。参数bUseCursorLib若为TRUE，则会装载光标库，否则不装载，快照需要光标库，动态集不需要光标库。 若连接成功，函数返回TRUE，若返回FALSE，则说明用户在数据源对话框中按了Cancel按钮。若函数内部出现错误，则框架会产生一个异常。下面是一个调用Open（）函数的例子：

CDatabase m_db; //在文档类中嵌入一个CDatabase对象
//连接到一个名为＂Student Registration＂的数据源
m_db.Open("Student Registration");
//在连接数据源的同时指定了用户帐号和口令
m_db.Open(NULL,FALSE,FALSE,"ODBC;DSN=Student
Registration;UID=ZYF;PWD=1234");

　　要从一个数据源中脱离，可调用函数Close（）。在脱离后，可以再次调用Open（）函数来建立一个新的连接。调用IsOpen（）函数可判断当前是否有一个连接，调用GetConnect（）可返回当前的连接字符串。需要注意的是CDatabase的析构函数会自动调用Close（）函数，所以只要删除了CDatabase对象就可以与数据源脱离。

　　2、CRecordset类

　　CRecordset类代表一个记录集。该类是MFC的ODBC类中最重要、功能最强大的类。

　　在多任务操作系统或网络环境中，多个用户可以共享同一个数据源。共享数据的一个主要问题是如何协调各个用户对数据源的修改。例如，当某一个应用改变了数据源中的记录时，别的连接至该数据源的应用应该如何处理。对于这个问题，基于MFC的ODBC应用程序可以采取几种不同的处理办法，这将由程序采用哪种记录集决定。

　　记录集主要分为快照(Snapshot) 和动态集(Dynaset)两种，CRecordset类对这两者都支持。这两种记录集的不同表现在它们对别的应用改变数据源记录采取了不同的处理方法。

　　快照型记录集提供了对数据的静态视。快照是个很形象的术语，就好象对数据源的某些记录照了一张照片一样。当别的用户改变了记录时（包括修改、添加和删除），快照中的记录不受影响，也就是说，快照不反映别的用户对数据源记录的改变。直到调用了CRecordset::Requery重新查询后，快照才会反映变化。对于象产生报告或执行计算这样的不希望中途变动的工作，快照是很有用的。需要指出的是，快照的这种静态特性是相对于别的用户而言的，它会正确反映由本身用户对记录的修改和删除，但对于新添加的记录直到调用Requery后才能反映到快照中。动态集提供了数据的动态视，当别的用户修改或删除了记录集中的记录时，会在动态集中反映出来：当滚动到修改过的记录时对其所作的修改会立即反映到动态集中，当记录被删除时，MFC代码会跳过记录集中的删除部分。对于其它用户添加的记录，直到调用Requery时，才会在动态集中反映出来。本身应用程序对记录的修改、添加和删除会反映在动态集中。当数据必须是动态的时侯，使用动态集是最适合的。例如，在一个火车票联网售票系统中，显然应该用动态集随时反映出共享数据的变化。

　　在记录集中滚动，需要有一个标志来指明滚动后的位置（当前位置）。ODBC驱动程序会维护一个光标，用来跟踪记录集的当前记录，可以把光标理解成跟踪记录集位置的一种机制。光标库(Cursor Library)是处于ODBC驱动程序管理器和驱动程序之间的动态链接库(ODBCCR32.DLL)。光标库的主要功能是支持快照以及为底层驱动程序提供双向滚动能力，高层次的驱动程序不需要光标库，因为它们是可滚动的。光标库管理快照记录的缓冲区，该缓冲区反映本程序对记录的修改和删除，但不反映其它用户对记录的改变，由此可见，快照实际上相当于当前的光标库缓冲区。

　　应注意的是，快照是一种静态光标(Static Cursor)。静态光标直到滚动到某个记录才能取得该记录的数据。因此，要保证所有的记录都被快照，可以先滚动到记录集的末尾，然后再滚动到感兴趣的第一个记录上，这样做的缺点是滚动到末尾需要额外的开销，会降低性能。

　　与快照不同，动态集不用光标库维持的缓冲区来存放记录。实际上，动态集是不使用光标库的，因为光标库会屏蔽掉一些支持动态集的底层驱动程序功能，动态集是一种键集驱动光标(Keyset-Driven Cursor)，当打开一个动态集时，驱动程序保存记录集中每个记录的键。只要光标在动态集中滚动，驱动程序就会通过键来从数据源中检取当前记录，从而保证选取的记录与数据源同步。从上面的分析中可以看出，快照和动态集有一个共同的特点，那就是在建立记录集后，记录集中的成员就已经确定了，这就是为什么两种记录集都不能反映别的用户添加记录的原因。

　　CRecordset类代表一个记录集，用户在操作数据库的时候，一般需要用ClassWizard创建一个CRecordset的派生类，ClassWizard可以为派生的记录集类创建一批数据成员，这些数据成员与记录的各字段相对应，被称为字段数据成员或域数据成员。域数据成员用来保存某条记录的各个字段，它们是程序与记录之间的缓冲区，域数据成员代表当前记录，当在记录集中滚动到某一记录时，框架自动地把记录的各个字段拷贝到记录集对象的域数据成员中。当用户要修改当前记录或增加新记录时，程序先将各字段的新值放入域数据成员中，然后调用相应的CRecordset成员函数把域数据成员设置到数据源中。

　　不难看出，在记录集与数据源之间有一个数据交换问题，CRecordset类使用＂记录域交换＂(Record Field Exchange，缩写为RFX)机制自动地在域数据成员和数据源之间交换数据。RFX机制与对话数据交换(DDX)类似，CRecordset的成员函数DoFieldExchange负责数据交换任务，在该函数中调用了一系列RFX函数，当用户用ClassWizard加入域数据成员时，ClassWizard会自动在DoFieldExchange中建立RFX。

　　记录集的建立实际上主要是一个查询过程，SQL的SELECT语句用来查询数据源，在建立记录集时，CRecordset会根据一些参数构造一个SELECT语句来查询数据源，并用查询的结果创建记录集，明白这一点对理解CRecordset至关重要。

　　要建立记录集，首先要构造一个CRecordset派生类对象，然后调用Open（）成员函数查询数据源中的记录并建立记录集。在Open（）函数中，可能会调用GetDefaultConnect（）和GetDefaultSQL（）函数。具体代码如下：

CRecordset( CDatabase* pDatabase = NULL);

　　参数pDatabase指向一个CDatabase对象，用来获取数据源。如果pDatabase为NULL，则会在Open（）函数中自动构建一个CDatabase对象。如果CDatabase对象还未与数据源连接，那么在Open函数中会建立连接，连接字符串由成员函数GetDefaultConnect（）提供。

virtual CString GetDefaultConnect( );

　　该函数返回缺省的连接字符串，Open（）函数在必要的时侯会调用该函数获取连接字符串以建立与数据源的连接，一般需要在CRecordset派生类中覆盖该函数并在新版的函数中提供连接字符串。

virtual BOOL Open( UINT nOpenType = AFX_DB_USE_DEFAULT_TYPE,
LPCTSTR lpszSQL = NULL, DWORD dwOptions = none );

　　该函数使用指定的SQL语句查询数据源中的记录并按指定的类型和选项建立记录集。参数nOpenType说明了记录集的类型。如果要求的类型驱动程序不支持，则函数将产生一个异常。参数lpszSQL是一个SQL的SELECT语句，或是一个表名。函数用lpszSQL来进行查询，如果该参数为NULL，则函数会调用GetDefaultSQL（）获取缺省的SQL语句。参数dwOptions可以是一些选项的组合，具体参见MSDN。若函数调用了CDatabase::Open且返回FALSE，则函数返回FALSE。

virtual CString GetDefaultSQL( );

        Open（）函数在必要时会调用该函数返回缺省的SQL语句或表名以查询数据源中的记录。一般需要在CRecordset派生类中覆盖该函数并在新版的函数中提供SQL语句或表名。

　　上面介绍过，在建立记录集时，CRecordset会构造一个SELECT语句来查询数据源。如果在调用Open时只提供了表名，那么SELECT语句还缺少选择列参数rfx-field-list，那么选择列的信息从DoFieldExchange中的RFX语句里提取。

　　建立记录集后，用户可以随时调用Requery（）成员函数来重新查询和建立记录集。Requery（）有两个重要用途：一是使记录集能反映用户对数据源的改变；二是按照新的过滤或排序方法查询记录并重新建立记录集。在调用Requery之前，可调用CanRestart（）来判断记录集是否支持Requery（）操作。要记住Requery只能在成功调用Open（）后调用，所以程序应调用IsOpen来判断记录集是否已建立。函数的原型如下：

virtual BOOL Requery( );

　　返回TRUE表明记录集建立成功，否则返回FALSE。

　　CRecordset类还有两个公共数据成员m_strFilter和m_strSort用来设置对记录的过滤和排序。在调用Open（）或Requery（）前，如果在这两个数据成员中指定了过滤或排序，那么Open（）和Requery（）将按这两个数据成员指定的过滤和排序来查询数据源。成员m_strFilter用于指定过滤器。m_strFilter实际上包含了SQL的WHERE子句的内容，但它不含WHERE关键字。使用m_strFilter的一个例子为：

m_pSet->m_strFilter="CourseID='MATH101'";
//只选择CourseID为MATH101的记录
if(m_pSet->Open(CRecordset::snapshot, "Section"))

　　成员m_strSort用于指定排序。m_strSort实际上包含了ORDER BY子句的内容，但它不含ORDER BY关键字。m_strSort的一个例子为：

m_pSet->m_strSort="CourseID DESC"; //按CourseID的降序排列记录
m_pSet->Open();

　　事实上，Open（）函数在构造SELECT语句时，会把m_strFilter和m_strSort的内容放入SELECT语句的WHERE和ORDER BY子句中。如果在Open的lpszSQL参数中已包括了WHERE和ORDER BY子句，那么m_strFilter和m_strSort必需为空。

　　调用无参数成员函数Close（）可以关闭记录集。在调用了Close（）函数后，程序可以再次调用Open（）建立新的记录集。CRecordset的析构函数会调用Close（）函数，所以当删除CRecordset对象时记录集也随之关闭。

　　CRecordset提供了几个成员函数用来在记录集中滚动，如下所示。当用这些函数滚动到一个新记录时，框架会自动地把新记录的内容拷贝到域数据成员中。

void MoveNext( ); //前进一个记录
void MovePrev( ); //后退一个记录
void MoveFirst( ); //滚动到记录集中的第一个记录
void MoveLast( ); //滚动到记录集中的最后一个记录
void SetAbsolutePosition( long nRows );

　　该函数用于滚动到由参数nRows指定的绝对位置处。若nRows为负数，则从后往前滚动。例如，当nRows为-1时，函数就滚动到记录集的末尾。注意，该函数不会跳过被删除的记录。

virtual void Move( long nRows, WORD wFetchType = SQL_FETCH_RELATIVE );

　　该函数功能强大。通过将wFetchType参数指定为SQL_FETCH_NEXT、SQL_FETCH_PRIOR、SQL_FETCH_FIRST、SQL_FETCH_LAST和SQL_FETCH_ABSOLUTE，可以完成上面五个函数的功能。若wFetchType为SQL_FETCH_RELATIVE，那么将相对当前记录移动，若nRows为正数，则向前移动，若nRows为负数，则向后移动。

　　如果在建立记录集时选择了CRecordset::skipDeletedRecords选项，那么除了SetAbsolutePosition外，在滚动记录时将跳过被删除的记录，这一点对象FoxPro这样的数据库十分重要。如果记录集是空的，那么调用上述函数将产生异常。另外，必须保证滚动没有超出记录集的边界。调用IsEOF（）和IsBOF（）可以进行这方面的检测。
如果记录集为空或滚动过了最后一个记录，那么函数返回TRUE，否则返回FALSE。

BOOL IsBOF( ) const;

　　如果记录集为空或滚动过了第一个记录，那么函数返回TRUE，否则返回FALSE。

　　调用GetRecordCound可获得记录集中的记录总数，该函数的原型如下：

long GetRecordCount( ) const;

　　要注意这个函数返回的实际上是用户在记录集中滚动的最远距离。要想真正返回记录总数，只有调用MoveNext移动到记录集的末尾(MoveLast不行)。

　　要修改当前记录，应该按下列步骤进行：

　　（1）调用Edit（）成员函数。调用该函数后就进入了编辑模式，程序可以修改域数据成员。注意不要在一个空的记录集中调用Edit，否则会产生异常。Edit（）函数会把当前域数据成员的内容保存在一个缓冲区中，这样做有两个目的，一是可以与域数据成员作比较以判断哪些字段被改变了，二是在必要的时侯可以恢复域数据成员原来的值。若再次调用Edit（），则将从缓冲区中恢复域数据成员，调用后程序仍处于编辑模式。调用Move(AFX_MOVE_REFRESH)或Move(0)可退出编辑模式(AFX_MOVE_REFRESH的值为0)，同时该函数会从缓冲区中恢复域数据成员。

（2）设置域数据成员的新值。

（3）调用Update（）函数完成编辑。Update把变化后的记录写入数据源并结束编辑模式。

　　要向记录集中添加新的记录，应该按下列步骤进行：调用AddNew（）成员函数。调用该函数后就进入了添加模式，该函数把所有的域数据成员都设置成NULL(注意，在数据库术语中，NULL是指没有值，这与C++的NULL是不同的)。与Edit（）一样，AddNew（）会把当前域数据成员的内容保存在一个缓冲区中，在必要的时侯，程序可以再次调用AddNew（）取消添加操作并恢复域数据成员原来的值，调用后程序仍处于添加模式。调用Move(AFX_MOVE_REFRESH)可退出添加模式，同时该函数会从缓冲区中恢复域数据成员。最后调用Update（）函数把域数据成员中的内容作为新记录写入数据源，从而结束了添加。

　　如果记录集是快照，那么在添加一个新的记录后，需要调用Requery重新查询，因为快照无法反映添加操作。

　　要删除记录集的当前记录，应按下面两步进行：调用Delete（）成员函数。该函数会同时给记录集和数据源中当前记录加上删除标记。注意不要在一个空记录集中调用Delete（），否则会产生一个异常。滚动到另一个记录上以跳过删除记录。上面提到的函数声明为：

virtual void Edit( );
virtual void AddNew( );
virtual void Delete( );
virtual BOOL Update( );

若更新失败则函数返回FALSE，且会产生一个异常。

　　在对记录集进行更改以前，程序也许要调用下列函数来判断记录集是否是可以更改的，因为如果在不能更改的记录集中进行修改、添加或删除将导致异常的产生。

BOOL CanUpdate( ) const; //返回TRUE表明记录是可以修改、添加和删除的。
BOOL CanAppend( ) const; //返回TRUE则表明可以添加记录。

3、CRecordView类

　　CRecordView（记录视图）是CFormView的派生类，它提供了一个表单视图来显示当前记录，用户可以通过表单视图显示、修改、添加和删除数据，用户一般需要创建一个CRecordView的派生类并在其对应的对话框模板中加入控件。

　　记录视图使用DDX数据交换机制在表单中的控件和记录集之间交换数据。在前面介绍的DDX都是在控件和控件父窗口的数据成员之间交换数据，而记录视图则是在控件和一个外部对象（CRecordset的派生类对象）之间交换数据，交换数据的代码是ClassWizard自动加入的。在后面的例子中，将向读者介绍用ClassWizard连接记录视图与记录集对象的方法．

　　CRecordView本身提供了对下面四个命令的支持：

　　CRecordView提供了OnMove（）成员函数处理ID_RECORD_FIRST（滚动到记录集的第一个记录）、ID_RECORD_LAST（滚动到记录集的最后一个记录）、ID_RECORD_NEXT（前进一个记录）、ID_RECORD_PREV（后退一个记录）这四个命令消息，OnMove函数（）对用户是透明的OnMove（）函数的源代码如下：

BOOL CRecordView::OnMove(UINT nIDMoveCommand)
{
　CRecordset* pSet = OnGetRecordset();
　if (pSet->CanUpdate())
　{
　　pSet->Edit();
　　if (!UpdateData())
　　　return TRUE;
　　pSet->Update();
　}
　switch (nIDMoveCommand)
　{
　　case ID_RECORD_PREV:
　　　pSet->MovePrev();
　　　if (!pSet->IsBOF())
　　　break;
　　case ID_RECORD_FIRST:
　　　pSet->MoveFirst();
　　　break;
　　case ID_RECORD_NEXT:
　　　pSet->MoveNext();
　　　if (!pSet->IsEOF())
　　　break;
　　　if (!pSet->CanScroll())
　　　{
　　　　// clear out screen since we're sitting on EOF
　　　　pSet->SetFieldNull(NULL);
　　　　break;
　　　}
　　case ID_RECORD_LAST:
　　　pSet->MoveLast();
　　　break;
　　default:
　　　// Unexpected case value
　　　ASSERT(FALSE);
　}
　// Show results of move operation
　UpdateData(FALSE);
　return TRUE;
}

　　在函数的开头先调用CRecordset::Edit（）进入编辑模式，接着调用UpdateData（）将控件中的数据更新到记录集对象的域数据成员中，然后调用CRecordset::Update（）将域数据成员的值写入数据源，这说明OnMove（）函数在滚动记录的同时会完成对原来记录的修改。
在函数的中间有一个分支语句用来处理四个不同的命令，在这个分支语句中调用了CRecordset的各种用于滚动记录的成员函数，这些函数在滚动到一个新的记录时会把该记录的内容设置到域数据成员中。在函数的末尾调用UpdateData(FALSE)把新的当前记录的内容设置到表单的控件中。由此可见，OnMove（）函数一来一回完成了两次表单控件和数据源的数据交换过程，通过分析该函数，读者可以学会在浏览记录时如何控制DDX和DFX数据交换。

二、编程步骤

　　1、启动Visual C++6.0，生成一个单文档视图结构的应用程序，将该程序命名为"Enroll"。在MFC AppWizard的第一步选择Single document，在MFC AppWizard的第二步选择Database view without file support，然后点击Data Source...按钮，在Database Options对话框中的ODBC组合框中选择Student Registration数据源，则会打开一个Select Database Table对话框，在该对话框中选择数据库中的Section表按OK按钮退出，在MFC AppWizard的第六步中，将类CEnrollSet改名为CSectionSet，将类CEnrollView改名为CSectionForm；

　　2、接下来的任务设计应用程序的界面（具体设置请参见原代码部分），并用ClassWizard把表单中的控件与记录集的域数据成员连接起来，以实现控件与当前记录的DDX数据交换。请读者按如下步骤操作：进入ClassWizard，选择Member Variables页并且选择CSectionForm类。在变量列表中双击IDC_CAPACITY项，则会显示Add Member Variable对话框。注意该对话框的Member variable name栏显示的是一个组合框，而不是平常看到的编辑框。在组合框的列表中选择m_pSet->m_Capacity并按OK按钮确认。其它控件依此类推。

　　3、对于组合框控件IDC_COURSELIST项，除在Add Member Variable对话框的组合框中选择m_pSet->m_CourseID外，还要再次双击IDC_COURSELIST，并为CSectionForm类加入一个名为m_ctlCourseList的CComboBox类成员。

　　4、使用Class Wizard为IDC_COURSELIST组合框加入CBN_SELENDOK通知消息处理函数，函数名为OnSelendokCourselist。该函数负责响应用户在组合框中选择的变化。

　　5、接着使用ClassWizard为数据库中的Course表创建一个名为CCourseSet的记录集类；

　　6、在CEnrollDoc类的定义中，紧接着m_sectionSet成员，加入下面一行：CCourseSet m_courseSet。这样CEnrollDoc就包含了两个记录集。由于CEnrollDoc类用到了CCourseSet类，所以要在所有含有#include "EnrolDoc.h"语句的CPP文件中，在#include "EnrolDoc.h"语句的前面加上#include "CourseSet.h"语句。

　　7、在CSectionSet类的定义中，紧接着域数据成员，在"//}}AFX_FIELD"注释外加入下面一行CString m_strCourseIDParam;

　　8、添加代码，编译运行程序。

　　三、程序代码

/ SectSet.h : interface of the CSectionSet class
class CSectionSet : public CRecordset
{
　public:
　　CSectionSet(CDatabase* pDatabase = NULL);
　　DECLARE_DYNAMIC(CSectionSet)
　　// Field/Param Data
　　//{{AFX_FIELD(CSectionSet, CRecordset)
　　　CString m_CourseID;
　　　CString m_SectionNo;
　　　CString m_InstructorID;
　　　CString m_RoomNo;
　　　CString m_Schedule;
　　　int m_Capacity;
　　//}}AFX_FIELD
　　CString m_strCourseIDParam;
　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CSectionSet)
　　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
};

/// SectSet.cpp : implementation of the CSectionSet class
#include "stdafx.h"
#include "Enroll.h"
#include "SectSet.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNAMIC(CSectionSet, CRecordset)

CSectionSet::CSectionSet(CDatabase* pdb)
: CRecordset(pdb)
{
　//{{AFX_FIELD_INIT(CSectionSet)
　　m_CourseID = _T("");
　　m_SectionNo = _T("");
　　m_InstructorID = _T("");
　　m_RoomNo = _T("");
　　m_Schedule = _T("");
　　m_Capacity = 0;
　　m_nFields = 6;
　//}}AFX_FIELD_INIT
　m_nDefaultType = snapshot;
　m_nParams = 1;
　m_strCourseIDParam = "";
}

CString CSectionSet::GetDefaultConnect()
{
　return _T("ODBC;DSN=Student Registration");
}

CString CSectionSet::GetDefaultSQL()
{
　return _T("[Section]");
}

void CSectionSet::DoFieldExchange(CFieldExchange* pFX)
{
　//{{AFX_FIELD_MAP(CSectionSet)
　　pFX->SetFieldType(CFieldExchange::outputColumn);
　　RFX_Text(pFX, _T("[CourseID]"), m_CourseID);
　　RFX_Text(pFX, _T("[SectionNo]"), m_SectionNo);
　　RFX_Text(pFX, _T("[InstructorID]"), m_InstructorID);
　　RFX_Text(pFX, _T("[RoomNo]"), m_RoomNo);
　　RFX_Text(pFX, _T("[Schedule]"), m_Schedule);
　　RFX_Int(pFX, _T("[Capacity]"), m_Capacity);
　//}}AFX_FIELD_MAP
　pFX->SetFieldType(CFieldExchange::param);
　RFX_Text(pFX, "CourseIDParam", m_strCourseIDParam);
}

#ifdef _DEBUG
void CSectionSet::AssertValid() const
{
　CRecordset::AssertValid();
}

void CSectionSet::Dump(CDumpContext& dc) const
{
　CRecordset::Dump(dc);
}
#endif //_DEBUG
 coursset.h : header file
class CCourseSet : public CRecordset
{
　public:
　　CCourseSet(CDatabase* pDatabase = NULL);
　　DECLARE_DYNAMIC(CCourseSet)
　　// Field/Param Data
　　//{{AFX_FIELD(CCourseSet, CRecordset)
　　　CString m_CourseID;
　　　CString m_CourseTitle;
　　　int m_Hours;
　　//}}AFX_FIELD
　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CCourseSet)
　　　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
};

/// coursset.cpp : implementation file
#include "stdafx.h"
#include "enroll.h"
#include "coursset.h"
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNAMIC(CCourseSet, CRecordset)

CCourseSet::CCourseSet(CDatabase* pdb)
: CRecordset(pdb)
{
　//{{AFX_FIELD_INIT(CCourseSet)
　　m_CourseID = _T("");
　　m_CourseTitle = _T("");
　　m_Hours = 0;
　　m_nFields = 3;
　//}}AFX_FIELD_INIT
}

CString CCourseSet::GetDefaultConnect()
{
　return _T("ODBC;DSN=Student Registration;");
}

CString CCourseSet::GetDefaultSQL()
{
　return _T("COURSE");
}

void CCourseSet::DoFieldExchange(CFieldExchange* pFX)
{
　//{{AFX_FIELD_MAP(CCourseSet)
　　pFX->SetFieldType(CFieldExchange::outputColumn);
　　RFX_Text(pFX, "CourseID", m_CourseID);
　　RFX_Text(pFX, "CourseTitle", m_CourseTitle);
　　RFX_Int(pFX, "Hours", m_Hours);
　//}}AFX_FIELD_MAP
}

#ifdef _DEBUG
void CCourseSet::AssertValid() const
{
　CRecordset::AssertValid();
}

void CCourseSet::Dump(CDumpContext& dc) const
{
　CRecordset::Dump(dc);
}
#endif //_DEBUG

// EnrolDoc.h : interface of the CEnrollDoc class
class CEnrollDoc : public CDocument
{
　protected: // create from serialization only
　　CEnrollDoc();
　　DECLARE_DYNCREATE(CEnrollDoc)
　　// Attributes
　public:
　　CSectionSet m_sectionSet;
　　CCourseSet m_courseSet;
　　// Operations
　public:
　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CEnrollDoc)
　　　public:
　　　　virtual BOOL OnNewDocument();
　　//}}AFX_VIRTUAL
　　// Implementation
　public:
　　virtual ~CEnrollDoc();
　　#ifdef _DEBUG
　　　virtual void AssertValid() const;
　　　virtual void Dump(CDumpContext& dc) const;
　　#endif
　protected:
　　// Generated message map functions
　protected:
　　//{{AFX_MSG(CEnrollDoc)
　　　// 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()
};

 EnrolDoc.cpp : implementation of the CEnrollDoc class
#include "Stdafx.h"
#include "Enroll.h"
#include "SectSet.h"
#include "CoursSet.h"
#include "EnrolDoc.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNCREATE(CEnrollDoc, CDocument)

BEGIN_MESSAGE_MAP(CEnrollDoc, CDocument)
　//{{AFX_MSG_MAP(CEnrollDoc)
　　// NOTE - the ClassWizard will add and remove mapping macros here.
　　// DO NOT EDIT what you see in these blocks of generated code!
　//}}AFX_MSG_MAP
END_MESSAGE_MAP()
CEnrollDoc::CEnrollDoc()
{
　// TODO: add one-time construction code here
}

CEnrollDoc::~CEnrollDoc()
{}

BOOL CEnrollDoc::OnNewDocument()
{
　if (!CDocument::OnNewDocument())
　　return FALSE;
　return TRUE;
}

#ifdef _DEBUG
void CEnrollDoc::AssertValid() const
{
　CDocument::AssertValid();
}

void CEnrollDoc::Dump(CDumpContext& dc) const
{
　CDocument::Dump(dc);
}
#endif //_DEBUG

 SectForm.h : interface of the CSectionForm class
class CSectionSet;
class CSectionForm : public CRecordView
{
　protected: // create from serialization only
　　CSectionForm();
　　DECLARE_DYNCREATE(CSectionForm)
　public:
　　//{{AFX_DATA(CSectionForm)
　　　enum{ IDD = IDD_ENROLL_FORM };
　　　CEdit m_ctlSection;
　　　CComboBox m_ctlCourseList;
　　　CSectionSet* m_pSet;
　　//}}AFX_DATA
　　// Attributes
　public:
　　CEnrollDoc* GetDocument();
　protected:
　　BOOL m_bAddMode;
　　// Operations
　public:
　　// Overrides
　　// ClassWizard generated virtual function overrides
　　//{{AFX_VIRTUAL(CSectionForm)
　　　public:
　　　　virtual CRecordset* OnGetRecordset();
　　　　virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
　　　　virtual BOOL OnMove(UINT nIDMoveCommand);
　　　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 ~CSectionForm();
　　#ifdef _DEBUG
　　　virtual void AssertValid() const;
　　　virtual void Dump(CDumpContext& dc) const;
　　#endif
　protected:
　　// Generated message map functions
　protected:
　　//{{AFX_MSG(CSectionForm)
　　　afx_msg void OnSelendokCourselist();
　　　afx_msg void OnRecordAdd();
　　　afx_msg void OnRecordDelete();
　　　afx_msg void OnRecordRefresh();
　　//}}AFX_MSG
　　DECLARE_MESSAGE_MAP()
};
#ifndef _DEBUG // debug version in SectForm.cpp
inline CEnrollDoc* CSectionForm::GetDocument()
{ return (CEnrollDoc*)m_pDocument; }
#endif
 SectForm.cpp : implementation of the CSectionForm class
#include "stdafx.h"
#include "Enroll.h"
#include "SectSet.h"
#include "CoursSet.h"
#include "EnrolDoc.h"
#include "SectForm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNCREATE(CSectionForm, CRecordView)
BEGIN_MESSAGE_MAP(CSectionForm, CRecordView)
//{{AFX_MSG_MAP(CSectionForm)
　ON_CBN_SELENDOK(IDC_COURSELIST, OnSelendokCourselist)
　ON_COMMAND(ID_RECORD_ADD, OnRecordAdd)
　ON_COMMAND(ID_RECORD_DELETE, OnRecordDelete)
　ON_COMMAND(ID_RECORD_REFRESH, OnRecordRefresh)
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CRecordView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CRecordView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CRecordView::OnFilePrintPreview)
END_MESSAGE_MAP()

CSectionForm::CSectionForm()
: CRecordView(CSectionForm::IDD)
{
　//{{AFX_DATA_INIT(CSectionForm)
　　m_pSet = NULL;
　//}}AFX_DATA_INIT
　m_bAddMode = FALSE;
}

CSectionForm::~CSectionForm()
{}

void CSectionForm::DoDataExchange(CDataExchange* pDX)
{
　CRecordView::DoDataExchange(pDX);
　//{{AFX_DATA_MAP(CSectionForm)
　　DDX_Control(pDX, IDC_COURSELIST, m_ctlCourseList);
　　DDX_FieldText(pDX, IDC_SECTION, m_pSet->m_SectionNo, m_pSet);
　　DDX_Control(pDX, IDC_SECTION, m_ctlSection);
　　DDX_FieldText(pDX, IDC_INSTRUCTOR, m_pSet->m_InstructorID, m_pSet);
　　DDX_FieldText(pDX, IDC_ROOM, m_pSet->m_RoomNo, m_pSet);
　　DDX_FieldText(pDX, IDC_SCHEDULE, m_pSet->m_Schedule, m_pSet);
　　DDX_FieldText(pDX, IDC_CAPACITY, m_pSet->m_Capacity, m_pSet);
　　DDX_FieldCBString(pDX, IDC_COURSELIST, m_pSet->m_CourseID, m_pSet);
　//}}AFX_DATA_MAP
}

BOOL CSectionForm::PreCreateWindow(CREATESTRUCT& cs)
{
　return CRecordView::PreCreateWindow(cs);
}

void CSectionForm::OnInitialUpdate()
{
　m_pSet = &GetDocument()->m_sectionSet;
　// Fill the combo box with all of the courses
　CEnrollDoc* pDoc = GetDocument();
　pDoc->m_courseSet.m_strSort = "CourseID";
　if (!pDoc->m_courseSet.Open())
　　return;
　// Filter, parameterize and sort the course recordset
　m_pSet->m_strFilter = "CourseID = ?";
　m_pSet->m_strCourseIDParam = pDoc->m_courseSet.m_CourseID;
　m_pSet->m_strSort = "SectionNo";
　m_pSet->m_pDatabase = pDoc->m_courseSet.m_pDatabase;
　CRecordView::OnInitialUpdate();
　m_ctlCourseList.ResetContent();
　if (pDoc->m_courseSet.IsOpen())
　{
　　while (!pDoc->m_courseSet.IsEOF())
　　{
　　　m_ctlCourseList.AddString(pDoc->m_courseSet.m_CourseID);
　　　pDoc->m_courseSet.MoveNext();
　　}　
　}　
　m_ctlCourseList.SetCurSel(0);
}

BOOL CSectionForm::OnPreparePrinting(CPrintInfo* pInfo)
{
　// default preparation
　return DoPreparePrinting(pInfo);
}

void CSectionForm::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
　// TODO: add extra initialization before printing
}

void CSectionForm::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
　// TODO: add cleanup after printing
}

#ifdef _DEBUG
void CSectionForm::AssertValid() const
{
　CRecordView::AssertValid();
}

void CSectionForm::Dump(CDumpContext& dc) const
{
　CRecordView::Dump(dc);
}

CEnrollDoc* CSectionForm::GetDocument() // non-debug version is inline
{
　ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CEnrollDoc)));
　return (CEnrollDoc*)m_pDocument;
}
#endif //_DEBUG

CRecordset* CSectionForm::OnGetRecordset()
{
　return m_pSet;
}

void CSectionForm::OnSelendokCourselist()
{
　if (!m_pSet->IsOpen())
　　return;
　m_ctlCourseList.GetLBText(m_ctlCourseList.GetCurSel(),
　m_pSet->m_strCourseIDParam);
　if (!m_bAddMode)
　{
　　m_pSet->Requery();
　　if (m_pSet->IsEOF())
　　{
　　　m_pSet->SetFieldNull(&(m_pSet->m_CourseID), FALSE);
　　　m_pSet->m_CourseID = m_pSet->m_strCourseIDParam;
　　}
　　UpdateData(FALSE);
　}
}

void CSectionForm::OnRecordAdd()
{
　// If already in add mode, then complete previous new record
　if (m_bAddMode)
　　OnMove(ID_RECORD_FIRST);
　CString strCurrentCourse = m_pSet->m_CourseID;
　m_pSet->AddNew();
　m_pSet->SetFieldNull(&(m_pSet->m_CourseID), FALSE);
　m_pSet->m_CourseID = strCurrentCourse;
　m_bAddMode = TRUE;
　m_ctlSection.SetReadOnly(FALSE);
　UpdateData(FALSE);
}

void CSectionForm::OnRecordDelete()
{
　TRY
　{
　　m_pSet->Delete();
　}
　CATCH(CDBException, e)
　{
　　AfxMessageBox(e->m_strError);
　　return;
　}
　END_CATCH
　// Move to the next record after the one just deleted
　m_pSet->MoveNext();
　// If we moved off the end of file, then move back to last record
　if (m_pSet->IsEOF())
　　m_pSet->MoveLast();
　　// If the recordset is now empty, then clear the fields
　　// left over from the deleted record
　if (m_pSet->IsBOF())
　　m_pSet->SetFieldNull(NULL);
　　UpdateData(FALSE);
}

void CSectionForm::OnRecordRefresh()
{
　if (m_bAddMode == TRUE)
　{
　　m_pSet->Move(AFX_MOVE_REFRESH);
　　m_ctlSection.SetReadOnly(TRUE);
　　m_bAddMode = FALSE;
　}
　// Copy fields from recordset to form, thus
　// overwriting any changes user may have made
　// on the form
　UpdateData(FALSE);
}

BOOL CSectionForm::OnMove(UINT nIDMoveCommand)
{
　if (m_bAddMode)
　{
　　if (!UpdateData())
　　　return FALSE;
　　TRY
　　{
　　　m_pSet->Update();
　　}
　　CATCH(CDBException, e)
　　{
　　　AfxMessageBox(e->m_strError);
　　　return FALSE;
　　}
　　END_CATCH
　　m_pSet->Requery();
　　UpdateData(FALSE);
　　m_ctlSection.SetReadOnly(TRUE);
　　m_bAddMode = FALSE;
　　return TRUE;
　}
　else
　{
　　return CRecordView::OnMove(nIDMoveCommand);
　}
}

　　四、小结

　　由于ODBC数据库编程是学习DAO、ADO等数据库编程的基础，所以上文用了大量的篇幅，详细介绍了ODBC数据库编程所涉及到的一些基础知识，并通过一个具体的实例，实现了对数据库中的两个表的关联操作，读者朋友可以将文章和代码结合起来学习，慢慢的体会，相信可以从中学习到很多数据编程的应用技巧。

 

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

ODBC连接ORACLE数据库的设置

 

一、建立服务名
1、选择“Net8 Configuration Assistant” ，选择“本地网络服务名配置”。
2、选择“添加”。
3、选择“Oracle 8i数据库或服务”。
4、输入服务名。此为远程数据库已经定制好的数据库服务名字，比如“ORCL”。
5、选择网络协议“TCP”。
6、输入主机名和端口名。比如“DB”和“1521”。
7、选择是否测试。
8、输入本地网络服务名，缺省跟远程一样。可以输入“HelloDB”等。

二、 配置ODBC
1、 添加一个"Oracle ODBC driver"的系统数据源。
2、 输入名字，用户名和服务器。服务器为刚才所建立的本地网络服务名，例如"HelloDB"。

以后就可以使用ODBC进行连接ORACLE数据库了。

1.ODBCOpen（WindowHandle, Var,数据源，用户名，密码） ，WindowHandle只要照写

　　就行了，它是Authorware的系统变量，是演示窗口的句柄。

　　举个例子：odbchd:=ODBCOpen（WindowHandle, Var, "dd", ）

　　假设这里dd是我在控制面板中设的ODBC数据源，是PARADOX数据库，所以不用用户名和密码；

　　2.然后可以用SQL语句来查询结果了，如果要从我的PARADOX目录中的KEY.DB表中查出所有记录的KEYNO字段值，这样写： Data:=ODBCExecute（odbchd, "select KEYNO from key.db"） ODBCClose（odbchd） ,从中取出KEYNO的值放在变量DATA中。

　　3.关闭数据库连接，ODBCCLOSE（odbchd） 要注意结果是一个字符串，可以用字符串处理函数处理，为了防止不必要的麻烦，请构造好合适的SQL语句，以免产生巨大的结果字串，详见各种SQL语言资料。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

ODBC无绑定数据类动态完成数据库操作

database类建一个对象，调用成员函数open函数可以连接到数据源了，用crecordset对象将前面的database对象传给他，然后调用crecordset对象的open函数，可以连接具体表
还有一个办法初学者好直接用，就是直接创建一个类继承crecordset对象，然后会提示你连接数据源和默认表，后头建一个该类对象就可以用他的成员函数直接调用了，用open重新打开某个表，movefirst和movenext，getfieldvalue来取值

 

CString sql;
CDatabase bass;
CString str1,str2;
CString SDNS=\"ODBC;DSN=LTSX;UID=stop;PWD=stop\";
bass.Open(NULL,false,false,SDNS);
     //bass.OpenEx(\"Driver={SQL Server};Server=127.0.0.1;Database=TEST;Uid=sa;Pwd=123456;\");
CRecord m_pSet(&bass);
sql=\"SELECT * FROM [dbo].[office_info]\";
m_pSet.Open(CRecord::forwardOnly, sql, CRecord::readOnly);
while (!m_pSet.IsEOF)
        {
           
            m_pSet.GetFieldValue(\"office_code\",str1);
            m_pSet.GetFieldValue(\"office_name\",str2);

            // 移到下行
            m_pSet.MoveNext;
        }

        // 关闭数据库
        bass.Close;
  m_pSet.Close;
如果要执行SQL语句,那更简单了
bass.ExecuteSQL(SQL);