dbm数据库源代码分析(5)：gdbmopen.c和gdbmclose.c

   现在解剖gdbmopen.c和gdbmclose.c的源码。
   gdbmopen.c包含打开数据库的函数gdbm_oepen和初始化桶缓存的函数_gdbm_init_cache。注意其中的函数签名格式，函数参数列表中没给出类型，类型信息在圆括号和语句开始的左花括号之间。这种风格的函数签名是为了兼容老式的非标准的C编译器，gcc也支持这种风格的函数签名。

 

   （1）gdbm_file_info* gdbm_oepen(name,block_size,flags,mode,fatal_func)函数。name是指向文件名指针。注意这个函数返回一个指向gdbm_file_info结构的指针变量（称为文件句柄），而在导出的头文件中（参看gdbm.proto），此函数声明返回的是GDBM_FILE型变量，也是一个指针变量。由于都是指针型变量，即都是int型，存放的是一个地址值，因此是一致的。至于这个指针具体指向什么类型的结构，对用户来说无关紧要，他只需使用这个句柄来操作文件，并不需要知道结构中的具体内容。因此为了隐藏实现，在导出的用户接口中我们通常让这个返回的指针变量指向一个“虚设”的无实际用途的结构，这样用户就不会知道gdbm_file_info结构的具体内容，但同时又不要影响他对接口的使用。这就是为什么gdbm.proto中要定义一个GDBM_FILE型的指针变量指向一个“虚设”的结构。在其他导出的用户接口中，这个打开的文件句柄dbf也被声明为GDBM_FILE类型的指针变量，在具体的函数实现时，dbf实际上是指向打开的gdbm_file_info结构的。

   函数执行时，如果文件大小为0字节，则执行一个文件初始化过程，设置文件中的一些初始结构。block_size用来在初始化过程中确定各个结构的大小，如果它的值小于512，则使用文件系统的默认值，否则就使用这个传进来的block_size值。如果文件事先已经初始化过了，则忽略block_size值。如果flags设置为GDBM_READER，用户以只读方式访问数据库，则任何对dbm_store或dbm_delete的调用都将会失败。多个用户可同时访问一个数据库（使用文件锁）。如果flag设置为GDBM_WRITER，说明用户以可读写方式访问数据库，这需要一个排它锁。如果flags是GDBM_WRCREAT，则用户以可读写的的方式访问数据库，且当数据库不存在时，创建一个新的数据库（也是可读写的）。整个过程中任何的操作出错都将导致返回NULL，并且把错误码设置到全局变量gdbm_errno中。如果没有错误发生，将返回一个指向gdbm文件结构的指针。
   gdbm_open的执行流程：
   1）创建文件结构dbf并分配空间，然后一些指针域被初始化为空；
   2）为文件名的字符串存储分配空间，然后保存文件名；
   3）初始化错误处理函数及一些访问标志；
   4）根据flags确定是否设置快速写模式；
   5）根据flags用open函数打开文件，获得其文件描述符；
   6）获取文件的状态信息，然后以适当的方式（共享锁或排它锁）锁定文件；
   7）根据状态信息确定打开的是新文件还是已经存在的数据库文件；
   8）若是新文件（即文件大小为0字节），则
      a）设置传递块的大小；
      b）为文件头分配空间，设置其魔数和传递块大小；
      c）创建要跟踪的散列桶目录表，并分配空间；
      d）创建文件头要跟踪的散列桶，先计算桶中元素个数，然后分配空间；
      f）调用_gdbm_new_bucket初始化这个新桶并设置其中的一些标志，然后初始化每个目录项；
      g）将所有这些初始化信息写入文件，开始是文件头和活动的可用块，接着是目录表，最后是桶。
   9）若是一个已经存在的数据库文件，则
      a）读取文件中的文件头，并用魔数对其进行校验；
      b）为我们的文件头分配空间，并设置为所读取的文件头信息；
      c）为我们的散列表目录分配空间，并设置为所读取的散列表目录。
   10）完成文件的操作后，将dbf中其他的指针域（如桶缓存）初始化为空，并完成记帐信息的初始化；
   11）返回最终的文件信息结构指针dbf。
   注意我们要获取的文件的各项信息，如文件头、散列桶目录表、第一个散列桶等，被读入到了内存（若是新文件则直接在内存中创建），并且在dbf中都有指针指向它。
   我们知道，数据库文件中只包含gdbm_file_header（其中包含avail_block及avail_elem）、dir[dir_size/4]、hash_bucket（其中包含bucket_element）。在初始化新文件时，会先截断文件，表示文件将从位置0处开始初始化。gdbm_file_header本身只有52个字节，但初始化时它要占blocksize个字节（此参数由用户指定，但不能小于512，小于512时会重设为文件系统的默认值，目前Linux上一般为1024），空出来的部分用来存放avail_elem元素列表（指明可用存储块的实际位置和大小）。文件头中的block_size域、dir_size域都会被初始化为blocksize，dir_bits为其所占的二进制位数。可见散列桶目录表中有blocksize/4个目录项（每个目录项为off_t类型，即long，占4个字节），且整个散列桶目录表共占blocksize个字节。目录表跟在文件头之后，因此文件头中的指向目录表起始地址的dir域恰好初始化为blocksize。
   一个hash_bucket本身只有80个字节，但初始化时它也要占blocksize个字节，因此文件头的中bucket_size域也被初始化为blocksize。后面空出的部分用来存放以后分裂出来的bucket_element[]列表（即可扩展散列表），能存放的桶元素个数为(blocksize-sizeof(hash_bucket))/sizeof(bucket_element)+1 = (blocksize-80)/20+1，加1是因为hash_bucket中那个活动的bucket_element也要算进去。这个值会设置到文件头的bucket_elems域中去。这样bucket_elems记录了一个blocksize个字节的hash_bucket总共能存放的bucket_element个数。在用_gdbm_new_bucket初始化这个hash_bucket时，bucket_bits标识域和count域设为0，每个桶元素的哈希值hash_val初始化为-1。然后可用块个数av_count设为1，表示桶对应了1个分配的可用存储块（目前一个hash_bucket最多只能对应6个可用存储块），用bucket_avail[0]（avail_elem结构）指明这个可用块。这个可用块紧跟在hash_bucket之后，因此它的地址av_adr为3*blocksize，可用块的大小av_size也设置为blocksize。
   之后，对目录表中的每个目录项以及文件头中的活动的可用块进行初始化。由于初始时只有一个hash_bucket，因此dir[0...dir_size/4-1]中的每个目录项初始时都指向这个hash_bucket。文件头中的avail（avail_block类型）的size域表示文件头空间中能存储的avail_elem元素个数，它的值为(blocksize-sizeof(gdbm_file_header))/sizeof(avail_elem)+1 = (blocksize-52)/8+1，加1是因为avail中的那个活动的avail_elem也要算进去。这样avail.size记录了一个blocksize个字节的文件头总共能存放的avail_elem个数。avail的count和next_block（下一个可用块的偏移地址）均初始化为0。文件头的next_block指针表示下一个未分配可用块地址，因此要初始化为4*blocksize。所有工作做完后，把这些数据按顺序写入到文件中。
   可见，数据库文件上的排布为：文件头、目录表、散列桶，每一部分都占blocksize个字节。后面接着的就是存放关键字/数据的可用块，每个可用块也占blocksize个字节。散列桶可以对可用块及块中的关键字/数据（这是我们需要的）进行定位、查找、存取等。
   （2）int _gdbm_init_cache(dbf,size)函数。用于初始化桶缓存数组。dbf为文件信息结构，size为桶缓存中缓存项的个数，默认为DEFAULT_CACHESIZE，在gdbmconst.h中定义，为100。桶缓存为一个数组，每个元素为一个缓存项（cache_elem），缓存项不仅包含了实际的桶指针，还包含了数据缓存块及一些标志。数据缓存块包含包含哈希值、数据长度、关键字长度、指向数据起点的指针、偏移位置值等字段。
   函数执行流程如下：
   1）根据size参数为桶楥存数组分配空间；
   2）初始化每个缓存项持有的桶，并分配空间；
   3）初始化每个缓存项的的数据缓存块；
   4）设置文件信息结构中的当前桶和当前缓存项指针；
   5）成功，返回0。
   dbf中的cache_size域是缓存项的个数，初始化为size；bucket域初始化为指向第一个缓存项持有的桶；cache_entry域初始化为指向第一个缓存项。每个缓存项的桶偏移地址ca_adr初始化为0，其数据缓存元素的hash_val和elem_loc初始化为-1，数据起点指针dptr初始化NULL。
