berkeley db简介

　　berkeley db是一个开放源代码的内嵌式数据库管理系统，能够为应用程序提供高性能的数据管理服务。应用它程序员只需要调用一些简单的api就可以完成对数据的访问 和管理。与常用的数据库管理系统（如mysql和oracle等）有所不同，在berkeley db中并没有数据库服务器的概念。应用程序不需要事先同数据库服务建立起网络连接，而是通过内嵌在程序中的berkeley db函数库来完成对数据的保存、查询、修改和删除等操作。
　　berkeley db为许多编程语言提供了实用的api接口，包括c、c++、java、perl、tcl、python和php等。所有同数据库相关的操作都由 berkeley db函数库负责统一完成。这样无论是系统中的多个进程，或者是相同进程中的多个线程，都可以在同一时间调用访问数据库的函数。而底层的数据加锁、事务日志 和存储管理等都在berkeley db函数库中实现。它们对应用程序来讲是完全透明的。俗话说：“麻雀虽小五脏俱全。”berkeley db函数库本身虽然只有300kb左右，但却能够用来管理多达256tb的数据，并且在许多方面的性能还能够同商业级的数据库系统相抗衡。就拿对数据的并 发操作来说，berkeley db能够很轻松地应付几千个用户同时访问同一个数据库的情况。此外，如果想在资源受限的嵌入式系统上进行数据库管理，berkeley db可能就是惟一正确的选择了。
　　berkeley db作为一种嵌入式数据库系统在许多方面有着独特的优势。首先，由于其应用程序和数据库管理系统运行在相同的进程空间当中，进行数据操作时可以避免繁琐的 进程间通信，因此耗费在通信上的开销自然也就降低到了极低程度。其次，berkeley db使用简单的函数调用接口来完成所有的数据库操作，而不是在数据库系统中经常用到的sql语言。这样就避免了对结构化查询语言进行解析和处理所需的开 销。

 

基本概念

　　berkeley db简化了数据库的操作模式，同时引入了一些新的基本概念，从而使得访问和管理数据库变得相对简单起来。在使用berkeley db提供的函数库编写数据库应用程序之前，有必要先了解以下这些基本概念。
　　关键字和数据
　　关 键字（key）和数据（data）是berkeley db用来进行数据库管理的基础，由这两者构成的key/data对（见表1）组成了数据库中的一个基本结构单元，而整个数据库实际上就是由许多这样的结构 单元所构成的。通过使用这种方式，开发人员在使用berkeley db提供的api来访问数据库时，只需提供关键字就能够访问到相应的数据。
　　key        data
　　sport        football
　　fruit        orange
　　drink        beer
　　表1 key/data对
　　如果想将第一行中的 “sport”和“football”保存到berkeley db数据库中，可以调用berkeley db函数库提供的数据保存接口。此时“sport”和“football”将分别当成关键字和数据来看待。之后如果需要从数据库中检索出该数据，可以用 “sport”作为关键字进行查询。此时berkeley db提供的接口函数会返回与之对应的数据“football”。
　　关键字和数据在berkeley db中都是用一个名为dbt的简单结构来表示的。实际上两者都可以是任意长度的二进制数据，而dbt的作用主要是保存相应的内存地址及其长度，其结构如下所示：
　　typedef struct {
　　void *data;
　　u_int32_t size;
　　u_int32_t ulen;
　　u_int32_t dlen;
　　u_int32_t doff;
　　u_int32_t flags;
　　} dbt;
　　在使用berkeley db进行数据管理时，缺省情况下是一个关键字对应于一个数据，但事实上也可以将数据库配置成一个关键字对应于多个数据。

 

对象句柄

　　在berkeley db函数库定义的大多数函数都遵循同样的调用原则：首先创建某个结构，然后再调用该结构中的某些方法。从程序设计的角度来讲，这一点同面向对象的设计原则 是非常类似的，即先创建某个对象的一个实例，然后再调用该实例的某些方法。正因如此，berkeley db引入了对象句柄的概念来表示实例化后的结构，并且将结构中的成员函数称为该句柄的方法。
　　对象句柄的引入使得程序员能够完全凭借面向对象的思想，来完成对berkeley db数据库的访问和操作，即使当前使用的是像c这样的结构化语言。例如，对于打开数据库的操作来说，可以调用db的对象句柄所提供的open函数，其原型如下所示：
　　int db->open(db *db, db_txn *txnid, const char *file,
　　const char *database, dbtype type, u_int32_t flags, int mode);

 

