Programming

Tuesday, May 6, 2008

DAO and MFC

This article describes MFC''''s implementation of Microsoft Data Access Objects (DAO). Topics covered include:

Note Whether you use the MFC DAO classes or the MFC ODBC classes depends on your situation and your needs. For a discussion of the differences between the two and guidance on choosing one, see the article Database Topics (DAO).

How MFC Encapsulates DAO

The MFC DAO classes treat DAO much as the MFC classes for programming Windows treat the Windows API: MFC encapsulates, or "wraps," DAO functionality in a number of classes that correspond closely to DAO objects. Class CDaoWorkspace encapsulates the DAO workspace object, class CDaoRecordset encapsulates the DAO recordset object, class CDaoDatabase encapsulates the DAO database object, and so on.

MFC''''s encapsulation of DAO is thorough, but it is not completely one-for-one. Most major DAO objects do correspond to an MFC class, and the classes supply generally thorough access to the underlying DAO object''''s properties and methods. But some DAO objects, including fields, indexes, parameters, and relations, do not. Instead, the appropriate MFC class provides an interface, via member functions, through which you can access, for example:

The fields of a recordset object
The indexes or fields of a table
The parameters of a querydef
The relations defined between tables in a database

Mapping of DAO Objects to MFC Classes

The following tables show how DAO objects correspond to MFC objects. MFC Classes and Corresponding DAO Objects shows the MFC classes and the DAO objects they encapsulate. How MFC Manages DAO Objects Not Mapped to Classes shows how MFC deals with DAO objects that do not map directly to an MFC class.

Note MFC now supports DAO 3.5. MFC DAO classes work either with DAO 3.0 or DAO 3.5, but have not been designed to take advantage of any new DAO 3.5 features, including ODBCDirect.

MFC Classes and Corresponding DAO Objects

Class	DAO object	Remarks
CDaoWorkspace	Workspace	Manages a transaction space and provides access to the database engine.
CDaoDatabase	Database	Represents a connection to a database.
CDaoTableDef	Tabledef	Used to examine and manipulate the structure of a table.
CDaoQueryDef	Querydef	Used to store queries in a database. You can create recordsets from a querydef or use it to execute action or SQL pass-through queries.
CDaoRecordset	Recordset	Used to manage a result set, a set of records based on a table or selected by a query.
CDaoException	Error	MFC responds to all DAO errors by throwing exceptions of this type.
CDaoFieldExchange	None	Manages exchange of data between a record in the database and the field data members of a recordset.

How MFC Manages DAO Objects Not Mapped to Classes

DAO object	How MFC manages it
Field	Objects of classes CDaoTableDef and CDaoRecordset encapsulate fields and supply member functions for adding them, deleting them, and examining them.
Index	Objects of classes CDaoTableDef and CDaoRecordset encapsulate indexes and supply member functions for managing them. Tabledefs can add, delete, and examine indexes. Tabledefs and recordsets can set or get the currently active index.
Parameter	Objects of class CDaoQueryDef encapsulate parameters and supply member functions for adding them, deleting them, examining them, and getting and setting their values.
Relation	Objects of class CDaoDatabase encapsulate relations and supply member functions for adding them, deleting them, and examining them.

DAO Objects Not Exposed in MFC

MFC and DAO do not supply abstractions for some objects used within Microsoft Access: Application, Container, Control, Debug, Document, Form, Module, Report, Screen, and Section. If you create a Microsoft Access database and manipulate it from an MFC application, you can''''t access those objects through code.

MFC doesn''''t supply classes or interfaces to the DAO group and user objects — to work with DAO security, you must write your own code.

MFC also doesn''''t encapsulate DAO property objects, except that the MFC DAO classes do give you access to the properties of all exposed objects.

MFC does give you access to DAO''''s DBEngine object, through class CDaoWorkspace.

Accessing the Unexposed DAO Objects

The unexposed objects listed above can be accessed in two ways:

Outside the MFC classes by using the non-MFC C++ classes provided in the DAO SDK.
Inside the MFC classes by calling DAO directly through a DAO interface pointer supplied by one of the MFC classes. For information, see Technical Note 54.

Key Differences Between MFC and DAO

MFC''''s version of data access objects differs from the underlying structure of DAO in some ways.

How MFC Accesses the Database Engine

DAO has a DBEngine object that represents the Microsoft Jet database engine. The DBEngine object provides properties and methods you can use to configure the database engine.

In MFC, there is no DBEngine object. Access to important properties of the database engine is supplied via class CDaoWorkspace. To set or get these properties, call any of the static member functions of CDaoWorkspace. For more information, see the articles DAO Workspace: The Database Engine and DAO Workspace: Accessing Properties of the Database Engine.

MFC Flattening of the DAO Object Hierarchy

Because MFC doesn''''t supply a class for every DAO object, the effect is that the DAO object hierarchy is somewhat "flattened" in MFC. The main examples of this flattening are:

Putting access to the database engine in class CDaoWorkspace rather than in a database engine class.
Encapsulating DAO field, index, parameter, and relation objects inside the classes that represent their owning objects. For example, access to fields is encapsulated in classes CDaoTableDef and CDaoRecordset. For information, see the table How MFC Manages DAO Objects Not Mapped to Classes.

MFC and DAO Security

MFC does not encapsulate the DAO user and group objects in any way, which means that MFC doesn''''t provide DAO''''s security functionality.

You can still use DAO security from your MFC applications, but you will have to call DAO directly, using the m_pDAOWorkspace data member of class CDaoWorkspace. That member is a pointer to an interface that gives access to a DAO workspace object''''s methods and properties. For information about calling DAO directly, see Technical Note 54.

MFC does allow password protection via various MFC classes. For example, when you create a CDaoWorkspace object, you can specify a password to protect the database(s) that the workspace contains. To use this functionality, a SYSTEM.MDW file must be available to the database engine on the machine running your application. If no SYSTEM.MDW file is available to the database engine, your application cannot use any of the security features. For information about the SYSTEM.MDW file, see the topic "Permissions Property" in DAO Help.

Monday, May 5, 2008

DAO

DAO (Data Access Objects) 数据访问对象是第一个面向对象的接口，它显露了 Microsoft Jet 数据库引擎（由 Microsoft Access 所使用），并允许 Visual Basic 开发者通过 ODBC 象直接连接到其他数据库一样，直接连接到 Access 表。DAO 最适用于单系统应用程序或小范围本地分布使用。

DAO就是Database Access Objects，数据访问对象的英文缩写。在VB中提供了两种与Jet数据库引擎接口的方法：Data控件和数据访问对象（DAO）。Data控件只给出有限的不需编程而能访问现存数据库的功能，而DAO模型则是全面控制数据库的完整编程接口。Data控件将常用的DAO功能封装在其中，它与DAO控件的关系就好象内存与CACHE之间的关系一样，所以这两种方法并不是互斥的，实际上，它们常同时使用。

DAO数据访问对象(DataAccessObjects)是一种面向对象的界面接口。通过DAO/Jet功能可以访问ISAM数据库，使用DAO/ODBCDirect功能可以实现远程RDO功能。使用DAO的程序编码非常简单，DAO提供丰富的游标(Cursor)类型的结果集和非游标(Cursor-Less)类型的结果集，同DDL(数据描述语言)的功能很类似。现在vb数据库编程大都使用ADO,很少人还用DAO.

DAO是集合，对象，方法和属性；它用对象集合来处理数据库，表，视图和索引等。使用DAO编程，可以访问并操作数据库，管理数据库的对象和定义数据库的结构等。

DAO模型是设计关系数据库系统结构的对象类的集合。它们提供了完成管理一个关系型数据库系统所需的全部操作的属性和方法，这其中包括创建数据库，定义表、字段和索引，建立表间的关系，定位和查询数据库等。

Visual Basic中的数据库编程就是创建数据访问对象，这些数据访问对象对应于被访问物理数据库的不同部分，如数据库、表、字段和索引等，同时用这些对象的属性和方法来实现对数据库的操作，以便在Visual Basic窗体中使用绑定和非绑定控件来显示操作结果并接收用户输入。

Visual Basic通过DAO和Jet引擎可以识别三类数据库：

■ VisualBasic数据库

也就是*.MDB数据库

■ 外部数据库

它们是使用几种流行格式的“索引顺序访问方法(ISAM)”数据库，这些流行格式包括Btrieve、dBASEIII、dBASEIV、 Microsoft FoxPro versions2.0和2.5以及Paradox versions 3.x和4.0。在Visual Basic中能够创建和操作所有以上格式的数据库。也可以访问文本文件数据库和Microsoft Excel或Lotus1-2-3电子表格。

■ ODBC数据库

包括符合ODBC标准的客户/服务器数据库，如Microsoft SQL Server。要在Visual Basic中创建真正的客户/服务器应用程序，可以使用ODBC Direct直接把命令传递给服务器处理。也就是说Visual Basic还支持其它不使用Jet数据库引擎的数据访问方法。数据访问对象的ODBC Direct模式允许使用同样的对象模型和语法绕过Jet引擎直接访问ODBC数据。

由上面的叙述可知，对于编程人员来讲，你只须了解DAO的使用，对具体的数据库系统无须做深入的探讨，就可对几乎任何一种数据库进行操作，“以不便应万变”，而对数据库文件自身的物理操作，将由相应的数据库引擎把数据访问对象上的这些操作转换为对数据库文件自身的物理操作，这些引擎来处理所有与各种数据库的接口。

一、数据访问对象DAO的结构

上一章我们知道了DAO是什么，它可以干什么，以及简单的了解了它是如何实现这一功能，这一章我们讲逐步学习DAO的结构。在将讲这一章之前，首先讲两个题外话：

面向对象编程

大家对面向对象编程一定不陌生，但究竟什么是面向对象编程，很多人一下子也说不出个所以然来；在VB的DAO中又是如何体现面向对象的呢，恐怕即便是使用了一段VB的网友也很难说清。这也难怪，VB本身并不是个完全的面向对象的编程环境，它的很多如动态数组等就不是面向对象的，但在DAO中是完全的面向对象的。其实面向对象的最初思想就是将数据和操作封装在一起，形成对象，而在DAO中正是体现了这一点，它将数据的值作为属性，数据的查询作为方法，数据值的变化作为事件，完全封装在DAO对象中，希望诸位盟友在使用中注意，逐步领悟面向对象的编程方法。