/* gdbmopen.c - 打开dbm文件，并且初始化要使用的数据结构 *//* 先包含系统相关配置 */#include "autoconf.h" /* 包含平台相关头文件和函数的常量标志 */#include "gdbmdefs.h" /* 包含桶、缓存项、数据库文件结构的定义 所有平台相关的头文件和函数声明、gdbm的所有函数声明和要用到的常量也在这里 */#include "gdbmerrno.h" /* 包含所有的错误码列表 *//* 打开数据库文件，不存在时则创建新的数据库文件，并执行一个文件初始化过程 */gdbm_file_info *gdbm_open (file, block_size, flags, mode, fatal_func) char *file; /* 要打开的文件名 */ int block_size; /* 设置内存与磁盘IO传递数据的单位，最小为512字节 */ int flags; /* 文件打开标志，可以是gdbmconst.h中定义的标志GDMB_READER、 GDMB_WRITER */ int mode; /* 文件创建模式，与open（2）函数相同 */ void (*fatal_func) (); /* 错误处理函数 */{ gdbm_file_info *dbf;/* 要返回的文件结构记录 */ struct stat file_stat;/* 封装文件信息stat结构 */ int len;/* 文件名的长度 */ int num_bytes;/* 在读和写的过程中使用 */ off_t file_pos;/* 文件读写位置 */ int lock_val; /* Returned by the flock call. */ int file_block_size;/* 传递的数据块大小（用于新文件） */ int index;/* 作为循环索引 */ char need_trunc;/* 是否需要截断处理，在使用GDBM_NEWDB和锁时需要截断，以避免在只读 的方式下截断文件 */ gdbm_errno = GDBM_NO_ERROR; /* 初始化变量gdbm_errno */ /* 为一个新的文件结构分配空间 */ dbf = (gdbm_file_info *) malloc (sizeof (gdbm_file_info)); if (dbf == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; /* 设置内存分配错误码 */ return NULL; } /* 先初始化一些域为空，这样如果在分配这些结构前gdbm_close被调用，则也能正常工作 */ dbf->dir = NULL; dbf->bucket = NULL; dbf->header = NULL; dbf->bucket_cache = NULL; dbf->cache_size = 0; /* 保存文件名 */ len = strlen (file); dbf->name = (char *) malloc (len + 1); /* 为文件名分配内存空间 */ if (dbf->name == NULL) /* 若分配未成功，则释放已分配的文件结构，直接返回 */ { free (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL; } strcpy (dbf->name, file); /* 保存好文件名 */ /* 初始化错误处理函数 */ dbf->fatal_err = fatal_func; dbf->fast_write = TRUE;/* 默认为快速写模式 */ dbf->file_locking = TRUE;/* 默认需要文件锁 */ dbf->central_free = FALSE;/* 默认不使用central_free */ dbf->coalesce_blocks = FALSE; /* 默认不合并空闲块 */ /* GDBM_FAST用来确定是否设置快速写模式 */ if (flags & GDBM_SYNC) { /* 如果GDBM_SYNC被设置，则不做快速写 */ dbf->fast_write = FALSE; } if (flags & GDBM_NOLOCK) /* 如果设置了无需文件锁标志 */ { dbf->file_locking = FALSE; } /* 打开文件 */ need_trunc = FALSE; switch (flags & GDBM_OPENMASK) /* 掩码可以掩掉除尾三位的所有其他位 */ { case GDBM_READER: /* 只读方式打开 */dbf->desc = open (dbf->name, O_RDONLY, 0);break; case GDBM_WRITER: /* 可写方式打开 */dbf->desc = open (dbf->name, O_RDWR, 0);break; case GDBM_NEWDB: /* 要创建新文件（O_CREATE标志），则要使用mode参数 */dbf->desc = open (dbf->name, O_RDWR|O_CREAT, mode);need_trunc = TRUE;break; default:dbf->desc = open (dbf->name, O_RDWR|O_CREAT, mode);break;bucket_cache } if (dbf->desc < 0) { free (dbf->name); free (dbf); gdbm_errno = GDBM_FILE_OPEN_ERROR; /* 设置打开文件错误 */ return NULL; } /* 获取文件的状态信息 */ fstat (dbf->desc, &file_stat); /* 以适当的方式锁定文件 */ if ((flags & GDBM_OPENMASK) == GDBM_READER) /* 只读时的锁写 */ { if (file_stat.st_size == 0) /* 文件大小为0，即读的是一个空文件 */{ close (dbf->desc); free (dbf->name); free (dbf); gdbm_errno = GDBM_EMPTY_DATABASE; /* 设置读取空数据库错误 */ return NULL;} if (dbf->file_locking){ /* 只读方式锁定文件（共享锁），成功则会设置lock_val为0，参看system.h */ READLOCK_FILE(dbf);} } else if (dbf->file_locking) /* 否则加可写锁 */ { /* 可写方式锁定文件（排它锁），成功则会设置lock_val为0，参看system.h */ WRITELOCK_FILE(dbf); } if (dbf->file_locking && (lock_val != 0)) /* 锁定未成功 */ { close (dbf->desc); free (dbf->name); free (dbf); if ((flags & GDBM_OPENMASK) == GDBM_READER)gdbm_errno = GDBM_CANT_BE_READER; /* 设置为不能加共享锁 */ elsegdbm_errno = GDBM_CANT_BE_WRITER; /* 设置为不能加排它锁 */ return NULL; } /* 设置读写标志 */ dbf->read_write = (flags & GDBM_OPENMASK); /* 若我们有一个排它锁，且打开标志为GDBM＿NEWDB，则要截断文件，即把文件长度设为0，丢弃已有内容 */ if (need_trunc && file_stat.st_size != 0) { TRUNCATE (dbf); /* 截断文件，参看system.h */ fstat (dbf->desc, &file_stat); /* 重新获得文件的状态信息 */ } /* 确定它是新文件还是旧文件 */ if (file_stat.st_size == 0) /* 是一个新文件，创建一个新数据库 */ { /* 先设置内存和磁盘间传递块的大小，不能小于512字节 */ if (block_size < 512)file_block_size = STATBLKSIZE; /* 参看system.h */ elsefile_block_size = block_size; /* 为文件头分配空间 */ dbf->header = (gdbm_file_header *) malloc (file_block_size); if (dbf->header == NULL){ gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL;} /* 设置文件头的魔数和传递块的大小 */ dbf->header->header_magic = 0x13579ace; dbf->header->block_size = file_block_size; /* 创建初始的散列桶目录表 */ dbf->header->dir_size = 8 * sizeof (off_t); /* 初始的目录表大小 */ dbf->header->dir_bits = 3; /* 初始时目录地址占用的比特数为3位 */ while (dbf->header->dir_size < dbf->header->block_size) /* 使得目录表大小与传递块的大小相等 */{ dbf->header->dir_size <<= 1; dbf->header->dir_bits += 1;} /* 最后dir_size=block_size=2^dir_bits */ /* 检查目录项的正确性 */ if (dbf->header->dir_size != dbf->header->block_size){ gdbm_close (dbf); gdbm_errno = GDBM_BLOCK_SIZE_ERROR; /* 传递块大小错误 */ return NULL;} /* 为散列桶目录表分配空间 */ dbf->dir = (off_t *) malloc (dbf->header->dir_size); if (dbf->dir == NULL){ gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL;} dbf->header->dir = dbf->header->block_size; /* 指向目录表起始地址 */ /* 创建首个也是唯一的散列桶 */ dbf->header->bucket_elems =(dbf->header->block_size - sizeof (hash_bucket))/ sizeof (bucket_element) + 1; /* 计算桶中元素的个数 */ dbf->header->bucket_size = dbf->header->block_size; /* 桶的大小为传递块的大小 */ dbf->bucket = (hash_bucket *) malloc (dbf->header->bucket_size); /* 为桶分配内存空间 */ if (dbf->bucket == NULL){ gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL;} _gdbm_new_bucket (dbf, dbf->bucket, 0); /* 初始化这个新桶 */ dbf->bucket->av_count = 1; /* 设置桶对应可用块的个数 */ dbf->bucket->bucket_avail[0].av_adr = 3*dbf->header->block_size; dbf->bucket->bucket_avail[0].av_size = dbf->header->block_size; /* 目录表中的每个目录项指向一个散列桶 */ for (index = 0; index < dbf->header->dir_size / sizeof (off_t); index++)dbf->dir[index] = 2*dbf->header->block_size; /* 初始化活动的可用块 */ dbf->header->avail.size= ( (dbf->header->block_size - sizeof (gdbm_file_header)) / sizeof (avail_elem)) + 1; /* 可用块中可用块元素的个数 */ dbf->header->avail.count = 0; dbf->header->avail.next_block = 0; /* 下一个可用块的偏移地址 */ dbf->header->next_block = 4*dbf->header->block_size; /* 将初始化配置信息写入文件 */ /* 块0是文件头和活动的可用块 */ num_bytes = write (dbf->desc, dbf->header, dbf->header->block_size); /* block_size一般为1024 */ if (num_bytes != dbf->header->block_size) /* 实际必须要写入block_size个字节，否则出错 */{ gdbm_close (dbf); gdbm_errno = GDBM_FILE_WRITE_ERROR; /* 文件写入错误 */ return NULL;} /* 块1是初始的散列桶目录表 */ num_bytes = write (dbf->desc, dbf->dir, dbf->header->dir_size); if (num_bytes != dbf->header->dir_size){ gdbm_close (dbf); gdbm_errno = GDBM_FILE_WRITE_ERROR; return NULL;} /* 块2是这个唯一的桶 */ num_bytes = write (dbf->desc, dbf->bucket, dbf->header->bucket_size); if (num_bytes != dbf->header->bucket_size){ gdbm_close (dbf); gdbm_errno = GDBM_FILE_WRITE_ERROR; return NULL;} /* 等待初始化配置信息被写入磁盘 */ fsync (dbf->desc); free (dbf->bucket); } else /* 否则是一个已经存在的数据，从其文件头中读取信息，然后初始化散列目录 */ { gdbm_file_header partial_header; /* 第1部分 */ /* 读取文件头部分 */ num_bytes = read (dbf->desc, &partial_header, sizeof (gdbm_file_header)); if (num_bytes != sizeof (gdbm_file_header)){ gdbm_close (dbf); gdbm_errno = GDBM_FILE_READ_ERROR; /* 读取文件错误 */ return NULL;} /* 用魔数来校验文件的头是否完好 */ if (partial_header.header_magic != 0x13579ace){ gdbm_close (dbf); gdbm_errno = GDBM_BAD_MAGIC_NUMBER; /* 文件头校验出错 */ return NULL;} /* 是一个完好的数据，则读取整个文件头 */ dbf->header = (gdbm_file_header *) malloc (partial_header.block_size); if (dbf->header == NULL){ gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL;} bcopy (&partial_header, dbf->header, sizeof (gdbm_file_header)); num_bytes = read (dbf->desc, &dbf->header->avail.av_table[1],dbf->header->block_size-sizeof (gdbm_file_header)); if (num_bytes != dbf->header->block_size-sizeof (gdbm_file_header)){ gdbm_close (dbf); gdbm_errno = GDBM_FILE_READ_ERROR; return NULL;} /* 为散列表目录分配空间 */ dbf->dir = (off_t *) malloc (dbf->header->dir_size); if (dbf->dir == NULL){ gdbm_close (dbf); gdbm_errno = GDBM_MALLOC_ERROR; return NULL;} /* 读取散列表目录 */ file_pos = lseek (dbf->desc, dbf->header->dir, L_SET); /* L_SET表示一个绝对位置 */ if (file_pos != dbf->header->dir){ gdbm_close (dbf); gdbm_errno = GDBM_FILE_SEEK_ERROR; return NULL;} num_bytes = read (dbf->desc, dbf->dir, dbf->header->dir_size); if (num_bytes != dbf->header->dir_size){ gdbm_close (dbf); gdbm_errno = GDBM_FILE_READ_ERROR; return NULL;} } /* 完成dbf的初始化 */ dbf->last_read = -1; dbf->bucket = NULL; dbf->bucket_dir = 0; dbf->cache_entry = NULL; dbf->header_changed = FALSE; dbf->directory_changed = FALSE; dbf->bucket_changed = FALSE; dbf->second_changed = FALSE; /* 大功告成，返回文件信息结构的指针 */ return dbf;}/* 桶缓存的初始化工作：为缓存分配空间，初始化每个缓存项，初始化缓存项持有的桶和数据缓存元素， 设置文件的桶缓存指针、缓存大小、当前桶及当前缓存项等 */int_gdbm_init_cache(dbf, size) gdbm_file_info *dbf; /* 数据库文件结构的指针 */ int size; /* 缓存的大小（即缓存项的个数） */{register int index; if (dbf->bucket_cache == NULL) { /* 为缓存分配内存空间 */ dbf->bucket_cache = (cache_elem *) malloc(sizeof(cache_elem) * size); if(dbf->bucket_cache == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; /* 设置内存分配错误标志 */ return(-1); } dbf->cache_size = size; /* 设置缓存项的个数 */ for(index = 0; index < size; index++) /* 初始化每个缓存项及其中的数据缓存元素 */ { (dbf->bucket_cache[index]).ca_bucket = (hash_bucket *) malloc (dbf->header->bucket_size); /* 为桶分配内存空间 */ if ((dbf->bucket_cache[index]).ca_bucket == NULL) { gdbm_errno = GDBM_MALLOC_ERROR; /* 设置内存分配错误标志 */ return(-1); } (dbf->bucket_cache[index]).ca_adr = 0; /* 缓存项的偏移地址初始化为0 */ (dbf->bucket_cache[index]).ca_changed = FALSE; /* 更改标志初始为FALSE */ (dbf->bucket_cache[index]).ca_data.hash_val = -1; /* 数据缓存元素的哈希值初始化为-1 */ (dbf->bucket_cache[index]).ca_data.elem_loc = -1; /* 数据缓存元素的位置偏移初始化为-1 */ (dbf->bucket_cache[index]).ca_data.dptr = NULL; /* 数据缓存元素的数据起点初始化NULL */ } dbf->bucket = dbf->bucket_cache[0].ca_bucket; /* 文件的当前桶设为缓存中的第一个实际桶 */ dbf->cache_entry = &dbf->bucket_cache[0]; /* 文件的当前缓存项设为第一个缓存项 */ } return(0);}
   (3)gdbm_close.c中的唯一一个函数void gdbm_close(dbf)。dbf为事先打开的数据库文件句柄。
   执行流程如下：
   1）确保未写入的数据全部写入到磁盘；
   2）若加了锁，则对文件解锁；
   3）关闭文件，释放文件名和散列目录表；
   4）对每个缓存项，释放其持有的桶、其数据缓存元素中的数据；
   5）释放整个桶缓存（即所有的缓存项）；
   6）最后释放文件头和文件信息结构。

