hyperestraier/trunk/estmtdb.c

/*************************************************************************************************
 * Implementation of the MT-safe API
 *                                                      Copyright (C) 2004-2005 Mikio Hirabayashi
 * This file is part of Hyper Estraier.
 * Hyper Estraier is free software; you can redistribute it and/or modify it under the terms of
 * the GNU Lesser General Public License as published by the Free Software Foundation; either
 * version 2.1 of the License or any later version.  Hyper Estraier is distributed in the hope
 * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 * You should have received a copy of the GNU Lesser General Public License along with Hyper
 * Estraier; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA.
 *************************************************************************************************/


#include "estraier.h"
#include "estmtdb.h"
#include "myconf.h"

#define ESTMINIBNUM    31                /* bucket number of map for attributes */


/* private function prototypes */
static int est_global_lock(void);
static void est_global_unlock(void);
static int est_mtdb_lock(ESTMTDB *db);
static void est_mtdb_unlock(ESTMTDB *db);


/*************************************************************************************************
 * API for MT-safe database
 *************************************************************************************************/


/* Global mutex. */
pthread_mutex_t est_global_mutex = PTHREAD_MUTEX_INITIALIZER;
CBMAP *est_global_db_names = NULL;


/* Open a database. */
ESTMTDB *est_mtdb_open(const char *name, int omode, int *ecp){
  ESTMTDB *mtdb;
  ESTDB *db;
  char *path;
  assert(name && ecp);
  if(!est_global_lock()){
    *ecp = ESTELOCK;
    return NULL;
  }
  if(!est_global_db_names){
    est_global_db_names = cbmapopenex(ESTMINIBNUM);
    cbglobalgc(est_global_db_names, (void (*)(void *))cbmapclose);
  }
  path = est_realpath(name);
  if(cbmapget(est_global_db_names, path, -1, NULL)){
    free(path);
    *ecp = ESTEACCES;
    est_global_unlock();
    return NULL;
  }
  mtdb = cbmalloc(sizeof(ESTMTDB));
  if(!(db = est_db_open(name, omode, ecp))){
    free(path);
    est_global_unlock();
    return NULL;
  }
  free(path);
  path = est_realpath(name);
  cbmapput(est_global_db_names, path, -1, "", 0, FALSE);
  mtdb->db = db;
  mtdb->path = path;
  pthread_mutex_init(&(mtdb->mutex), NULL);
  est_global_unlock();
  return mtdb;
}


/* Close a database. */
int est_mtdb_close(ESTMTDB *db, int *ecp){
  int err;
  assert(db && ecp);
  if(!est_global_lock()){
    *ecp = ESTELOCK;
    return FALSE;
  }
  err = FALSE;
  cbmapout(est_global_db_names, db->path, -1);
  pthread_mutex_destroy(&(db->mutex));
  free(db->path);
  if(!est_db_close(db->db, ecp)) err = TRUE;
  free(db);
  est_global_unlock();
  return err ? FALSE : TRUE;
}