数据库前端开发系统和后台系统

经常由朋友说他会DELPHI，会PB，实际上用前端和后台的概念来看，他们都只是会一种前端开发工具而已，严格说起来并不能算会数据库的开发。人们往往只看到前台应用的功能而忽视了后台系统的应用，或者认为这两者根本就是一回事。前端后台概念用在单机上，就是VB与Access，用在网络中就是VB与SQL Sever，只会VB或DELPHI是不能称为掌握数据库编程的，而且在编程中，要善于利用后台数据库提供功能，这样的程序运行起来更快，程序更精练。

题外话讲完，现在切入正题。DAO的结构如图所示：
　

以上是DAO整体结构图，下面将分章节逐步讲述每个对象的使用

二、数据访问对象DAO的功能

1. DAO用来封装Data Source的..就比如,Connection conn = DAOFacotry.createConnection()..
就可以把Driver. URL. username, passpword这一些放在DAO中
以后要更改数据库的类型.比如要把MSSQL换成Oracle的话..只需要更改DAOFacory里面的getConnection()里面的Driver.URL.之类的..

2. DAO也是把对数据库的操作(比如最基本的CRUD操作)全部封装在里面..
比如说你要你要插入一个新的用户..那么.在DAO中我们只需要提供一个insertUser(User user)这一个方法就可以了..具体的操作是在DAO中实现的...
那么对于要调用DAO的时候.我们只要知道insertUser(User)是用来插入一个新的用户...而不需要知道是如何实现的..

一般 DAO是与Abstract Factory模式一起来用的...

Factory来建立数据库和定位具体的DAO(比如说是UserDao.. CustomerDao..)..一般将getConnection设置为static..也可以把HibernateSessionFactory这一个公共类放在这一AbstractFactory类中去...

public class DAOFactory {
private static final SessionFactory sessionFacotory;
// 定义一个TrheadLocal .
static Session currentSession().....
public UserDao getUserDAO() { return new UserDaoImpl(sesssion);}
pulbic OtherDao getOtherDAO() { return new OtherDaoImpl(session);}
......
}

public interface UserDao {
public insertUser(FormBean)
public updateUser(FormBean);
}
然后就实现DAO的接口: (Struts的FormBean...VO来的..)
public class UserDaoImpl implements UserDao {
privateSession session;
public UserDaoImpl(Session session){
this.session = session;
}...
public insertUser(FormBean) {
..//..
session.save(UserPO);
..//..
return FormBean;
}
public FormBean updateUser(FormBean) {
..//..
session.update(UserPO);
..//..
return FormBean;
}
}
最后定义你的PO:
public class UserPO {
String firstname, lastname, password..........
}

Huhmmmm..........

（Copyright 2003-2005 www.sohozu.com All Rights Reserved）

三、实战应用——使用数据访问对象DAO

1 概述

Visual C++提供了对DAO的封装，MFC DAO类封装了DAO（数据库访问对象）的大部分功能，从面Visual C++程序就可以使用Visual C++提供的MFC DAO类方便的访问Microsoft Jet 数据库，编制简洁、有Visaul C++特色的数据库应用程序。

数据库访问对象（DAO）提供了一种通过程序代码创建和操纵数据库的机制。多个DAO对象构成一个体系结构，在这个结构里，各个DAO对象协同工作。DAO支持以下四个数据库选项：

打开访问数据库（MDB文件）——MDB文件是一个自包含的数据库，它包括查询定义、安全信息、索引、关系，当然还有实际的数据表。用户只须指定MDB文件的路径名。

直接打开ODBC数据源——这里有一个很重要的限制。不能找开以Jet引擎作为驱动程序的ODBC数据源；只可以使用具有自己的ODBC驱动程序DLL的数据源。

用Jet引擎找开ISAM型（索引顺序访问方法）数据源（包括dBase,FoxPro,Paradox,Btrieve,Excel或文本文件）——即使已经设置了ODBC数据源，要用Jet引擎来访问这些文件类型中的一种，也必须以ISAM型数据源的方式来找开文件，而不是以ODBC数据源的方式。

给ACCESS数据库附加外部表——这实际上是用 DAO访问ODBC数据源的首选方法。首先使用ACCESS把ODBC表添加到一个MDB文件上，然后依照第一选项中介绍的方法用DAO找开这个MDB文件就可以了。用户也可以用ACCESS把IASM文件附加到一个MDB文件上。

2 应用DAO编程

2.1 打开数据库
CDaoWorkspace对象代表一个DAO Workspace对象，在MFC DAO体系结构中处于最高处，定义了一个用户的同数据库的会话，并包含打开的数据库，负责完成数据库的事务处理。我们可以使用隐含的workspace对象。

CDaoDatabase对象代表了一个到数据库的连接，在MFC中，是通过CDaoDatabase封装的。

在构造CDaoDatabase对象时，有如下两种方法:

创建一个CDaoDatabase对象，并向其传递一个指向一个已经找开的CdaoWorkspace对象的指针。

创建一个CDaoDatabase对象，而不明确地指定使用的workspace,此时，MFC将创建一个新的临时的CDaoWorkspace对象。

如下代码所示：

CDaoDatabase db;

db.Open(“test.mdb”,FALSE,FALSE,_T(“”);

其中参数一包括要打开的文件的全路径名。

2.2 查询记录
一个DAO recordset对象，代表一个数据记录的集合，该集合是一个库表或者是一个查询的运行结果中的全部记录。CDaoRecorset对象有三种类型：表、动态集、快照。

通常情况下，我们在应用程序中可以使用CDaoRecordset的导出类，这一般是通过ClassWizard或AppWizard来生成的。但我们也可以直接使用CDaoRecordset类生成的对象。此时，我们可以动态地绑定recordset对象的数据成员。

如下代码所示：

COleVariant var;

long id;

CString str;

CDaoRecordset m_Set(&db);

m_Set.Open(“查询的SQL语句”);

while(!m_Set.IsEOF())

{
/*处理
m_Set.GetFieldValue(“ID”,var);

id=V_I4(var);
m_Set.GetFieldValue(“Name”,var);
str=var.pbVal;
*/
m_Set.MoveNext();

}

m_Set.Close();

2.3 添加记录

添加记录用AddNew函数，此时用SetFieldValue来进行赋值。

如下代码所示:

m_pDaoRecordset->AddNew ();
sprintf(strValue,"%s",>m_UserName );
m_pDaoRecordset->SetFieldValue ("UserName",strValue);
sprintf(strValue,"%d",m_PointId );
m_pDaoRecordset->SetFieldValue ("PointId",strValue);
dataSrc.SetDateTime (m_UpdateTime .GetYear ), m_UpdateTime .GetMonth ), m_UpdateTime .GetDay (),
m_UpdateTime .GetHour (),m_UpdateTime .GetMinute (),m_UpdateTime .GetSecond ());
valValue=dataSrc;
m_pDaoRecordset->SetFieldValue ("UpdateTime",valValue);
sprintf(strValue,"%f",m_pRecordset->m_OldValue );
m_pDaoRecordset->SetFieldValue ("OldValue",strValue);
sprintf(strValue,"%f",m_pRecordset->m_NewValue );
m_pDaoRecordset->SetFieldValue ("NewValue",strValue);
m_pDaoRecordset->Update ();

此时，要注意，日期时间型数据要用SetDataTime函数来赋值,这里面要用到COleVariant类型数据，具体用法可以参考有关帮助。

2.4 修改记录

修改记录用Edit()函数，把记录定位到要修改的位置，调用Edit函数，修改完成后，调用Update函数。

如下代码所示：

m_Set.Edit();
m_Set.SetFieldValue(“列名”,”字符串”);
m_Set.Update();

2.5 删除记录

删除记录用Delete()函数，使用后不需调用Update()函数。

2.6 统计记录

可以使用如下代码来统计记录数：

COleVariant varValue;
CDaoRecordset m_Set(&db);
m_Set.Open(dbOpenDynaset,”SQL语句”);
varValue=m_Set.GetFieldValue(0);
m_lMaxCount=V_I4(&varValue);
m_Set.Close();

如果是统计一张表中总记录，可以使用CDaoTableDef对象，如下代码所示：
CDaoTableDef m_Set(&gUseDB);
Count=m_Set.GetRecordCount();
m_Set.Close();

不能用CDaoRecordset对象的GetRecordCount()来取得记录数。

3 总结

使用DAO技术可以便我们方便的访问Microsoft Jet引擎数据库，由于Microsoft Jet不支持多线程，因此，必须限制调用到应用程序主线程的所有DAO。（来源CNET Networks ）

从功能简单的数据库(如Jet Engine)到复杂的大型数据库系统(如oracle)，VC++6.0都提供了一些编程接口。本文主要介绍以下五种:

1.ODBC API；

2.MFC ODBC类；

3.MFC DAO类；(数据访问对象)

4.MFC的OLE/DB；

5.ActiveX数据对象(ADO)。

1.开放数据库连接(ODBC API)：

提供了一个通用的编程接口，允许程序与多种不同的数据库连接。它为Oracle， SQL Server，MS Excel等都提供了驱动程序，使得用户可以使用SQL语句对数据库进行直接的底层功能操作。在使用ODBC API时，用户须引入的头文件为"sql.h"，"sqlext.h"，"sqltypes.h"。用ODBC API创建数据库应用程序遵循一定的基本步骤：

第一步是分配ODBC环境，使一些内部结构初始化。完成这一步，须分配一个SQLHENV类型的变量在ODBC环境中做句柄使用。

第二步是为将要使用的每一个数据源分配一个连接句柄，由函数SQLALLocHandle()完成。

第三步是使用SQLConnect()把连接句柄与数据库连接，可以先通过SQLSetConnectAttr()设置连接属性。

然后就可以进行SQL语句的操作，限于篇幅，相关的函数就不具体介绍了，读者可以参考相关书籍。