/* gdbmclose.c - 关闭一个事先打开的dbm文件 */#include "autoconf.h" /* 包含平台相关头文件和函数的常量标志 */#include "gdbmdefs.h" /* 包含桶、缓存项、数据库文件结构的定义 所有平台相关的头文件和函数声明、gdbm的所有函数声明和要用到的常量也在这里 *//* 关闭dbm文件，并释放与dbf关联的所有内存。在释放dbf的成员之前，要检查并确保它们被分配了空间 */voidgdbm_close (dbf) gdbm_file_info *dbf;{ register int index;/* 用来释放桶缓存的索引 */ /* 确保数据库已经全部写入了磁盘 */ if (dbf->read_write != GDBM_READER) fsync (dbf->desc); /* 将未写入的数据全部写入磁盘 */ /* 关闭文件并且释放所有的被分配的内存 */ if (dbf->file_locking) { UNLOCK_FILE(dbf); /* 对文件解锁 */ } close (dbf->desc); /* 关闭文件 */ free (dbf->name); /* 释放文件名 */ if (dbf->dir != NULL) free (dbf->dir); /* 释放散列目录表 */ if (dbf->bucket_cache != NULL) { for (index = 0; index < dbf->cache_size; index++) { /* 释放每个缓存项中的相应域 */ if (dbf->bucket_cache[index].ca_bucket != NULL) free (dbf->bucket_cache[index].ca_bucket); /* 释放缓存项所持有的桶 */ if (dbf->bucket_cache[index].ca_data.dptr != NULL)free (dbf->bucket_cache[index].ca_data.dptr); /* 释放缓存项中数据缓存元素的数据 */ } free (dbf->bucket_cache); /* 释放整个桶缓存 */ } if ( dbf->header != NULL ) free (dbf->header); /* 释放文件头 */ free (dbf); /* 最后释放文件信息结构 */}