当前各种主流数据库有很多，包括oracle, ms sql server, sybase, informix, mysql, db2, interbase / firebird, postgresql, sqlite, sap/db, timesten, ms access等等。数据库编程是对数据库的创建、读写等一列的操作。数据库编程分为数据库客户端编程与数据库服务器端编程。数据库客户端编程主要使用odbc api、ado、ado.net、oci、otl等方法；数据库服务端编程主要使用ole db等方法。数据库编程需要掌握一些访问数据库技术方法，还需要注意怎么设计高效的数据库、数据库管理与运行的优化、数据库语句的优化。
一、访问数据库技术方法
数据库编程分为数据库客户端编程与数据库服务器端编程。数据库客户端编程主要使用odbc api、ado、ado.net、oci、otl等方法；数据库服务端编程主要使用ole db等方法。
1、几种是数据库访问方法比较
odbc api是一种适合数据库底层开发的编程方法,odbc api提供大量对数据源的操作,odbc api能够灵活地操作游标,支持各种帮定选项,在所有odbc相关编程中,api编程具有最高的执行速度。
dao提供了很好的数据库编程的对象模型.但是,对数据库的所有调用以及输出的数据都必须通过access/jet数据库引擎,这对于使用数据库应用程序,是严重的瓶颈。
ole db提供了com接口，与传统的数据库接口相比，有更好的健壮性和灵活性，具有很强的错误处理能力,能够同非关系数据源进行通信。
ado最主要的优点在于易于使用、速度快、内存支出少和磁盘遗迹小。
ado.net 是利用数据集的概念将数据库数据读入内存中，然后在内存中对数据进行操作，最后将数据集数据回写到源数据库中。
otl 是 oracle, odbc and db2-cli template library 的缩写，是一个c++编译中操控关系数据库的模板库， otl中直接操作oracle主要是通过oracle提供的oci接口进行，进行操作db2数据库则是通过cli接口来进行，至于ms的数据库和其它一些数据库，则otl只提供了odbc来操作的方式。当然oracle和db2也可以由otl间接使用odbc的方式来进行操纵。具有以下优点：跨平台；运行效率高，与c语言直接调用api相当；开发效率高，起码比ado.net使用起来更简单，更简洁；部署容易，不需要ado组件，不需要.net framework 等。
2、vc数据库编程几种方法
vc数据库编程几种方法，包括odbc连接、mfc odbc连接、dao连接、ole db、ole db templates连接、ado、oracle专用方法(oci(oracle call interface)访问、oracle object ole c++ class library )。
通用方法
1. odbc连接
odbc(open database connectivity)是msoa的一部分,是一个标准数据库接口。它提供对关系数据库访问的统一接口,实现对异构数据源的一致访问。
odbc数据访问由以下部分组成:
句柄(handles):odbc使用句柄来标识odbc环境、连接、语句和描述器.
缓存区(buffers):
数据类型(data types)
一致性级别(conformance levels)
用odbc设计客户端的一般步骤:
分配odbc环境
分配连接句柄
连接数据源
构造和执行sql语句
获得查询结果
断开数据源的连接
释放odbc环境
odbc api是一种适合数据库底层开发的编程方法,odbc api提供大量对数据源的操作,odbc api能够灵活地操作游标,支持各种帮定选项,在所有odbc相关编程中,api编程具有最高的执行速度.因此,odbc api编程属于底层编程。
2. mfc odbc连接
mfc odbc是mfc对odbc进行的封装,以简化对odbc api的 调用,从而实现面向对象的数据库编程接口.
mfc odbc的封装主要开发了cdatabase类和crecordset类
(1) cdatabase类
cdatabase类用于应用程序建立同数据源的连接。cdatabase类中包含一个m_hdbc变量,它代表了数据源的连接句柄。如果要建立cdatabase类的实例,应先调用该类的构造函数,再调用open函数,通过调用,初始化环境变量,并执行与数据源的连接。在通过close函数关闭数据源。
cdatabase类提供了对数据库进行操作的函数及事务操作。
(2) crecordset类
crecordset类定义了从数据库接收或者发送数据到数据库的成员变量,以实现对数据集的数据操作。
crecordset类的成员变量m_hstmt代表了定义该记录集的sql语句句柄,m_nfields为记录集中字段的个数,m_nparams为记录集所使用的参数个数。
crecordset的记录集通过cdatabase实例的指针实现同数据源的连接,即crecordset的成员变量m_pdatabase.
mfc odbc编程更适合于界面型数据库应用程序的开发,但由于cdatabase类和crecordset类提供的数据库操作函数有限,支持的游标类型也有限,限制了高效的数据库开发。在编程层次上属于高级编程。
应用实例：
1.打开数据库
cdatabase database;
database.openex( _t( dsn=zhuxue ),cdatabase::noodbcdialog);//zhuxue为数据源名称
2.关联记录集
crecordset recset(&database);
3.查询记录
cstring ssql1=;
ssql1 = select * from tablename ;
recset.open(crecordset::forwardonly, ssql1, crecordset::readonly);
int ti=0;
cdbvariant var;//var可以转换为其他类型的值
while (!recset.iseof())
{
//读取excel内部数值
recset.getfieldvalue(id,var);
jiangxiang[ti].id=var.m_ival;
recset.getfieldvalue(name, jiangxiang[ti].name);
ti++;
recset.movenext();
}
recset.close();//关闭记录集
4.执行sql语句
cstring ssql=;
ssql+=delete * from 院系审核;//清空表
database.executesql(ssql);
ssql也可以为insert ,update等语句
5.读取字段名
ssql = select * from sheet1 ; //读取的文件有sheet1表的定义,或为本程序生成的表.
// 执行查询语句
recset.open(crecordset::forwardonly, ssql, crecordset::readonly);
int excelcolcount=recset.getodbcfieldcount();//列数
cstring excelfield[30];
//得到记录集的字段集合中的字段的总个数
for( i=0;i {
codbcfieldinfo fieldinfo;
recset.getodbcfieldinfo(i,fieldinfo);
excelfield[i].name =fieldinfo.m_strname;//字段名
}
6.打开excel文件
cstring sdriver = microsoft excel driver (*.xls); // excel安装驱动
cstring ssql,sexcelfile; //sexcelfile为excel的文件路径
try
{
// 创建进行存取的字符串
ssql.format(driver={%s};dsn='';firstrowhasnames=1;readonly=false;create_db=/%s/;dbq=%s,sdriver, sexcelfile, sexcelfile);
// 创建数据库 (既excel表格文件)
if( database.openex(ssql,cdatabase::noodbcdialog) )
{
//可以把excel作为一个数据库操作
}
}
catch(e)
{
trace1(excel驱动没有安装: %s,sdriver);
afxmessagebox(读取失败,请检查是否定义数据区sheet1);
}
3. dao连接
dao(data access object)是一组microsoft access/jet数据库引擎的com自动化接口.dao直接与access/jet数据库通信.通过jet数据库引擎,dao也可以同其他数据库进行通信。dao还封装了access数据库的结构单元,通过dao可以直接修改access数据库的结构,而不必使用sql的数据定义语言(ddl)。
dao的体系结构如下:
dao封装的类：
(1)cdaoworkspace:对dao工作区(数据库处理事务管理器)的封装
(2)cdaodatabase:对dao数据库对象的封装,负责数据库连接.
(3)cdaorecordset:对dao记录集对象的封装,代表所选的一组记录.
(4)cdaotabledef:对表定义对象的封装,代表基本表或附加表定义.
(5)cdaoquerydef:对查询对象的封装,包含所有查询的定义.
(6)cdaoexception:dao用于接收数据库操作异常的类.
(7)cdaofieldexchange
dao提供了很好的数据库编程的对象模型.但是,对数据库的所有调用以及输出的数据都必须通过access/jet数据库引擎,这对于使用数据库应用程序,是严重的瓶颈。
dao相对于odbc来说，属于高层的数据库接口.
4. ole db连接
ole db对odbc进行了两方面的扩展:一是提供了数据库编程的ole接口即com，二是提供了一个可用于关系型和非关系型数据源的接口。
ole db提供了com接口，与传统的数据库接口相比，有更好的健壮性和灵活性，具有很强的错误处理能力,能够同非关系数据源进行通信。
与odbc api一样,ole db也属于底层的数据库编程接口,ole db结合了odbc对关系数据库的操作功能，并进行扩展，可以访问非关系数据库。
ole db访问数据库的原理如下:
ole db程序结构:
ole db由客户(consumer)和服务器(provider)。客户是使用数据的应用程序，它通过ole db接口对数据提供者的数据进行访问和控制。ole db服务器是提供ole db接口的软件组件。根据提供的内容可以分为数据提供程序(data provider)和服务提供程序(service provider)。
程序结构原理图如下:
数据提供程序
数据提供程序拥有自己的数据并把数据以表格的形式呈现给使用者使用.
服务提供程序
服务提供程序是数据提供程序和使用者的结合。它是ole db体系结构中的中间件,它是ole db数据源的使用者和数据使用程序的提供者
数据使用程序
数据使用程序对存储在数据提供程序中的数据进行使用和控制.
ole db开发程序的一般步骤:
初始化com环境
连接数据源
打开对话
执行命令
处理结果
清除对象
应用实例：
使用oledb编写数据库应用程序
1 概述
ole db的存在为用户提供了一种统一的方法来访问所有不同种类的数据源。ole db可以在不同的数据源中进行转换。利用ole db，客户端的开发人员在进行数据访问时只需把精力集中在很少的一些细节上，而不必弄懂大量不同数据库的访问协议。
ole db是一套通过com接口访问数据的activex接口。这个ole db接口相当通用，足以提供一种访问数据的统一手段，而不管存储数据所使用的方法如何。同时，ole db还允许开发人员继续利用基础数据库技术的优点，而不必为了利用这些优点而把数据移出来。
2 使用atl使用ole db数据使用程序
由于直接使用ole db的对象和接口设计数据库应用程序需要书写大量的代码。为了简化程序设计，visual c++提供了atl模板用于设计ole db数据应用程序和数据提供程序。
利用atl模板可以很容易地将ole db与mfc结合起来，使数据库的参数查询等复杂的编程得到简化。mfc提供的数据库类使ole db的编程更具有面向对象的特性。viual c++所提供用于ole db的atl模板可分为数据提供程序的模板和数据使用程序的模板。
使用atl模板创建数据应用程序一般有以下几步骤：
1）、 创建应用框架
2）、 加入atl产生的模板类
3）、 在应用中使用产生的数据访问对象
3 不用atl使用ole db数据使用程序
利用atl模板产生数据使用程序较为简单，但适用性不广，不能动态适应数据库的变化。下面我们介绍直接使用mfc ole db类来生成数据使用程序。
模板的使用
ole db数据使用者模板是由一些模板组成的，包括如下一些模板，下面对一些常用类作一些介绍。
1）、 会话类
cdatasource类
cdatasource类与ole db的数据源对象相对应。这个类代表了ole db数据提供程序和数据源之间的连接。只有当数据源的连接被建立之后，才能产生会话对象，可以调用open来打开数据源的连接。
csession类
csession所创建的对象代表了一个单独的数据库访问的会话。一个用cdatasource类产生的数据源对象可以创建一个或者多个会话，要在数据源对象上产生一个会话对象，需要调用函数open()来打开。同时，会话对象还可用于创建事务操作。
cenumeratoraccessor类
cenumeratoraccessor类是用来访问枚举器查询后所产生的行集中可用数据提供程序的信息的访问器，可提供当前可用的数据提供程序和可见的访问器。
2）、 访问器类
cacessor类
caccessor类代表与访问器的类型。当用户知道数据库的类型和结构时，可以使用此类。它支持对一个行集采用多个访问器，并且，存放数据的缓冲区是由用户分配的。
cdynamicaccessor类
cdynamicaccessor类用来在程序运行时动态的创建访问器。当系统运行时，可以动态地从行集中获得列的信息，可根据此信息动态地创建访问器。
cmanualaccessor类
cmanualaccessor类中以在程序运行时将列与变量绑定或者是将参数与变量捆定。
3）、 行集类
crowset类
crowset类封装了行集对象和相应的接口，并且提供了一些方法用于查询、设置数据等。可以用move（）等函数进行记录移动，用getdata()函数读取数据，用insert()、delete()、setdata()来更新数据。
cbulkrowset类
cbulkrowset类用于在一次调用中取回多个行句柄或者对多个行进行操作。
carrayrowset类
carrayrowset类提供用数组下标进行数据访问。
4）、 命令类
ctable类
ctable类用于对数据库的简单访问，用数据源的名称得到行集，从而得到数据。
ccommand类
ccommand类用于支持命令的数据源。可以用open()函数来执行sql命令，也可以prepare（）函数先对命令进行准备，对于支持命令的数据源，可以提高程序的灵活性和健壮性。
在stdafx.h头文件里，加入如下代码。
#include
extern ccommodule _module;
#include
#include
#include // if you are using schema templates
在stdafx.cpp文件里，加入如下代码。
#include
ccommodule _module;
决定使用何种类型的存取程序和行集。
获取数据
在打开数据源，会话，行集对象后就可以获取数据了。所获取的数据类型取决于所用的存取程序，可能需要绑定列。按以下步骤。
1、 用正确的命令打开行集对象。
2、 如果使用cmanualaccessor，在使用之前与相应列进行绑定。要绑定列，可以用函数getcolumninfo,如下所示：
// get the column information
ulong ulcolumns = 0;
dbcolumninfo* pcolumninfo = null;
lpolestr pstrings = null;
if (rs.getcolumninfo(&ulcolumns, &pcolumninfo, &pstrings) != s_ok)
afxthrowoledbexception(rs.m_prowset, iid_icolumnsinfo);
struct mybind* pbind = new mybind[ulcolumns];
rs.createaccessor(ulcolumns, &pbind[0], sizeof(mybind)*ulcolumns);
for (ulong l=0; lrs.addbindentry(l+1, dbtype_str, sizeof(tchar)*40, &pbind[l].szvalue, null, &pbind[l].dwstatus);
rs.bind();
3、 用while循环来取数据。在循环中，调用movenext来测试光标的返回值是否为s_ok，如下所示：
while (rs.movenext() == s_ok)
{
// add code to fetch data here
// if you are not using an auto accessor, call rs.getdata()
}
4、 在while循环内，可以通过不同的存取程序获取数据。
1） 如果使用的是caccessor类，可以通过使用它们的数据成员进行直接访问。如下所示：
2） 如果使用的是cdynamicaccessor 或cdynamicparameteraccessor 类，可以通过getvalue或getcolumn函数来获取数据。可以用gettype来获取所用数据类型。如下所示：
while (rs.movenext() == s_ok)
{
// use the dynamic accessor functions to retrieve your
// data
ulong ulcolumns = rs.getcolumncount();
for (ulong i=0; i {
rs.getvalue(i);
}
}
3） 如果使用的是cmanualaccessor,可以指定自己的数据成员，绑定它们。就可以直接存取。如下所示：
while (rs.movenext() == s_ok)
{
// use the data members you specified in the calls to
// addbindentry.
wsprintf(%s, szfoo);
}
决定行集的数据类型
在运行时决定数据类型，要用动态或手工的存取程序。如果用的是手工存取程序，可以用getcolumninfo函数得到行集的列信息。从这里可以得到数据类型。
4 总结
由于现在有多种数据源，，想要对这些数据进行访问管理的唯一途径就是通过一些同类机制来实现，如ole db。高级ole db结构分成两部分：客户和提供者。客户使用由提供者生成的数据。
就像其它基于com的多数结构一样，ole db的开发人员需要实现很多的接口，其中大部分是模板文件。
当生成一个客户对象时，可以通过atl对象向导指向一个数据源而创建一个简单的客户。atl对象向导将会检查数据源并创建数据库的客户端代理。从那里，可以通过ole db客户模板使用标准的浏览函数。
当生成一个提供者时，向导提供了一个很好的开端，它们仅仅是生成了一个简单的提供者来列举某一目录下的文件。然后，提供者模板包含了ole db支持的完全补充内容。在这种支持下，用户可以创建ole db提供者，来实现行集定位策略、数据的读写以及建立书签。
应用案例：
visual c++中使用ole db读写sql server
在需要对数据库进行操作时，ole db总是被认为是一种效率最高但最难的方法。但是以我最近使用ole db的经验看来，ole db的效率高则高矣，但却一点都不难。说它难恐怕主要是因为可参考的中文资料太少，为了帮助以后需要接触ole db的同行，我撰写了这篇文章。本文包含如下内容：
1. ole db写数据库；
2. ole db读数据库；
3. ole db对二进制数据(text、ntext、image等)的处理。
首先来看看对sql server进行写操作的代码，有一定vc基础的读者应该可以很顺利地看懂。ole db写数据库，就是这么简单！
注:
1.以下代码中使用的模板类eautoreleaseptr与atl中的ccomptr类似，是一个在析构时自动调用release的类。ccomptr的代码在atlbase.h中定义。
2.以下代码均在unicode环境下编译，因为执行的sql语句必须是unicode的。设置工程为unicode的方法是:首先在project->settings->c/c++的属性页中的preprocessor中，删除_mbcs写入unicode,_unicode。然后在link属性页中category中选择output，在entry-point symbol 中添加wwinmaincrtstartup。
eautoreleaseptr pidbinitialize;
hresult hresult = connectdatabase( &pidbinitialize, _t(127.0.0.1), _t(“sa”), _t(password) );
if( failed( hresult ) )
{
//失败，可能是因为数据库没有启动、用户名密码错等等
return;
}
eautoreleaseptr piopenrowset;
hresult = createsession( pidbinitialize, &piopenrowset );
if( failed( hresult ) )
{
//出错
return;
}
eautoreleaseptr picommand;
eautoreleaseptr picommandtext;
hresult = createcommand( piopenrowset, &picommand, &picommandtext );
if( failed( hresult ) )
{
//出错
return;
}
hresult = executesql( picommand, picommandtext, _t(use pbdata) );
if( failed( hresult ) )
{
//如果这里失败，那就是sql语句执行失败。在此处，就是pbdata还未创建
return;
}
// 创建表
executesql( picommand, picommandtext, _t(create table 2005_1(volume real not null,id int not null identity)) );
// 添加记录
executesql( picommand, picommandtext, _t(insert into 2005_1 values(100.0)) );
//...
其中几个函数的代码如下:
hresult connectdatabase( idbinitialize** ppidbinitialize, lpctstr pszdatasource, lpctstr pszuserid, lpctstr pszpassword )
{
assert( ppidbinitialize != null && pszdatasource != null && pszuserid != null && pszpassword != null );
uint utimeout ＝ 15u; // 连接数据库超时（秒）
tchar szinitstr[1024];
verify( 1023 >= wsprintf( szinitstr, _t(provider=sqloledb;data source=%s;initial catalog=master;user id=%s;password=%s;connect timeout=%u), pszdatasource, pszuserid, pszpassword, utimeout ) );
//initial catalog=master指明连接成功后，use master。
eautoreleaseptr pidatainitialize;
hresult hresult = ::cocreateinstance( clsid_msdainitialize, null, clsctx_inproc_server,
iid_idatainitialize, ( void** )&pidatainitialize );
if( failed( hresult ) )
{
return hresult;
}
eautoreleaseptr pidbinitialize;
hresult = pidatainitialize->getdatasource( null, clsctx_inproc_server, ( lpcolestr )szinitstr,
iid_idbinitialize, ( iunknown** )&pidbinitialize );
if( failed( hresult ) )
{
return hresult;
}
hresult = pidbinitialize->initialize( );
if( failed( hresult ) )
{
return hresult;
}
* ppidbinitialize = pidbinitialize.detach( );
return s_ok;
}
hresult createsession( idbinitialize* pidbinitialize, iopenrowset** ppiopenrowset )
{
assert( pidbinitialize != null && ppiopenrowset != null );
eautoreleaseptr psession;
hresult hresult = pidbinitialize->queryinterface( iid_idbcreatesession, ( void** )&psession );
if( failed( hresult ) )
{
return hresult;
}
eautoreleaseptr piopenrowset;
hresult = psession->createsession( null, iid_iopenrowset, ( iunknown** )&piopenrowset );
if( failed( hresult ) )
{
return hresult;
}
* ppiopenrowset = piopenrowset.detach( );
return s_ok;
}
hresult createcommand( iopenrowset* piopenrowset, icommand** ppicommand, icommandtext** ppicommandtext )
{
assert( piopenrowset != null && ppicommand != null && ppicommandtext != null );
hresult hresult;
eautoreleaseptr picommand;
{
eautoreleaseptr picreatecommand;
hresult = piopenrowset->queryinterface( iid_idbcreatecommand, ( void** )&picreatecommand );
if( failed( hresult ) )
{
return hresult;
}
hresult = picreatecommand->createcommand( null, iid_icommand, (iunknown**)&picommand );
if( failed( hresult ) )
{
return hresult;
}
}
eautoreleaseptr picommandtext;
hresult = picommand->queryinterface( &picommandtext );
if( failed( hresult ) )
{
return hresult;
}
* ppicommand = picommand.detach( );
* ppicommandtext = picommandtext.detach( );
return s_ok;
}
hresult executesql( icommand* picommand, icommandtext* picommandtext, lpctstr pszcommand, long* plrowsaffected )
{
assert( picommand != null && picommandtext != null && pszcommand != null && pszcommand[0] != 0 );
hresult hresult = picommandtext->setcommandtext( dbguid_dbsql, ( lpcolestr )pszcommand );
if( failed( hresult ) )
{
return hresult;
}
long laffected;
hresult = picommand->execute( null, iid_null, null, plrowsaffected == null ? &laffected : plrowsaffected, ( iunknown** )null );
return hresult;
}
以上就是写数据库的全部代码了，是不是很简单呢？下面再来读的。
// 先用与上面代码中一样的步骤获取picommand，picommandtext。此处省略
hresult hresult = picommandtext->setcommandtext( dbguid_dbsql, ( lpcolestr )_t(select volume from 2005_1 where id = @@identity) ); //取我们刚刚添加的那一条记录
if( failed( hresult ) )
{
return;
}
long laffected;
eautoreleaseptr pirowset;
hresult = picommand->execute( null, iid_irowset, null, &laffected, ( iunknown** )&pirowset );
if( failed( hresult ) )
{
return;
}
eautoreleaseptr piaccessor;
hresult = pirowset->queryinterface( iid_iaccessor, ( void** )&piaccessor );
if( failed( hresult ) )
{
return;
}
// 一个根据表中各字段的数值类型而定义的结构，用于存储返回的各字段的值
struct cloadlastfromdb
{
dbstatus dwdsvolume;
dword dwlenvolume;
float fvolume;
};
// 此处我们只查询了一个字段。如果要查询多个字段，cloadlastfromdb中要添加相应的字段定义，下面的dbbinding也要相应扩充。dbbinding[].iordinal要分别指向各个字段，dbbinding[].wtype要根据字段类型赋合适的值。
dbbinding dbbinding[1];
dbbinding[0].iordinal = 1; // volume 字段的位置，从 1 开始
dbbinding[0].obvalue = offsetof( cloadlastfromdb, fvolume );
dbbinding[0].oblength = offsetof( cloadlastfromdb, dwlenvolume );
dbbinding[0].obstatus = offsetof( cloadlastfromdb, dwdsvolume );
dbbinding[0].ptypeinfo = null;
dbbinding[0].pobject = null;
dbbinding[0].pbindext = null;
dbbinding[0].dwpart = dbpart_value | dbpart_status | dbpart_length;
dbbinding[0].dwmemowner = dbmemowner_clientowned;
dbbinding[0].eparamio = dbparamio_notparam;
dbbinding[0].cbmaxlen = 0;
dbbinding[0].dwflags = 0;
dbbinding[0].wtype = dbtype_r4; // float就是dbtype_r4，int就是dbtype_i4。参见msdn
dbbinding[0].bprecision = 0;
dbbinding[0].bscale = 0;
haccessor haccessor = db_null_haccessor;
dbbindstatus dbs[1];
hresult = piaccessor->createaccessor( dbaccessor_rowdata, 1, dbbinding, sizeof( cloadlastdatafromdb ), &haccessor, dbs );
if( failed( hresult ) )
{
return;
}
assert( dbs[0] == dbbindstatus_ok );
ulong urowsobtained = 0;
hrow hrows[1]; // 这里我们只查询了最新的那一条记录
hrow* phrows = hrows;
cloadlastfromdb rmd;
hresult = pirowset->getnextrows( null, 0, 1, &urowsobtained, &phrows );
if( succeeded( hresult ) && urowsobtained != 0u )
{
hresult = pirowset->getdata( phrows[0], haccessor, &rmd );
if( failed( hresult ) )
{
assert( false );
}
assert( rmd.dwdsvolume == dbstatus_s_ok );
// rmd.fvolume 就是我们要取的值
}
pirowset->releaserows( urowsobtained, phrows, null, null, null );
piaccessor->releaseaccessor( haccessor, null );
piaccessor.release( );
pirowset.release( );
读操作也完成了，是不是仍然很简单呢？下面我们再来看看最麻烦的二进制数据（text、ntext、image等）的读写。要实现blob数据的读写，我们需要一个辅助的类，定义如下：
class csequentialstream : public isequentialstream // blob 数据访问类
{
public:
csequentialstream( );
virtual ~csequentialstream( );
virtual bool seek( ulong uposition );
virtual bool clear( );
virtual ulong getlength( ) { return m_ubufferused; };
virtual operator void* const( ) { return m_pbuffer; };
stdmethodimp_( ulong ) addref( ) { return ++ m_urefcount; };
stdmethodimp_( ulong ) release( ) { assert( m_urefcount != 0u ); -- m_urefcount; if( m_urefcount == 0u ) { delete this; } return m_urefcount; };
stdmethodimp queryinterface( refiid riid, lpvoid* ppv );
stdmethodimp read( void __rpc_far* pv, ulong cb, ulong __rpc_far* pcbread );
stdmethodimp write( const void __rpc_far* pv, ulong cb, ulong __rpc_far* pcbwritten );
void resetposition( ) { m_uposition = 0u; };
hresult preallocbuffer( ulong usize );
private:
ulong m_urefcount; // reference count
void* m_pbuffer; // buffer
ulong m_ubufferused; // buffer used
ulong m_ubuffersize; // buffer size
ulong m_uposition; // current index position in the buffer
};
实现如下：
csequentialstream::csequentialstream( ) : m_urefcount( 0u ), m_pbuffer( null ), m_ubufferused( 0u ), m_ubuffersize( 0u ), m_uposition( 0u )
{
addref( );
}
csequentialstream::~csequentialstream( )
{
clear( );
}
hresult csequentialstream::queryinterface( refiid riid, void** ppv )
{
if( riid == iid_iunknown || riid == iid_isequentialstream )
{
* ppv = this;
( ( iunknown* )*ppv )->addref( );
return s_ok;
}
* ppv = null;
return e_nointerface;
}
bool csequentialstream::seek( ulong uposition )
{
assert( uposition m_uposition = uposition;
return true;
}
bool csequentialstream::clear( )
{
m_ubufferused = 0u;
m_ubuffersize = 0u;
m_uposition = 0u;
( m_pbuffer != null ? cotaskmemfree( m_pbuffer ) : 0 );
m_pbuffer = null;
return true;
}
hresult csequentialstream::preallocbuffer( ulong usize )
{
if( m_ubuffersize {
m_ubuffersize = usize;
m_pbuffer = cotaskmemrealloc( m_pbuffer, m_ubuffersize );
if( m_pbuffer == null )
{
clear( );
return stg_e_insufficientmemory;
}
}
return s_ok;
}
hresult csequentialstream::read( void* pv, ulong cb, ulong* pcbread )
{
( pcbread != null ? ( * pcbread = 0u ) : 0 );
if( pv == null ) { return stg_e_invalidpointer; }
if( cb == 0u ) { return s_ok; }
assert( m_uposition ulong ubytesleft = m_ubufferused - m_uposition;
if( ubytesleft == 0u ) { return s_false; } //no more bytes
ulong ubytesread = ( cb > ubytesleft ? ubytesleft : cb );
memcpy( pv, ( byte* )m_pbuffer + m_uposition, ubytesread );
m_uposition += ubytesread;
( pcbread != null ? ( * pcbread = ubytesread ) : 0 );
return ( cb != ubytesread ? s_false : s_ok );
}
hresult csequentialstream::write( const void* pv, ulong cb, ulong* pcbwritten )
{
if( pv == null ) { return stg_e_invalidpointer; }
( pcbwritten != null ? ( * pcbwritten = 0u ) : 0 );
if( cb == 0u ){ return s_ok; }
assert( m_uposition if( m_ubuffersize {
m_ubuffersize = m_uposition + cb;
m_pbuffer = cotaskmemrealloc( m_pbuffer, m_ubuffersize );
if( m_pbuffer == null )
{
clear( );
return stg_e_insufficientmemory;
}
}
m_ubufferused = m_uposition + cb;
memcpy( ( byte* )m_pbuffer + m_uposition, pv, cb );
m_uposition += cb;
( pcbwritten != null ? ( * pcbwritten = cb ) : 0 );
return s_ok;
}
下面我们开始往一个包含ntext字段的表中添加记录。假设这个表（news）的结构为：id int not null identity、title nchar(80)、 contents ntext。
// 先将记录添加进去，ntext字段留空。我们稍后再更新ntext的内容。
hresult hresult = executesql( picommand, picommandtext, _t(insert into news values('test','')) );
dbprop dbprop;
dbpropset.guidpropertyset = dbpropset_rowset;
dbpropset.cproperties = 1;
dbpropset.rgproperties = &dbprop;
dbpropset dbpropset;
dbpropset.rgproperties[0].dwpropertyid = dbprop_updatability;
dbpropset.rgproperties[0].dwoptions = dbpropoptions_required;
dbpropset.rgproperties[0].dwstatus = dbpropstatus_ok;
dbpropset.rgproperties[0].colid = db_nullid;
dbpropset.rgproperties[0].vvalue.vt = vt_i4;
v_i4( &dbpropset.rgproperties[0].vvalue ) = dbpropval_up_change;
eautoreleaseptr picommandproperties;
hresult = picommandtext->queryinterface( iid_icommandproperties, ( void** )&picommandproperties );
// 设置 rowset 属性为“可以更新某字段的值”
hresult = picommandproperties->setproperties( 1, &dbpropset );
hresult = picommandtext->setcommandtext( dbguid_dbsql, ( lpcolestr )lselect contents from news where id = @@identity );
long laffected;
eautoreleaseptr pirowsetchange;
hresult = picommand->execute( null, iid_irowsetchange, null, &laffected, ( iunknown** )&pirowsetchange );
eautoreleaseptr piaccessor;
hresult = pirowsetchange->queryinterface( iid_iaccessor, ( void** )&piaccessor );
struct blobdata
{
dbstatus dwstatus;
dword dwlength;
isequentialstream* piseqstream;
};
// 有关dbobject、dbbinding的设置，建议参考msdn，很容易懂。
dbobject dbobj;
dbobj.dwflags = stgm_read;
dbobj.iid = iid_isequentialstream;
dbbinding dbbinding;
dbbinding.iordinal = 1; // blob 字段的位置，从 1 开始
dbbinding.obvalue = offsetof( blobdata, piseqstream );
dbbinding.oblength = offsetof( blobdata, dwlength );
dbbinding.obstatus = offsetof( blobdata, dwstatus );
dbbinding.ptypeinfo = null;
dbbinding.pobject = &dbobj;
dbbinding.pbindext = null;
dbbinding.dwpart = dbpart_value | dbpart_status | dbpart_length;
dbbinding.dwmemowner = dbmemowner_clientowned;
dbbinding.eparamio = dbparamio_notparam;
dbbinding.cbmaxlen = 0;
dbbinding.dwflags = 0;
dbbinding.wtype = dbtype_iunknown;
dbbinding.bprecision = 0;
dbbinding.bscale = 0;
haccessor haccessor = db_null_haccessor;
dbbindstatus dbs;
hresult = piaccessor->createaccessor( dbaccessor_rowdata, 1, &dbbinding, sizeof( blobdata ), &haccessor, &dbs );
eautoreleaseptr pirowset;
hresult = pirowsetchange->queryinterface( iid_irowset, ( void** )&pirowset );
ulong urowsobtained = 0;
hrow* phrows = null;
hresult = pirowset->getnextrows( null, 0, 1, &urowsobtained, &phrows );
csequentialstream* pss = new csequentialstream;
pss->preallocbuffer( 1024 ); // 预先分配好内存，并读入数据
pss->write( pszsomebuffer, 512, null ); // pss->write可以连续调用
pss->write( pszsomebuffer+512, 512, null );
pss->resetposition( );
blobdata bd;
bd.piseqstream = ( isequentialstream* )pss;
bd.dwstatus = dbstatus_s_ok;
bd.dwlength = pss->getlength( );
// 将 blob 数据写入到数据库
hresult = pirowsetchange->setdata( phrows[0], haccessor, &bd );
piaccessor->releaseaccessor( haccessor, null );
pirowset->releaserows( urowsobtained, phrows, null, null, null );
// pss was released by pirowsetchange->setdata.
这样，我们就完成了一条记录的添加。读取blob字段的代码跟上面的完全类似，只要把
hresult = pirowset->getnextrows( null, 0, 1, &urowsobtained, &phrows );
后面的那些改成下面的代码即可。
blobdata bd;
hresult = pirowset->getdata( phrows[0], haccessor, &bd );
if( bd.dwstatus == dbstatus_s_isnull )
{
// 此字段为空
}
else if( bd.dwstatus != dbstatus_s_ok || bd.piseqstream == null )
{
// 失败
}
else
{
// 从系统分配的 isequentialstream 接口读入 blob 数据
byte szreadbuffer[1024];
for( ulong uread = 0u; ; )
{
if( failed( bd.piseqstream->read( szreadbuffer, 1024, &uread ) ) )
{
break;
}
//szreadbuffer中就包含了blob字段的数据
if( uread != 1024 )
{
break;
}
}
bd.piseqstream->release( );
}
piaccessor->releaseaccessor( haccessor, null );
pirowset->releaserows( urowsobtained, phrows, null, null, null );
5. ole db templates连接
使用ole db接口编程属于最低可能层，代码冗长并且很难维护。因此ms visual studio对ole db进一步抽象和封装，提供com ole db templates这个可行的中间层，从而简化了ole db应用程序的编写。
ole db templates编写客户数据库程序方法:
以mfc appwizard为向导建立应用程序框架,添加ole db支持的头文件,然后使用ole db类进行数据库应用开发。
以atl com appwizard为向导建立应用程序框架,该框架直接支持ole db模板类。
ole db templates包括:consumer templates和provider templates。
(1) consumer templates使用者模板
使用者模板(consumer templates)体系结构:
(2) provider templates服务器模板
服务器模板类体系结构：
6. ado连接
ado(activex data object,activex数据对象)是ms为最新和最强大的数据访问接口ole db而设计,是一个便于使用的应用程序层接口。ado是一种面向对象的、与语言无关的(language_neutral)数据访问应用编程接口。它对ole db api进行封装,实现对数据的高层访问,同时它也提供了多语言的访问技术，此外,由于ado提供了访问自动化接口,它也支持脚本语言。ado最主要的优点在于易于使用、速度快、内存支出少和磁盘遗迹小。ado是用来访问ole db的数据库技术。在模型层次上它基于ole db,但在应用上又高于ole db,因此它简化了对对象模型的操作,并且不依赖于对象之间的相互层次关系。但是ole的接口可以数据提供程序、服务提供程序和数据使用程序使用，而ado所提供的对象只能被数据应用程序使用。并且,ado对象使用了ole db服务提供程序和ole db数据提供程序所提供的接口和服务。
(1)ado访问数据库的结构原理图:
(2)ado对象模型:
ado对象模型包括以下关键对象：
connection对象:在数据库应用里操作数据源都通过该对象,这是数据交换的环境，代表与数据源的一个会话。
command对象:是一个对数据源执行命令的定义。
parameter对象:用于制定参数化查询或者存储过程的参数。
recordset对象:是执行结果集存储到本地的ado对象。
field对象:ado中对列进行操作的对象。
error对象:对ado数据操作时发生错误的详细描述。
property对象:代表一个由提供者定义的ado对象的动态特征。
ado对象编程模型:
parameters
collection
execute
source
error collection
(optional) active fields
connection collection
(3)ado编程一般步骤：
创建一个connection对象。
打开数据源，建立同数据源的连接。
执行一个sql命令。
使用结果集。
终止连接。
(4)ado的数据库访问规范
引入ado支持
#import program files/common files/system/ado/msado*.dll
初始化和释放ado环境：
coinitialize(null);
couninitialize();
封装的ado类a set of ado classes：
http://blog.csdn.net/byxdaz/archive/2008/06/19/2563174.aspx
ado编程小结：http://hi.baidu.com/sunkanghome/blog/item/273171f9ffb4735c252df286.html
http://hi.baidu.com/sunkanghome/blog/item/cea70101bdb177031d95839a.html
应用实例：
在visual c++中用ado进行数据库编程
1. 生成应用程序框架并初始化ole/com库环境
创建一个标准的mfc appwizard(exe)应用程序，然后在使用ado数据库的initinstance函数中初始化ole/com库（因为ado库是一个com dll库）。
本例为：
bool cadotestdlg::oninitdialog()
{
::coinitialize(null); //初始化ole/com库环境
}
程序最后要调用 ::couninitialize()；//释放程序占用的com 资源。
另外：
m_precordset->close(); 注意！！！不要多次关闭！！！！！！！！！！！！
m_pconnection->close();
m_precordset = null;
m_pconnection = null;
2. 引入ado库文件
使用ado前必须在工程的stdafx.h文件最后用直接引入符号＃import引入ado库文件，以使编译器能正确编译。代码如下：
#import c:/program files/common files/system/ado/msado15.dll no_namespace rename(eof,adoeof)
ado类的定义是作为一种资源存储在ado dll(msado15.dll）中，在其内部称为类型库。类型库描述了自治接口，以及c＋＋使用的com vtable接口。当使用＃import指令时，在运行时visual c＋＋需要从ado dll中读取这个类型库，并以此创建一组c＋＋头文件。这些头文件具有.tli 和.tlh扩展名，读者可以在项目的目录下找到这两个文件。在c＋＋程序代码中调用的ado类要在这些文件中定义。
程序的第三行指示ado对象不使用名称空间。在有些应用程序中，由于应用程序中的对象与ado中的对象之间可能会出现命名冲突，所以有必要使用名称空间。如果要使用名称空间，则可把第三行程序修改为： rename_namespace(adons)。第四行代码将ado中的eof(文件结束)更名为adoeof，以避免与定义了自己的eof的其他库冲突。
3．利用智能指针进行数据库操作
在caboutdlg头文件中定义两个ado智能指针类实例,并在对话框中加入一个listctrl。
class cadotestdlg : public cdialog
{
_connectionptr m_pconnection;
_recordsetptr m_precordset;
clistctrl m_list;
......
}
ado库包含三个智能指针:_connectionptr、_commandptr和_recordsetptr。
_connectionptr通常被用来创建一个数据连接或执行一条不返回任何结果的sql语句，如一个存储过程。
_commandptr返回一个记录集。它提供了一种简单的方法来执行返回记录集的存储过程和sql语句。在使用_commandptr接口时，可以利用全局_connectionptr接口，也可以在_commandptr接口里直接使用连接串。_recordsetptr是一个记录集对象。与以上两种对象相比，它对记录集提供了更多的控制功能，如记录锁定、游标控制等。
在使用ado程序的事件响应中onbutton1加入以下代码:
void cadotestdlg::onbutton1()
{
m_list.resetcontent();
m_pconnection.createinstance(_uuidof(connection)); //初始化connection指针
m_precordset.createinstance(_uuidof(recordset));//初始化recordset指针
try
{
m_pconnection->open(dsn=adotest,,,0); //连接叫作adotest的odbc数据源
//注意：这是连接不需要用户id或密码的open 函数
// 否则形式为 ->open(dsn=test;uid=sa;pwd=123;,,,0);
// 执行sql语句得到一个记录集把其指针赋值给m_precordset
cstring strsql=select * from middle;
bstr bstrsql = strsql.allocsysstring();
m_precordset->open(bstrsql,(idispatch*)m_pconnection,adopendynamic,adlockoptimistic,adcmdtext);
//adopendynamic：动态 adlockoptimistic乐观封锁法 adcmdtext：文本查询语句
while(!m_precordset->adoeof)//遍历所有记录
{
//取纪录字段值方式之一
_variant_t thevalue; //variant数据类型
thevalue = m_precordset->getcollect(big_name);//得到字段big_name的值
if(thevalue.vt!=vt_null)
m_list.addstring((char*)_bstr_t(thevalue));
//将该值加入到列表控件中
//取纪录字段值方式之二
// _bstr_t thevalue1=m_precordset->fields->getitem(big_name)->value;
// cstring temp=thevalue1.copy();
// m_list.addstring(temp);
//数据类型转换
_variant_t vusername,vbirthday,vid,vold;
trace(id:%d,姓名:%s,年龄:%d,生日:%s/r/n,
vid.lval,(lpctstr)(_bstr_t)vusername,vold.lval,(lpctstr)(_bstr_t)vbirthday);
m_precordset->movenext();//转到下一条纪录
}
m_precordset->close();
m_pconnection->close();
}
catch (_com_error e)//异常处理
{
afxmessagebox(e.errormessage());
}
m_precordset->close(); //注意！！！不要多次关闭！！！！否则会出错
m_pconnection->close();
m_precordset = null;
m_pconnection = null;
}
程序中通过_variant_t和_bstr_t转换com对象和c＋＋类型的数据, _variant_t类封装了ole自治variant数据类型。在c++中使用_variant_t类要比直接使用variant数据类型容易得多。
好，编译后该程序就能运行了，但记住运行前要创建一个叫adotest的odbc数据