操作完成后，用户取回相应的结果，就可以取消与数据库的连接。

最后需要释放ODBC环境。

ODBC API的特点是功能强大丰富，提供了异步操作，事务处理等高级功能，但相应的编程复杂，工作量大。

2.MFC ODBC类：

MFC1.5后的版本里引入封装了ODBC功能的类。通过这些类提供与ODBC的接口，使得用户可以不须处理ODBC API中的繁杂处理就可以进行数据库操作。主要的MFC ODBC类如下。

CDatabase类:一个CDatabase对象表示一个到数据源的连接，通过它可以操作数据源。应用程序可使用多个CDatabase对象：构造一个对象并调用OpenEx()成员函数打开一个连接。接着构造CRecordSet对象以操作连接的数据源，并向CDatabase对象传递记录集构造程序指针。完成使用后用Close()成员函数销毁CDatabase对象。一般情况下并不需要直接使用CDatabase对象，因为CRecordSet对象可以实现大多数的功能。但是在进行事务处理时，CDatabase就起到关键作用。事务(Transaction)指的是将一系列对数据源的更新放在一起，同时提交或一个也不提交，为的是确保多用户对数据源同时操作时的数据正确性。

CRecordSet类：一个CRecordSet对象代表一个从数据源选择的一组记录的集合-记录集。记录集有两种形式：snapshot和dynaset。前者表示数据的静态视图，后者表示记录集与其他用户对数据库的更新保持同步。通过CRecordSet对象，用户可以对数据库中的记录进行各种操作。

CRecordView类：CRecordView对象是在空间中显示数据库记录的视图。这种视图是一种直接连到一个CRecordSet对象的格式视图，它从一个对话框模板资源创建，并将CRecordSet对象的字段显示在对话框模板的控件里。对象利用DDX和RFX机制，使格式上的控件和记录集的字段之间数据移动自动化，也就是说，用户甚至不要编写一行代码就可以实现简单的数据库记录查看程序。

CDBException类：由Cexception类派生，以三个继承的成员变量反映对数据库操作时的异常:

m_nRetCode：以ODBC返回代码(SQL_RETURN)的形式表明造成异常的原因。

m_strError：字符串，描述造成抛出异常的错误原因。

m_strStateNativeOrigin：字符串，用以描述以ODBC错误代码表示的异常错误。

MFC数据库类成员函数都能抛出CDBException类型的异常，所以在代码对数据库进行操作后监测异常是正确做法。

MFC ODBC类在实际开发中应用最广，因为它功能丰富，操作相对简便。

3.MFC DAO(数据访问对象)编程：

DAO用于和微软的Access数据库接口。在数据库应用程序如果只需与Access数据库接口时，使用DAO编程较方便。其主要类如下。

CDaoWorkspace：CDaoWorkspace对象可以让一个用户管理从登陆到离开期间，指定的密码保护的数据库会话全过程。大多数情况下不要多个工作区也不要创建明确的工作区对象。因为在打开数据库和记录集对象时，它们可以使用DAO缺省工作区。

CDaoDatabase：代表一个连接，类似上述CDatabase类。

CDaoRecordSet：用来选择记录集并操作，类似上述CRecordSet类。

CDaoRecordView：类似上述CRecordView类。

CDaoException：类似上述CDBException类。

CDaoTableDef：表示基本表或附加表的定义。每个DAO数据库对象包括一个称为TableDef的收集，包含所有存储的DAO表定义对象。CDaoTableDef对象可以用来控制表定义。

CDaoQueryDef：CDaoQueryDef对象表示了一个查询定义(querydef)。

CDaoFieldExchange：支持数据库类使用的DAO字段交换(DFX)例程。也可处理事务，类似MFC ODBC类。

MFC DAO仅用来支持Access数据库，应用范围相对固定。

4.OLE DB：

OLE DB在数据提供程序和用户之间提供了灵活的组件对象模型(COM)接口，这种灵活性有时会使得操作复杂化。OLE DB框架定义了应用的三个基本类。

数据提供程序Data Provider：拥有自己的数据并以表格形式显示数据的应用程序。提供OLE DB的行集COM接口，期显示范围可以从单一数据表格的简单提供者知道更复杂的分布式数据库系统。

使用者Consumers：使用OLE DB接口对存储在数据提供程序中的数据进行控制的应用程序。用户应用程序归为使用类。

服务提供程序Service Provider：是数据提供程序和使用者的组合。服务提供程序没有自己的数据，但使用OLE DB使用者接口来访问存储在数据提供程序中的数据。然后，服务提供程序通过打开数据提供程序接口使得数据对使用者有效。服务提供程序常用于向应用程序提供高层次服务，比如高级分布式查询。

OLE DB编程时，用户使用组件对象开发应用程序。这些组件有：

枚举器：用于列出可用的数据源；

数据源：代表单独的数据和服务提供程序，用于创建对话；

对话：用于创建事务和命令；

事务：用于将多个操作归并为单一事务处理；

命令：用于向数据源发送文本命令(SQL)，返回行集；

错误：用于获得错误信息。

5.ActiveX数据对象(ADO)：是微软提供的面向对象的接口，与OLE DB类似，但接口更简单，具有更广泛的特征数组和更高程度的灵活性。ADO基于COM,提供编程语言可利用的对象，除了面向VC++，还提供面向其他各种开发工具的应用，如VB，VJ等。ADO在服务器应用方面非常有用，特别是对于动态服务器页面ASP(Active Server Page)。

ADO对象结构类似于OLE DB，但并不依靠对象层次。大多数情况下，用户只需要创建并只使用需要处理的对象。下面的对象类组成了ADO接口。

Connection：用于表示与数据库的连接，以及处理一些命令和事务。

Command：用于处理传送给数据源的命令。

Recordset：用于处理数据的表格集，包括获取和修改数据。

Field：用于表示记录集中的列信息，包括列值和其他信息。

Parameter：用于对传送给数据源的命令之间来回传送数据。

Property：用与操作在ADO中使用的其他对象的详细属性。

Error：用于获得可能发生的错误的详细信息。

在VC++使用ADO需要进行COM操作，详细方法在此就不赘述了。

在当今流行的分布式开发环境下，VC++6.0在数据库开发方面有较强的优势，学会在不同的场合选用不同的技术，对开发人员来说是必要的技术。

(T113)

从功能简单的数据库(如Jet Engine)到复杂的大型数据库系统(如oracle)，VC++6.0都提供了一些编程接口。本文主要介绍以下五种:

1.ODBC API；

2.MFC ODBC类；

3.MFC DAO类；(数据访问对象)

4.MFC的OLE/DB；

5.ActiveX数据对象(ADO)。

1.开放数据库连接(ODBC API)：

第一步是分配ODBC环境，使一些内部结构初始化。完成这一步，须分配一个SQLHENV类型的变量在ODBC环境中做句柄使用。

第二步是为将要使用的每一个数据源分配一个连接句柄，由函数SQLALLocHandle()完成。

第三步是使用SQLConnect()把连接句柄与数据库连接，可以先通过SQLSetConnectAttr()设置连接属性。

然后就可以进行SQL语句的操作，限于篇幅，相关的函数就不具体介绍了，读者可以参考相关书籍。

操作完成后，用户取回相应的结果，就可以取消与数据库的连接。

最后需要释放ODBC环境。

ODBC API的特点是功能强大丰富，提供了异步操作，事务处理等高级功能，但相应的编程复杂，工作量大。

2.MFC ODBC类：

CDBException类：由Cexception类派生，以三个继承的成员变量反映对数据库操作时的异常:

m_nRetCode：以ODBC返回代码(SQL_RETURN)的形式表明造成异常的原因。

m_strError：字符串，描述造成抛出异常的错误原因。

m_strStateNativeOrigin：字符串，用以描述以ODBC错误代码表示的异常错误。

MFC数据库类成员函数都能抛出CDBException类型的异常，所以在代码对数据库进行操作后监测异常是正确做法。

MFC ODBC类在实际开发中应用最广，因为它功能丰富，操作相对简便。

3.MFC DAO(数据访问对象)编程：

DAO用于和微软的Access数据库接口。在数据库应用程序如果只需与Access数据库接口时，使用DAO编程较方便。其主要类如下。

CDaoDatabase：代表一个连接，类似上述CDatabase类。

CDaoRecordSet：用来选择记录集并操作，类似上述CRecordSet类。

CDaoRecordView：类似上述CRecordView类。

CDaoException：类似上述CDBException类。

CDaoQueryDef：CDaoQueryDef对象表示了一个查询定义(querydef)。

CDaoFieldExchange：支持数据库类使用的DAO字段交换(DFX)例程。也可处理事务，类似MFC ODBC类。

MFC DAO仅用来支持Access数据库，应用范围相对固定。

4.OLE DB：

OLE DB在数据提供程序和用户之间提供了灵活的组件对象模型(COM)接口，这种灵活性有时会使得操作复杂化。OLE DB框架定义了应用的三个基本类。

使用者Consumers：使用OLE DB接口对存储在数据提供程序中的数据进行控制的应用程序。用户应用程序归为使用类。

OLE DB编程时，用户使用组件对象开发应用程序。这些组件有：

枚举器：用于列出可用的数据源；

数据源：代表单独的数据和服务提供程序，用于创建对话；

对话：用于创建事务和命令；

事务：用于将多个操作归并为单一事务处理；

命令：用于向数据源发送文本命令(SQL)，返回行集；

错误：用于获得错误信息。

ADO对象结构类似于OLE DB，但并不依靠对象层次。大多数情况下，用户只需要创建并只使用需要处理的对象。下面的对象类组成了ADO接口。

Connection：用于表示与数据库的连接，以及处理一些命令和事务。

Command：用于处理传送给数据源的命令。

Recordset：用于处理数据的表格集，包括获取和修改数据。

Field：用于表示记录集中的列信息，包括列值和其他信息。

Parameter：用于对传送给数据源的命令之间来回传送数据。

Property：用与操作在ADO中使用的其他对象的详细属性。

Error：用于获得可能发生的错误的详细信息。

在VC++使用ADO需要进行COM操作，详细方法在此就不赘述了。

