1%{ 2#include "db_config.h" 3#include "db_int.h" 4#include "dbinc/txn.h" 5 6#ifdef HAVE_CRYPTO 7#define CRYPTO_ONLY(x) (x); 8#else 9#define CRYPTO_ONLY(x) 10#endif 11%} 12 13#if defined(SWIGJAVA) 14%include "db_java.i" 15#elif defined(SWIGCSHARP) 16%include "db_csharp.i" 17#endif 18 19typedef unsigned char u_int8_t; 20typedef long int32_t; 21typedef long long db_seq_t; 22typedef long long pid_t; 23#ifndef SWIGJAVA 24typedef long long db_threadid_t; 25#endif 26typedef unsigned long u_int32_t; 27typedef u_int32_t db_recno_t; /* Record number type. */ 28typedef u_int32_t db_timeout_t; /* Type of a timeout. */ 29 30typedef int db_recops; 31typedef int db_lockmode_t; 32typedef int DBTYPE; 33typedef int DB_CACHE_PRIORITY; 34 35/* Fake typedefs for SWIG */ 36typedef int db_ret_t; /* An int that is mapped to a void */ 37typedef int int_bool; /* An int that is mapped to a boolean */ 38 39%{ 40typedef int db_ret_t; 41typedef int int_bool; 42 43struct __db_lk_conflicts { 44 u_int8_t *lk_conflicts; 45 int lk_modes; 46}; 47 48struct __db_out_stream { 49 void *handle; 50 int (*callback) __P((void *, const void *)); 51}; 52 53struct __db_repmgr_sites { 54 DB_REPMGR_SITE *sites; 55 u_int32_t nsites; 56}; 57 58#define Db __db 59#define Dbc __dbc 60#define Dbt __db_dbt 61#define DbEnv __db_env 62#define DbLock __db_lock_u 63#define DbLogc __db_log_cursor 64#define DbLsn __db_lsn 65#define DbMpoolFile __db_mpoolfile 66#define DbSequence __db_sequence 67#define DbTxn __db_txn 68 69/* Suppress a compilation warning for an unused symbol */ 70void *unused = SWIG_JavaThrowException; 71%} 72 73struct Db; typedef struct Db DB; 74struct Dbc; typedef struct Dbc DBC; 75struct Dbt; typedef struct Dbt DBT; 76struct DbEnv; typedef struct DbEnv DB_ENV; 77struct DbLock; typedef struct DbLock DB_LOCK; 78struct DbLogc; typedef struct DbLogc DB_LOGC; 79struct DbLsn; typedef struct DbLsn DB_LSN; 80struct DbMpoolFile; typedef struct DbMpoolFile DB_MPOOLFILE; 81struct DbSequence; typedef struct Db DB_SEQUENCE; 82struct DbTxn; typedef struct DbTxn DB_TXN; 83 84/* Methods that allocate new objects */ 85%newobject Db::join(DBC **curslist, u_int32_t flags); 86%newobject Db::dup(u_int32_t flags); 87%newobject DbEnv::lock_get(u_int32_t locker, 88 u_int32_t flags, const DBT *object, db_lockmode_t lock_mode); 89%newobject DbEnv::log_cursor(u_int32_t flags); 90 91struct Db 92{ 93%extend { 94 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 95 Db(DB_ENV *dbenv, u_int32_t flags) { 96 DB *self = NULL; 97 errno = db_create(&self, dbenv, flags); 98 if (errno == 0 && dbenv == NULL) 99 self->env->dbt_usercopy = __dbj_dbt_memcopy; 100 return self; 101 } 102 103 JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) 104 db_ret_t associate(DB_TXN *txnid, DB *secondary, 105 int (*callback)(DB *, const DBT *, const DBT *, DBT *), 106 u_int32_t flags) { 107 return self->associate(self, txnid, secondary, callback, flags); 108 } 109 110 db_ret_t associate_foreign(DB *primary, 111 int (*callback)(DB *, const DBT *, DBT *, const DBT *, int *), u_int32_t flags) { 112 return self->associate_foreign(self, primary, callback, flags); 113 } 114 115 db_ret_t compact(DB_TXN *txnid, DBT *start, DBT *stop, 116 DB_COMPACT *c_data, u_int32_t flags, DBT *end) { 117 return self->compact(self, txnid, start, stop, c_data, flags, 118 end); 119 } 120 121 /* 122 * Should probably be db_ret_t, but maintaining backwards compatibility 123 * for now. 124 */ 125 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 126 int close(u_int32_t flags) { 127 errno = self->close(self, flags); 128 return errno; 129 } 130 131 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) 132 DBC *cursor(DB_TXN *txnid, u_int32_t flags) { 133 DBC *cursorp = NULL; 134 errno = self->cursor(self, txnid, &cursorp, flags); 135 return cursorp; 136 } 137 138 JAVA_EXCEPT(DB_RETOK_DBDEL, DB2JDBENV) 139 int del(DB_TXN *txnid, DBT *key, u_int32_t flags) { 140 return self->del(self, txnid, key, flags); 141 } 142 143 JAVA_EXCEPT_NONE 144 void err(int error, const char *message) { 145 self->err(self, error, message); 146 } 147 148 void errx(const char *message) { 149 self->errx(self, message); 150 } 151 152 JAVA_EXCEPT(DB_RETOK_EXISTS, DB2JDBENV) 153 int exists(DB_TXN *txnid, DBT *key, u_int32_t flags) { 154 return self->exists(self, txnid, key, flags); 155 } 156 157#ifndef SWIGJAVA 158 int fd() { 159 int ret = 0; 160 errno = self->fd(self, &ret); 161 return ret; 162 } 163#endif 164 165 JAVA_EXCEPT(DB_RETOK_DBGET, DB2JDBENV) 166 int get(DB_TXN *txnid, DBT *key, DBT *data, u_int32_t flags) { 167 return self->get(self, txnid, key, data, flags); 168 } 169 170 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) 171 int_bool get_byteswapped() { 172 int ret = 0; 173 errno = self->get_byteswapped(self, &ret); 174 return ret; 175 } 176 177 jlong get_cachesize() { 178 u_int32_t gbytes = 0, bytes = 0; 179 errno = self->get_cachesize(self, &gbytes, &bytes, NULL); 180 return (jlong)gbytes * GIGABYTE + bytes; 181 } 182 183 u_int32_t get_cachesize_ncache() { 184 int ret = 0; 185 errno = self->get_cachesize(self, NULL, NULL, &ret); 186 return ret; 187 } 188 189 const char *get_filename() { 190 const char *ret = NULL; 191 errno = self->get_dbname(self, &ret, NULL); 192 return ret; 193 } 194 195 const char *get_dbname() { 196 const char *ret = NULL; 197 errno = self->get_dbname(self, NULL, &ret); 198 return ret; 199 } 200 201 u_int32_t get_encrypt_flags() { 202 u_int32_t ret = 0; 203 CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) 204 return ret; 205 } 206 207 /* 208 * This method is implemented in Java to avoid wrapping the object on 209 * every call. 210 */ 211#ifndef SWIGJAVA 212 DB_ENV *get_env() { 213 DB_ENV *env = NULL; 214 errno = self->get_env(self, &env); 215 return env; 216 } 217 218 const char *get_errpfx() { 219 const char *ret = NULL; 220 errno = 0; 221 self->get_errpfx(self, &ret); 222 return ret; 223 } 224#endif 225 226 u_int32_t get_flags() { 227 u_int32_t ret = 0; 228 errno = self->get_flags(self, &ret); 229 return ret; 230 } 231 232 int get_lorder() { 233 int ret = 0; 234 errno = self->get_lorder(self, &ret); 235 return ret; 236 } 237 238 DB_MPOOLFILE *get_mpf() { 239 errno = 0; 240 return self->get_mpf(self); 241 } 242 243 u_int32_t get_open_flags() { 244 u_int32_t ret = 0; 245 errno = self->get_open_flags(self, &ret); 246 return ret; 247 } 248 249 u_int32_t get_pagesize() { 250 u_int32_t ret = 0; 251 errno = self->get_pagesize(self, &ret); 252 return ret; 253 } 254 255 u_int32_t get_bt_minkey() { 256 u_int32_t ret = 0; 257 errno = self->get_bt_minkey(self, &ret); 258 return ret; 259 } 260 261 u_int32_t get_h_ffactor() { 262 u_int32_t ret = 0; 263 errno = self->get_h_ffactor(self, &ret); 264 return ret; 265 } 266 267 u_int32_t get_h_nelem() { 268 u_int32_t ret = 0; 269 errno = self->get_h_nelem(self, &ret); 270 return ret; 271 } 272 273 int get_re_delim() { 274 int ret = 0; 275 errno = self->get_re_delim(self, &ret); 276 return ret; 277 } 278 279 DB_CACHE_PRIORITY get_priority() { 280 DB_CACHE_PRIORITY ret; 281 errno = self->get_priority(self, &ret); 282 return ret; 283 } 284 285 u_int32_t get_re_len() { 286 u_int32_t ret = 0; 287 errno = self->get_re_len(self, &ret); 288 return ret; 289 } 290 291 int get_re_pad() { 292 int ret = 0; 293 errno = self->get_re_pad(self, &ret); 294 return ret; 295 } 296 297 const char *get_re_source() { 298 const char *ret = NULL; 299 errno = self->get_re_source(self, &ret); 300 return ret; 301 } 302 303 u_int32_t get_q_extentsize() { 304 u_int32_t ret = 0; 305 errno = self->get_q_extentsize(self, &ret); 306 return ret; 307 } 308 309 JAVA_EXCEPT_NONE 310 int_bool get_multiple() { 311 return self->get_multiple(self); 312 } 313 314 int_bool get_transactional() { 315 return self->get_transactional(self); 316 } 317 318 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) 319 DBTYPE get_type() { 320 DBTYPE type = (DBTYPE)0; 321 errno = self->get_type(self, &type); 322 return type; 323 } 324 325 DBC *join(DBC **curslist, u_int32_t flags) { 326 DBC *dbcp = NULL; 327 errno = self->join(self, curslist, &dbcp, flags); 328 return dbcp; 329 } 330 331 JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) 332 db_ret_t key_range(DB_TXN *txnid, DBT *key, DB_KEY_RANGE *key_range, 333 u_int32_t flags) { 334 return self->key_range(self, txnid, key, key_range, flags); 335 } 336 337 db_ret_t open(DB_TXN *txnid, const char *file, const char *database, 338 DBTYPE type, u_int32_t flags, int mode) { 339 return self->open(self, txnid, file, database, 340 type, flags, mode); 341 } 342 343 JAVA_EXCEPT(DB_RETOK_DBGET, DB2JDBENV) 344 int pget(DB_TXN *txnid, DBT *key, DBT *pkey, DBT *data, 345 u_int32_t flags) { 346 return self->pget(self, txnid, key, pkey, data, flags); 347 } 348 349 JAVA_EXCEPT(DB_RETOK_DBPUT, DB2JDBENV) 350 int put(DB_TXN *txnid, DBT *key, DBT *data, u_int32_t flags) { 351 return self->put(self, txnid, key, data, flags); 352 } 353 354 JAVA_EXCEPT(DB_RETOK_STD, NULL) 355 db_ret_t remove(const char *file, const char *database, 356 u_int32_t flags) { 357 return self->remove(self, file, database, flags); 358 } 359 360 db_ret_t rename(const char *file, const char *database, 361 const char *newname, u_int32_t flags) { 362 return self->rename(self, file, database, newname, flags); 363 } 364 365 JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) 366 db_ret_t set_append_recno( 367 int (*db_append_recno_fcn)(DB *, DBT *, db_recno_t)) { 368 return self->set_append_recno(self, db_append_recno_fcn); 369 } 370 371 db_ret_t set_bt_compare( 372 int (*bt_compare_fcn)(DB *, const DBT *, const DBT *)) { 373 return self->set_bt_compare(self, bt_compare_fcn); 374 } 375 376 db_ret_t set_bt_minkey(u_int32_t bt_minkey) { 377 return self->set_bt_minkey(self, bt_minkey); 378 } 379 380 db_ret_t set_bt_prefix( 381 size_t (*bt_prefix_fcn)(DB *, const DBT *, const DBT *)) { 382 return self->set_bt_prefix(self, bt_prefix_fcn); 383 } 384 385 db_ret_t set_cachesize(jlong bytes, int ncache) { 386 return self->set_cachesize(self, 387 (u_int32_t)(bytes / GIGABYTE), 388 (u_int32_t)(bytes % GIGABYTE), ncache); 389 } 390 391 db_ret_t set_dup_compare( 392 int (*dup_compare_fcn)(DB *, const DBT *, const DBT *)) { 393 return self->set_dup_compare(self, dup_compare_fcn); 394 } 395 396 db_ret_t set_encrypt(const char *passwd, u_int32_t flags) { 397 return self->set_encrypt(self, passwd, flags); 398 } 399 400 JAVA_EXCEPT_NONE 401#ifndef SWIGJAVA 402 void set_errcall( 403 void (*db_errcall_fcn)(const DB_ENV *, const char *, const char *)) { 404 self->set_errcall(self, db_errcall_fcn); 405 } 406 407 void set_errpfx(const char *errpfx) { 408 self->set_errpfx(self, errpfx); 409 } 410#endif /* SWIGJAVA */ 411 412 JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) 413 db_ret_t set_feedback(void (*db_feedback_fcn)(DB *, int, int)) { 414 return self->set_feedback(self, db_feedback_fcn); 415 } 416 417 db_ret_t set_flags(u_int32_t flags) { 418 return self->set_flags(self, flags); 419 } 420 421 db_ret_t set_h_compare( 422 int (*h_compare_fcn)(DB *, const DBT *, const DBT *)) { 423 return self->set_h_compare(self, h_compare_fcn); 424 } 425 426 db_ret_t set_h_ffactor(u_int32_t h_ffactor) { 427 return self->set_h_ffactor(self, h_ffactor); 428 } 429 430 db_ret_t set_h_hash( 431 u_int32_t (*h_hash_fcn)(DB *, const void *, u_int32_t)) { 432 return self->set_h_hash(self, h_hash_fcn); 433 } 434 435 db_ret_t set_h_nelem(u_int32_t h_nelem) { 436 return self->set_h_nelem(self, h_nelem); 437 } 438 439 db_ret_t set_lorder(int lorder) { 440 return self->set_lorder(self, lorder); 441 } 442 443#ifndef SWIGJAVA 444 void set_msgcall(void (*db_msgcall_fcn)(const DB_ENV *, const char *)) { 445 self->set_msgcall(self, db_msgcall_fcn); 446 } 447#endif /* SWIGJAVA */ 448 449 db_ret_t set_pagesize(u_int32_t pagesize) { 450 return self->set_pagesize(self, pagesize); 451 } 452 453#ifndef SWIGJAVA 454 db_ret_t set_paniccall(void (* db_panic_fcn)(DB_ENV *, int)) { 455 return self->set_paniccall(self, db_panic_fcn); 456 } 457#endif /* SWIGJAVA */ 458 459 db_ret_t set_priority(DB_CACHE_PRIORITY priority) { 460 return self->set_priority(self, priority); 461 } 462 463 db_ret_t set_re_delim(int re_delim) { 464 return self->set_re_delim(self, re_delim); 465 } 466 467 db_ret_t set_re_len(u_int32_t re_len) { 468 return self->set_re_len(self, re_len); 469 } 470 471 db_ret_t set_re_pad(int re_pad) { 472 return self->set_re_pad(self, re_pad); 473 } 474 475 db_ret_t set_re_source(char *source) { 476 return self->set_re_source(self, source); 477 } 478 479 db_ret_t set_q_extentsize(u_int32_t extentsize) { 480 return self->set_q_extentsize(self, extentsize); 481 } 482 483 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) 484 void *stat(DB_TXN *txnid, u_int32_t flags) { 485 void *statp = NULL; 486 errno = self->stat(self, txnid, &statp, flags); 487 return statp; 488 } 489 490 JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) 491 db_ret_t sync(u_int32_t flags) { 492 return self->sync(self, flags); 493 } 494 495 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) 496 int truncate(DB_TXN *txnid, u_int32_t flags) { 497 u_int32_t count = 0; 498 errno = self->truncate(self, txnid, &count, flags); 499 return count; 500 } 501 502 JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) 503 db_ret_t upgrade(const char *file, u_int32_t flags) { 504 return self->upgrade(self, file, flags); 505 } 506 507 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 508 int_bool verify(const char *file, const char *database, 509 struct __db_out_stream outfile, u_int32_t flags) { 510 /* 511 * We can't easily #include "dbinc/db_ext.h" because of name 512 * clashes, so we declare this explicitly. 513 */ 514 extern int __db_verify_internal __P((DB *, const char *, const 515 char *, void *, int (*)(void *, const void *), u_int32_t)); 516 errno = __db_verify_internal(self, file, database, 517 outfile.handle, outfile.callback, flags); 518 if (errno == DB_VERIFY_BAD) { 519 errno = 0; 520 return 0; 521 } else 522 return 1; 523 } 524} 525}; 526 527struct Dbc 528{ 529%extend { 530 JAVA_EXCEPT(DB_RETOK_STD, NULL) 531 db_ret_t close() { 532 return self->close(self); 533 } 534 535 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) 536 db_recno_t count(u_int32_t flags) { 537 db_recno_t count = 0; 538 errno = self->count(self, &count, flags); 539 return count; 540 } 541 542 JAVA_EXCEPT(DB_RETOK_DBCDEL, DBC2JDBENV) 543 int del(u_int32_t flags) { 544 return self->del(self, flags); 545 } 546 547 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) 548 DBC *dup(u_int32_t flags) { 549 DBC *newcurs = NULL; 550 errno = self->dup(self, &newcurs, flags); 551 return newcurs; 552 } 553 554 JAVA_EXCEPT(DB_RETOK_DBCGET, DBC2JDBENV) 555 int get(DBT* key, DBT *data, u_int32_t flags) { 556 return self->get(self, key, data, flags); 557 } 558 559 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) 560 DB_CACHE_PRIORITY get_priority() { 561 DB_CACHE_PRIORITY ret; 562 errno = self->get_priority(self, &ret); 563 return ret; 564 } 565 566 JAVA_EXCEPT(DB_RETOK_DBCGET, DBC2JDBENV) 567 int pget(DBT* key, DBT* pkey, DBT *data, u_int32_t flags) { 568 return self->pget(self, key, pkey, data, flags); 569 } 570 571 JAVA_EXCEPT(DB_RETOK_DBCPUT, DBC2JDBENV) 572 int put(DBT* key, DBT *data, u_int32_t flags) { 573 return self->put(self, key, data, flags); 574 } 575 576 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) 577 db_ret_t set_priority(DB_CACHE_PRIORITY priority) { 578 return self->set_priority(self, priority); 579 } 580} 581}; 582 583struct DbEnv 584{ 585%extend { 586 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 587 DbEnv(u_int32_t flags) { 588 DB_ENV *self = NULL; 589 errno = db_env_create(&self, flags); 590 if (errno == 0) 591 self->env->dbt_usercopy = __dbj_dbt_memcopy; 592 return self; 593 } 594 595 JAVA_EXCEPT(DB_RETOK_STD, NULL) 596 db_ret_t close(u_int32_t flags) { 597 return self->close(self, flags); 598 } 599 600 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 601 db_ret_t dbremove(DB_TXN *txnid, const char *file, const char *database, 602 u_int32_t flags) { 603 return self->dbremove(self, txnid, file, database, flags); 604 } 605 606 db_ret_t dbrename(DB_TXN *txnid, const char *file, const char *database, 607 const char *newname, u_int32_t flags) { 608 return self->dbrename(self, 609 txnid, file, database, newname, flags); 610 } 611 612 JAVA_EXCEPT_NONE 613 void err(int error, const char *message) { 614 self->err(self, error, message); 615 } 616 617 void errx(const char *message) { 618 self->errx(self, message); 619 } 620 621#ifndef SWIGJAVA 622 u_int32_t get_thread_count() { 623 u_int32_t ret; 624 errno = self->get_thread_count(self, &ret); 625 return ret; 626 } 627 628 pid_t getpid() { 629 pid_t ret; 630 db_threadid_t junk; 631 __os_id(self, &ret, &junk); 632 return ret; 633 } 634 635 db_threadid_t get_threadid() { 636 pid_t junk; 637 db_threadid_t ret; 638 __os_id(self, &junk, &ret); 639 return ret; 640 } 641 642 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 643 db_ret_t failchk(u_int32_t flags) { 644 return self->failchk(self, flags); 645 } 646 647 db_ret_t set_isalive( 648 int (*isalive_fcn)(DB_ENV *, pid_t, db_threadid_t)) { 649 return self->set_isalive(self, isalive_fcn); 650 } 651 652 db_ret_t set_thread_count(u_int32_t count) { 653 return self->set_thread_count(self, count); 654 } 655 656 db_ret_t set_thread_id(void (*thread_id_fcn)(DB_ENV *, pid_t *, 657 db_threadid_t *)) { 658 return self->set_thread_id(self, thread_id_fcn); 659 } 660 661 db_ret_t set_thread_id_string(char *(*thread_id_string_fcn)(DB_ENV *, 662 pid_t, db_threadid_t, char *)) { 663 return self->set_thread_id_string(self, thread_id_string_fcn); 664 } 665#endif 666 667 DB_TXN *cdsgroup_begin() { 668 DB_TXN *tid = NULL; 669 errno = self->cdsgroup_begin(self, &tid); 670 return tid; 671 } 672 673 db_ret_t fileid_reset(const char *file, u_int32_t flags) { 674 return self->fileid_reset(self, file, flags); 675 } 676 677 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 678 const char **get_data_dirs() { 679 const char **ret; 680 errno = self->get_data_dirs(self, &ret); 681 return ret; 682 } 683 684 u_int32_t get_encrypt_flags() { 685 u_int32_t ret = 0; 686 CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) 687 return ret; 688 } 689 690#ifndef SWIGJAVA 691 const char *get_errpfx() { 692 const char *ret; 693 errno = 0; 694 self->get_errpfx(self, &ret); 695 return ret; 696 } 697#endif /* SWIGJAVA */ 698 699 u_int32_t get_flags() { 700 u_int32_t ret; 701 errno = self->get_flags(self, &ret); 702 return ret; 703 } 704 705 const char *get_home() { 706 const char *ret; 707 errno = self->get_home(self, &ret); 708 return ret; 709 } 710 711 const char *get_intermediate_dir_mode() { 712 const char *ret; 713 errno = self->get_intermediate_dir_mode(self, &ret); 714 return ret; 715 } 716 717 u_int32_t get_open_flags() { 718 u_int32_t ret; 719 errno = self->get_open_flags(self, &ret); 720 return ret; 721 } 722 723 long get_shm_key() { 724 long ret; 725 errno = self->get_shm_key(self, &ret); 726 return ret; 727 } 728 729 const char *get_tmp_dir() { 730 const char *ret; 731 errno = self->get_tmp_dir(self, &ret); 732 return ret; 733 } 734 735 int_bool get_verbose(u_int32_t which) { 736 int ret; 737 errno = self->get_verbose(self, which, &ret); 738 return ret; 739 } 740 741 JAVA_EXCEPT_NONE 742 int_bool is_bigendian() { 743 return self->is_bigendian(); 744 } 745 746 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 747 db_ret_t lsn_reset(const char *file, u_int32_t flags) { 748 return self->lsn_reset(self, file, flags); 749 } 750 751 db_ret_t open(const char *db_home, u_int32_t flags, int mode) { 752 return self->open(self, db_home, flags, mode); 753 } 754 755 JAVA_EXCEPT(DB_RETOK_STD, NULL) 756 db_ret_t remove(const char *db_home, u_int32_t flags) { 757 return self->remove(self, db_home, flags); 758 } 759 760 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 761 db_ret_t set_cachesize(jlong bytes, int ncache) { 762 return self->set_cachesize(self, 763 (u_int32_t)(bytes / GIGABYTE), 764 (u_int32_t)(bytes % GIGABYTE), ncache); 765 } 766 767 db_ret_t set_cache_max(jlong bytes) { 768 return self->set_cache_max(self, 769 (u_int32_t)(bytes / GIGABYTE), 770 (u_int32_t)(bytes % GIGABYTE)); 771 } 772 773 db_ret_t set_data_dir(const char *dir) { 774 return self->set_data_dir(self, dir); 775 } 776 777 db_ret_t set_intermediate_dir_mode(const char *mode) { 778 return self->set_intermediate_dir_mode(self, mode); 779 } 780 781 db_ret_t set_encrypt(const char *passwd, u_int32_t flags) { 782 return self->set_encrypt(self, passwd, flags); 783 } 784 785 JAVA_EXCEPT_NONE 786 void set_errcall(void (*db_errcall_fcn)(const DB_ENV *, const char *, 787 const char *)) { 788 self->set_errcall(self, db_errcall_fcn); 789 } 790 791#ifndef SWIGJAVA 792 void set_errpfx(const char *errpfx) { 793 self->set_errpfx(self, errpfx); 794 } 795#endif 796 797 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 798 db_ret_t set_flags(u_int32_t flags, int_bool onoff) { 799 return self->set_flags(self, flags, onoff); 800 } 801 802 db_ret_t set_feedback(void (*env_feedback_fcn)(DB_ENV *, int, int)) { 803 return self->set_feedback(self, env_feedback_fcn); 804 } 805 806 db_ret_t set_mp_max_openfd(int maxopenfd) { 807 return self->set_mp_max_openfd(self, maxopenfd); 808 } 809 810 db_ret_t set_mp_max_write(int maxwrite, db_timeout_t maxwrite_sleep) { 811 return self->set_mp_max_write(self, maxwrite, maxwrite_sleep); 812 } 813 814 db_ret_t set_mp_mmapsize(size_t mp_mmapsize) { 815 return self->set_mp_mmapsize(self, mp_mmapsize); 816 } 817 818 JAVA_EXCEPT_NONE 819 void set_msgcall(void (*db_msgcall_fcn)(const DB_ENV *, const char *)) { 820 self->set_msgcall(self, db_msgcall_fcn); 821 } 822 823 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 824 db_ret_t set_paniccall(void (*db_panic_fcn)(DB_ENV *, int)) { 825 return self->set_paniccall(self, db_panic_fcn); 826 } 827 828 db_ret_t set_rpc_server(char *host, 829 long cl_timeout, long sv_timeout, u_int32_t flags) { 830 return self->set_rpc_server(self, NULL, host, 831 cl_timeout, sv_timeout, flags); 832 } 833 834 db_ret_t set_shm_key(long shm_key) { 835 return self->set_shm_key(self, shm_key); 836 } 837 838 db_ret_t set_timeout(db_timeout_t timeout, u_int32_t flags) { 839 return self->set_timeout(self, timeout, flags); 840 } 841 842 db_ret_t set_tmp_dir(const char *dir) { 843 return self->set_tmp_dir(self, dir); 844 } 845 846 db_ret_t set_tx_max(u_int32_t max) { 847 return self->set_tx_max(self, max); 848 } 849 850 db_ret_t set_app_dispatch( 851 int (*tx_recover)(DB_ENV *, DBT *, DB_LSN *, db_recops)) { 852 return self->set_app_dispatch(self, tx_recover); 853 } 854 855 db_ret_t set_event_notify( 856 void (*event_notify)(DB_ENV *, u_int32_t, void *)) { 857 return self->set_event_notify(self, event_notify); 858 } 859 860 db_ret_t set_tx_timestamp(time_t *timestamp) { 861 return self->set_tx_timestamp(self, timestamp); 862 } 863 864 db_ret_t set_verbose(u_int32_t which, int_bool onoff) { 865 return self->set_verbose(self, which, onoff); 866 } 867 868 /* Lock functions */ 869 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 870 struct __db_lk_conflicts get_lk_conflicts() { 871 struct __db_lk_conflicts ret; 872 errno = self->get_lk_conflicts(self, 873 (const u_int8_t **)&ret.lk_conflicts, &ret.lk_modes); 874 return ret; 875 } 876 877 u_int32_t get_lk_detect() { 878 u_int32_t ret; 879 errno = self->get_lk_detect(self, &ret); 880 return ret; 881 } 882 883 u_int32_t get_lk_max_locks() { 884 u_int32_t ret; 885 errno = self->get_lk_max_locks(self, &ret); 886 return ret; 887 } 888 889 u_int32_t get_lk_max_lockers() { 890 u_int32_t ret; 891 errno = self->get_lk_max_lockers(self, &ret); 892 return ret; 893 } 894 895 u_int32_t get_lk_max_objects() { 896 u_int32_t ret; 897 errno = self->get_lk_max_objects(self, &ret); 898 return ret; 899 } 900 901 int lock_detect(u_int32_t flags, u_int32_t atype) { 902 int aborted; 903 errno = self->lock_detect(self, flags, atype, &aborted); 904 return aborted; 905 } 906 907 DB_LOCK *lock_get(u_int32_t locker, 908 u_int32_t flags, const DBT *object, db_lockmode_t lock_mode) { 909 DB_LOCK *lock = NULL; 910 if ((errno = __os_malloc(self->env, sizeof (DB_LOCK), &lock)) == 0) 911 errno = self->lock_get(self, locker, flags, object, 912 lock_mode, lock); 913 return lock; 914 } 915 916 u_int32_t lock_id() { 917 u_int32_t id; 918 errno = self->lock_id(self, &id); 919 return id; 920 } 921 922 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 923 db_ret_t lock_id_free(u_int32_t id) { 924 return self->lock_id_free(self, id); 925 } 926 927 db_ret_t lock_put(DB_LOCK *lock) { 928 return self->lock_put(self, lock); 929 } 930 931 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 932 DB_LOCK_STAT *lock_stat(u_int32_t flags) { 933 DB_LOCK_STAT *statp = NULL; 934 errno = self->lock_stat(self, &statp, flags); 935 return statp; 936 } 937 938#ifndef SWIGJAVA 939 /* For Java, this is defined in native code */ 940 db_ret_t lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ *list, 941 int offset, int nlist) 942 { 943 DB_LOCKREQ *elistp; 944 return self->lock_vec(self, locker, flags, list + offset, 945 nlist, &elistp); 946 } 947#endif 948 949 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 950 db_ret_t set_lk_conflicts(struct __db_lk_conflicts conflicts) { 951 return self->set_lk_conflicts(self, 952 conflicts.lk_conflicts, conflicts.lk_modes); 953 } 954 955 db_ret_t set_lk_detect(u_int32_t detect) { 956 return self->set_lk_detect(self, detect); 957 } 958 959 db_ret_t set_lk_max_lockers(u_int32_t max) { 960 return self->set_lk_max_lockers(self, max); 961 } 962 963 db_ret_t set_lk_max_locks(u_int32_t max) { 964 return self->set_lk_max_locks(self, max); 965 } 966 967 db_ret_t set_lk_max_objects(u_int32_t max) { 968 return self->set_lk_max_objects(self, max); 969 } 970 971 /* Log functions */ 972 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 973 u_int32_t get_lg_bsize() { 974 u_int32_t ret; 975 errno = self->get_lg_bsize(self, &ret); 976 return ret; 977 } 978 979 const char *get_lg_dir() { 980 const char *ret; 981 errno = self->get_lg_dir(self, &ret); 982 return ret; 983 } 984 985 int get_lg_filemode() { 986 int ret; 987 errno = self->get_lg_filemode(self, &ret); 988 return ret; 989 } 990 991 u_int32_t get_lg_max() { 992 u_int32_t ret; 993 errno = self->get_lg_max(self, &ret); 994 return ret; 995 } 996 997 u_int32_t get_lg_regionmax() { 998 u_int32_t ret; 999 errno = self->get_lg_regionmax(self, &ret); 1000 return ret; 1001 } 1002 1003 char **log_archive(u_int32_t flags) { 1004 char **list = NULL; 1005 errno = self->log_archive(self, &list, flags); 1006 return list; 1007 } 1008 1009 JAVA_EXCEPT_NONE 1010 static int log_compare(const DB_LSN *lsn0, const DB_LSN *lsn1) { 1011 return log_compare(lsn0, lsn1); 1012 } 1013 1014 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1015 DB_LOGC *log_cursor(u_int32_t flags) { 1016 DB_LOGC *cursor = NULL; 1017 errno = self->log_cursor(self, &cursor, flags); 1018 return cursor; 1019 } 1020 1021 char *log_file(DB_LSN *lsn) { 1022 char namebuf[DB_MAXPATHLEN]; 1023 errno = self->log_file(self, lsn, namebuf, sizeof namebuf); 1024 return (errno == 0) ? strdup(namebuf) : NULL; 1025 } 1026 1027 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1028 db_ret_t log_flush(const DB_LSN *lsn_or_null) { 1029 return self->log_flush(self, lsn_or_null); 1030 } 1031 1032 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1033 int_bool log_get_config(u_int32_t which) { 1034 int ret; 1035 errno = self->log_get_config(self, which, &ret); 1036 return ret; 1037 } 1038 1039 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1040 db_ret_t log_put(DB_LSN *lsn, const DBT *data, u_int32_t flags) { 1041 return self->log_put(self, lsn, data, flags); 1042 } 1043 1044 db_ret_t log_print(DB_TXN *txn, const char *msg) { 1045 return self->log_printf(self, txn, "%s", msg); 1046 } 1047 1048 db_ret_t log_set_config(u_int32_t which, int_bool onoff) { 1049 return self->log_set_config(self, which, onoff); 1050 } 1051 1052 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1053 DB_LOG_STAT *log_stat(u_int32_t flags) { 1054 DB_LOG_STAT *sp = NULL; 1055 errno = self->log_stat(self, &sp, flags); 1056 return sp; 1057 } 1058 1059 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1060 db_ret_t set_lg_bsize(u_int32_t lg_bsize) { 1061 return self->set_lg_bsize(self, lg_bsize); 1062 } 1063 1064 db_ret_t set_lg_dir(const char *dir) { 1065 return self->set_lg_dir(self, dir); 1066 } 1067 1068 db_ret_t set_lg_filemode(int mode) { 1069 return self->set_lg_filemode(self, mode); 1070 } 1071 1072 db_ret_t set_lg_max(u_int32_t lg_max) { 1073 return self->set_lg_max(self, lg_max); 1074 } 1075 1076 db_ret_t set_lg_regionmax(u_int32_t lg_regionmax) { 1077 return self->set_lg_regionmax(self, lg_regionmax); 1078 } 1079 1080 /* Memory pool functions */ 1081 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1082 jlong get_cachesize() { 1083 u_int32_t gbytes, bytes; 1084 errno = self->get_cachesize(self, &gbytes, &bytes, NULL); 1085 return (jlong)gbytes * GIGABYTE + bytes; 1086 } 1087 1088 int get_cachesize_ncache() { 1089 int ret; 1090 errno = self->get_cachesize(self, NULL, NULL, &ret); 1091 return ret; 1092 } 1093 1094 jlong get_cache_max() { 1095 u_int32_t gbytes, bytes; 1096 errno = self->get_cache_max(self, &gbytes, &bytes); 1097 return (jlong)gbytes * GIGABYTE + bytes; 1098 } 1099 1100 int get_mp_max_openfd() { 1101 int ret; 1102 errno = self->get_mp_max_openfd(self, &ret); 1103 return ret; 1104 } 1105 1106 int get_mp_max_write() { 1107 int maxwrite; 1108 db_timeout_t sleep; 1109 errno = self->get_mp_max_write(self, &maxwrite, &sleep); 1110 return maxwrite; 1111 } 1112 1113 db_timeout_t get_mp_max_write_sleep() { 1114 int maxwrite; 1115 db_timeout_t sleep; 1116 errno = self->get_mp_max_write(self, &maxwrite, &sleep); 1117 return sleep; 1118 } 1119 1120 size_t get_mp_mmapsize() { 1121 size_t ret; 1122 errno = self->get_mp_mmapsize(self, &ret); 1123 return ret; 1124 } 1125 1126 DB_MPOOL_STAT *memp_stat(u_int32_t flags) { 1127 DB_MPOOL_STAT *mp_stat = NULL; 1128 errno = self->memp_stat(self, &mp_stat, NULL, flags); 1129 return mp_stat; 1130 } 1131 1132 DB_MPOOL_FSTAT **memp_fstat(u_int32_t flags) { 1133 DB_MPOOL_FSTAT **mp_fstat = NULL; 1134 errno = self->memp_stat(self, NULL, &mp_fstat, flags); 1135 return mp_fstat; 1136 } 1137 1138 int memp_trickle(int percent) { 1139 int ret; 1140 errno = self->memp_trickle(self, percent, &ret); 1141 return ret; 1142 } 1143 1144 /* Mutex functions */ 1145 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1146 u_int32_t mutex_get_align() { 1147 u_int32_t ret; 1148 errno = self->mutex_get_align(self, &ret); 1149 return ret; 1150 } 1151 1152 u_int32_t mutex_get_increment() { 1153 u_int32_t ret; 1154 errno = self->mutex_get_increment(self, &ret); 1155 return ret; 1156 } 1157 1158 u_int32_t mutex_get_max() { 1159 u_int32_t ret; 1160 errno = self->mutex_get_max(self, &ret); 1161 return ret; 1162 } 1163 1164 u_int32_t mutex_get_tas_spins() { 1165 u_int32_t ret; 1166 errno = self->mutex_get_tas_spins(self, &ret); 1167 return ret; 1168 } 1169 1170 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1171 db_ret_t mutex_set_align(u_int32_t align) { 1172 return self->mutex_set_align(self, align); 1173 } 1174 1175 db_ret_t mutex_set_increment(u_int32_t increment) { 1176 return self->mutex_set_increment(self, increment); 1177 } 1178 1179 db_ret_t mutex_set_max(u_int32_t mutex_max) { 1180 return self->mutex_set_increment(self, mutex_max); 1181 } 1182 1183 db_ret_t mutex_set_tas_spins(u_int32_t tas_spins) { 1184 return self->mutex_set_tas_spins(self, tas_spins); 1185 } 1186 1187 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1188 DB_MUTEX_STAT *mutex_stat(u_int32_t flags) { 1189 DB_MUTEX_STAT *statp = NULL; 1190 errno = self->mutex_stat(self, &statp, flags); 1191 return statp; 1192 } 1193 1194 /* Transaction functions */ 1195 u_int32_t get_tx_max() { 1196 u_int32_t ret; 1197 errno = self->get_tx_max(self, &ret); 1198 return ret; 1199 } 1200 1201 time_t get_tx_timestamp() { 1202 time_t ret; 1203 errno = self->get_tx_timestamp(self, &ret); 1204 return ret; 1205 } 1206 1207 db_timeout_t get_timeout(u_int32_t flag) { 1208 db_timeout_t ret; 1209 errno = self->get_timeout(self, &ret, flag); 1210 return ret; 1211 } 1212 1213 DB_TXN *txn_begin(DB_TXN *parent, u_int32_t flags) { 1214 DB_TXN *tid = NULL; 1215 errno = self->txn_begin(self, parent, &tid, flags); 1216 return tid; 1217 } 1218 1219 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1220 db_ret_t txn_checkpoint(u_int32_t kbyte, u_int32_t min, 1221 u_int32_t flags) { 1222 return self->txn_checkpoint(self, kbyte, min, flags); 1223 } 1224 1225 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1226 DB_PREPLIST *txn_recover(int count, u_int32_t flags) { 1227 DB_PREPLIST *preplist; 1228 long retcount; 1229 1230 /* Add a NULL element to terminate the array. */ 1231 if ((errno = __os_malloc(self->env, 1232 (count + 1) * sizeof(DB_PREPLIST), &preplist)) != 0) 1233 return NULL; 1234 1235 if ((errno = self->txn_recover(self, preplist, count, 1236 &retcount, flags)) != 0) { 1237 __os_free(self->env, preplist); 1238 return NULL; 1239 } 1240 1241 preplist[retcount].txn = NULL; 1242 return preplist; 1243 } 1244 1245 DB_TXN_STAT *txn_stat(u_int32_t flags) { 1246 DB_TXN_STAT *statp = NULL; 1247 errno = self->txn_stat(self, &statp, flags); 1248 return statp; 1249 } 1250 1251 /* Replication functions */ 1252 jlong rep_get_limit() { 1253 u_int32_t gbytes, bytes; 1254 errno = self->rep_get_limit(self, &gbytes, &bytes); 1255 return (jlong)gbytes * GIGABYTE + bytes; 1256 } 1257 1258 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1259 db_ret_t rep_elect(u_int32_t nsites, int nvotes, u_int32_t flags) { 1260 return self->rep_elect(self, nsites, nvotes, flags); 1261 } 1262 1263 JAVA_EXCEPT(DB_RETOK_REPPMSG, JDBENV) 1264 int rep_process_message(DBT *control, DBT *rec, int envid, 1265 DB_LSN *ret_lsn) { 1266 return self->rep_process_message(self, control, rec, envid, 1267 ret_lsn); 1268 } 1269 1270 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1271 db_ret_t rep_flush() { 1272 return self->rep_flush(self); 1273 } 1274 1275 db_ret_t rep_set_config(u_int32_t which, int_bool onoff) { 1276 return self->rep_set_config(self, which, onoff); 1277 } 1278 1279 db_ret_t rep_set_clockskew(u_int32_t fast_clock, u_int32_t slow_clock) { 1280 return self->rep_set_clockskew(self, fast_clock, slow_clock); 1281 } 1282 1283 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1284 u_int32_t rep_get_clockskew_fast() { 1285 u_int32_t fast_clock, slow_clock; 1286 errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); 1287 return fast_clock; 1288 } 1289 1290 u_int32_t rep_get_clockskew_slow() { 1291 u_int32_t fast_clock, slow_clock; 1292 errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); 1293 return slow_clock; 1294 } 1295 1296 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1297 db_ret_t rep_start(DBT *cdata, u_int32_t flags) { 1298 return self->rep_start(self, cdata, flags); 1299 } 1300 1301 db_ret_t rep_sync(u_int32_t flags) { 1302 return self->rep_sync(self, flags); 1303 } 1304 1305 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1306 int_bool rep_get_config(u_int32_t which) { 1307 int ret; 1308 errno = self->rep_get_config(self, which, &ret); 1309 return ret; 1310 } 1311 1312 DB_REP_STAT *rep_stat(u_int32_t flags) { 1313 DB_REP_STAT *statp = NULL; 1314 errno = self->rep_stat(self, &statp, flags); 1315 return statp; 1316 } 1317 1318 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1319 db_ret_t rep_set_limit(jlong bytes) { 1320 return self->rep_set_limit(self, 1321 (u_int32_t)(bytes / GIGABYTE), 1322 (u_int32_t)(bytes % GIGABYTE)); 1323 } 1324 1325 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1326 u_int32_t rep_get_request_min(){ 1327 u_int32_t min, max; 1328 errno = self->rep_get_request(self, &min, &max); 1329 return min; 1330 } 1331 1332 u_int32_t rep_get_request_max(){ 1333 u_int32_t min, max; 1334 errno = self->rep_get_request(self, &min, &max); 1335 return max; 1336 } 1337 1338 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1339 db_ret_t rep_set_request(u_int32_t min, u_int32_t max) { 1340 return self->rep_set_request(self, min, max); 1341 } 1342 1343 db_ret_t rep_set_transport(int envid, 1344 int (*send)(DB_ENV *, const DBT *, const DBT *, 1345 const DB_LSN *, int, u_int32_t)) { 1346 return self->rep_set_transport(self, envid, send); 1347 } 1348 1349 /* Advanced replication functions. */ 1350 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1351 u_int32_t rep_get_nsites() { 1352 u_int32_t ret; 1353 errno = self->rep_get_nsites(self, &ret); 1354 return ret; 1355 } 1356 1357 u_int32_t rep_get_priority() { 1358 u_int32_t ret; 1359 errno = self->rep_get_priority(self, &ret); 1360 return ret; 1361 } 1362 1363 u_int32_t rep_get_timeout(int which) { 1364 u_int32_t ret; 1365 errno = self->rep_get_timeout(self, which, &ret); 1366 return ret; 1367 } 1368 1369 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1370 db_ret_t rep_set_nsites(u_int32_t number) { 1371 return self->rep_set_nsites(self, number); 1372 } 1373 1374 db_ret_t rep_set_priority(u_int32_t priority) { 1375 return self->rep_set_priority(self, priority); 1376 } 1377 1378 db_ret_t rep_set_timeout(int which, db_timeout_t timeout) { 1379 return self->rep_set_timeout(self, which, timeout); 1380 } 1381 1382 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1383 int repmgr_add_remote_site(const char * host, u_int32_t port, 1384 u_int32_t flags) { 1385 int eid; 1386 errno = self->repmgr_add_remote_site(self, host, port, &eid, flags); 1387 return eid; 1388 } 1389 1390 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1391 db_ret_t repmgr_get_ack_policy() { 1392 int ret; 1393 errno = self->repmgr_get_ack_policy(self, &ret); 1394 return ret; 1395 } 1396 1397 db_ret_t repmgr_set_ack_policy(int policy) { 1398 return self->repmgr_set_ack_policy(self, policy); 1399 } 1400 1401 db_ret_t repmgr_set_local_site(const char * host, u_int32_t port, u_int32_t flags) { 1402 return self->repmgr_set_local_site(self, host, port, flags); 1403 } 1404 1405 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1406 struct __db_repmgr_sites repmgr_site_list() { 1407 struct __db_repmgr_sites sites; 1408 errno = self->repmgr_site_list(self, 1409 &sites.nsites, &sites.sites); 1410 return sites; 1411 } 1412 1413 JAVA_EXCEPT(DB_RETOK_STD, JDBENV) 1414 db_ret_t repmgr_start(int nthreads, u_int32_t flags) { 1415 return self->repmgr_start(self, nthreads, flags); 1416 } 1417 1418 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) 1419 DB_REPMGR_STAT *repmgr_stat(u_int32_t flags) { 1420 DB_REPMGR_STAT *statp = NULL; 1421 errno = self->repmgr_stat(self, &statp, flags); 1422 return statp; 1423 } 1424 1425 /* Convert DB errors to strings */ 1426 JAVA_EXCEPT_NONE 1427 static const char *strerror(int error) { 1428 return db_strerror(error); 1429 } 1430 1431 /* Versioning information */ 1432 static int get_version_major() { 1433 return DB_VERSION_MAJOR; 1434 } 1435 1436 static int get_version_minor() { 1437 return DB_VERSION_MINOR; 1438 } 1439 1440 static int get_version_patch() { 1441 return DB_VERSION_PATCH; 1442 } 1443 1444 static const char *get_version_string() { 1445 return DB_VERSION_STRING; 1446 } 1447} 1448}; 1449 1450struct DbLock 1451{ 1452%extend { 1453 JAVA_EXCEPT_NONE 1454 ~DbLock() { 1455 __os_free(NULL, self); 1456 } 1457} 1458}; 1459 1460struct DbLogc 1461{ 1462%extend { 1463 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1464 db_ret_t close(u_int32_t flags) { 1465 return self->close(self, flags); 1466 } 1467 1468 JAVA_EXCEPT(DB_RETOK_LGGET, NULL) 1469 int get(DB_LSN *lsn, DBT *data, u_int32_t flags) { 1470 return self->get(self, lsn, data, flags); 1471 } 1472 1473 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1474 u_int32_t version(u_int32_t flags) { 1475 u_int32_t result; 1476 errno = self->version(self, &result, flags); 1477 return result; 1478 } 1479} 1480}; 1481 1482#ifndef SWIGJAVA 1483struct DbLsn 1484{ 1485%extend { 1486 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1487 DbLsn(u_int32_t file, u_int32_t offset) { 1488 DB_LSN *self = NULL; 1489 if ((errno = __os_malloc(NULL, sizeof (DB_LSN), &self)) == 0) { 1490 self->file = file; 1491 self->offset = offset; 1492 } 1493 return self; 1494 } 1495 1496 JAVA_EXCEPT_NONE 1497 ~DbLsn() { 1498 __os_free(NULL, self); 1499 } 1500 1501 u_int32_t get_file() { 1502 return self->file; 1503 } 1504 1505 u_int32_t get_offset() { 1506 return self->offset; 1507 } 1508} 1509}; 1510#endif 1511 1512struct DbMpoolFile 1513{ 1514%extend { 1515 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1516 DB_CACHE_PRIORITY get_priority() { 1517 DB_CACHE_PRIORITY ret; 1518 errno = self->get_priority(self, &ret); 1519 return ret; 1520 } 1521 1522 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1523 db_ret_t set_priority(DB_CACHE_PRIORITY priority) { 1524 return self->set_priority(self, priority); 1525 } 1526 1527 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1528 u_int32_t get_flags() { 1529 u_int32_t ret; 1530 errno = self->get_flags(self, &ret); 1531 return ret; 1532 } 1533 1534 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1535 db_ret_t set_flags(u_int32_t flags, int_bool onoff) { 1536 return self->set_flags(self, flags, onoff); 1537 } 1538 1539 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1540 jlong get_maxsize() { 1541 u_int32_t gbytes, bytes; 1542 errno = self->get_maxsize(self, &gbytes, &bytes); 1543 return (jlong)gbytes * GIGABYTE + bytes; 1544 } 1545 1546 /* New method - no backwards compatibility version */ 1547 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1548 db_ret_t set_maxsize(jlong bytes) { 1549 return self->set_maxsize(self, 1550 (u_int32_t)(bytes / GIGABYTE), 1551 (u_int32_t)(bytes % GIGABYTE)); 1552 } 1553} 1554}; 1555 1556struct DbSequence 1557{ 1558%extend { 1559 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1560 DbSequence(DB *db, u_int32_t flags) { 1561 DB_SEQUENCE *self = NULL; 1562 errno = db_sequence_create(&self, db, flags); 1563 return self; 1564 } 1565 1566 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1567 db_ret_t close(u_int32_t flags) { 1568 return self->close(self, flags); 1569 } 1570 1571 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1572 db_seq_t get(DB_TXN *txnid, int32_t delta, u_int32_t flags) { 1573 db_seq_t ret = 0; 1574 errno = self->get(self, txnid, delta, &ret, flags); 1575 return ret; 1576 } 1577 1578 int32_t get_cachesize() { 1579 int32_t ret = 0; 1580 errno = self->get_cachesize(self, &ret); 1581 return ret; 1582 } 1583 1584 DB *get_db() { 1585 DB *ret = NULL; 1586 errno = self->get_db(self, &ret); 1587 return ret; 1588 } 1589 1590 u_int32_t get_flags() { 1591 u_int32_t ret = 0; 1592 errno = self->get_flags(self, &ret); 1593 return ret; 1594 } 1595 1596 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1597 db_ret_t get_key(DBT *key) { 1598 return self->get_key(self, key); 1599 } 1600 1601 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1602 db_seq_t get_range_min() { 1603 db_seq_t ret = 0; 1604 errno = self->get_range(self, &ret, NULL); 1605 return ret; 1606 } 1607 1608 db_seq_t get_range_max() { 1609 db_seq_t ret = 0; 1610 errno = self->get_range(self, NULL, &ret); 1611 return ret; 1612 } 1613 1614 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1615 db_ret_t initial_value(db_seq_t val) { 1616 return self->initial_value(self, val); 1617 } 1618 1619 db_ret_t open(DB_TXN *txnid, DBT *key, u_int32_t flags) { 1620 return self->open(self, txnid, key, flags); 1621 } 1622 1623 db_ret_t remove(DB_TXN *txnid, u_int32_t flags) { 1624 return self->remove(self, txnid, flags); 1625 } 1626 1627 db_ret_t set_cachesize(int32_t size) { 1628 return self->set_cachesize(self, size); 1629 } 1630 1631 db_ret_t set_flags(u_int32_t flags) { 1632 return self->set_flags(self, flags); 1633 } 1634 1635 db_ret_t set_range(db_seq_t min, db_seq_t max) { 1636 return self->set_range(self, min, max); 1637 } 1638 1639 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) 1640 DB_SEQUENCE_STAT *stat(u_int32_t flags) { 1641 DB_SEQUENCE_STAT *ret = NULL; 1642 errno = self->stat(self, &ret, flags); 1643 return ret; 1644 } 1645} 1646}; 1647 1648struct DbTxn 1649{ 1650%extend { 1651 JAVA_EXCEPT(DB_RETOK_STD, NULL) 1652 db_ret_t abort() { 1653 return self->abort(self); 1654 } 1655 1656 db_ret_t commit(u_int32_t flags) { 1657 return self->commit(self, flags); 1658 } 1659 1660 db_ret_t discard(u_int32_t flags) { 1661 return self->discard(self, flags); 1662 } 1663 1664 JAVA_EXCEPT_ERRNO(DB_RETOK_STD, TXN2JDBENV) 1665 const char *get_name() { 1666 const char *name = NULL; 1667 errno = self->get_name(self, &name); 1668 return name; 1669 } 1670 1671 JAVA_EXCEPT_NONE 1672 u_int32_t id() { 1673 return self->id(self); 1674 } 1675 1676 JAVA_EXCEPT(DB_RETOK_STD, TXN2JDBENV) 1677 db_ret_t prepare(u_int8_t *gid) { 1678 return self->prepare(self, gid); 1679 } 1680 1681 db_ret_t set_timeout(db_timeout_t timeout, u_int32_t flags) { 1682 return self->set_timeout(self, timeout, flags); 1683 } 1684 1685 db_ret_t set_name(const char *name) { 1686 return self->set_name(self, name); 1687 } 1688} 1689}; 1690 1691