/* Get the last happended error code of a database. */
int est_mtdb_error(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return ESTELOCK;
  rv = est_db_error(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Check whether a database has a fatal error. */
int est_mtdb_fatal(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_fatal(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Flush index words in the cache of a database. */
int est_mtdb_flush(ESTMTDB *db, int max){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_flush(db->db, max);
  est_mtdb_unlock(db);
  return rv;
}


/* Synchronize updating contents of a database. */
int est_mtdb_sync(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_sync(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Optimize a database. */
int est_mtdb_optimize(ESTMTDB *db, int options){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_optimize(db->db, options);
  est_mtdb_unlock(db);
  return rv;
}


/* Add a document to a database. */
int est_mtdb_put_doc(ESTMTDB *db, ESTDOC *doc, int options){
  int rv;
  assert(db && doc);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_put_doc(db->db, doc, options);
  est_mtdb_unlock(db);
  return rv;
}


/* Remove a document from a database. */
int est_mtdb_out_doc(ESTMTDB *db, int id, int options){
  int rv;
  assert(db && id > 0);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_out_doc(db->db, id, options);
  est_mtdb_unlock(db);
  return rv;
}


/* Retrieve a document in a database. */
ESTDOC *est_mtdb_get_doc(ESTMTDB *db, int id, int options){
  ESTDOC *rv;
  assert(db && id > 0);
  if(!est_mtdb_lock(db)) return NULL;
  rv = est_db_get_doc(db->db, id, options);
  est_mtdb_unlock(db);
  return rv;
}


/* Retrieve the value of an attribute of a document in a database. */
char *est_mtdb_get_doc_attr(ESTMTDB *db, int id, const char *name){
  char *rv;
  assert(db && id > 0 && name);
  if(!est_mtdb_lock(db)) return NULL;
  rv = est_db_get_doc_attr(db->db, id, name);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the ID of a document spacified by URI. */
int est_mtdb_uri_to_id(ESTMTDB *db, const char *uri){
  int rv;
  assert(db && uri);
  if(!est_mtdb_lock(db)) return -1;
  rv = est_db_uri_to_id(db->db, uri);
  est_mtdb_unlock(db);
  return rv;
}


/* Extract keywords of a document object. */
CBMAP *est_mtdb_etch_doc(ESTMTDB *db, ESTDOC *doc, int max){
  CBMAP *rv;
  assert(doc && max >= 0);
  if(!est_mtdb_lock(db)) return cbmapopenex(1);
  rv = est_db_etch_doc(db->db, doc, max);
  est_mtdb_unlock(db);
  return rv;
}


/* Initialize the iterator of a database. */
int est_mtdb_iter_init(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_iter_init(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the next ID of the iterator of a database. */
int est_mtdb_iter_next(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return -1;
  rv = est_db_iter_next(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the name of a database. */
const char *est_mtdb_name(ESTMTDB *db){
  const char *rv;
  assert(db);
  if(!est_mtdb_lock(db)) return "";
  rv = est_db_name(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the number of documents in a database. */
int est_mtdb_doc_num(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return 0;
  rv = est_db_doc_num(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the number of unique words in a database. */
int est_mtdb_word_num(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return 0;
  rv = est_db_word_num(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the size of a database. */
double est_mtdb_size(ESTMTDB *db){
  double rv;
  assert(db);
  if(!est_mtdb_lock(db)) return 0.0;
  rv = est_db_size(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Search documents corresponding a condition for a database. */
int *est_mtdb_search(ESTMTDB *db, ESTCOND *cond, int *nump, CBMAP *hints){
  int *rv;
  assert(db && cond && nump);
  if(!est_mtdb_lock(db)){
    est_db_set_ecode(db->db, ESTELOCK);
    cbmapput(hints, "", 0, "0", -1, TRUE);
    *nump = 0;
    return cbmalloc(1);
  }
  rv = est_db_search(db->db, cond, nump, hints);
  est_mtdb_unlock(db);
  return rv;
}


/* Set the maximum size of the cache memory of a database. */
void est_mtdb_set_cache_size(ESTMTDB *db, size_t size, int anum, int tnum){
  assert(db);
  if(!est_mtdb_lock(db)) return;
  est_db_set_cache_size(db->db, size, anum, tnum);
  est_mtdb_unlock(db);
}


/* Set the special cache for narrowing and sorting with document attributes. */
void est_mtdb_set_special_cache(ESTMTDB *db, const char *name, int num){
  assert(db && name && num >= 0);
  if(!est_mtdb_lock(db)) return;
  est_db_set_special_cache(db->db, name, num);
  est_mtdb_unlock(db);
}


/*************************************************************************************************
 * features for experts
 *************************************************************************************************/


/* Edit attributes of a document object in a database. */
int est_mtdb_edit_doc(ESTMTDB *db, ESTDOC *doc){
  int rv;
  assert(db && doc);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_edit_doc(db->db, doc);
  est_mtdb_unlock(db);
  return rv;
}


/* Add a piece of meta data to a database. */
void est_mtdb_add_meta(ESTMTDB *db, const char *name, const char *value){
  assert(db && name);
  if(!est_mtdb_lock(db)) return;
  est_db_add_meta(db->db, name, value);
  est_mtdb_unlock(db);
}


/* Get a list of names of meta data of a database. */
CBLIST *est_mtdb_meta_names(ESTMTDB *db){
  CBLIST *rv;
  assert(db);
  if(!est_mtdb_lock(db)) return NULL;
  rv = est_db_meta_names(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the value of a piece of meta data of a database. */
char *est_mtdb_meta(ESTMTDB *db, const char *name){
  char *rv;
  assert(db && name);
  if(!est_mtdb_lock(db)) return NULL;
  rv = est_db_meta(db->db, name);
  est_mtdb_unlock(db);
  return rv;
}


/* Get the number of records in the cache memory of a database. */
int est_mtdb_cache_num(ESTMTDB *db){
  int rv;
  assert(db);
  if(!est_mtdb_lock(db)) return FALSE;
  rv = est_db_cache_num(db->db);
  est_mtdb_unlock(db);
  return rv;
}


/* Set the callback function to inform of database events. */
void est_mtdb_set_informer(ESTMTDB *db, void (*func)(const char *)){
  assert(db && func);
  if(!est_mtdb_lock(db)) return;
  est_db_set_informer(db->db, func);
  est_mtdb_unlock(db);
}


/* Set the callback function to create a vector of keywords of a document. */
void est_mtdb_set_vectorizer(ESTMTDB *db, CBMAP *(*func)(void *, int, void *), void *data){
  assert(db && func);
  if(!est_mtdb_lock(db)) return;
  est_db_set_vectorizer(db->db, func, data);
  est_mtdb_unlock(db);
}


/* Fill the cache for keys for TF-IDF. */
void est_mtdb_fill_key_cache(ESTMTDB *db){
  assert(db);
  if(!est_mtdb_lock(db)) return;
  est_db_fill_key_cache(db->db);
  est_mtdb_unlock(db);
}


/*************************************************************************************************
 * private objects
 *************************************************************************************************/


/* Lock the global environment.
   The return value is true if success, else it is false. */
static int est_global_lock(void){
  return pthread_mutex_lock(&est_global_mutex) == 0;
}


/* Unlock the global environment. */
static void est_global_unlock(void){
  pthread_mutex_unlock(&est_global_mutex);
}


/* Lock a database object.
   `db' specifies a database object.
   The return value is true if success, else it is false. */
static int est_mtdb_lock(ESTMTDB *db){
  assert(db);
  if(dpisreentrant){
    if(pthread_mutex_lock(&(db->mutex)) != 0){
      est_db_set_ecode(db->db, ESTELOCK);
      return FALSE;
    }
    return TRUE;
  }
  if(pthread_mutex_lock(&est_global_mutex) != 0){
    est_db_set_ecode(db->db, ESTELOCK);
    return FALSE;
  }
  return TRUE;
}


/* Unlock a database object.
   `db' specifies a database object. */
static void est_mtdb_unlock(ESTMTDB *db){
  assert(db);
  if(dpisreentrant){
    pthread_mutex_unlock(&(db->mutex));
  } else {
    pthread_mutex_unlock(&est_global_mutex);
  }
}


/* END OF FILE */
1	dpavlin	2	/*************************************************************************************************
2			* Implementation of the MT-safe API
3			* Copyright (C) 2004-2005 Mikio Hirabayashi
4			* This file is part of Hyper Estraier.
5			* Hyper Estraier is free software; you can redistribute it and/or modify it under the terms of
6			* the GNU Lesser General Public License as published by the Free Software Foundation; either
7			* version 2.1 of the License or any later version. Hyper Estraier is distributed in the hope
8			* that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
9			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
10			* License for more details.
11			* You should have received a copy of the GNU Lesser General Public License along with Hyper
12			* Estraier; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
13			* Boston, MA 02111-1307 USA.
14			*************************************************************************************************/
15
16
17			#include "estraier.h"
18			#include "estmtdb.h"
19			#include "myconf.h"
20
21			#define ESTMINIBNUM 31 /* bucket number of map for attributes */
22
23
24			/* private function prototypes */
25			static int est_global_lock(void);
26			static void est_global_unlock(void);
27			static int est_mtdb_lock(ESTMTDB *db);
28			static void est_mtdb_unlock(ESTMTDB *db);
29
30
31
32			/*************************************************************************************************
33			* API for MT-safe database
34			*************************************************************************************************/
35
36
37			/* Global mutex. */
38			pthread_mutex_t est_global_mutex = PTHREAD_MUTEX_INITIALIZER;
39			CBMAP *est_global_db_names = NULL;
40
41
42			/* Open a database. */
43			ESTMTDB est_mtdb_open(const char name, int omode, int *ecp){
44			ESTMTDB *mtdb;
45			ESTDB *db;
46			char *path;
47			assert(name && ecp);
48			if(!est_global_lock()){
49			*ecp = ESTELOCK;
50			return NULL;
51			}
52			if(!est_global_db_names){
53			est_global_db_names = cbmapopenex(ESTMINIBNUM);
54			cbglobalgc(est_global_db_names, (void ()(void ))cbmapclose);
55			}
56			path = est_realpath(name);
57			if(cbmapget(est_global_db_names, path, -1, NULL)){
58			free(path);
59			*ecp = ESTEACCES;
60			est_global_unlock();
61			return NULL;
62			}
63			mtdb = cbmalloc(sizeof(ESTMTDB));
64			if(!(db = est_db_open(name, omode, ecp))){
65			free(path);
66			est_global_unlock();
67			return NULL;
68			}
69			free(path);
70			path = est_realpath(name);
71			cbmapput(est_global_db_names, path, -1, "", 0, FALSE);
72			mtdb->db = db;
73			mtdb->path = path;
74			pthread_mutex_init(&(mtdb->mutex), NULL);
75			est_global_unlock();
76			return mtdb;
77			}
78
79
80			/* Close a database. */
81			int est_mtdb_close(ESTMTDB db, int ecp){
82			int err;
83			assert(db && ecp);
84			if(!est_global_lock()){
85			*ecp = ESTELOCK;
86			return FALSE;
87			}
88			err = FALSE;
89			cbmapout(est_global_db_names, db->path, -1);
90			pthread_mutex_destroy(&(db->mutex));
91			free(db->path);
92			if(!est_db_close(db->db, ecp)) err = TRUE;
93			free(db);
94			est_global_unlock();
95			return err ? FALSE : TRUE;
96			}
97
98
99			/* Get the last happended error code of a database. */
100			int est_mtdb_error(ESTMTDB *db){
101			int rv;
102			assert(db);
103			if(!est_mtdb_lock(db)) return ESTELOCK;
104			rv = est_db_error(db->db);
105			est_mtdb_unlock(db);
106			return rv;
107			}
108
109
110			/* Check whether a database has a fatal error. */
111			int est_mtdb_fatal(ESTMTDB *db){
112			int rv;
113			assert(db);
114			if(!est_mtdb_lock(db)) return FALSE;
115			rv = est_db_fatal(db->db);
116			est_mtdb_unlock(db);
117			return rv;
118			}
119
120
121			/* Flush index words in the cache of a database. */
122			int est_mtdb_flush(ESTMTDB *db, int max){
123			int rv;
124			assert(db);
125			if(!est_mtdb_lock(db)) return FALSE;
126			rv = est_db_flush(db->db, max);
127			est_mtdb_unlock(db);
128			return rv;
129			}
130
131
132			/* Synchronize updating contents of a database. */
133			int est_mtdb_sync(ESTMTDB *db){
134			int rv;
135			assert(db);
136			if(!est_mtdb_lock(db)) return FALSE;
137			rv = est_db_sync(db->db);
138			est_mtdb_unlock(db);
139			return rv;
140			}
141
142
143			/* Optimize a database. */
144			int est_mtdb_optimize(ESTMTDB *db, int options){
145			int rv;
146			assert(db);
147			if(!est_mtdb_lock(db)) return FALSE;
148			rv = est_db_optimize(db->db, options);
149			est_mtdb_unlock(db);
150			return rv;
151			}
152
153
154			/* Add a document to a database. */
155			int est_mtdb_put_doc(ESTMTDB db, ESTDOC doc, int options){
156			int rv;
157			assert(db && doc);
158			if(!est_mtdb_lock(db)) return FALSE;
159			rv = est_db_put_doc(db->db, doc, options);
160			est_mtdb_unlock(db);
161			return rv;
162			}
163
164
165			/* Remove a document from a database. */
166			int est_mtdb_out_doc(ESTMTDB *db, int id, int options){
167			int rv;
168			assert(db && id > 0);
169			if(!est_mtdb_lock(db)) return FALSE;
170			rv = est_db_out_doc(db->db, id, options);
171			est_mtdb_unlock(db);
172			return rv;
173			}
174
175
176			/* Retrieve a document in a database. */
177			ESTDOC est_mtdb_get_doc(ESTMTDB db, int id, int options){
178			ESTDOC *rv;
179			assert(db && id > 0);
180			if(!est_mtdb_lock(db)) return NULL;
181			rv = est_db_get_doc(db->db, id, options);
182			est_mtdb_unlock(db);
183			return rv;
184			}
185
186
187			/* Retrieve the value of an attribute of a document in a database. */
188			char est_mtdb_get_doc_attr(ESTMTDB db, int id, const char *name){
189			char *rv;
190			assert(db && id > 0 && name);
191			if(!est_mtdb_lock(db)) return NULL;
192			rv = est_db_get_doc_attr(db->db, id, name);
193			est_mtdb_unlock(db);
194			return rv;
195			}
196
197
198			/* Get the ID of a document spacified by URI. */
199			int est_mtdb_uri_to_id(ESTMTDB db, const char uri){
200			int rv;
201			assert(db && uri);
202			if(!est_mtdb_lock(db)) return -1;
203			rv = est_db_uri_to_id(db->db, uri);
204			est_mtdb_unlock(db);
205			return rv;
206			}
207
208
209			/* Extract keywords of a document object. */
210			CBMAP est_mtdb_etch_doc(ESTMTDB db, ESTDOC *doc, int max){
211			CBMAP *rv;
212			assert(doc && max >= 0);
213			if(!est_mtdb_lock(db)) return cbmapopenex(1);
214			rv = est_db_etch_doc(db->db, doc, max);
215			est_mtdb_unlock(db);
216			return rv;
217			}
218
219
220			/* Initialize the iterator of a database. */
221			int est_mtdb_iter_init(ESTMTDB *db){
222			int rv;
223			assert(db);
224			if(!est_mtdb_lock(db)) return FALSE;
225			rv = est_db_iter_init(db->db);
226			est_mtdb_unlock(db);
227			return rv;
228			}
229
230
231			/* Get the next ID of the iterator of a database. */
232			int est_mtdb_iter_next(ESTMTDB *db){
233			int rv;
234			assert(db);
235			if(!est_mtdb_lock(db)) return -1;
236			rv = est_db_iter_next(db->db);
237			est_mtdb_unlock(db);
238			return rv;
239			}
240
241
242			/* Get the name of a database. */
243			const char est_mtdb_name(ESTMTDB db){
244			const char *rv;
245			assert(db);
246			if(!est_mtdb_lock(db)) return "";
247			rv = est_db_name(db->db);
248			est_mtdb_unlock(db);
249			return rv;
250			}
251
252
253			/* Get the number of documents in a database. */
254			int est_mtdb_doc_num(ESTMTDB *db){
255			int rv;
256			assert(db);
257			if(!est_mtdb_lock(db)) return 0;
258			rv = est_db_doc_num(db->db);
259			est_mtdb_unlock(db);
260			return rv;
261			}
262
263
264			/* Get the number of unique words in a database. */
265			int est_mtdb_word_num(ESTMTDB *db){
266			int rv;
267			assert(db);
268			if(!est_mtdb_lock(db)) return 0;
269			rv = est_db_word_num(db->db);
270			est_mtdb_unlock(db);
271			return rv;
272			}
273
274
275			/* Get the size of a database. */
276			double est_mtdb_size(ESTMTDB *db){
277			double rv;
278			assert(db);
279			if(!est_mtdb_lock(db)) return 0.0;
280			rv = est_db_size(db->db);
281			est_mtdb_unlock(db);
282			return rv;
283			}
284
285
286			/* Search documents corresponding a condition for a database. */
287			int est_mtdb_search(ESTMTDB db, ESTCOND cond, int nump, CBMAP *hints){
288			int *rv;
289			assert(db && cond && nump);
290			if(!est_mtdb_lock(db)){
291			est_db_set_ecode(db->db, ESTELOCK);
292			cbmapput(hints, "", 0, "0", -1, TRUE);
293			*nump = 0;
294			return cbmalloc(1);
295			}
296			rv = est_db_search(db->db, cond, nump, hints);
297			est_mtdb_unlock(db);
298			return rv;
299			}
300
301
302			/* Set the maximum size of the cache memory of a database. */
303			void est_mtdb_set_cache_size(ESTMTDB *db, size_t size, int anum, int tnum){
304			assert(db);
305			if(!est_mtdb_lock(db)) return;
306			est_db_set_cache_size(db->db, size, anum, tnum);
307			est_mtdb_unlock(db);
308			}
309
310
311			/* Set the special cache for narrowing and sorting with document attributes. */
312			void est_mtdb_set_special_cache(ESTMTDB db, const char name, int num){
313			assert(db && name && num >= 0);
314			if(!est_mtdb_lock(db)) return;
315			est_db_set_special_cache(db->db, name, num);
316			est_mtdb_unlock(db);
317			}
318
319
320
321			/*************************************************************************************************
322			* features for experts
323			*************************************************************************************************/
324
325
326			/* Edit attributes of a document object in a database. */
327			int est_mtdb_edit_doc(ESTMTDB db, ESTDOC doc){
328			int rv;
329			assert(db && doc);
330			if(!est_mtdb_lock(db)) return FALSE;
331			rv = est_db_edit_doc(db->db, doc);
332			est_mtdb_unlock(db);
333			return rv;
334			}
335
336
337			/* Add a piece of meta data to a database. */
338			void est_mtdb_add_meta(ESTMTDB db, const char name, const char *value){
339			assert(db && name);
340			if(!est_mtdb_lock(db)) return;
341			est_db_add_meta(db->db, name, value);
342			est_mtdb_unlock(db);
343			}
344
345
346			/* Get a list of names of meta data of a database. */
347			CBLIST est_mtdb_meta_names(ESTMTDB db){
348			CBLIST *rv;
349			assert(db);
350			if(!est_mtdb_lock(db)) return NULL;
351			rv = est_db_meta_names(db->db);
352			est_mtdb_unlock(db);
353			return rv;
354			}
355
356
357			/* Get the value of a piece of meta data of a database. */
358			char est_mtdb_meta(ESTMTDB db, const char *name){
359			char *rv;
360			assert(db && name);
361			if(!est_mtdb_lock(db)) return NULL;
362			rv = est_db_meta(db->db, name);
363			est_mtdb_unlock(db);
364			return rv;
365			}
366
367
368			/* Get the number of records in the cache memory of a database. */
369			int est_mtdb_cache_num(ESTMTDB *db){
370			int rv;
371			assert(db);
372			if(!est_mtdb_lock(db)) return FALSE;
373			rv = est_db_cache_num(db->db);
374			est_mtdb_unlock(db);
375			return rv;
376			}
377
378
379			/* Set the callback function to inform of database events. */
380			void est_mtdb_set_informer(ESTMTDB db, void (func)(const char *)){
381			assert(db && func);
382			if(!est_mtdb_lock(db)) return;
383			est_db_set_informer(db->db, func);
384			est_mtdb_unlock(db);
385			}
386
387
388			/* Set the callback function to create a vector of keywords of a document. */
389			void est_mtdb_set_vectorizer(ESTMTDB db, CBMAP (func)(void , int, void ), void data){
390			assert(db && func);
391			if(!est_mtdb_lock(db)) return;
392			est_db_set_vectorizer(db->db, func, data);
393			est_mtdb_unlock(db);
394			}
395
396
397			/* Fill the cache for keys for TF-IDF. */
398			void est_mtdb_fill_key_cache(ESTMTDB *db){
399			assert(db);
400			if(!est_mtdb_lock(db)) return;
401			est_db_fill_key_cache(db->db);
402			est_mtdb_unlock(db);
403			}
404
405
406
407			/*************************************************************************************************
408			* private objects
409			*************************************************************************************************/
410
411
412			/* Lock the global environment.
413			The return value is true if success, else it is false. */
414			static int est_global_lock(void){
415			return pthread_mutex_lock(&est_global_mutex) == 0;
416			}
417
418
419			/* Unlock the global environment. */
420			static void est_global_unlock(void){
421			pthread_mutex_unlock(&est_global_mutex);
422			}
423
424
425			/* Lock a database object.
426			`db' specifies a database object.
427			The return value is true if success, else it is false. */
428			static int est_mtdb_lock(ESTMTDB *db){
429			assert(db);
430			if(dpisreentrant){
431			if(pthread_mutex_lock(&(db->mutex)) != 0){
432			est_db_set_ecode(db->db, ESTELOCK);
433			return FALSE;
434			}
435			return TRUE;
436			}
437			if(pthread_mutex_lock(&est_global_mutex) != 0){
438			est_db_set_ecode(db->db, ESTELOCK);
439			return FALSE;
440			}
441			return TRUE;
442			}
443
444
445			/* Unlock a database object.
446			`db' specifies a database object. */
447			static void est_mtdb_unlock(ESTMTDB *db){
448			assert(db);
449			if(dpisreentrant){
450			pthread_mutex_unlock(&(db->mutex));
451			} else {
452			pthread_mutex_unlock(&est_global_mutex);
453			}
454			}
455
456
457
458			/* END OF FILE */