Berkeley DB是Sleepcat开发的开源的嵌入式数据库。具有轻巧、可扩展的优点。
但是它不支持SQL语句，而且操作起来相对比较复杂。
下面讲讲在VC下为了使其能够存储数据结构做的封装。
在google搜索Berkely DB 进入sleepycat下载zip安装包，编译。
建立工程TestBerkeleyDB，拷贝libdb43.dll和libdb43.lib到当前工程下，添加libdb43.dll到工程的setting。
把db.h和db_cxx.h拷贝到当前目录下。
添加icqtypes.h：
#ifndef _ICQ_TYPES_H_
#define _ICQ_TYPES_H_
#include <string>
#include <list>
#include <vector>
#include <bitset>
using namespace std;
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned long uint32;
typedef list<string> StrList;
typedef list<void *> PtrList;
typedef list<uint32> UinList;
#endif
添加icqdb.h;
#ifndef _ICQ_DB_H
#define _ICQ_DB_H
#include "icqtypes.h"
#include "db_cxx.h"
#define MAX_BLOCK_SIZE 4096
class DBOutStream {
public:
DBOutStream() {
cursor = data;
}
char *getData() {
return data;
}
int getSize() {
return (cursor - data);
}
DBOutStream &operator <<(uint8 b);
DBOutStream &operator <<(uint16 w);
DBOutStream &operator <<(uint32 dw);
DBOutStream &operator <<(const char *str);
DBOutStream &operator <<(const string &str) {
return operator <<(str.c_str());
}
DBOutStream &operator <<(StrList &strList);
private:
char data[MAX_BLOCK_SIZE];
char *cursor;
};
class DBInStream {
public:
DBInStream(void *d, int n) {
cursor = data = (char *) d;
datalen = n;
}
DBInStream &operator >>(uint8 &b);
DBInStream &operator >>(uint16 &w);
DBInStream &operator >>(uint32 &dw);
DBInStream &operator >>(string &str);
DBInStream &operator >>(StrList &strList);
private:
char *data;
char *cursor;
int datalen;
};
class DBSerialize {
public:
virtual void save(DBOutStream &out) = 0;
virtual void load(DBInStream &in) = 0;
};
#endif
添加icqdb.cpp:
#include "stdafx.h"
#include "icqdb.h"
#include "string.h"
#include "icqtypes.h"
#define INDEX_USER 0
#define INDEX_OPTIONS 0xffffffff
#define INDEX_GROUP 0xfffffffe
DBOutStream &DBOutStream::operator <<(uint8 b)
{
if (cursor <= data + MAX_BLOCK_SIZE - sizeof(b))
*cursor++ = b;
return (*this);
}
DBOutStream &DBOutStream::operator <<(uint16 w)
{
if (cursor <= data + MAX_BLOCK_SIZE - sizeof(w)) {
*(uint16 *) cursor = w;
cursor += sizeof(w);
}
return (*this);
}
DBOutStream &DBOutStream::operator <<(uint32 dw)
{
if (cursor <= data + MAX_BLOCK_SIZE - sizeof(dw)) {
*(uint32 *) cursor = dw;
cursor += sizeof(dw);
}
return (*this);
}
DBOutStream &DBOutStream::operator <<(const char *str)
{
uint16 len = strlen(str) + 1;
if (cursor <= data + MAX_BLOCK_SIZE - sizeof(len) - len) {
*this << len;
memcpy(cursor, str, len);
cursor += len;
}
return (*this);
}
DBOutStream &DBOutStream::operator <<(StrList &strList)
{
uint16 n = 0;
char *old = cursor;
cursor += sizeof(n);
StrList::iterator i;
for (i = strList.begin(); i != strList.end(); i++) {
operator <<(*i);
n++;
}
char *p = cursor;
cursor = old;
operator <<(n);
cursor = p;
return (*this);
}
DBInStream &DBInStream::operator >>(uint8 &b)
{
if (cursor <= data + datalen - sizeof(b))
b = *cursor++;
else
b = 0;
return (*this);
}
DBInStream &DBInStream::operator >>(uint16 &w)
{
if (cursor <= data + datalen - sizeof(w)) {
w = *(uint16 *) cursor;
cursor += sizeof(w);
} else
w = 0;
return (*this);
}
DBInStream &DBInStream::operator >>(uint32 &dw)
{
if (cursor <= data + datalen - sizeof(dw)) {
dw = *(uint32 *) cursor;
cursor += sizeof(dw);
} else
dw = 0;
return (*this);
}
DBInStream &DBInStream::operator >>(string &str)
{
uint16 len;
operator >>(len);
if (cursor <= data + datalen - len && !cursor[len - 1]) {
str = cursor;
cursor += len;
} else
str = "";
return (*this);
}
DBInStream &DBInStream::operator >>(StrList &strList)
{
uint16 num;
operator >>(num);
int n = (int) num;
strList.clear();
while (n-- > 0) {
string s;
operator >>(s);
strList.push_back(s);
}
return (*this);
}
添加CPerson类：
CPerson.h:
// Person.h: interface for the CPerson class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_PERSON_H__D259A8B7_7ACB_4624_8C9E_394B11FFA5C9__INCLUDED_)
#define AFX_PERSON_H__D259A8B7_7ACB_4624_8C9E_394B11FFA5C9__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "icqdb.h"
class CPerson: public DBSerialize
{
public:
CPerson();
virtual ~CPerson();
public:
string Name;
uint16 age;
string Describe;
void save(DBOutStream &out);
void load(DBInStream &in);
};
#endif // !defined(AFX_PERSON_H__D259A8B7_7ACB_4624_8C9E_394B11FFA5C9__INCLUDED_)
Person.cpp:
// Person.cpp: implementation of the CPerson class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "TestBerkeleyDB.h"
#include "Person.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CPerson::CPerson()
{
}
CPerson::~CPerson()
{
}
void CPerson::save(DBOutStream &out)
{
out << Name << age << Describe;
}
void CPerson::load(DBInStream &in)
{
in >> Name >> age >> Describe;
}
下面是主函数：
// TestBerkeleyDB.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "TestBerkeleyDB.h"
#include "db_cxx.h"
#include "icqtypes.h"
#include "icqdb.h"
#include "Person.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// The one and only application object
CWinApp theApp;
//using namespace std;
bool delPeople(char *fileName, string index)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
Dbc *cursorp;
try {
// Database open omitted
// Get the cursor
db.cursor(NULL, &cursorp, 0);
// Set up our DBTs
Dbt data;
Dbt key;
key.set_data((void*)index.c_str());
key.set_size(index.length()+1);
// Iterate over the database, deleting each record in turn.
int ret;
while ((ret = cursorp->get(&key, &data,
DB_SET)) == 0) {
cursorp->del(0);
}
} catch(DbException &e) {
db.err(e.get_errno(), "Error!");
} catch(std::exception &e) {
db.errx("Error! %s", e.what());
}
// Cursors must be closed
if (cursorp != NULL)
cursorp->close();
db.close(0);
return true;
}
bool delPeople(char *fileName, uint32 index)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
Dbc *cursorp;
try {
// Database open omitted
// Get the cursor
db.cursor(NULL, &cursorp, 0);
// Set up our DBTs
Dbt data;
Dbt key;
key.set_data(&index);
key.set_size(sizeof(index));
// Iterate over the database, deleting each record in turn.
int ret;
while ((ret = cursorp->get(&key, &data,
DB_SET)) == 0) {
cursorp->del(0);
}
} catch(DbException &e) {
db.err(e.get_errno(), "Error!");
} catch(std::exception &e) {
db.errx("Error! %s", e.what());
}
// Cursors must be closed
if (cursorp != NULL)
cursorp->close();
db.close(0);
return true;
}
bool loadPeople(char *fileName, uint32 index, DBSerialize &obj)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
Dbt key, data;
key.set_data(&index);
key.set_size(sizeof(index));
if (db.get(NULL, &key, &data, 0) != 0) {
db.close(0);
return false;
}
DBInStream in(data.get_data(), data.get_size());
obj.load(in);
db.close(0);
return true;
}
bool loadPeople(char *fileName, string index, DBSerialize &obj)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
Dbt key, data;
key.set_data((void*)index.c_str());
key.set_size(index.length()+1);
if (db.get(NULL, &key, &data, 0) != 0) {
db.close(0);
return false;
}
DBInStream in(data.get_data(), data.get_size());
obj.load(in);
db.close(0);
return true;
}
bool savePeople(char *fileName, uint32 index, DBSerialize &obj)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
DBOutStream out;
obj.save(out);
Dbt key, data;
key.set_data(&index);
key.set_size(sizeof(index));
data.set_data(out.getData());
data.set_size(out.getSize());
int ret = db.put(NULL, &key, &data, 0) ;
db.close(0);
return (ret == 0);
}
bool savePeople(char *fileName, string index, DBSerialize &obj)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
DBOutStream out;
obj.save(out);
Dbt key, data;
key.set_data((void*)index.c_str());
key.set_size(index.length()+1);
data.set_data(out.getData());
data.set_size(out.getSize());
int ret = db.put(NULL, &key, &data, 0);
db.close(0);
return (ret == 0);
}
bool printAllPeople(char *fileName)
{
Db db(NULL, 0); // Instantiate the Db object
u_int32_t oFlags = DB_CREATE; // Open flags;
try {
// Open the database
db.open(NULL, // Transaction pointer
fileName, // Database file name
NULL, // Optional logical database name
DB_BTREE, // Database access method
oFlags, // Open flags
0); // File mode (using defaults)
// DbException is not subclassed from std::exception, so
// need to catch both of these.
} catch(DbException &e) {
// Error handling code goes here
} catch(std::exception &e) {
// Error handling code goes here
}
Dbc *cursorp;
try {
// Database open omitted
// Get the cursor
db.cursor(NULL, &cursorp, 0);
// Set up our DBTs
Dbt data;
Dbt key;
// Iterate over the database, deleting each record in turn.
int ret;
while ((ret = cursorp->get(&key, &data,
DB_NEXT)) == 0) {
//cursorp->del(0);
CPerson p;
DBInStream in(data.get_data(), data.get_size());
p.load(in);
printf("%s\n",p.Describe);
}
} catch(DbException &e) {
db.err(e.get_errno(), "Error!");
} catch(std::exception &e) {
db.errx("Error! %s", e.what());
}
// Cursors must be closed
if (cursorp != NULL)
cursorp->close();
db.close(0);
return true;
}
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
int nRetCode = 0;
// initialize MFC and print and error on failure
if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
{
// TODO: change error code to suit your needs
cerr << _T("Fatal Error: MFC initialization failed") << endl;
nRetCode = 1;
}
else
{
string index1 = "Liang Zhijian";
string index2 = "Zou Dan";
CPerson p1;
p1.age = 0;
p1.Name = "Liang Zhijian";
p1.Describe = "student1";
savePeople("mydb.db",index1,p1);
CPerson p2;
p2.age = 1;
p2.Name = "Zou Dan";
p2.Describe = "student2";
savePeople("mydb.db",index2,p2);
CPerson p3;
loadPeople("mydb.db","Liang Zhijian",p3);
printf("%s\n",p3.Describe);
printAllPeople("mydb.db");
delPeople("mydb.db","Liang Zhijian");
printAllPeople("mydb.db");
}
return nRetCode;
}
