Berkeley DB for C（2）

Berkeley DB for C（2）

DB中存储结构体

       如果结构体中不包含指针，则你可以跟存储普通类型的数据一样，安全的使用。

       存储不带指针的结构体示例：

#include <db.h>

#include <string.h>

typedef struct my_struct {

int id;

char familiar_name[MAXLINE]; /* MAXLINE是一个常量 */

char surname[MAXLINE];

} MY_STRUCT;

...

DBT key, data;

DB *my_database;

MY_STRUCT user;

char *fname = "David";

       char *sname = "Rider";

/* 给结构体赋值*/

user.id = 1;

strncpy(user.familiar_name, fname, strlen(fname)+1);

strncpy(user.surname, sname, strlen(sname)+1);

/* 初始化key和data */

memset(&key, 0, sizeof(DBT));

memset(&data, 0, sizeof(DBT));

key.data = &(user.id);

key.size = sizeof(int);

data.data = &user;

data.size = sizeof(MY_STRUCT);

//调用PUT方法，赋值

my_database->put(my_database, NULL, &key, &data, DB_NOOVERWRITE);

从db中读出结构体的数据

#include <db.h>

#include <string.h>

...

DBT key, data;

DB *my_database;

MY_STRUCT user;

/* 在使用前初始化key和data */

memset(&key, 0, sizeof(DBT));

memset(&data, 0, sizeof(DBT));

/* 把结构体在内存中的地址赋给memset */

memset(&user, 0, sizeof(MY_STRUCT));

user.id = 1;

key.data = &user.id;

key.size = sizeof(int);

/* 把结构体user的地址赋给data */

data.data = &user;

data.ulen = sizeof(MY_STRUCT);

data.flags = DB_DBT_USERMEM;

my_database->get(my_database, NULL, &key, &data, 0);

//可以直接使用了，已经把取到的数据赋予了结构体

printf("Familiar name: %s/n", user.familiar_name);

printf("Surname: %s/n", user.surname);

 

存储和读取带指针的结构体

       在C中结构体中使用指针是一个很常见的想象，比如可以用一个char[]类型的指针指向一个字符串。如果想要在DB中存储带指针的结构头，必须确保结构体中的所有数据在内存中是一个连续的块。所以说在存储结构体的时候需要对数据先进行一下转换。

       使用带指针的结构体示例：

       #include <db.h>

#include <string.h>

#include <stdlib.h>

//定义结构体

typedef struct my_struct {

int id;

char *familiar_name;//注意这里又指针

char *surname;

} MY_STRUCT;

...

DBT key, data;

DB *my_database;

MY_STRUCT user;

int buffsize, bufflen;

char fname[ ] = "Pete";

char sname[10];

char *databuff;

strncpy(sname, "Oar", strlen("Oar")+1);

/* 先给结构体赋值 */

user.id = 1;

user.familiar_name = fname;

user.surname = sname;

/* 计算结构体中存储的数据长度，包括指针所指向的数据的长度 */

buffsize = sizeof(int) +

(strlen(user.familiar_name) + strlen(user.surname) + 2);

//申请一个连续的内存块

databuff = malloc(buffsize);

memset(databuff, 0, buffsize);

/* 把数据COPY到申请的内存块中 */

memcpy(databuff, &(user.id), sizeof(int));

bufflen = sizeof(int);

//把指针所指向的数据也COPY过去，注意偏移量的计算

memcpy(databuff + bufflen, user.familiar_name,

strlen(user.familiar_name) + 1);

bufflen += strlen(user.familiar_name) + 1;

memcpy(databuff + bufflen, user.surname,

strlen(user.surname) + 1);

bufflen += strlen(user.surname) + 1;

/* 现在开始存储 */

/* 初始化数据. */

memset(&key, 0, sizeof(DBT));

memset(&data, 0, sizeof(DBT));

//设置key

key.data = &(user.id);

key.size = sizeof(int);

//设置data

data.data = databuff;//实际上传的是内存的块的起始地址

data.size = bufflen;//内存块的长度

my_database->put(my_database, NULL, &key, &data, DB_NOOVERWRITE);//存储数据

free(sname);//释放变量

free(databuff);//释放

 

从db中接手带指针的结构体示例：

       #include <db.h>

#include <string.h>

#include <stdlib.h>

typedef struct my_struct {

char *familiar_name;

char *surname;

int id;

} MY_STRUCT;

...

int id;

DBT key, data;

DB *my_database;

MY_STRUCT user;

char *buffer;

/* 初始化key和value */

memset(&key, 0, sizeof(DBT));

memset(&data, 0, sizeof(DBT));

id = 1;

key.data = &id;

key.size = sizeof(int);

my_database->get(my_database, NULL, &key, &data, 0);

/*

* 很多编译器不允许使用void类型，所以可以使用char类型来代替

* 分别指定每个指针在内存块中的地址（需要自己根据每块数据的大小来判断的）

*/

buffer = data.data;

user.id = *((int *)data.data);

user.familiar_name = buffer + sizeof(int);

user.surname = buffer + sizeof(int) + strlen(user.familiar_name) + 1;