在当今流行的分布式开发环境下，VC++6.0在数据库开发方面有较强的优势，学会在不同的场合选用不同的技术，对开发人员来说是必要的技术。

(T113)

什么是DAO

10.8.1 什么是DAO

DAO(Database Access Object)使用Microsoft Jet数据库引擎来访问数据库。Microsoft Jet为象Access和Visual Basic这样的产品提供了数据引擎。

与ODBC一样，DAO提供了一组API供编程使用。MFC也提供了一组DAO类，封装了底层的API，从而大大简化了程序的开发。利用MFC的DAO类，用户可以编写独立于DBMS的应用程序。

DAO是从Visual C++4.0版开始引入的。一般地讲，DAO类提供了比ODBC类更广泛的支持。一方面，只要有ODBC驱动程序，使用Microsoft Jet的DAO就可以访问ODBC数据源。另一方面，由于DAO是基于Microsoft Jet引擎的，因而在访问Access数据库(即*.MDB文件)时具有很好的性能。

10.8.2 DAO和ODBC的相似之处

DAO类与ODBC类相比具有很多相似之处，这主要有下面几点：

二者都支持对各种ODBC数据源的访问。虽然二者使用的数据引擎不同，但都可以满足用户编写独立于DBMS的应用程序的要求。

DAO提供了与ODBC功能相似的MFC类。例如，DAO的CDaoDatabase类对应ODBC的CDatabase类，CDaoRecordset对应CRecordset，CDaoRecordView对应CRecordView，CDaoException对应CDBException。这些对应的类功能相似，它们的大部分成员函数都是相同的。

AppWizard和ClassWizard对使用DAO和ODBC对象的应用程序提供了类似的支持。

由于DAO和ODBC类的许多方面都比较相似，因此只要用户掌握了ODBC，就很容易学会使用DAO。实际上，用户可以很轻松地把数据库应用程序从ODBC移植到DAO。

Visual C++随盘提供了一个名为DaoEnrol的例子，该例实际上是Enroll的一个DAO版本。读者可以打开DaoEnrol工程看一看，它的源代码与Enroll的极为相似。读者可以按照建立Enroll的步骤来建立DaoEnrol，其中只有若干个地方有差别，这主要有以下几点：

选取的数据源不同。在用AppWizard创建DaoEnrol时，以及在用ClassWizard创建CDaoRecordset类的派生类时，在Database Options对话框中应该选择DAO而不是ODBC。而且DAO的数据源是通过选择一个.MDB文件来指定的，即点击“...”按钮后在文件对话框中选择要访问的.MDB文件。

记录集的缺省类型不同。ODBC记录集的缺省类型是快照(Snapshot)，而DAO则是动态集(Dynaset)。

参数化的方式不同。DAO记录集的m_strFilter和m_strSort中的参数不是“?”号，而是一个有意义的参数名。例如，在下面的过滤器中有一个名为CourseIDParam的参数。
m_pSet->m_strFilter ="CourseID = CourseIDParam";
在DoFieldExchange函数中，有下面两行：
pFX->SetFieldType(CDaoFieldExchange::param);
DFX_Text(pFX, _T("CourseIDParam"), m_strCourseIDParam);
DFX函数的第二个参数也是CourseIDParam。

处理异常的方式不同。例如，在删除记录时，对异常的处理如下所示：

try
{
m_pSet->Delete();
}
catch(CDaoException* e)
{
AfxMessageBox(e->
m_pErrorInfo->m_strDescription);
e->Delete();
}

除了上述差别外，AppWizard和ClassWizard也隐藏了一些细微的不同之处，例如，DAO记录集是使用是DFX数据交换机制(DAO record field exchange)而不是RFX，在DAO记录集的DoFieldExchange中使用的是DFX函数而不是RFX函数。

10.8.3 DAO的特色

　　DAO可以通过ODBC驱动程序访问ODBC数据源。但DAO是基于Microsoft Jet引擎的，通过该引擎，DAO可以直接访问Access、FoxPro、dBASE、Paradox、Excel和Lotus WK等数据库。CDaoDatabase类可以直接与这些数据库进行连接，而不必在ODBC管理器中注册DSN。例如，下面的代码用来打开一个FoxPro数据库：

CDaoDatabase daoDb;

daoDb.Open( “”,FALSE,FALSE,"FoxPro 2.5;DATABASE=c:\\zyf");

CDaoDatabase::Open函数用来连接某个数据库，该函数的声明为：

virtual void Open( LPCTSTR lpszName, BOOL bExclusive = FALSE, BOOL
bReadOnly = FALSE, LPCTSTR lpszConnect = _T("") );
throw( CDaoException, CMemoryException );

参数bExclusive如果为TRUE，则函数以独占方式打开数据库，否则就用共享方式。如果bReadOnly为TRUE，那么就以只读方式打开数据库。如果要打开一个Access数据库，则可以在lpszName参数中指定MDB文件名。如果要访问非Access数据库，则应使该参数为“”，并在lpszConnect中说明一个连接字符串。连接字符串的形式一般为 “数据库类型;DATABASE=路径（文件）”，例如 “dBASE III;DATABASE=c:\\MYDIR”

　　Open函数也可以打开一个ODBC数据源，但这需要相应的ODBC驱动程序，并需要在ODBC管理器中注册DSN。此时lpszConnect的形式为 “ODBC;DSN=MyDataSource”。显然，用DAO访问象FoxPro这样的数据库时，直接打开比把它当作ODBC数据源打开要省事。

　　支持DDL是DAO对数据库编程良好支持的一个重要体现。DDL(Data Definition Language)在SQL术语中叫做“数据定义语言”，它用来完成生成、修改和删除数据库结构的操作。ODBC类只支持DML(Data Manipulation Language，数据操作语言)，不支持DDL，所以用ODBC类只能完成数据的操作，不能涉及数据库的结构。要执行DDL操作，只有通过ODBC API。而DAO类同时提供了对DML和DDL的支持，这意味着程序可以使用DAO类方便的创建数据库及修改数据库的结构。

　　与ODBC相比，DAO提供了一些新类来加强其功能，这些新类包括：

CDaoTableDef类提供了对表的结构的定义。调用CDaoTableDef::Open可以获得表的结构定义。调用CDaoTableDef::Create可以创建一张新表，调用CDaoTableDef:: CreateField可为表添加字段，调用CDaoTableDef::CreateIndex可以为表添加索引。调用CDaoTableDef::Append可以把新创建的表保存到数据库中。

CDaoQueryDef类代表一个查询定义(Query definition)，该定义可以被存储到数据库中。

CDaoWorkspace提供了数据工作区(Workspace)。一个工作区可以包含几个数据库，工作区可以对所属的数据库进行全体或单独的事务处理，工作区也负责数据库的安全性。如果需要，程序可以打开多个工作区。

　　DAO的另一个重要特色在于它对Access数据库提供了强大的支持。由于DAO是基于Microsoft Jet引擎的，所以DAO肯定要在Access数据库上多作一些文章。例如，调用CDaoDatabase::Create可以直接建立一个MDB文件，代码如下所示：
m_db.Create(“C:\\MYDIR\\MYDB.MDB”);

利用AppWizard和ClassWizard，用户可以方便地开发出性能优良的基于DAO的
Access数据库应用程序。

10.8.4 ODBC还是DAO

由于DAO可以访问ODBC数据源，下面几条可以作为DAO替代ODBC的理由：

在某些情况下可以获得更好的性能，特别是在访问Microsoft Jet（.MDB）数据库时。

与ODBC兼容
DAO允许数据有效检查
DAO允许用户说明表与表之间的关系

当然，DAO的出现并不意味着ODBC已经过时了。如果用户的工作必须严格限于ODBC数据源，尤其是在开发Client/Server结构的应用程序时，用ODBC有较好的性能。

Visual C++ ADO数据库编程入门

摘要本文简要介绍了在VC++ 6.0中使用 ADO进行客户端数据库编程的基本步骤，以及常见问题的解决方法，可供入门级的参考之用。

　　关键字 ADO VC++ 数据库编程

　　ADO 是目前在Windows环境中比较流行的客户端数据库编程技术。ADO是建立在OLE DB底层技术之上的高级编程接口，因而它兼具有强大的数据处理功能（处理各种不同类型的数据源、分布式的数据处理等等）和极其简单、易用的编程接口，因而得到了广泛的应用。而且按微软公司的意图，OLE DB和ADO将逐步取代 ODBC和DAO。现在介绍ADO各种应用的文章和书籍有很多，本文着重站在初学者的角度，简要探讨一下在VC++中使用ADO编程时的一些问题。我们希望阅读本文之前，您对ADO技术的基本原理有一些了解。

　　一、在VC++中使用ADO编程

　　ADO实际上就是由一组Automation对象构成的组件，因此可以象使用其它任何Automation对象一样使用ADO。ADO中最重要的对象有三个：Connection、Command和Recordset，它们分别表示连接对象、命令对象和记录集对象。如果您熟悉使用MFC中的ODBC类（CDatabase、CRecordset)编程，那么学习ADO编程就十分容易了。

　　使用ADO编程时可以采用以下三种方法之一：

　　1、使用预处理指令#import

#import "C:\Program Files\Common Files\System\ADO\msado15.dll" \
no_namespace rename("EOF", "EndOfFile")

　　但要注意不能放在stdAfx.h文件的开头，而应该放在所有include指令的后面。否则在编译时会出错。
程序在编译过程中，VC++会读出msado15.dll中的类型库信息，自动产生两个该类型库的头文件和实现文件msado15.tlh和msado15.tli（在您的Debug或Release目录下）。在这两个文件里定义了ADO的所有对象和方法，以及一些枚举型的常量等。我们的程序只要直接调用这些方法就行了，与使用MFC中的COleDispatchDriver类调用Automation对象十分类似。

　　2、使用MFC中的CIDispatchDriver

　　就是通过读取msado15.dll中的类型库信息，建立一个COleDispatchDriver类的派生类，然后通过它调用ADO对象。

　　3、直接用COM提供的API

　　如使用如下代码：

