1 /* DO NOT EDIT: automatically built by dist/s_vxworks. */
3 * See the file LICENSE for redistribution information.
5 * Copyright (c) 1997, 2012 Oracle and/or its affiliates. All rights reserved.
15 // To ensure portability to many platforms, both new and old, we make
16 // few assumptions about the C++ compiler and library. For example,
17 // we do not expect STL, templates or namespaces to be available. The
18 // "newest" C++ feature used is exceptions, which are used liberally
19 // to transmit error information. Even the use of exceptions can be
20 // disabled at runtime, to do so, use the DB_CXX_NO_EXCEPTIONS flags
21 // with the DbEnv or Db constructor.
23 // C++ naming conventions:
25 // - All top level class names start with Db.
26 // - All class members start with lower case letter.
27 // - All private data members are suffixed with underscore.
28 // - Use underscores to divide names into multiple words.
29 // - Simple data accessors are named with get_ or set_ prefix.
30 // - All method names are taken from names of functions in the C
31 // layer of db (usually by dropping a prefix like "db_").
32 // These methods have the same argument types and order,
33 // other than dropping the explicit arg that acts as "this".
35 // As a rule, each DbFoo object has exactly one underlying DB_FOO struct
36 // (defined in db.h) associated with it. In some cases, we inherit directly
37 // from the DB_FOO structure to make this relationship explicit. Often,
38 // the underlying C layer allocates and deallocates these structures, so
39 // there is no easy way to add any data to the DbFoo class. When you see
40 // a comment about whether data is permitted to be added, this is what
41 // is going on. Of course, if we need to add data to such C++ classes
42 // in the future, we will arrange to have an indirect pointer to the
43 // DB_FOO struct (as some of the classes already have).
46 ////////////////////////////////////////////////////////////////
47 ////////////////////////////////////////////////////////////////
49 // Forward declarations
54 #define HAVE_CXX_STDHEADERS 1
55 #ifdef HAVE_CXX_STDHEADERS
58 #define __DB_STD(x) std::x
61 #include <exception.h>
69 class DbChannel; // forward
70 class DbEnv; // forward
71 class DbHeapRecordId; // forward
72 class DbInfo; // forward
73 class DbLock; // forward
74 class DbLogc; // forward
75 class DbLsn; // forward
76 class DbMpoolFile; // forward
77 class DbPreplist; // forward
78 class DbSequence; // forward
79 class DbSite; // forward
81 class DbTxn; // forward
83 class DbMultipleIterator; // forward
84 class DbMultipleKeyDataIterator; // forward
85 class DbMultipleRecnoDataIterator; // forward
86 class DbMultipleDataIterator; // forward
88 class DbException; // forward
89 class DbDeadlockException; // forward
90 class DbLockNotGrantedException; // forward
91 class DbMemoryException; // forward
92 class DbRepHandleDeadException; // forward
93 class DbRunRecoveryException; // forward
95 ////////////////////////////////////////////////////////////////
96 ////////////////////////////////////////////////////////////////
98 // Turn off inappropriate compiler warnings
103 // These are level 4 warnings that are explicitly disabled.
104 // With Visual C++, by default you do not see above level 3 unless
105 // you use /W4. But we like to compile with the highest level
106 // warnings to catch other errors.
108 // 4201: nameless struct/union
109 // triggered by standard include file <winnt.h>
111 // 4514: unreferenced inline function has been removed
112 // certain include files in MSVC define methods that are not called
114 #pragma warning(push)
115 #pragma warning(disable: 4201 4514)
119 ////////////////////////////////////////////////////////////////
120 ////////////////////////////////////////////////////////////////
122 // Mechanisms for declaring classes
126 // Every class defined in this file has an _exported next to the class name.
127 // This is needed for WinTel machines so that the class methods can
128 // be exported or imported in a DLL as appropriate. Users of the DLL
129 // use the define DB_USE_DLL. When the DLL is built, DB_CREATE_DLL
132 #if defined(_MSC_VER)
134 # if defined(DB_CREATE_DLL)
135 # define _exported __declspec(dllexport) // creator of dll
136 # elif defined(DB_USE_DLL)
137 # define _exported __declspec(dllimport) // user of dll
139 # define _exported // static lib creator or user
146 #endif /* _MSC_VER */
148 // Some interfaces can be customized by allowing users to define
149 // callback functions. For performance and logistical reasons, some
150 // callback functions must be declared in extern "C" blocks. For others,
151 // we allow you to declare the callbacks in C++ or C (or an extern "C"
152 // block) as you wish. See the set methods for the callbacks for
156 typedef void * (*db_malloc_fcn_type)
158 typedef void * (*db_realloc_fcn_type)
160 typedef void (*db_free_fcn_type)
162 typedef int (*bt_compare_fcn_type) /*C++ version available*/
163 (DB *, const DBT *, const DBT *);
164 typedef size_t (*bt_prefix_fcn_type) /*C++ version available*/
165 (DB *, const DBT *, const DBT *);
166 typedef int (*dup_compare_fcn_type) /*C++ version available*/
167 (DB *, const DBT *, const DBT *);
168 typedef int (*h_compare_fcn_type) /*C++ version available*/
169 (DB *, const DBT *, const DBT *);
170 typedef u_int32_t (*h_hash_fcn_type) /*C++ version available*/
171 (DB *, const void *, u_int32_t);
172 typedef int (*pgin_fcn_type)
173 (DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
174 typedef int (*pgout_fcn_type)
175 (DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
179 // Represents a database table = a set of keys with associated values.
186 Db(DbEnv*, u_int32_t); // Create a Db object.
187 virtual ~Db(); // Calls close() if the user hasn't.
189 // These methods exactly match those in the C interface.
191 virtual int associate(DbTxn *txn, Db *secondary, int (*callback)
192 (Db *, const Dbt *, const Dbt *, Dbt *), u_int32_t flags);
193 virtual int associate_foreign(Db *foreign, int (*callback)
194 (Db *, const Dbt *, Dbt *, const Dbt *, int *), u_int32_t flags);
195 virtual int close(u_int32_t flags);
196 virtual int compact(DbTxn *txnid, Dbt *start,
197 Dbt *stop, DB_COMPACT *c_data, u_int32_t flags, Dbt *end);
198 virtual int cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags);
199 virtual int del(DbTxn *txnid, Dbt *key, u_int32_t flags);
200 virtual void err(int, const char *, ...);
201 virtual void errx(const char *, ...);
202 virtual int exists(DbTxn *txnid, Dbt *key, u_int32_t flags);
203 virtual int fd(int *fdp);
204 virtual int get(DbTxn *txnid, Dbt *key, Dbt *data, u_int32_t flags);
205 virtual int get_alloc(
206 db_malloc_fcn_type *, db_realloc_fcn_type *, db_free_fcn_type *);
207 virtual int get_append_recno(int (**)(Db *, Dbt *, db_recno_t));
208 virtual int get_bt_compare(int (**)(Db *, const Dbt *, const Dbt *));
209 virtual int get_bt_compress(
211 Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *),
212 int (**)(Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *));
213 virtual int get_bt_minkey(u_int32_t *);
214 virtual int get_bt_prefix(size_t (**)(Db *, const Dbt *, const Dbt *));
215 virtual int get_byteswapped(int *);
216 virtual int get_cachesize(u_int32_t *, u_int32_t *, int *);
217 virtual int get_create_dir(const char **);
218 virtual int get_dbname(const char **, const char **);
219 virtual int get_dup_compare(int (**)(Db *, const Dbt *, const Dbt *));
220 virtual int get_encrypt_flags(u_int32_t *);
221 virtual void get_errcall(
222 void (**)(const DbEnv *, const char *, const char *));
223 virtual void get_errfile(FILE **);
224 virtual void get_errpfx(const char **);
225 virtual int get_feedback(void (**)(Db *, int, int));
226 virtual int get_flags(u_int32_t *);
227 virtual int get_heapsize(u_int32_t *, u_int32_t *);
228 virtual int get_heap_regionsize(u_int32_t *);
229 virtual int get_h_compare(int (**)(Db *, const Dbt *, const Dbt *));
230 virtual int get_h_ffactor(u_int32_t *);
231 virtual int get_h_hash(u_int32_t (**)(Db *, const void *, u_int32_t));
232 virtual int get_h_nelem(u_int32_t *);
233 virtual int get_lk_exclusive(bool *, bool *);
234 virtual int get_lorder(int *);
235 virtual void get_msgcall(void (**)(const DbEnv *, const char *));
236 virtual void get_msgfile(FILE **);
237 virtual int get_multiple();
238 virtual int get_open_flags(u_int32_t *);
239 virtual int get_pagesize(u_int32_t *);
240 virtual int get_partition_callback(
241 u_int32_t *, u_int32_t (**)(Db *, Dbt *key));
242 virtual int get_partition_dirs(const char ***);
243 virtual int get_partition_keys(u_int32_t *, Dbt **);
244 virtual int get_priority(DB_CACHE_PRIORITY *);
245 virtual int get_q_extentsize(u_int32_t *);
246 virtual int get_re_delim(int *);
247 virtual int get_re_len(u_int32_t *);
248 virtual int get_re_pad(int *);
249 virtual int get_re_source(const char **);
250 virtual int get_transactional();
251 virtual int get_type(DBTYPE *);
252 virtual int join(Dbc **curslist, Dbc **dbcp, u_int32_t flags);
253 virtual int key_range(DbTxn *, Dbt *, DB_KEY_RANGE *, u_int32_t);
254 virtual int open(DbTxn *txnid,
255 const char *, const char *subname, DBTYPE, u_int32_t, int);
256 virtual int pget(DbTxn *txnid,
257 Dbt *key, Dbt *pkey, Dbt *data, u_int32_t flags);
258 virtual int put(DbTxn *, Dbt *, Dbt *, u_int32_t);
259 virtual int remove(const char *, const char *, u_int32_t);
260 virtual int rename(const char *, const char *, const char *, u_int32_t);
261 virtual int set_alloc(
262 db_malloc_fcn_type, db_realloc_fcn_type, db_free_fcn_type);
263 virtual void set_app_private(void *);
264 virtual int set_append_recno(int (*)(Db *, Dbt *, db_recno_t));
265 virtual int set_bt_compare(bt_compare_fcn_type); /*deprecated*/
266 virtual int set_bt_compare(int (*)(Db *, const Dbt *, const Dbt *));
267 virtual int set_bt_compress(
269 (Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *),
270 int (*)(Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *));
271 virtual int set_bt_minkey(u_int32_t);
272 virtual int set_bt_prefix(bt_prefix_fcn_type); /*deprecated*/
273 virtual int set_bt_prefix(size_t (*)(Db *, const Dbt *, const Dbt *));
274 virtual int set_cachesize(u_int32_t, u_int32_t, int);
275 virtual int set_create_dir(const char *);
276 virtual int set_dup_compare(dup_compare_fcn_type); /*deprecated*/
277 virtual int set_dup_compare(int (*)(Db *, const Dbt *, const Dbt *));
278 virtual int set_encrypt(const char *, u_int32_t);
279 virtual void set_errcall(
280 void (*)(const DbEnv *, const char *, const char *));
281 virtual void set_errfile(FILE *);
282 virtual void set_errpfx(const char *);
283 virtual int set_feedback(void (*)(Db *, int, int));
284 virtual int set_flags(u_int32_t);
285 virtual int set_heapsize(u_int32_t, u_int32_t);
286 virtual int set_heap_regionsize(u_int32_t);
287 virtual int set_h_compare(h_compare_fcn_type); /*deprecated*/
288 virtual int set_h_compare(int (*)(Db *, const Dbt *, const Dbt *));
289 virtual int set_h_ffactor(u_int32_t);
290 virtual int set_h_hash(h_hash_fcn_type); /*deprecated*/
291 virtual int set_h_hash(u_int32_t (*)(Db *, const void *, u_int32_t));
292 virtual int set_h_nelem(u_int32_t);
293 virtual int set_lk_exclusive(bool);
294 virtual int set_lorder(int);
295 virtual void set_msgcall(void (*)(const DbEnv *, const char *));
296 virtual void set_msgfile(FILE *);
297 virtual int set_pagesize(u_int32_t);
298 virtual int set_paniccall(void (*)(DbEnv *, int));
299 virtual int set_partition(
300 u_int32_t, Dbt *, u_int32_t (*)(Db *, Dbt *));
301 virtual int set_partition_dirs(const char **);
302 virtual int set_priority(DB_CACHE_PRIORITY);
303 virtual int set_q_extentsize(u_int32_t);
304 virtual int set_re_delim(int);
305 virtual int set_re_len(u_int32_t);
306 virtual int set_re_pad(int);
307 virtual int set_re_source(const char *);
308 virtual int sort_multiple(Dbt *, Dbt *, u_int32_t);
309 virtual int stat(DbTxn *, void *sp, u_int32_t flags);
310 virtual int stat_print(u_int32_t flags);
311 virtual int sync(u_int32_t flags);
312 virtual int truncate(DbTxn *, u_int32_t *, u_int32_t);
313 virtual int upgrade(const char *name, u_int32_t flags);
315 const char *, const char *, __DB_STD(ostream) *, u_int32_t);
317 // These additional methods are not in the C interface, and
318 // are only available for C++.
320 virtual void *get_app_private() const;
321 virtual __DB_STD(ostream) *get_error_stream();
322 virtual void set_error_stream(__DB_STD(ostream) *);
323 virtual __DB_STD(ostream) *get_message_stream();
324 virtual void set_message_stream(__DB_STD(ostream) *);
326 virtual DbEnv *get_env();
327 virtual DbMpoolFile *get_mpf();
329 virtual ENV *get_ENV()
339 virtual const DB *get_const_DB() const
344 static Db* get_Db(DB *db)
346 return (Db *)db->api_internal;
349 static const Db* get_const_Db(const DB *db)
351 return (const Db *)db->api_internal;
354 u_int32_t get_create_flags() const
356 return construct_flags_;
362 Db &operator = (const Db &);
372 int construct_error_;
374 u_int32_t construct_flags_;
376 static int alt_close(DB *, u_int32_t);
379 // These are public only because they need to be called
380 // via C callback functions. They should never be used by
381 // external users of this class.
383 int (*append_recno_callback_)(Db *, Dbt *, db_recno_t);
384 int (*associate_callback_)(Db *, const Dbt *, const Dbt *, Dbt *);
385 int (*associate_foreign_callback_)
386 (Db *, const Dbt *, Dbt *, const Dbt *, int *);
387 int (*bt_compare_callback_)(Db *, const Dbt *, const Dbt *);
388 int (*bt_compress_callback_)(
389 Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *);
390 int (*bt_decompress_callback_)(
391 Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *);
392 size_t (*bt_prefix_callback_)(Db *, const Dbt *, const Dbt *);
393 u_int32_t (*db_partition_callback_)(Db *, Dbt *);
394 int (*dup_compare_callback_)(Db *, const Dbt *, const Dbt *);
395 void (*feedback_callback_)(Db *, int, int);
396 int (*h_compare_callback_)(Db *, const Dbt *, const Dbt *);
397 u_int32_t (*h_hash_callback_)(Db *, const void *, u_int32_t);
403 class _exported Dbc : protected DBC
409 int cmp(Dbc *other_csr, int *result, u_int32_t flags);
410 int count(db_recno_t *countp, u_int32_t flags);
411 int del(u_int32_t flags);
412 int dup(Dbc** cursorp, u_int32_t flags);
413 int get(Dbt* key, Dbt *data, u_int32_t flags);
414 int get_priority(DB_CACHE_PRIORITY *priorityp);
415 int pget(Dbt* key, Dbt* pkey, Dbt *data, u_int32_t flags);
416 int put(Dbt* key, Dbt *data, u_int32_t flags);
417 int set_priority(DB_CACHE_PRIORITY priority);
420 // No data is permitted in this class (see comment at top)
422 // Note: use Db::cursor() to get pointers to a Dbc,
423 // and call Dbc::close() rather than delete to release them.
430 Dbc &operator = (const Dbc &);
434 // A channel in replication group
436 class _exported DbChannel
442 int send_msg(Dbt *msg, u_int32_t nmsg, u_int32_t flags);
443 int send_request(Dbt *request, u_int32_t nrequest, Dbt *response,
444 db_timeout_t timeout, u_int32_t flags);
445 int set_timeout(db_timeout_t timeout);
447 virtual DB_CHANNEL *get_DB_CHANNEL()
452 virtual const DB_CHANNEL *get_const_DB_CHANNEL() const
459 virtual ~DbChannel();
462 DbChannel(const DbChannel &);
463 DbChannel &operator = (const DbChannel &);
469 // Berkeley DB environment class. Provides functions for opening databases.
470 // User of this library can use this class as a starting point for
471 // developing a DB application - derive their application class from
472 // this one, add application control logic.
474 // Note that if you use the default constructor, you must explicitly
475 // call appinit() before any other db activity (e.g. opening files)
477 class _exported DbEnv
481 friend class DbMpoolFile;
484 // After using this constructor, you can set any needed
485 // parameters for the environment using the set_* methods.
486 // Then call open() to finish initializing the environment
487 // and attaching it to underlying files.
489 DbEnv(u_int32_t flags);
493 // These methods match those in the C interface.
495 virtual int add_data_dir(const char *);
496 virtual int backup(const char *target, u_int32_t flags);
497 virtual int cdsgroup_begin(DbTxn **tid);
498 virtual int close(u_int32_t);
499 virtual int dbbackup(
500 const char *dbfile, const char *target, u_int32_t flags);
501 virtual int dbremove(DbTxn *txn, const char *name, const char *subdb,
503 virtual int dbrename(DbTxn *txn, const char *name, const char *subdb,
504 const char *newname, u_int32_t flags);
505 virtual void err(int, const char *, ...);
506 virtual void errx(const char *, ...);
507 virtual int failchk(u_int32_t);
508 virtual int fileid_reset(const char *, u_int32_t);
509 virtual int get_alloc(db_malloc_fcn_type *, db_realloc_fcn_type *,
511 virtual void *get_app_private() const;
512 virtual int get_home(const char **);
513 virtual int get_open_flags(u_int32_t *);
514 virtual int open(const char *, u_int32_t, int);
515 virtual int remove(const char *, u_int32_t);
516 virtual int stat_print(u_int32_t flags);
518 virtual int set_alloc(db_malloc_fcn_type, db_realloc_fcn_type,
520 virtual void set_app_private(void *);
521 virtual int get_backup_callbacks(
522 int (**)(DbEnv *, const char *, const char *, void **),
523 int (**)(DbEnv *, u_int32_t, u_int32_t, u_int32_t, u_int8_t *, void *),
524 int (**)(DbEnv *, const char *, void *));
525 virtual int set_backup_callbacks(
526 int (*)(DbEnv *, const char *, const char *, void **),
527 int (*)(DbEnv *, u_int32_t, u_int32_t, u_int32_t, u_int8_t *, void *),
528 int (*)(DbEnv *, const char *, void *));
529 virtual int get_backup_config(DB_BACKUP_CONFIG, u_int32_t *);
530 virtual int set_backup_config(DB_BACKUP_CONFIG, u_int32_t);
531 virtual int get_cachesize(u_int32_t *, u_int32_t *, int *);
532 virtual int set_cachesize(u_int32_t, u_int32_t, int);
533 virtual int get_cache_max(u_int32_t *, u_int32_t *);
534 virtual int set_cache_max(u_int32_t, u_int32_t);
535 virtual int get_create_dir(const char **);
536 virtual int set_create_dir(const char *);
537 virtual int get_data_dirs(const char ***);
538 virtual int set_data_dir(const char *);
539 virtual int get_encrypt_flags(u_int32_t *);
540 virtual int get_intermediate_dir_mode(const char **);
541 virtual int set_intermediate_dir_mode(const char *);
542 virtual int get_isalive(
543 int (**)(DbEnv *, pid_t, db_threadid_t, u_int32_t));
544 virtual int set_isalive(
545 int (*)(DbEnv *, pid_t, db_threadid_t, u_int32_t));
546 virtual int set_encrypt(const char *, u_int32_t);
547 virtual void get_errcall(
548 void (**)(const DbEnv *, const char *, const char *));
549 virtual void set_errcall(
550 void (*)(const DbEnv *, const char *, const char *));
551 virtual void get_errfile(FILE **);
552 virtual void set_errfile(FILE *);
553 virtual void get_errpfx(const char **);
554 virtual void set_errpfx(const char *);
555 virtual int set_event_notify(void (*)(DbEnv *, u_int32_t, void *));
556 virtual int get_flags(u_int32_t *);
557 virtual int set_flags(u_int32_t, int);
558 virtual bool is_bigendian();
559 virtual int lsn_reset(const char *, u_int32_t);
560 virtual int get_feedback(void (**)(DbEnv *, int, int));
561 virtual int set_feedback(void (*)(DbEnv *, int, int));
562 virtual int get_lg_bsize(u_int32_t *);
563 virtual int set_lg_bsize(u_int32_t);
564 virtual int get_lg_dir(const char **);
565 virtual int set_lg_dir(const char *);
566 virtual int get_lg_filemode(int *);
567 virtual int set_lg_filemode(int);
568 virtual int get_lg_max(u_int32_t *);
569 virtual int set_lg_max(u_int32_t);
570 virtual int get_lg_regionmax(u_int32_t *);
571 virtual int set_lg_regionmax(u_int32_t);
572 virtual int get_lk_conflicts(const u_int8_t **, int *);
573 virtual int set_lk_conflicts(u_int8_t *, int);
574 virtual int get_lk_detect(u_int32_t *);
575 virtual int set_lk_detect(u_int32_t);
576 virtual int get_lk_max_lockers(u_int32_t *);
577 virtual int set_lk_max_lockers(u_int32_t);
578 virtual int get_lk_max_locks(u_int32_t *);
579 virtual int set_lk_max_locks(u_int32_t);
580 virtual int get_lk_max_objects(u_int32_t *);
581 virtual int set_lk_max_objects(u_int32_t);
582 virtual int get_lk_partitions(u_int32_t *);
583 virtual int set_lk_partitions(u_int32_t);
584 virtual int get_lk_priority(u_int32_t, u_int32_t *);
585 virtual int set_lk_priority(u_int32_t, u_int32_t);
586 virtual int get_lk_tablesize(u_int32_t *);
587 virtual int set_lk_tablesize(u_int32_t);
588 virtual int get_memory_init(DB_MEM_CONFIG, u_int32_t *);
589 virtual int set_memory_init(DB_MEM_CONFIG, u_int32_t);
590 virtual int get_memory_max(u_int32_t *, u_int32_t *);
591 virtual int set_memory_max(u_int32_t, u_int32_t);
592 virtual int get_metadata_dir(const char **);
593 virtual int set_metadata_dir(const char *);
594 virtual int get_mp_mmapsize(size_t *);
595 virtual int set_mp_mmapsize(size_t);
596 virtual int get_mp_max_openfd(int *);
597 virtual int set_mp_max_openfd(int);
598 virtual int get_mp_max_write(int *, db_timeout_t *);
599 virtual int set_mp_max_write(int, db_timeout_t);
600 virtual int get_mp_pagesize(u_int32_t *);
601 virtual int set_mp_pagesize(u_int32_t);
602 virtual int get_mp_tablesize(u_int32_t *);
603 virtual int set_mp_tablesize(u_int32_t);
604 virtual void get_msgcall(void (**)(const DbEnv *, const char *));
605 virtual void set_msgcall(void (*)(const DbEnv *, const char *));
606 virtual void get_msgfile(FILE **);
607 virtual void set_msgfile(FILE *);
608 virtual int set_paniccall(void (*)(DbEnv *, int));
609 virtual int get_shm_key(long *);
610 virtual int set_shm_key(long);
611 virtual int get_timeout(db_timeout_t *, u_int32_t);
612 virtual int set_timeout(db_timeout_t, u_int32_t);
613 virtual int get_tmp_dir(const char **);
614 virtual int set_tmp_dir(const char *);
615 virtual int get_tx_max(u_int32_t *);
616 virtual int set_tx_max(u_int32_t);
617 virtual int get_app_dispatch(
618 int (**)(DbEnv *, Dbt *, DbLsn *, db_recops));
619 virtual int set_app_dispatch(int (*)(DbEnv *,
620 Dbt *, DbLsn *, db_recops));
621 virtual int get_tx_timestamp(time_t *);
622 virtual int set_tx_timestamp(time_t *);
623 virtual int get_verbose(u_int32_t which, int *);
624 virtual int set_verbose(u_int32_t which, int);
626 // Version information. Static methods, can be called at any time.
628 static char *version(int *major, int *minor, int *patch);
629 static char *full_version(int *family, int *release,
630 int *major, int *minor, int *patch);
632 // Convert DB errors to strings
633 static char *strerror(int);
635 // If an error is detected and the error call function
636 // or stream is set, a message is dispatched or printed.
637 // If a prefix is set, each message is prefixed.
639 // You can use set_errcall() or set_errfile() above to control
640 // error functionality. Alternatively, you can call
641 // set_error_stream() to force all errors to a C++ stream.
642 // It is unwise to mix these approaches.
644 virtual __DB_STD(ostream) *get_error_stream();
645 virtual void set_error_stream(__DB_STD(ostream) *);
646 virtual __DB_STD(ostream) *get_message_stream();
647 virtual void set_message_stream(__DB_STD(ostream) *);
650 static void runtime_error(DbEnv *dbenv, const char *caller, int err,
652 static void runtime_error_dbt(DbEnv *dbenv, const char *caller, Dbt *dbt,
654 static void runtime_error_lock_get(DbEnv *dbenv, const char *caller,
655 int err, db_lockop_t op, db_lockmode_t mode,
656 Dbt *obj, DbLock lock, int index,
661 virtual int lock_detect(u_int32_t flags, u_int32_t atype, int *aborted);
662 virtual int lock_get(u_int32_t locker, u_int32_t flags, Dbt *obj,
663 db_lockmode_t lock_mode, DbLock *lock);
664 virtual int lock_id(u_int32_t *idp);
665 virtual int lock_id_free(u_int32_t id);
666 virtual int lock_put(DbLock *lock);
667 virtual int lock_stat(DB_LOCK_STAT **statp, u_int32_t flags);
668 virtual int lock_stat_print(u_int32_t flags);
669 virtual int lock_vec(u_int32_t locker, u_int32_t flags,
670 DB_LOCKREQ list[], int nlist, DB_LOCKREQ **elistp);
674 virtual int log_archive(char **list[], u_int32_t flags);
675 static int log_compare(const DbLsn *lsn0, const DbLsn *lsn1);
676 virtual int log_cursor(DbLogc **cursorp, u_int32_t flags);
677 virtual int log_file(DbLsn *lsn, char *namep, size_t len);
678 virtual int log_flush(const DbLsn *lsn);
679 virtual int log_get_config(u_int32_t, int *);
680 virtual int log_put(DbLsn *lsn, const Dbt *data, u_int32_t flags);
681 virtual int log_printf(DbTxn *, const char *, ...);
682 virtual int log_set_config(u_int32_t, int);
683 virtual int log_stat(DB_LOG_STAT **spp, u_int32_t flags);
684 virtual int log_stat_print(u_int32_t flags);
685 virtual int log_verify(DB_LOG_VERIFY_CONFIG *);
689 virtual int memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags);
690 virtual int memp_register(int ftype,
691 pgin_fcn_type pgin_fcn,
692 pgout_fcn_type pgout_fcn);
693 virtual int memp_stat(DB_MPOOL_STAT
694 **gsp, DB_MPOOL_FSTAT ***fsp, u_int32_t flags);
695 virtual int memp_stat_print(u_int32_t flags);
696 virtual int memp_sync(DbLsn *lsn);
697 virtual int memp_trickle(int pct, int *nwrotep);
701 virtual int mutex_alloc(u_int32_t, db_mutex_t *);
702 virtual int mutex_free(db_mutex_t);
703 virtual int mutex_get_align(u_int32_t *);
704 virtual int mutex_get_increment(u_int32_t *);
705 virtual int mutex_get_init(u_int32_t *);
706 virtual int mutex_get_max(u_int32_t *);
707 virtual int mutex_get_tas_spins(u_int32_t *);
708 virtual int mutex_lock(db_mutex_t);
709 virtual int mutex_set_align(u_int32_t);
710 virtual int mutex_set_increment(u_int32_t);
711 virtual int mutex_set_init(u_int32_t);
712 virtual int mutex_set_max(u_int32_t);
713 virtual int mutex_set_tas_spins(u_int32_t);
714 virtual int mutex_stat(DB_MUTEX_STAT **, u_int32_t);
715 virtual int mutex_stat_print(u_int32_t);
716 virtual int mutex_unlock(db_mutex_t);
718 // Transaction functions
720 virtual int txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags);
721 virtual int txn_checkpoint(u_int32_t kbyte, u_int32_t min,
723 virtual int txn_recover(DbPreplist *preplist, long count,
724 long *retp, u_int32_t flags);
725 virtual int txn_stat(DB_TXN_STAT **statp, u_int32_t flags);
726 virtual int txn_stat_print(u_int32_t flags);
728 // Replication functions
730 virtual int rep_elect(u_int32_t, u_int32_t, u_int32_t);
731 virtual int rep_flush();
732 virtual int rep_process_message(Dbt *, Dbt *, int, DbLsn *);
733 virtual int rep_start(Dbt *, u_int32_t);
734 virtual int rep_stat(DB_REP_STAT **statp, u_int32_t flags);
735 virtual int rep_stat_print(u_int32_t flags);
736 virtual int rep_get_clockskew(u_int32_t *, u_int32_t *);
737 virtual int rep_set_clockskew(u_int32_t, u_int32_t);
738 virtual int rep_get_limit(u_int32_t *, u_int32_t *);
739 virtual int rep_set_limit(u_int32_t, u_int32_t);
740 virtual int rep_set_transport(int, int (*)(DbEnv *,
741 const Dbt *, const Dbt *, const DbLsn *, int, u_int32_t));
742 virtual int rep_set_request(u_int32_t, u_int32_t);
743 virtual int rep_get_request(u_int32_t *, u_int32_t *);
744 virtual int get_thread_count(u_int32_t *);
745 virtual int set_thread_count(u_int32_t);
746 virtual int get_thread_id_fn(
747 void (**)(DbEnv *, pid_t *, db_threadid_t *));
748 virtual int set_thread_id(void (*)(DbEnv *, pid_t *, db_threadid_t *));
749 virtual int get_thread_id_string_fn(
750 char *(**)(DbEnv *, pid_t, db_threadid_t, char *));
751 virtual int set_thread_id_string(char *(*)(DbEnv *,
752 pid_t, db_threadid_t, char *));
753 virtual int rep_set_config(u_int32_t, int);
754 virtual int rep_get_config(u_int32_t, int *);
755 virtual int rep_sync(u_int32_t flags);
757 // Advanced replication functions
759 virtual int rep_get_nsites(u_int32_t *n);
760 virtual int rep_set_nsites(u_int32_t n);
761 virtual int rep_get_priority(u_int32_t *priorityp);
762 virtual int rep_set_priority(u_int32_t priority);
763 virtual int rep_get_timeout(int which, db_timeout_t *timeout);
764 virtual int rep_set_timeout(int which, db_timeout_t timeout);
765 virtual int repmgr_channel(int eid, DbChannel **channel,
767 virtual int repmgr_get_ack_policy(int *policy);
768 virtual int repmgr_set_ack_policy(int policy);
769 virtual int repmgr_local_site(DbSite **site);
770 virtual int repmgr_msg_dispatch(void (*) (DbEnv *,
771 DbChannel *, Dbt *, u_int32_t, u_int32_t), u_int32_t flags);
772 virtual int repmgr_site(const char *host, u_int port, DbSite **site,
774 virtual int repmgr_site_by_eid(int eid, DbSite **site);
775 virtual int repmgr_site_list(u_int *countp, DB_REPMGR_SITE **listp);
776 virtual int repmgr_start(int nthreads, u_int32_t flags);
777 virtual int repmgr_stat(DB_REPMGR_STAT **statp, u_int32_t flags);
778 virtual int repmgr_stat_print(u_int32_t flags);
780 // Conversion functions
782 virtual ENV *get_ENV()
787 virtual DB_ENV *get_DB_ENV()
792 virtual const DB_ENV *get_const_DB_ENV() const
797 static DbEnv* get_DbEnv(DB_ENV *dbenv)
799 return dbenv ? (DbEnv *)dbenv->api1_internal : 0;
802 static const DbEnv* get_const_DbEnv(const DB_ENV *dbenv)
804 return dbenv ? (const DbEnv *)dbenv->api1_internal : 0;
807 u_int32_t get_create_flags() const
809 return construct_flags_;
812 // For internal use only.
813 static DbEnv* wrap_DB_ENV(DB_ENV *dbenv);
815 // These are public only because they need to be called
816 // via C functions. They should never be called by users
819 static int _app_dispatch_intercept(DB_ENV *dbenv, DBT *dbt, DB_LSN *lsn,
821 static int _backup_close_intercept(DB_ENV *dbenv,
822 const char *dbname, void *handle);
823 static int _backup_open_intercept(DB_ENV *dbenv,
824 const char *dbname, const char *target, void **handle);
825 static int _backup_write_intercept(DB_ENV *dbenv, u_int32_t off_gbytes,
826 u_int32_t off_bytes, u_int32_t size, u_int8_t *buf, void *handle);
827 static void _paniccall_intercept(DB_ENV *dbenv, int errval);
828 static void _feedback_intercept(DB_ENV *dbenv, int opcode, int pct);
829 static void _event_func_intercept(DB_ENV *dbenv, u_int32_t, void *);
830 static int _isalive_intercept(DB_ENV *dbenv, pid_t pid,
831 db_threadid_t thrid, u_int32_t flags);
832 static int _rep_send_intercept(DB_ENV *dbenv, const DBT *cntrl,
833 const DBT *data, const DB_LSN *lsn, int id, u_int32_t flags);
834 static void _stream_error_function(const DB_ENV *dbenv,
835 const char *prefix, const char *message);
836 static void _stream_message_function(const DB_ENV *dbenv,
837 const char *message);
838 static void _thread_id_intercept(DB_ENV *dbenv, pid_t *pidp,
839 db_threadid_t *thridp);
840 static char *_thread_id_string_intercept(DB_ENV *dbenv, pid_t pid,
841 db_threadid_t thrid, char *buf);
842 static void _message_dispatch_intercept(DB_ENV *dbenv,
843 DB_CHANNEL *dbchannel, DBT *request, u_int32_t nrequest,
848 int initialize(DB_ENV *dbenv);
851 // For internal use only.
852 DbEnv(DB_ENV *, u_int32_t flags);
855 DbEnv(const DbEnv &);
856 void operator = (const DbEnv &);
860 int construct_error_;
861 u_int32_t construct_flags_;
862 __DB_STD(ostream) *error_stream_;
863 __DB_STD(ostream) *message_stream_;
865 int (*app_dispatch_callback_)(DbEnv *, Dbt *, DbLsn *, db_recops);
866 int (*backup_close_callback_)(DbEnv *, const char *, void *);
867 int (*backup_open_callback_)(
868 DbEnv *, const char *, const char *, void **);
869 int (*backup_write_callback_)(
870 DbEnv *, u_int32_t, u_int32_t, u_int32_t, u_int8_t *, void *);
871 int (*isalive_callback_)(DbEnv *, pid_t, db_threadid_t, u_int32_t);
872 void (*error_callback_)(const DbEnv *, const char *, const char *);
873 void (*feedback_callback_)(DbEnv *, int, int);
874 void (*message_callback_)(const DbEnv *, const char *);
875 void (*paniccall_callback_)(DbEnv *, int);
876 void (*event_func_callback_)(DbEnv *, u_int32_t, void *);
877 int (*rep_send_callback_)(DbEnv *, const Dbt *, const Dbt *,
878 const DbLsn *, int, u_int32_t);
879 void (*thread_id_callback_)(DbEnv *, pid_t *, db_threadid_t *);
880 char *(*thread_id_string_callback_)(DbEnv *, pid_t, db_threadid_t,
882 void (*message_dispatch_callback_)(DbEnv *, DbChannel *, Dbt *,
883 u_int32_t, u_int32_t);
889 class _exported DbHeapRecordId : private DB_HEAP_RID
892 db_pgno_t get_pgno() const { return pgno; }
893 void set_pgno(db_pgno_t value) { pgno = value; }
895 db_indx_t get_indx() const { return indx; }
896 void set_indx(db_indx_t value) { indx = value; }
898 DB_HEAP_RID *get_DB_HEAP_RID() { return (DB_HEAP_RID *)this; }
899 const DB_HEAP_RID *get_const_DB_HEAP_RID() const
900 { return (const DB_HEAP_RID *)this; }
902 static DbHeapRecordId* get_DbHeapRecordId(DB_HEAP_RID *rid)
903 { return (DbHeapRecordId *)rid; }
904 static const DbHeapRecordId* get_const_DbHeapRecordId(DB_HEAP_RID *rid)
905 { return (const DbHeapRecordId *)rid; }
907 DbHeapRecordId(db_pgno_t pgno, db_indx_t indx);
910 DbHeapRecordId(const DbHeapRecordId &);
911 DbHeapRecordId &operator = (const DbHeapRecordId &);
917 class _exported DbLock
923 DbLock(const DbLock &);
924 DbLock &operator = (const DbLock &);
927 // We can add data to this class if needed
928 // since its contained class is not allocated by db.
929 // (see comment at top)
938 class _exported DbLogc : protected DB_LOGC
943 int close(u_int32_t _flags);
944 int get(DbLsn *lsn, Dbt *data, u_int32_t _flags);
945 int version(u_int32_t *versionp, u_int32_t _flags);
948 // No data is permitted in this class (see comment at top)
950 // Note: use Db::cursor() to get pointers to a Dbc,
951 // and call Dbc::close() rather than delete to release them.
958 DbLogc &operator = (const Dbc &);
962 // Log sequence number
964 class _exported DbLsn : public DB_LSN
966 friend class DbEnv; // friendship needed to cast to base class
967 friend class DbLogc; // friendship needed to cast to base class
973 class _exported DbMpoolFile
979 int close(u_int32_t flags);
980 int get(db_pgno_t *pgnoaddr, DbTxn *txn, u_int32_t flags, void *pagep);
981 int get_clear_len(u_int32_t *len);
982 int get_fileid(u_int8_t *fileid);
983 int get_flags(u_int32_t *flagsp);
984 int get_ftype(int *ftype);
985 int get_last_pgno(db_pgno_t *pgnop);
986 int get_lsn_offset(int32_t *offsetp);
987 int get_maxsize(u_int32_t *gbytes, u_int32_t *bytes);
988 int get_pgcookie(DBT *dbt);
989 int get_priority(DB_CACHE_PRIORITY *priorityp);
990 int get_transactional(void);
991 int open(const char *file, u_int32_t flags, int mode, size_t pagesize);
992 int put(void *pgaddr, DB_CACHE_PRIORITY priority, u_int32_t flags);
993 int set_clear_len(u_int32_t len);
994 int set_fileid(u_int8_t *fileid);
995 int set_flags(u_int32_t flags, int onoff);
996 int set_ftype(int ftype);
997 int set_lsn_offset(int32_t offset);
998 int set_maxsize(u_int32_t gbytes, u_int32_t bytes);
999 int set_pgcookie(DBT *dbt);
1000 int set_priority(DB_CACHE_PRIORITY priority);
1003 virtual DB_MPOOLFILE *get_DB_MPOOLFILE()
1008 virtual const DB_MPOOLFILE *get_const_DB_MPOOLFILE() const
1016 // We can add data to this class if needed
1017 // since it is implemented via a pointer.
1018 // (see comment at top)
1020 // Note: use DbEnv::memp_fcreate() to get pointers to a DbMpoolFile,
1021 // and call DbMpoolFile::close() rather than delete to release them.
1027 virtual ~DbMpoolFile();
1031 DbMpoolFile(const DbMpoolFile &);
1032 void operator = (const DbMpoolFile &);
1036 // This is filled in and returned by the DbEnv::txn_recover() method.
1038 class _exported DbPreplist
1042 u_int8_t gid[DB_GID_SIZE];
1046 // A sequence record in a database
1048 class _exported DbSequence
1051 DbSequence(Db *db, u_int32_t flags);
1052 virtual ~DbSequence();
1054 int open(DbTxn *txnid, Dbt *key, u_int32_t flags);
1055 int initial_value(db_seq_t value);
1056 int close(u_int32_t flags);
1057 int remove(DbTxn *txnid, u_int32_t flags);
1058 int stat(DB_SEQUENCE_STAT **sp, u_int32_t flags);
1059 int stat_print(u_int32_t flags);
1061 int get(DbTxn *txnid, int32_t delta, db_seq_t *retp, u_int32_t flags);
1062 int get_cachesize(int32_t *sizep);
1063 int set_cachesize(int32_t size);
1064 int get_flags(u_int32_t *flagsp);
1065 int set_flags(u_int32_t flags);
1066 int get_range(db_seq_t *minp, db_seq_t *maxp);
1067 int set_range(db_seq_t min, db_seq_t max);
1072 virtual DB_SEQUENCE *get_DB_SEQUENCE()
1077 virtual const DB_SEQUENCE *get_const_DB_SEQUENCE() const
1082 static DbSequence* get_DbSequence(DB_SEQUENCE *seq)
1084 return (DbSequence *)seq->api_internal;
1087 static const DbSequence* get_const_DbSequence(const DB_SEQUENCE *seq)
1089 return (const DbSequence *)seq->api_internal;
1092 // For internal use only.
1093 static DbSequence* wrap_DB_SEQUENCE(DB_SEQUENCE *seq);
1096 DbSequence(DB_SEQUENCE *seq);
1098 DbSequence(const DbSequence &);
1099 DbSequence &operator = (const DbSequence &);
1106 // A site in replication group
1108 class _exported DbSite
1114 int get_address(const char **hostp, u_int *port);
1115 int get_config(u_int32_t which, u_int32_t *value);
1116 int get_eid(int *eidp);
1118 int set_config(u_int32_t which, u_int32_t value);
1120 virtual DB_SITE *get_DB_SITE()
1125 virtual const DB_SITE *get_const_DB_SITE() const
1135 DbSite(const DbSite &);
1136 DbSite &operator = (const DbSite &);
1143 class _exported DbTxn
1149 int commit(u_int32_t flags);
1150 int discard(u_int32_t flags);
1152 int get_name(const char **namep);
1153 int get_priority(u_int32_t *priorityp);
1154 int prepare(u_int8_t *gid);
1155 int set_name(const char *name);
1156 int set_priority(u_int32_t priority);
1157 int set_timeout(db_timeout_t timeout, u_int32_t flags);
1159 virtual DB_TXN *get_DB_TXN()
1164 virtual const DB_TXN *get_const_DB_TXN() const
1169 static DbTxn* get_DbTxn(DB_TXN *txn)
1171 return (DbTxn *)txn->api_internal;
1174 static const DbTxn* get_const_DbTxn(const DB_TXN *txn)
1176 return (const DbTxn *)txn->api_internal;
1179 // For internal use only.
1180 static DbTxn* wrap_DB_TXN(DB_TXN *txn);
1181 void remove_child_txn(DbTxn *kid);
1182 void add_child_txn(DbTxn *kid);
1184 void set_parent(DbTxn *ptxn)
1192 // We use a TAILQ to store this object's kids of DbTxn objects, and
1193 // each kid has a "parent_txn_" to point to this DbTxn object.
1195 // If imp_ has a parent transaction which is not wrapped by DbTxn
1196 // class, parent_txn_ will be NULL since we don't need to maintain
1197 // this parent-kid relationship. This relationship only helps to
1198 // delete unresolved kids when the parent is resolved.
1201 // We can add data to this class if needed
1202 // since it is implemented via a pointer.
1203 // (see comment at top)
1205 // Note: use DbEnv::txn_begin() to get pointers to a DbTxn,
1206 // and call DbTxn::abort() or DbTxn::commit rather than
1207 // delete to release them.
1210 // For internal use only.
1211 DbTxn(DB_TXN *txn, DbTxn *ptxn);
1215 DbTxn(const DbTxn &);
1216 void operator = (const DbTxn &);
1220 * Explicit representations of structures from queue.h.
1221 * TAILQ_HEAD(__children, DbTxn) children;
1230 * Explicit representations of structures from queue.h.
1231 * TAILQ_ENTRY(DbTxn) child_entry;
1240 // A chunk of data, maybe a key or value.
1242 class _exported Dbt : private DBT
1247 friend class DbLogc;
1248 friend class DbSequence;
1252 void *get_data() const { return data; }
1253 void set_data(void *value) { data = value; }
1256 u_int32_t get_size() const { return size; }
1257 void set_size(u_int32_t value) { size = value; }
1259 // RO: length of user buffer.
1260 u_int32_t get_ulen() const { return ulen; }
1261 void set_ulen(u_int32_t value) { ulen = value; }
1263 // RO: get/put record length.
1264 u_int32_t get_dlen() const { return dlen; }
1265 void set_dlen(u_int32_t value) { dlen = value; }
1267 // RO: get/put record offset.
1268 u_int32_t get_doff() const { return doff; }
1269 void set_doff(u_int32_t value) { doff = value; }
1272 u_int32_t get_flags() const { return flags; }
1273 void set_flags(u_int32_t value) { flags = value; }
1275 // Conversion functions
1276 DBT *get_DBT() { return (DBT *)this; }
1277 const DBT *get_const_DBT() const { return (const DBT *)this; }
1279 static Dbt* get_Dbt(DBT *dbt) { return (Dbt *)dbt; }
1280 static const Dbt* get_const_Dbt(const DBT *dbt)
1281 { return (const Dbt *)dbt; }
1283 Dbt(void *data, u_int32_t size);
1287 Dbt &operator = (const Dbt &);
1290 // Note: no extra data appears in this class (other than
1291 // inherited from DBT) since we need DBT and Dbt objects
1292 // to have interchangable pointers.
1294 // When subclassing this class, remember that callback
1295 // methods like bt_compare, bt_prefix, dup_compare may
1296 // internally manufacture DBT objects (which later are
1297 // cast to Dbt), so such callbacks might receive objects
1298 // not of your subclassed type.
1301 ////////////////////////////////////////////////////////////////
1302 ////////////////////////////////////////////////////////////////
1304 // multiple key/data/recno iterator classes
1307 // DbMultipleIterator is a shared private base class for the three types
1308 // of bulk-return Iterator; it should never be instantiated directly,
1309 // but it handles the functionality shared by its subclasses.
1310 class _exported DbMultipleIterator
1313 DbMultipleIterator(const Dbt &dbt);
1319 class _exported DbMultipleKeyDataIterator : private DbMultipleIterator
1322 DbMultipleKeyDataIterator(const Dbt &dbt) : DbMultipleIterator(dbt) {}
1323 bool next(Dbt &key, Dbt &data);
1326 class _exported DbMultipleRecnoDataIterator : private DbMultipleIterator
1329 DbMultipleRecnoDataIterator(const Dbt &dbt) : DbMultipleIterator(dbt) {}
1330 bool next(db_recno_t &recno, Dbt &data);
1333 class _exported DbMultipleDataIterator : private DbMultipleIterator
1336 DbMultipleDataIterator(const Dbt &dbt) : DbMultipleIterator(dbt) {}
1337 bool next(Dbt &data);
1340 ////////////////////////////////////////////////////////////////
1341 ////////////////////////////////////////////////////////////////
1343 // multiple key/data/recno builder classes
1346 // DbMultipleBuilder is a shared private base class for the three types
1347 // of bulk buffer builders; it should never be instantiated directly,
1348 // but it handles the functionality shared by its subclasses.
1349 class _exported DbMultipleBuilder
1352 DbMultipleBuilder(Dbt &dbt);
1358 class _exported DbMultipleDataBuilder : DbMultipleBuilder
1361 DbMultipleDataBuilder(Dbt &dbt) : DbMultipleBuilder(dbt) {}
1362 bool append(void *dbuf, size_t dlen);
1363 bool reserve(void *&ddest, size_t dlen);
1366 class _exported DbMultipleKeyDataBuilder : DbMultipleBuilder
1369 DbMultipleKeyDataBuilder(Dbt &dbt) : DbMultipleBuilder(dbt) {}
1370 bool append(void *kbuf, size_t klen, void *dbuf, size_t dlen);
1371 bool reserve(void *&kdest, size_t klen, void *&ddest, size_t dlen);
1374 class _exported DbMultipleRecnoDataBuilder
1377 DbMultipleRecnoDataBuilder(Dbt &dbt);
1378 bool append(db_recno_t recno, void *dbuf, size_t dlen);
1379 bool reserve(db_recno_t recno, void *&ddest, size_t dlen);
1385 ////////////////////////////////////////////////////////////////
1386 ////////////////////////////////////////////////////////////////
1388 // Exception classes
1391 // Almost any error in the DB library throws a DbException.
1392 // Every exception should be considered an abnormality
1393 // (e.g. bug, misuse of DB, file system error).
1395 class _exported DbException : public __DB_STD(exception)
1398 virtual ~DbException() throw();
1399 DbException(int err);
1400 DbException(const char *description);
1401 DbException(const char *description, int err);
1402 DbException(const char *prefix, const char *description, int err);
1403 int get_errno() const;
1404 virtual const char *what() const throw();
1405 DbEnv *get_env() const;
1406 void set_env(DbEnv *dbenv);
1408 DbException(const DbException &);
1409 DbException &operator = (const DbException &);
1412 void describe(const char *prefix, const char *description);
1420 // A specific sort of exception that occurs when
1421 // an operation is aborted to resolve a deadlock.
1423 class _exported DbDeadlockException : public DbException
1426 virtual ~DbDeadlockException() throw();
1427 DbDeadlockException(const char *description);
1429 DbDeadlockException(const DbDeadlockException &);
1430 DbDeadlockException &operator = (const DbDeadlockException &);
1434 // A specific sort of exception that occurs when
1435 // a lock is not granted, e.g. by lock_get or lock_vec.
1436 // Note that the Dbt is only live as long as the Dbt used
1437 // in the offending call.
1439 class _exported DbLockNotGrantedException : public DbException
1442 virtual ~DbLockNotGrantedException() throw();
1443 DbLockNotGrantedException(const char *prefix, db_lockop_t op,
1444 db_lockmode_t mode, const Dbt *obj, const DbLock lock, int index);
1445 DbLockNotGrantedException(const char *description);
1447 DbLockNotGrantedException(const DbLockNotGrantedException &);
1448 DbLockNotGrantedException &operator =
1449 (const DbLockNotGrantedException &);
1451 db_lockop_t get_op() const;
1452 db_lockmode_t get_mode() const;
1453 const Dbt* get_obj() const;
1454 DbLock *get_lock() const;
1455 int get_index() const;
1459 db_lockmode_t mode_;
1466 // A specific sort of exception that occurs when
1467 // user declared memory is insufficient in a Dbt.
1469 class _exported DbMemoryException : public DbException
1472 virtual ~DbMemoryException() throw();
1473 DbMemoryException(Dbt *dbt);
1474 DbMemoryException(const char *prefix, Dbt *dbt);
1476 DbMemoryException(const DbMemoryException &);
1477 DbMemoryException &operator = (const DbMemoryException &);
1479 Dbt *get_dbt() const;
1485 // A specific sort of exception that occurs when a change of replication
1486 // master requires that all handles be re-opened.
1488 class _exported DbRepHandleDeadException : public DbException
1491 virtual ~DbRepHandleDeadException() throw();
1492 DbRepHandleDeadException(const char *description);
1494 DbRepHandleDeadException(const DbRepHandleDeadException &);
1495 DbRepHandleDeadException &operator = (const DbRepHandleDeadException &);
1499 // A specific sort of exception that occurs when
1500 // recovery is required before continuing DB activity.
1502 class _exported DbRunRecoveryException : public DbException
1505 virtual ~DbRunRecoveryException() throw();
1506 DbRunRecoveryException(const char *description);
1508 DbRunRecoveryException(const DbRunRecoveryException &);
1509 DbRunRecoveryException &operator = (const DbRunRecoveryException &);
1513 // A specific sort of exception that occurs when
1515 ////////////////////////////////////////////////////////////////
1516 ////////////////////////////////////////////////////////////////
1518 // Restore default compiler warnings
1521 #pragma warning(pop)
1524 #endif /* !_DB_CXX_H_ */