错误处理

　　对于任何一个函数库来说，如何对错误进行统一的处理都是需要考虑的问题。berkeley db提供的所有函数都遵循同样的错误处理原则，即函数成功执行后返回零，否则的话则返回非零值。
　　对 于系统错误（如磁盘空间不足和访问权限不够等），返回的是一个标准的值;而对于非系统错误，返回的则是一个特定的错误编码。例如，如果在数据库中没有与某 个特定关键字所对应的数据，那么在通过该关键字检索数据时就会出现错误。此时函数的返回值将是db_notfound，表示所请求的关键字并没有在数据库 中出现。所有标准的errno值都是大于零的，而由berkeley db定义的特殊错误编码则都是小于零的。
　　要求程序员记住所有的 错误代号既不现实也没有什么实际意义，因为berkeley db提供了相应的函数来获得错误代号所对应的错误描述。一旦有错误发生，只需首先调用db_strerror()函数来获得错误描述信息，然后再调用db ->err()或db->errx()就可以很轻松地输出格式化后的错误信息。

 

应用统一的编程接口

　　使用berkeley db提供的函数来进行数据库的访问和管理并不复杂，在大多数场合下只需按照统一的接口标准进行调用就可以完成最基本的操作。

 

打开数据库

　　打 开数据库通常要分两步进行：首先调用db_create()函数来创建db结构的一个实例，然后再调用db->open()函数来完成真正的打开操 作。berkeley db将所有对数据库的操作都封装在名为db的结构中。db_create()函数的作用就是创建一个该结构，其原型如下所示：
　　typedef struct__db db;
　　int db_create(db **dbp, db_env *dbenv, u_int32_t flags);
　　将磁盘上保存的文件作为数据库打开是由db->open()函数来完成的，其原型如下所示：
　　int db->open(db *db, db_txn *txnid, const char *file,
　　const char *database, dbtype type, u_int32_t flags, int mode);
　　下面这段代码示范了如何创建db对象句柄及如何打开数据库文件：
　　#include
　　#include
　　#include
　　#include
　　#include
　　#define database "demo.db"
　　/* 以下程序代码的程序头同此＊/
　　int main()
　　{ db *dbp;
　　int ret;
　　if ((ret = db_create(&dbp, null, 0)) != 0) {
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　exit (1);
　　}
　　if ((ret = dbp->open(dbp, null, database, null, db_btree, db_create, 0664)) != 0) {
　　dbp->err(dbp, ret, "%s", database);
　　exit (1);
　　}
　　}
　　代 码首先调用db_create()函数来创建一个db对象句柄。变量dbp在调用成功后将成为数据库句柄，通过它可以完成对底层数据库的配置或访问。接下 去调用db->open()函数打开数据库文件，参数“database”指明对应的磁盘文件名为demo.db；参数“db_btree”表示数 据库底层使用的数据结构是b树；而参数“db_create”和“0664”则表明当数据库文件不存在时创建一个新的数据库文件，并且将该文件的属性值设 置为0664。
　　错误处理是在打开数据库时必须的例行检查，这可以通过调用db->err()函数来完成。其中参数“ret”是在调用berkeley db函数后返回的错误代码，其余参数则用于显示结构化的错误信息。

 

添加数据

　　向berkeley db数据库中添加数据可以通过调用db->put()函数来完成，其原型如下所示：
　　int db->put(db *db, db_txn *txnid, dbt *key, dbt *data, u_int32_t flags);
　　下面这段代码示范了如何向数据库中添加新的数据：
　　int main()
　　{ db *dbp;
　　dbt key, data;
　　int ret;
　　if ((ret = db_create(&dbp, null, 0)) != 0) {
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　exit (1);
　　}
　　if ((ret = dbp->open(dbp,
　　null, database, null, db_btree, db_create, 0664)) != 0) {
　　dbp->err(dbp, ret, "%s", database);
　　exit (1);
　　}
　　memset(&key, 0, sizeof(key));
　　memset(&data, 0, sizeof(data));
　　key.data = "sport";
　　key.size = sizeof("sport");
　　data.data = "football";
　　data.size = sizeof("football");
　　if ((ret = dbp->put(dbp, null, &key, &data, 0)) == 0)
　　printf("db: %s: key stored.\n", (char *)key.data);
　　else
　　dbp->err(dbp, ret, "db->put");
　　}
　　代码首先声明了两个dbt结构变量，并分别用字符串“sport”和“football”进行填充。它们随后作为关键字和数据传递给用来添加数据的db->put()函数。dbt结构几乎会在所有同数据访问相关的函数中被用到。
　　在 向数据库中添加数据时，如果给定的关键字已经存在，大多数应用会对于已经存在的数据采用覆盖原则。也就是说，如果数据库中已经保存了一个 “sport/basketball”对，再次调用db->put()函数添加一个“sport/football”对，那么先前保存的那些数据将 会被覆盖。但berkeley db允许在调用db->put()函数时指定参数“db_nooverwrite”，声明不对数据库中已经存在的数据进行覆盖，其代码如下：
　　if ((ret = dbp->put(dbp, null, &key, &data, db_nooverwrite)) == 0)
　　printf("db: %s: key stored.\n", (char *)key.data);
　　else
　　dbp->err(dbp, ret, "db->put");
　　一旦给出“db_nooverwrite”标记，如果db->put()函数在执行过程中发现给出的关键字在数据库中已经存在了，就无法成功地把该key/data对添加到数据库中，于是将返回错误代号“db_keyexist”。

 

检索数据

　　从berkeley db数据库中检索数据可以通过调用db->get()函数来完成，其原型如下所示：
　　int db->get(db *db, db_txn *txnid, dbt *key, dbt *data, u_int32_t flags);
　　下面这段代码示范了如何从数据库中检索出所需的数据：
　　int main()
　　{ db *dbp;
　　dbt key, data;
　　int ret;
　　if ((ret = db_create(&dbp, null, 0)) != 0) {
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　exit (1);
　　}
　　if ((ret = dbp->open(dbp,
　　null, database, null, db_btree, db_create, 0664)) != 0) {
　　dbp->err(dbp, ret, "%s", database);
　　exit (1);
　　}
　　memset(&key, 0, sizeof(key));
　　memset(&data, 0, sizeof(data));
　　key.data = "sport";
　　key.size = sizeof("sport");
　　if ((ret = dbp->get(dbp, null, &key, &data, 0)) == 0)
　　printf("db: %s: key retrieved: data was %s.\n",
　　(char *)key.data, (char *)data.data);
　　else
　　dbp->err(dbp, ret, "db->get");
　　}
　　代 码同样声明了两个dbt结构变量，并且调用memset()函数对它们的内容清空。虽然berkeley db并不强制要求在进行数据操作之前先清空它们，但出于提高代码质量考虑还是建议先进行清空操作。在进行数据检索时，对db->get()函数的返 回值进行处理是必不可少的，因为它携带着检索操作是否成功完成等信息。下面列出的是db->get()函数的返回值：
　　◆ 0 函数调用成功，指定的关键字被找到；
　　◆ db_notfound 函数调用成功，但指定的关键字未被找到；
　　◆大于0 函数调用失败，可能出现了系统错误。

 

删除数据

　　从berkeley db数据库中删除数据可以通过调用db->del()函数来完成，其原型如下所示：
　　int db->del(db *db, db_txn *txnid, dbt *key, u_int32_t flags);
　　下面这段代码示范了如何从数据库中删除数据：
　　int main()
　　{ db *dbp;
　　dbt key;
　　int ret;
　　if ((ret = db_create(&dbp, null, 0)) != 0) {
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　exit (1);
　　}
　　if ((ret = dbp->open(dbp,
　　null, database, null, db_btree, db_create, 0664)) != 0) {
　　dbp->err(dbp, ret, "%s", database);
　　exit (1);
　　}
　　memset(&key, 0, sizeof(key));
　　key.data = "sport";
　　key.size = sizeof("sport");
　　if ((ret = dbp->del(dbp, null, &key, 0)) == 0)
　　printf("db: %s: key was deleted.\n", (char *)key.data);
　　else
　　dbp->err(dbp, ret, "db->del");
　　}
　　删除数据只需给出相应的关键字，不用指明与之对应的数据。

 

关闭数据库

　　对 于一次完整的数据库操作过程来说，关闭数据库是不可或缺的一个环节。这是因为berkeley db需要依赖于系统底层的缓冲机制，也就是说只有在数据库正常关闭的时候，修改后的数据才有可能全部写到磁盘上，同时它所占用的资源也才能真正被全部释 放。关闭数据库的操作是通过调用db->close()函数来完成的，其原型如下所示：
　　int db->close(db *db, u_int32_t flags);
　　下面这段代码示范了如何在需要的时候关闭数据库：
　　int main()
　　{ db *dbp;
　　dbt key, data;
　　int ret, t_ret;
　　if ((ret = db_create(&dbp, null, 0)) != 0) {
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　exit (1);
　　}
　　if ((ret = dbp->open(dbp,
　　null, database, null, db_btree, db_create, 0664)) != 0) {
　　dbp->err(dbp, ret, "%s", database);
　　goto err;
　　}
　　memset(&key, 0, sizeof(key));
　　memset(&data, 0, sizeof(data));
　　key.data = "sport";
　　key.size = sizeof("sport");
　　if ((ret = dbp->get(dbp, null, &key, &data, 0)) == 0)
　　printf("db: %s: key retrieved: data was %s.\n",
　　(char *)key.data, (char *)data.data);
　　else
　　dbp->err(dbp, ret, "db->get");
　　if ((t_ret = dbp->close(dbp, 0)) != 0 && ret == 0)
　　ret = t_ret;
　　exit(ret);
　　}

 

小结

　　berkeley db这个嵌入式数据库系统使用非常简单。它没有数据库服务器的概念，也不需要复杂的sql语句，所有对数据的操作和管理都可以通过函数调用来完成，非常适合于那些需要对数据进行简单管理的应用场合
　　include <db.h>
　　#include <string.h>
　　#include <stdlib.h>
　　#define MAXBUFFER 300
　　#define MAXSTRING 100
　　void getdata(void);
　　/* Declare our struct */
　　struct example_structure {
　　float myFloat;
　　int myInt;
　　char *myString;
　　};
　　typedef struct example_structure EXAMPLE_STRUCTURE;
　　char SAMPLE_KEY[] = "eins";
　　char * Database = "./sample.db";
　　DBT sampleKEY;
　　/*
　　* Program to illustrate marshalling and unmarshalling structures.
　　*
　　* Marshalling is the process of moving the contents of a structure's
　　* fields into a single contiguous memory location. This is done so that
　　* the structure can be stored in a Berkeley DB database.
　　*
　　* Unmarshalling is performed to take data retrieved from a Berkeley DB database
　　* and place it back into the structure so that it can be used by the
　　* application.
　　*/
　　int
　　main(void)
　　{
　　DBT sampleDBT; /* The Berkeley DB data structure that we use to store data
　　* in a database. Typically there are two of these for
　　* every database record, one for a key and one for the
　　* data. In this case, we need only one DBT for
　　* illustration purposes.
　　*/
　　DB *dbp;
　　char *SerialNumber;
　　int ret;
　　EXAMPLE_STRUCTURE myStruct; /* The structure we want to store */
　　int buffer_length; /* The amount of data stored in our buffer */
　　char buffer[MAXBUFFER]; /* The buffer itself */
　　char *bufferPtr; /* A pointer into the buffer */
　　memset(&sampleKEY, 0, sizeof(DBT));
　　memset(&sampleDBT, 0, sizeof(DBT));
　　/* First, we fill in our structure's data fields */
　　myStruct.myFloat = 3.04;
　　myStruct.myInt = 200;
　　/* malloc space for the string */
　　myStruct.myString = (char *)malloc(MAXSTRING * sizeof(char));
　　/* Copy a string into that space. */
　　strcpy(myStruct.myString, "My example string.");
　　/*
　　* In order to store the data for this structure, we must make sure that
　　* all its data is lined up in a single contiguous block of memory -- that
　　* is, in a single buffer. We also need to know how much data was put into
　　* that buffer. To do this, we copy the structure's data into the buffer.
　　* This is the actual marshalling process.
　　*
　　* Note that the order we use to copy the data is not important, except
　　* that we have to make sure that we unmarshall in the same order. Here
　　* we mix things up a bit in order to illustrate the concept.
　　*
　　* Notice that we keep track of how much data we've placed in the buffer as
　　* we go. Also, take care to copy each new bit of data to the end of the
　　* buffer, so as to not overwrite any data previously placed there.
　　*/
　　/* Initialize the buffer */
　　memset(&buffer, 0, MAXBUFFER);
　　/* Copy the struct's int into the buffer */
　　bufferPtr = &buffer[0];
　　memcpy(bufferPtr, &(myStruct.myInt), sizeof(int));
　　buffer_length = sizeof(int);
　　/* Copy the struct's string into the buffer */
　　bufferPtr = &buffer[buffer_length];
　　memcpy(bufferPtr, myStruct.myString,
　　strlen(myStruct.myString) + 1);
　　buffer_length += (strlen(myStruct.myString) + 1);
　　/* Copy the struct's float into the buffer */
　　bufferPtr = &buffer[buffer_length];
　　memcpy(bufferPtr, &(myStruct.myFloat), sizeof(float));
　　buffer_length += sizeof(float);
　　/*
　　* We now have a buffer that contains all our data. We also have the size of
　　* the data contained in that buffer. We can use this buffer with our DBT:
　　*/
　　sampleDBT.data = buffer;
　　sampleDBT.size = buffer_length;
　　sampleKEY.data = SAMPLE_KEY;
　　sampleKEY.size = sizeof(SAMPLE_KEY);
　　if ((ret = db_create(&dbp, NULL, 0)) != 0)
　　{
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　return(ret);
　　}
　　if ((ret = dbp->open(dbp,
　　NULL, Database, NULL, DB_BTREE, DB_CREATE, 0664)) != 0)
　　{
　　dbp->err(dbp, ret, "%s", Database);
　　return(ret);
　　}
　　if ((ret = dbp->put(dbp, NULL, &sampleKEY, &sampleDBT, 0)) != 0)
　　{
　　dbp->err(dbp, ret, "%s", Database);
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　return(ret);
　　}
　　//ret = dbp->close(dbp, 0);
　　/*
　　* We can now pass the data DBT to a DB->put() or DBC->c_put() call for
　　* storage in the database. We won't show that here.
　　*/
　　/*
　　* Upon retrieval from the database (again, we don't show the actual
　　* database get() activity), the DBT's data field is pointing to
　　* a void * buffer that contains exactly the data that we marshalled into
　　* our buffer above. We now need to only unmarshall that data. To do this,
　　* we have to remember the order in which we originally marshalled the
　　* data.
　　*/
　　/*
　　* Note that we're reusing the same DBT for unmarshalling process as we used
　　* to marshall the data. In real-world usage, the two would be different
　　* as they would almost certainly be declared in different scopes.
　　*/
　　/*
　　* Now we can print everything out to prove that the marshalling process
　　* worked
　　*/
　　printf("Original structure:\n");
　　printf("\tmyInt: %i, \tmyFloat: %f\n", myStruct.myInt, myStruct.myFloat);
　　printf("\tmyString: %s\n", myStruct.myString);
　　ret = dbp->close(dbp, 0);
　　getdata();
　　return(0);
　　}
　　void getdata(void)
　　{
　　char *bufferPtr; /* A pointer into the buffer */
　　EXAMPLE_STRUCTURE newStruct; /* The structure we want to place data into */
　　DBT sampleDBT;
　　DB *dbp;
　　int ret;
　　memset(&sampleDBT, 0, sizeof(DBT));
　　if ((ret = db_create(&dbp, NULL, 0)) != 0)
　　{
　　fprintf(stderr, "db_create: %s\n", db_strerror(ret));
　　}
　　if ((ret = dbp->open(dbp,
　　NULL, Database, NULL, DB_BTREE, DB_CREATE, 0664)) != 0)
　　{
　　dbp->err(dbp, ret, "%s", Database);
　　}
　　if ((ret = dbp->get(dbp, NULL, &sampleKEY, &sampleDBT, 0)) != 0)
　　{
　　dbp->err(dbp, ret, "%s", Database);
　　return;
　　}
　　bufferPtr = sampleDBT.data;
　　/* First, find the int (the first bit of data that we stored) */
　　newStruct.myInt = *((int *)bufferPtr);
　　bufferPtr += sizeof(int);
　　/* Next, the string */
　　newStruct.myString = (char *)bufferPtr;
　　bufferPtr += (strlen(newStruct.myString) + 1);
　　/* And finally, the float */
　　newStruct.myFloat = *((float *)bufferPtr);
　　printf("\nNew structure (after marshalling and unmarshalling:\n");
　　printf("\tmyInt: %i, \tmyFloat: %f\n", newStruct.myInt, newStruct.myFloat);
　　printf("\tmyString: %s\n", newStruct.myString);
　　/* Cleanup */
　　ret = dbp->close(dbp, 0);
　　}
　　output:
　　Original structure:
　　myInt: 200, myFloat: 3.040000
　　myString: My example string.
　　New structure (after marshalling and unmarshalling:
　　myInt: 200, myFloat: 3.040000
　　myString: My example string.
　　Press enter to continue...
　　I did not understand why you would us a u_int32_t for the buffer, and of course you have to either flush the output or close the database connection otherwise nothing is written.
　　Regards
　　Friedrich