CLSID clsid;
HRESULT hr = ::CLSIDFromProgID(L"ADODB.Connection", &clsid);
if(FAILED(hr))
{...}
::CoCreateInstance(clsid, NULL, CLSCTX_SERVER, IID_IDispatch, (void **)
&pDispatch);
if(FAILED(hr))
{...}

　　以上三种方法，第一和第二种类似，可能第一种好用一些，第三种编程可能最麻烦。但可能第三种方法也是效率最高的，程序的尺寸也最小，并且对ADO的控制能力也最强。

　　据微软资料介绍，第一种方法不支持方法调用中的默认参数，当然第二种方法也是这样，但第三种就不是这样了。采用第三种方法的水平也最高。当你需要绕过ADO而直接调用OLE DB底层的方法时，就一定要使用第三种方法了。

　　ADO编程的关键，就是熟练地运用ADO提供的各种对象(object)、方法(method)、属性(property)和容器（collection）。另外，如果是在MS SQL或Oracle等大型数据库上编程，还要能熟练使用SQL语言。
二、使用#import方法的编程步骤b>

　　这里建议您使用#import的方法，因为它易学、易用，代码也比较简洁。

　　1、添加#import指令

打开stdafx.h文件，将下列内容添加到所有的include指令之后：

#include <icrsint.h> //Include support for VC++
Extensions
#import "C:\Program Files\Common
Files\System\ADO\msado15.dll" \
no_namespace rename("EOF",
"adoEOF")

　　其中icrsint.h文件包含了VC++扩展的一些预处理指令、宏等的定义，用于COM编程时使用。

　　2、定义_ConnectionPtr型变量，并建立数据库连接

　　建立了与数据库服务器的连接后，才能进行其他有关数据库的访问和操作。ADO使用Connection对象来建立与数据库服务器的连接，所以它相当于MFC中的CDatabase类。和CDatabase类一样，调用Connection对象的Open方法即可建立与服务器的连接。

　　数据类型
_ConnectionPtr实际上就是由类模板_com_ptr_t而得到的一个具体的实例类，其定义可以到msado15.tlh、comdef.h
和comip.h这三个文件中找到。在msado15.tlh中有：

_COM_SMARTPTR_TYPEDEF(_Collection,
__uuidof(_Collection));

　　经宏扩展后就得到了_ConnectionPtr类。_ConnectionPtr类封装了Connection对象的Idispatch接口指针，及一些必要的操作。我们就是通过这个指针来操纵Connection对象。类似地，后面用到的_CommandPtr和_RecordsetPtr类型也是这样得到的，它们分别表示命令对象指针和记录集对象的指针。

　　（1）、连接到MS
SQL Server

　　注意连接字符串的格式，提供正确的连接字符串是成功连接到数据库服务器的第一步，有关连接字符串的详细信息参见微软MSDN
Library光盘。

　　本例连接字符串中的server_name，database_name，user_name和password在编程时都应该替换成实际的内容。

_ConnectionPtr pMyConnect=NULL;
HRESULT
hr=pMyConnect.CreateInstance(__uuidof(Connection)));
if(FAILED(hr))return;

_bstr_t
strConnect="Provider=SQLOLEDB;
Server=server_name;"
"Database=database_name; uid=user_name;
pwd=password;";
//connecting to the database server
now:
try{pMyConnect->Open(strConnect,"","",NULL);}
catch
(_com_error &e)
{
::MessageBox(NULL,e.Description(),"警告",MB_OK │
MB_ICONWARNING);
}

　　注意Connection对象的Open方法中的连接字符串参数必须是BSTR或_bstr_t类型。另外，本例是直接通过OLE
DB Provider建立连接，所以无需建立数据源。

　　（2）、通过ODBC Driver连接到Database
Server连接字符串格式与直接用ODBC编程时的差不多：

_bstr_t strConnect="DSN=datasource_name; Database=database_name;
uid=user_name;
pwd=password;";

　　此时与ODBC编程一样，必须先建立数据源。

　　3、定义_RecordsetPtr型变量，并打开数据集

　　定义_RecordsetPtr型变量，然后通过它调用Recordset对象的Open方法，即可打开一个数据集。所以Recordset对象与MFC中的CRecordset类类似，它也有当前记录、当前记录指针的概念。如：

_RecordsetPtr m_pRecordset;
if(!FAILED(m_pRecordset.CreateInstance(
__uuidof( Recordset
)))
{
m_pDoc->m_initialized=FALSE;
return;
}

try{
m_pRecordset->Open(_variant_t("mytable"),
_variant_t((IDispatch
*)pMyConnect,true), adOpenKeyset,
adLockOptimistic,
adCmdTable);
}
catch (_com_error
&e)
{
::MessageBox(NULL,"无法打开mytable表。","提示",
MB_OK │
MB_ICONWARNING);
}

　　Recordset对象的Open方法非常重要，它的第一个参数可以是一个SQL语句、一个表的名字或一个命令对象等等；第二个参数就是前面建立的连接对象的指针。此外，用Connection和Command对象的Execute方法也能得到记录集，但是只读的。
4、读取当前记录的数据

　　我认为读取数据的最方便的方法如下：

try{
m_pRecordset->MoveFirst();

while(m_pRecordset->adoEOF==VARIANT_FALSE)
{
//Retrieve
column's value:
CString
sName=(char*)(_bstr_t)(m_pRecordset->Fields->GetItem
(_variant_t("name"))->Value);
short
cAge=(short)(m_pRecordset->Fields->GetItem
(_variant_t("age"))->Value);
//Do
something what you want to do:
......
m_pRecordset->MoveNext();

}
}//try
catch (_com_error &e)
{
CString
str=(char*)e.Description();
::MessageBox(NULL,str+"\n又出毛病了。","提示",
MB_OK
│
MB_ICONWARNING);
}

　　本例中的name和age都是字段名，读取的字段值分别保存在sName和cAge变量内。例中的Fields是Recordset对象的容器，GetItem方法返回的是Field对象，而Value则是Field对象的一个属性（即该字段的值）。通过此例，应掌握操纵对象属性的方法。例如，要获得Field
对象的Value属性的值可以直接用属性名Value来引用它（如上例），但也可以调用Get方法，例如：

CString
sName=(char*)(_bstr_t)(m_pRecordset->Fields->GetItem
(_variant_t("name"))->GetValue());

　　从此例还可以看到，判断是否到达记录集的末尾，使用记录集的adoEOF属性，其值若为真即到了结尾，反之则未到。判断是否到达记录集开头，则可用BOF属性。

　　另外，读取数据还有一个方法，就是定义一个绑定的类，然后通过绑定的变量得到字段值（详见后面的介绍）。

　　5、修改数据

　　方法一：

try{
m_pRecordset->MoveFirst();

while(m_pRecordset->adoEOF==VARIANT_FALSE)
{

m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->Value=_bstr_t("赵薇");
......
m_pRecordset->Update();

m_pRecordset->MoveNext();

}
}//try

　　改变了Value属性的值，即改变了字段的值。

　　方法二：

m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->PutValue(_bstr_t("赵薇"));

　　方法三：就是用定义绑定类的方法（详见后面的介绍）。

　　6、添加记录

　　新记录添加成功后，即自动成为当前记录。AddNew方法有两种形式，一个含有参数，而另一个则不带参数。

　　方法一（不带参数）：

// Add new record into this
table:
try{
if(!m_pRecordset->Supports(adAddNew))
return;

m_pRecordset->AddNew();

m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->Value=_bstr_t("赵薇");
m_pRecordset->Fields->GetItem
(_variant_t("性别"))->Value=_bstr_t("女");
m_pRecordset->Fields->GetItem
(_variant_t("age"))->Value=_variant_t((short)20);
m_pRecordset->Fields->GetItem
(_variant_t("marry"))->Value=_bstr_t("未婚");
m_pRecordset->Update();

}//try
catch (_com_error &e)
{
::MessageBox(NULL,
"又出毛病了。","提示",MB_OK │
MB_ICONWARNING);
}

　　这种方法弄完了还要调用Update()。

　　方法二（带参数）：

_variant_t varName[4],narValue[4];
varName[0] =
L"姓名";
varName[1] = L"性别";
varName[2] = L"age";
varName[3] =
L"marry";
narValue[0]=_bstr_t("赵薇");
narValue[1]=_bstr_t("女");
narValue[2]=_variant_t((short)20);
narValue[3]=_bstr_t("未婚");

const
int nCrit = sizeof varName / sizeof varName[0];
// Create SafeArray
Bounds and initialize the array
SAFEARRAYBOUND
rgsaName[1],rgsaValue[1];
rgsaName[0].lLbound = 0;

rgsaName[0].cElements = nCrit;
SAFEARRAY *psaName =
SafeArrayCreate( VT_VARIANT, 1, rgsaName );
rgsaValue[0].lLbound =
0;
rgsaValue[0].cElements = nCrit;
SAFEARRAY *psaValue =
SafeArrayCreate( VT_VARIANT, 1, rgsaValue );
// Set the values for each
element of the array
HRESULT hr1=S_OK.hr2=S_OK;
for( long i = 0 ; i
< nCrit && SUCCEEDED( hr1 ) && SUCCEEDED( hr2 );i++)

{
hr1=SafeArrayPutElement(psaName,
&i,&varName[i]);
hr2=SafeArrayPutElement(psaValue,
&i,&narValue[i]); }

// Initialize and fill the
SafeArray
VARIANT vsaName,vsaValue;
vsaName.vt = VT_VARIANT │
VT_ARRAY;
vsaValue.vt = VT_VARIANT │ VT_ARRAY;
V_ARRAY(&vsaName)
= psaName;//&vsaName->parray=psaName;
//see definition in
oleauto.h file.
V_ARRAY(&vsaValue) = psaValue;

// Add a new
record:
m_pRecordset->AddNew(vsaName,vsaValue);

　　这种方法不需要调用Update，因为添加后，ADO会自动调用它。此方法主要是使用SafeArray挺麻烦。

　　方法三：就是用定义绑定类的方法（详见后面的介绍）。
7、删除记录

　　调用Recordset的Delete方法就行了，删除的是当前记录。要了解Delete的其它用法请查阅参考文献。

try{
m_pRecordset->MoveFirst();

while(m_pRecordset->adoEOF==VARIANT_FALSE)
{
CString
sName=(char*)(_bstr_t)(m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->Value);
if(::MessageBox(NULL,"姓名="+sName+"\n删除她吗？",
"提示",MB_YESNO
│
MB_ICONWARNING)==IDYES)
{
m_pRecordset->Delete(adAffectCurrent);

m_pRecordset->Update();
}
m_pRecordset->MoveNext();

}
}//try
catch (_com_error
&e)
{
::MessageBox(NULL,"又出毛病了。","提示",MB_OK │
MB_ICONWARNING);
}

　　8、使用带参数的命令

　　Command对象所代表的就是一个Provider能够理解的命令，如SQL语句等。使用Command对象的关键就是把表示命令的语句设置到CommandText属性中，然后调用Command对象的Execute方法就行了。一般情况下在命令中无需使用参数，但有时使用参数，可以增加其灵活性和效率。

　　(1).
建立连接、命令对象和记录集对象

　　本例中表示命令的语句就是一个SQL语句（SELECT语句）。SELECT语句中的问号?就代表参数，如果要多个参数，就多放几个问号，每个问号代表一个参数。

_ConnectionPtr Conn1;
_CommandPtr Cmd1;
ParametersPtr *Params1 =
NULL; // Not an instance of a smart pointer.
_ParameterPtr
Param1;
_RecordsetPtr Rs1;

try
{
// Create Connection
Object (1.5 Version)
Conn1.CreateInstance( __uuidof( Connection )
);
Conn1->ConnectionString = bstrConnect;
Conn1->Open(
bstrEmpty, bstrEmpty, bstrEmpty, -1 );
// Create Command
Object
Cmd1.CreateInstance( __uuidof( Command )
);
Cmd1->ActiveConnection = Conn1;
Cmd1->CommandText =
_bstr_t("SELECT * FROM mytable WHERE age<

?");
}//try

　　要注意命令对象必须与连接对象关联起来才能起作用，本例中将命令对象的ActiveConnection属性设置为连接对象的指针，即为此目的：

Cmd1->ActiveConnection = Conn1;

　　(2).
创建参数对象，并给参数赋值

// Create Parameter Object
Param1 = Cmd1->CreateParameter(
_bstr_t(bstrEmpty),
adInteger,
adParamInput,
-1,
_variant_t(
(long) 5) );
Param1->Value = _variant_t( (long) 5
);
Cmd1->Parameters->Append( Param1
);

　　用命令对象的方法来创建一个参数对象，其中的长度参数（第三个）如果是固定长度的类型，就填-1，如果是字符串等可变长度的就填其实际长度。Parameters是命令对象的一个容器，它的Append方法就是把创建的参数对象追加到该容器里。Append进去的参数按先后顺序与SQL语句中的问号从左至右一一对应。

　　(3).
执行命令打开记录集

// Open Recordset Object
Rs1 = Cmd1->Execute( &vtEmpty,
&vtEmpty2, adCmdText
);

　　但要注意，用Command和Connection对象的Execute方法得到的Recordset是只读的。因为在打开Recordset之前，我们无法设置它的LockType属性（其默认值为只读）。而在打开之后设置LockType不起作用。

　　我发现用上述方法得到记录集Rs1后，不但Rs1中的记录无法修改，即使直接用SQL语句修改同一表中任何记录都不行。

　　要想能修改数据，还是要用Recordset自己的Open方法才行，如：

try{
m_pRecordset->Open((IDispatch *) Cmd1,
vtMissing,
adOpenStatic, adLockOptimistic,
adCmdUnspecified);
}
catch (_com_error
&e)
{
::MessageBox(NULL,"mytable表不存在。","提示",MB_OK │
MB_ICONWARNING);
}

　　Recordset对象的Open方法真是太好了，其第一个参数可以是SQL语句、表名字、命令对象指针等等。

　　9、响应ADO的通知事件

　　通知事件就是当某个特定事件发生时，由Provider通知客户程序，换句话说，就是由Provider调用客户程序中的一个特定的方法（即事件的处理函数）。所以为了响应一个事件，最关键的就是要实现事件的处理函数。

　　(1).
从ConnectionEventsVt接口派生出一个类

　　为了响应_Connection的通知事件，应该从ConnectionEventsVt接口派生出一个类：

class CConnEvent : public ConnectionEventsVt
{
private:
ULONG
m_cRef;
public:
CConnEvent() { m_cRef = 0; };
~CConnEvent()
{};

STDMETHODIMP QueryInterface(REFIID riid, void **
ppv);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG)
Release(void);
STDMETHODIMP raw_InfoMessage(
struct Error
*pError,
EventStatusEnum *adStatus,
struct _Connection
*pConnection);
STDMETHODIMP raw_BeginTransComplete(
LONG
TransactionLevel,
struct Error *pError,
EventStatusEnum
*adStatus,
struct _Connection *pConnection);
......
};

　　　(2). 实现每一个事件的处理函数(凡是带raw_前缀的方法都把它实现了)：

STDMETHODIMP CConnEvent::raw_InfoMessage(
struct Error
*pError,
EventStatusEnum *adStatus,
struct _Connection
*pConnection)
{
*adStatus = adStatusUnwantedEvent;
return
S_OK;
};

　　有些方法虽然你并不需要，但也必须实现它，只需简单地返回一个S_OK即可。但如果要避免经常被调用，还应在其中将adStatus参数设置为adStatusUnwantedEvent，则在本次调用后，以后就不会被调用了。
另外还必须实现QueryInterface,
AddRef, 和Release三个方法:

STDMETHODIMP CConnEvent::QueryInterface(REFIID riid, void ** ppv)

{
*ppv = NULL;
if (riid == __uuidof(IUnknown) ││
riid ==
__uuidof(ConnectionEventsVt)) *ppv = this;
if (*ppv == NULL)
return
ResultFromScode(E_NOINTERFACE);
AddRef();
return
NOERROR;
}
STDMETHODIMP_(ULONG) CConnEvent::AddRef() { return
++m_cRef; };
STDMETHODIMP_(ULONG) CConnEvent::Release()
{
if (0
!= --m_cRef) return m_cRef;
delete this;
return
0;
}

　　(3). 开始响应通知事件

// Start using the Connection events
IConnectionPointContainer
*pCPC = NULL;
IConnectionPoint *pCP = NULL;

hr =
pConn.CreateInstance(__uuidof(Connection));
if (FAILED(hr))
return;

hr =
pConn->QueryInterface(__uuidof(IConnectionPointContainer),
(void
**)&pCPC);
if (FAILED(hr)) return;
hr =
pCPC->FindConnectionPoint(__uuidof(ConnectionEvents),
&pCP);
pCPC->Release();
if (FAILED(hr))
return;

pConnEvent = new CConnEvent();
hr =
pConnEvent->QueryInterface(__uuidof(IUnknown), (void **)
&pUnk);
if (FAILED(hr)) return rc;
hr = pCP->Advise(pUnk,
&dwConnEvt);
pCP->Release();
if (FAILED(hr))
return;

pConn->Open("dsn=Pubs;", "sa", "",
adConnectUnspecified);

　　也就是说在连接(Open)之前就做这些事。

　　(4).
停止响应通知事件

pConn->Close();
// Stop using the Connection events
hr =
pConn->QueryInterface(__uuidof(IConnectionPointContainer),
(void
**) &pCPC);
if (FAILED(hr)) return;
hr =
pCPC->FindConnectionPoint(__uuidof(ConnectionEvents),
&pCP);
pCPC->Release();
if (FAILED(hr)) return rc;
hr =
pCP->Unadvise( dwConnEvt );
pCP->Release();
if (FAILED(hr))
return;

　　在连接关闭之后做这件事。
10、邦定数据

　　定义一个绑定类，将其成员变量绑定到一个指定的记录集，以方便于访问记录集的字段值。

　　(1). 从CADORecordBinding派生出一个类：

class CCustomRs : public CADORecordBinding
{
BEGIN_ADO_BINDING(CCustomRs)
ADO_VARIABLE_LENGTH_ENTRY2(3, adVarChar, m_szau_fname,
sizeof(m_szau_fname), lau_fnameStatus, false)
ADO_VARIABLE_LENGTH_ENTRY2(2, adVarChar, m_szau_lname,
sizeof(m_szau_lname), lau_lnameStatus, false)
ADO_VARIABLE_LENGTH_ENTRY2(4, adVarChar, m_szphone,
sizeof(m_szphone), lphoneStatus, true)
END_ADO_BINDING()

public:
CHAR m_szau_fname[22];
ULONG lau_fnameStatus;
CHAR m_szau_lname[42];
ULONG lau_lnameStatus;
CHAR m_szphone[14];
ULONG lphoneStatus;
};

　　其中将要绑定的字段与变量名用BEGIN_ADO_BINDING宏关联起来。每个字段对应于两个变量，一个存放字段的值，另一个存放字段的状态。字段用从1开始的序号表示，如1，2，3等等。

　　特别要注意的是：如果要绑定的字段是字符串类型，则对应的字符数组的元素个数一定要比字段长度大2（比如m_szau_fname[22]，其绑定的字段au_fname的长度实际是20），不这样绑定就会失败。我分析多出的2可能是为了存放字符串结尾的空字符null和BSTR字符串开头的一个字（表示BSTR的长度）。这个问题对于初学者来说可能是一个意想不到的问题。

　　CADORecordBinding类的定义在icrsint.h文件里，内容是：

class CADORecordBinding
{
public:
STDMETHOD_(const ADO_BINDING_ENTRY*, GetADOBindingEntries) (VOID) PURE;
};

BEGIN_ADO_BINDING宏的定义也在icrsint.h文件里，内容是：
#define BEGIN_ADO_BINDING(cls) public: \
typedef cls ADORowClass; \
const ADO_BINDING_ENTRY* STDMETHODCALLTYPE GetADOBindingEntries() { \
static const ADO_BINDING_ENTRY rgADOBindingEntries[] = {

ADO_VARIABLE_LENGTH_ENTRY2宏的定义也在icrsint.h文件里：
#define ADO_VARIABLE_LENGTH_ENTRY2(Ordinal, DataType, Buffer, Size, Status, Modify)\
{Ordinal, \
DataType, \
0, \
0, \
Size, \
offsetof(ADORowClass, Buffer), \
offsetof(ADORowClass, Status), \
0, \
classoffset(CADORecordBinding, ADORowClass), \
Modify},

#define END_ADO_BINDING宏的定义也在icrsint.h文件里：
#define END_ADO_BINDING() {0, adEmpty, 0, 0, 0, 0, 0, 0, 0, FALSE}};\
return rgADOBindingEntries;}

　　　(2). 绑定

_RecordsetPtr Rs1;
IADORecordBinding *picRs=NULL;
CCustomRs rs;
......
Rs1->QueryInterface(__uuidof(IADORecordBinding),
(LPVOID*)&picRs));
picRs->BindToRecordset(&rs);

　　派生出的类必须通过IADORecordBinding接口才能绑定，调用它的BindToRecordset方法就行了。

　　(3). rs中的变量即是当前记录字段的值

//Set sort and filter condition:
// Step 4: Manipulate the data
Rs1->Fields->GetItem("au_lname")->Properties->GetItem("Optimize")->Value = true;
Rs1->Sort = "au_lname ASC";
Rs1->Filter = "phone LIKE '415 5*'";

Rs1->MoveFirst();
while (VARIANT_FALSE == Rs1->EndOfFile)
{
printf("Name: %s\t %s\tPhone: %s\n",
(rs.lau_fnameStatus == adFldOK ? rs.m_szau_fname : ""),
(rs.lau_lnameStatus == adFldOK ? rs.m_szau_lname : ""),
(rs.lphoneStatus == adFldOK ? rs.m_szphone : ""));
if (rs.lphoneStatus == adFldOK)
strcpy(rs.m_szphone, "777");
TESTHR(picRs->Update(&rs)); // Add change to the batch
Rs1->MoveNext();
}
Rs1->Filter = (long) adFilterNone;
......
if (picRs) picRs->Release();
Rs1->Close();
pConn->Close();

　　只要字段的状态是adFldOK，就可以访问。如果修改了字段，不要忘了先调用picRs的Update（注意不是Recordset的Update），然后才关闭，也不要忘了释放picRs（即picRs->Release();）。

　　(4). 此时还可以用IADORecordBinding接口添加新纪录

if(FAILED(picRs->AddNew(&rs)))
......

　　11. 访问长数据

　　在Microsoft SQL中的长数据包括text、image等这样长类型的数据，作为二进制字节来对待。

　　可以用Field对象的GetChunk和AppendChunk方法来访问。每次可以读出或写入全部数据的一部分，它会记住上次访问的位置。但是如果中间访问了别的字段后，就又得从头来了。

　　请看下面的例子：

//写入一张照片到数据库：
VARIANT varChunk;
SAFEARRAY *psa;
SAFEARRAYBOUND rgsabound[1];

//VT_ARRAY │ VT_UI1
CFile f("h:\\aaa.jpg",CFile::modeRead);
BYTE bVal[ChunkSize+1];
UINT uIsRead=0;
//Create a safe array to store the array of BYTES
while(1)
{
uIsRead=f.Read(bVal,ChunkSize);
if(uIsRead==0)break;
rgsabound[0].cElements =uIsRead;
rgsabound[0].lLbound = 0;
psa = SafeArrayCreate(VT_UI1,1,rgsabound);
for(long index=0;index<uIsRead;index++)
{
if(FAILED(SafeArrayPutElement(psa,&index,&bVal[index])))
::MessageBox(NULL,"啊，又出毛病了。","提示",MB_OK │ MB_ICONWARNING);
}
varChunk.vt = VT_ARRAY│VT_UI1;
varChunk.parray = psa;
try{
m_pRecordset->Fields->GetItem("photo")->AppendChunk(varChunk);
}
catch (_com_error &e)
{
CString str=(char*)e.Description();
::MessageBox(NULL,str+"\n又出毛病了。","提示",MB_OK │ MB_ICONWARNING);
}
::VariantClear(&varChunk);
::SafeArrayDestroyData( psa);
if(uIsRead<ChunkSize)break;
}//while(1)
f.Close();

//从数据库读一张照片：
CFile f;
f.Open("h:\\bbb.jpg",CFile::modeWrite│CFile::modeCreate);
long lPhotoSize = m_pRecordset->Fields->Item["photo"]->ActualSize;
long lIsRead=0;

_variant_t varChunk;
BYTE buf[ChunkSize];
while(lPhotoSize>0)
{
lIsRead=lPhotoSize>=ChunkSize? ChunkSize:lPhotoSize;
varChunk = m_pRecordset->Fields->
Item["photo"]->GetChunk(lIsRead);
for(long index=0;index<lIsRead;index++)
{
::SafeArrayGetElement(varChunk.parray,&index,buf+index);
}
f.Write(buf,lIsRead);
lPhotoSize-=lIsRead;
}//while()
f.Close();

12. 使用SafeArray问题

　　学会使用SafeArray也是很重要的，因为在ADO编程中经常要用。它的主要目的是用于automation中的数组型参数的传递。因为在网络环境中，数组是不能直接传递的，而必须将其包装成SafeArray。实质上SafeArray就是将通常的数组增加一个描述符，说明其维数、长度、边界、元素类型等信息。SafeArray也并不单独使用，而是将其再包装到VARIANT类型的变量中，然后才作为参数传送出去。在VARIANT的vt成员的值如果包含VT_ARRAY│...,那么它所封装的就是一个SafeArray，它的parray成员即是指向SafeArray的指针。SafeArray中元素的类型可以是VARIANT能封装的任何类型，包括VARIANT类型本身。

　　使用SafeArray的具体步骤：

　　方法一：

　　包装一个SafeArray：

　　(1). 定义变量，如：

VARIANT varChunk;
SAFEARRAY *psa;
SAFEARRAYBOUND rgsabound[1];

　　(2). 创建SafeArray描述符：

uIsRead=f.Read(bVal,ChunkSize);//read array from a file.
if(uIsRead==0)break;
rgsabound[0].cElements =uIsRead;
rgsabound[0].lLbound = 0;
psa = SafeArrayCreate(VT_UI1,1,rgsabound);

　　(3). 放置数据元素到SafeArray：

for(long index=0;index<uIsRead;index++)
{
if(FAILED(SafeArrayPutElement(psa,&index,&bVal[index])))
::MessageBox(NULL,"出毛病了。","提示",MB_OK │ MB_ICONWARNING);
}

　　一个一个地放，挺麻烦的。

　　(4). 封装到VARIANT内：

varChunk.vt = VT_ARRAY│VT_UI1;
varChunk.parray = psa;

　　这样就可以将varChunk作为参数传送出去了。

　　读取SafeArray中的数据的步骤：

　　(1). 用SafeArrayGetElement一个一个地读

BYTE buf[lIsRead];
for(long index=0;index<lIsRead;index++)
{
::SafeArrayGetElement(varChunk.parray,&index,buf+index);
}

　　就读到缓冲区buf里了。

　　方法二：

　　使用SafeArrayAccessData直接读写SafeArray的缓冲区：

　　(1). 读缓冲区：

BYTE *buf;
SafeArrayAccessData(varChunk.parray, (void **)&buf);
f.Write(buf,lIsRead);
SafeArrayUnaccessData(varChunk.parray);

　　(2). 写缓冲区：

BYTE *buf;
::SafeArrayAccessData(psa, (void **)&buf);
for(long index=0;index<uIsRead;index++)
{
buf[index]=bVal[index];
}
::SafeArrayUnaccessData(psa);

varChunk.vt = VT_ARRAY│VT_UI1;
varChunk.parray = psa;

　　这种方法读写SafeArray都可以，它直接操纵SafeArray的数据缓冲区，比用SafeArrayGetElement和SafeArrayPutElement速度快。特别适合于读取数据。但用完之后不要忘了调用::SafeArrayUnaccessData(psa)，否则会出错的。

　　13. 使用书签( bookmark )

　　书签可以唯一标识记录集中的一个记录，用于快速地将当前记录移回到已访问过的记录，以及进行过滤等等。Provider会自动为记录集中的每一条记录产生一个书签，我们只需要使用它就行了。我们不能试图显示、修改或比较书签。ADO用记录集的Bookmark属性表示当前记录的书签。

　　用法步骤：

　　(1). 建立一个VARIANT类型的变量

_variant_t VarBookmark;

　　(2). 将当前记录的书签值存入该变量

　　也就是记录集的Bookmark属性的当前值。

VarBookmark = rst->Bookmark;

　　(3). 返回到先前的记录

　　将保存的书签值设置到记录集的书签属性中：

// Check for whether bookmark set for a record
if (VarBookmark.vt == VT_EMPTY)
printf("No Bookmark set!\n");
else
rst->Bookmark = VarBookmark;

　　设置完后，当前记录即会移动到该书签指向的记录。
14、设置过滤条件

　　Recordset对象的Filter属性表示了当前的过滤条件。它的值可以是以AND或OR连接起来的条件表达式（不含WHERE关键字）、由书签组成的数组或ADO提供的FilterGroupEnum枚举值。为Filter属性设置新值后Recordset的当前记录指针会自动移动到满足过滤条件的第一个记录。例如：

rst->Filter = _bstr_t ("姓名='赵薇' AND 性别=’女’");

　　在使用条件表达式时应注意下列问题：

　　（1）、可以用圆括号组成复杂的表达式

　　例如：

rst->Filter = _bstr_t ("(姓名='赵薇' AND 性别=’女’) OR AGE<25");>Filter = _bstr_t ("(姓名='赵薇' OR 性别=’女’) AND AGE<25");>Filter = _bstr_t ("(姓名='赵薇' AND AGE<25)>Filter = _bstr_t ("姓名 LIKE '*赵*' ");

　　也可以只是尾部带星号：

rst->Filter = _bstr_t ("姓名 LIKE '赵*' ");

　　Filter属性值的类型是Variant，如果过滤条件是由书签组成的数组，则需将该数组转换为SafeArray，然后再封装到一个VARIANT或_variant_t型的变量中，再赋给Filter属性。

　　15、索引与排序

　　（1）、建立索引

　　当以某个字段为关键字用Find方法查找时，为了加快速度可以以该字段为关键字在记录集内部临时建立索引。只要将该字段的Optimize属性设置为true即可，例如：

pRst->Fields->GetItem("姓名")->Properties->
GetItem("Optimize")->PutValue("True");
pRst->Find("姓名 = '赵薇'",1,adSearchForward);
......
pRst->Fields->GetItem("姓名")->Properties->
GetItem("Optimize")->PutValue("False");
pRst->Close();

　　说明：Optimize属性是由Provider提供的属性（在ADO中称为动态属性），ADO本身没有此属性。

　　（2）、排序

　　要排序也很简单，只要把要排序的关键字列表设置到Recordset对象的Sort属性里即可，例如：

pRstAuthors->CursorLocation = adUseClient;
pRstAuthors->Open("SELECT * FROM mytable",
_variant_t((IDispatch *) pConnection),
adOpenStatic, adLockReadOnly, adCmdText);
......
pRst->Sort = "姓名 DESC, 年龄 ASC";

　　关键字（即字段名）之间用逗号隔开，如果要以某关键字降序排序，则应在该关键字后加一空格，再加DESC（如上例）。升序时ASC加不加无所谓。本操作是利用索引进行的，并未进行物理排序，所以效率较高。
但要注意，在打开记录集之前必须将记录集的CursorLocation属性设置为adUseClient，如上例所示。Sort属性值在需要时随时可以修改。

　　16、事务处理

　　ADO中的事务处理也很简单，只需分别在适当的位置调用Connection对象的三个方法即可，这三个方法是：

　　（1）、在事务开始时调用

pCnn->BeginTrans();

　　（2）、在事务结束并成功时调用

pCnn->CommitTrans ();

　　（3）、在事务结束并失败时调用

pCnn->RollbackTrans ();

　　在使用事务处理时，应尽量减小事务的范围，即减小从事务开始到结束（提交或回滚）之间的时间间隔，以便提高系统效率。需要时也可在调用BeginTrans()方法之前，先设置Connection对象的IsolationLevel属性值，详细内容参见MSDN中有关ADO的技术资料。
三、使用ADO编程常见问题解答

　　以下均是针对MS SQL 7.0编程时所遇问题进行讨论。

　　1、连接失败可能原因

　　Enterprise Managemer内，打开将服务器的属性对话框，在Security选项卡中，有一个选项Authentication。

　　如果该选项是Windows NT only，则你的程序所用的连接字符串就一定要包含Trusted_Connection参数，并且其值必须为yes，如：

"Provider=SQLOLEDB;Server=888;Trusted_Connection=yes"
";Database=master;uid=lad;";

　　如果不按上述操作，程序运行时连接必然失败。

　　如果Authentication选项是SQL Server and Windows NT，则你的程序所用的连接字符串可以不包含Trusted_Connection参数，如：

"Provider=SQLOLEDB;Server=888;Database=master;uid=lad;pwd=111;";

　　因为ADO给该参数取的默认值就是no，所以可以省略。我认为还是取默认值比较安全一些。

　　2、改变当前数据库的方法

　　使用Tansct-SQL中的USE语句即可。

　　3、如何判断一个数据库是否存在

　　(1)、可打开master数据库中一个叫做SCHEMATA的视图，其内容列出了该服务器上所有的数据库名称。

　　(2) 、更简便的方法是使用USE语句，成功了就存在；不成功，就不存在。例如：

try{
m_pConnect->Execute ( _bstr_t("USE INSURANCE_2002"),NULL,
adCmdText│adExecuteNoRecords );
}
catch (_com_error &e)
{
blSuccess=FALSE;
CString str="数据库INSURANCE_2002不存在！\n";
str+=e.Description();
::MessageBox(NULL,str,"警告",MB_OK │ MB_ICONWARNING);
}

　　4、判断一个表是否存在

　　（1）、同样判断一个表是否存在，也可以用是否成功地打开它来判断，十分方便，例如：

try{
m_pRecordset->Open(_variant_t("mytable"),
_variant_t((IDispatch *)m_pConnection,true), adOpenKeyset,
adLockOptimistic, adCmdTable);
}
catch (_com_error &e)
{
::MessageBox(NULL,"该表不存在。","提示",MB_OK │ MB_ICONWARNING);
}

　　(2)、要不然可以采用麻烦一点的办法，就是在MS-SQL服务器上的每个数据库中都有一个名为sysobjects的表，查看此表的内容即知指定的表是否在该数据库中。

　　(3)、同样，每个数据库中都有一个名为TABLES的视图(View)，查看此视图的内容即知指定的表是否在该数据库中。

　　5、类型转换问题

　　（1）、类型VARIANT_BOOL

　　类型VARIANT_BOOL等价于short类型。The VARIANT_BOOL is equivalent to short. see it's definition below:
typdef short VARIANT_BOOL

　　（2）、_com_ptr_t类的类型转换

　　_ConnectionPtr可以自动转换成IDspatch*类型，这是因为_ConnectionPtr实际上是_com_ptr_t类的一个实例，而这个类有此类型转换函数。

　　同理，_RecordsetPtr和_CommandPtr也都可以这样转换。

　　（3）、_bstr_t和_variant_t类

　　在ADO编程时，_bstr_t和_variant_t这两个类很有用，省去了许多BSTR和VARIANT类型转换的麻烦。

　　6、打开记录集时的问题

　　在打开记录集时，在调用Recordset的Open方法时，其最后一个参数里一定不能包含adAsyncExecute，否则将因为是异步操作，在读取数据时无法读到数据。

　　7、异常处理问题

　　对所有调用ADO的语句一定要用try和catch语句捕捉异常，否则在发生异常时，程序会异常退出。

　　8、使用SafeArray问题

　　在初学使用中，我曾遇到一个伤脑筋的问题，一定要注意：

　　在定义了SAFEARRAY的指针后，如果打算重复使用多次，则在中间可以调用::SafeArrayDestroyData释放数据，但决不能调用::SafeArrayDestroyDescriptor，否则必然出错，即使调用SafeArrayCreate也不行。例如：

SAFEARRAY *psa;
......
//When the data are no longer to be used:
::SafeArrayDestroyData( psa);

　　我分析在定义psa指针时，一个SAFEARRAY的实例（也就是SAFEARRAY描述符）也同时被自动建立了。但是只要一调用::SafeArrayDestroyDescriptor，描述符就被销毁了。

　　所以我认为::SafeArrayDestroyDescriptor可以根本就不调用，即使调用也必须在最后调用。

　　9、重复使用命令对象问题

　　一个命令对象如果要重复使用多次（尤其是带参数的命令），则在第一次执行之前，应将它的Prepared属性设置为TRUE。这样会使第一次执行减慢，但却可以使以后的执行全部加快。

　　10、绑定字符串型字段问题

　　如果要绑定的字段是字符串类型，则对应的字符数组的元素个数一定要比字段长度大2（比如m_szau_fname[22]，其绑定的字段au_fname的长度实际是20），不这样绑定就会失败。

　　11、使用AppendChunk的问题

　　当用AddNew方法刚刚向记录集内添加一个新记录之后，不能首先向一个长数据字段（image类型）写入数据，必须先向其他字段写入过数据之后，才能调用AppendChunk写该字段，否则出错。也就是说，AppendChunk不能紧接在AddNew之后。另外，写入其他字段后还必须紧接着调用 AppendChunk，而不能调用记录集的Update方法后，才调用AppendChunk，否则调用AppendChunk时也会出错。换句话说，就是必须AppendChunk在前，Update在后。因而这个时候就不能使用带参数的AddNew了，因为带参数的AddNew会自动调用记录集的 Update，所以AppendChunk就跑到Update的后面了，就只有出错了！因此，这时应该用不带参数的AddNew。

　　我推测这可能是MS SQL 7.0的问题，在MS SQL 2000中则不存在这些问题，但是AppendChunk仍然不能在Update之后。

　　四、小结

　　一般情况下，Connection和Command的Execute用于执行不产生记录集的命令，而Recordset的Open用于产生一个记录集，当然也不是绝对的。特别Command主要是用于执行参数化的命令，可以直接由Command对象执行，也可以将Command对象传递给 Recordset的Open。

　　本文中的代码片断均在VC++ 6.0、Windows NT 4.0 SP6和MS SQL 7.0中调试通过。相信您读过之后，编写简单的数据库程序应该没有问题了。当然要编写比较实用的、复杂一点的程序，还需要对OLE DB、ADO以及数据库平台再多了解一点，希望您继续努力，一定会很快成功的！详细参考资料请参见微软MSDN July 2000光盘或MS SQL 7.0在线文档资料（Books online）。文中难免有错误和不妥之处，敬请各位批评指正！

Dao访问Access2000的数据库

Dao访问Access2000的数据库！

前两天在修改一个VC6.0编写的数据库程序。由于程序是很早以前写的，用的访问数据库的方式是DAO访问Access97。但是现在的数据库升级到了Access2000，总是出现问题，提示为：不能识别数据库的格式？为此大伤脑筋，差了很多资料，也问了很多网上的高手,都说DAO不能访问Access2000。这该如何是好呢？如果改为ADO或是ODBC访问，对程序的改动将会很大，很复杂。最后，在一同事的帮助下解决了！解决方法很简单，就是加了一句话。

AfxGetModuleState()->m_dwVersion = 0x0601;
只要加在InitInstance()就可以了！

为什么呢？原来DAO的采用jet数据库引擎的原因,访问Access97的引擎是3.5版本，而访问Access2000的是4.0版本。所以，要用DAO访问Access2000必须升级引擎到4.0上面这句话就是这个作用。
唉！原来就这么简单！

#ifndef _AFXDLL
#define _MFC_VER 0x0601
#else
AfxGetModuleState()->m_dwVersion = 0x0601;
#endif

Programming - VC++