开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
java_DbEnv.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：36k
源码类别：

MySQL数据库

开发平台：

Visual C++

java_DbEnv.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  9. #ifndef lint
  10. static const char revid[] = "$Id: java_DbEnv.c,v 11.37 2001/01/11 18:19:52 bostic Exp $";
  11. #endif /* not lint */
  13. #include <jni.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  17. #include "db.h"
  18. #include "db_int.h"
  19. #include "java_util.h"
  20. #include "com_sleepycat_db_DbEnv.h"
  22. /* We keep these lined up, and alphabetical by field name,
  23.  * for comparison with C++'s list.
  24.  */
  25. JAVADB_WO_ACCESS_STRING(DbEnv,        data_1dir, DB_ENV, data_dir)
  26. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lg_1bsize, DB_ENV, lg_bsize)
  27. JAVADB_WO_ACCESS_STRING(DbEnv,        lg_1dir, DB_ENV, lg_dir)
  28. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lg_1max, DB_ENV, lg_max)
  29. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lk_1detect, DB_ENV, lk_detect)
  30. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lk_1max, DB_ENV, lk_max)
  31. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lk_1max_1locks, DB_ENV, lk_max_locks)
  32. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lk_1max_1lockers, DB_ENV, lk_max_lockers)
  33. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  lk_1max_1objects, DB_ENV, lk_max_objects)
  34. /* mp_mmapsize is declared below, it needs an extra cast */
  35. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  mutexlocks, DB_ENV, mutexlocks)
  36. JAVADB_WO_ACCESS_STRING(DbEnv,        tmp_1dir, DB_ENV, tmp_dir)
  37. JAVADB_WO_ACCESS_METHOD(DbEnv, jint,  tx_1max, DB_ENV, tx_max)
  39. static void DbEnv_errcall_callback(const char *prefix, char *message)
  40. {
  41. JNIEnv *jnienv;
  42. DB_ENV_JAVAINFO *envinfo = (DB_ENV_JAVAINFO *)prefix;
  43. jstring pre;
  45. /* Note: these error cases are "impossible", and would
  46.  * normally warrant an exception.  However, without
  47.  * a jnienv, we cannot throw an exception...
  48.  * We don't want to trap or exit, since the point of
  49.  * this facility is for the user to completely control
  50.  * error situations.
  51.  */
  52. if (envinfo == NULL) {
  53. /* Something is *really* wrong here, the
  54.  * prefix is set in every environment created.
  55.  */
  56. fprintf(stderr, "Error callback failed!n");
  57. fprintf(stderr, "error: %sn", message);
  58. return;
  59. }
  61. /* Should always succeed... */
  62. jnienv = dbjie_get_jnienv(envinfo);
  64. if (jnienv == NULL) {
  66. /* But just in case... */
  67. fprintf(stderr, "Cannot attach to current thread!n");
  68. fprintf(stderr, "error: %sn", message);
  69. return;
  70. }
  72. pre = dbjie_get_errpfx(envinfo, jnienv);
  73. report_errcall(jnienv,  dbjie_get_errcall(envinfo), pre, message);
  74. }
  76. static void DbEnv_initialize(JNIEnv *jnienv, DB_ENV *dbenv,
  77.      /*DbEnv*/ jobject jenv,
  78.      /*DbErrcall*/ jobject jerrcall,
  79.      int is_dbopen)
  80. {
  81. DB_ENV_JAVAINFO *envinfo;
  83. envinfo = get_DB_ENV_JAVAINFO(jnienv, jenv);
  84. DB_ASSERT(envinfo == NULL);
  85. envinfo = dbjie_construct(jnienv, jerrcall, is_dbopen);
  86. set_private_info(jnienv, name_DB_ENV, jenv, envinfo);
  87. dbenv->set_errpfx(dbenv, (const char*)envinfo);
  88. dbenv->set_errcall(dbenv, DbEnv_errcall_callback);
  89. dbenv->cj_internal = envinfo;
  90. set_private_dbobj(jnienv, name_DB_ENV, jenv, dbenv);
  91. }
  93. /* This is called when this DbEnv was made on behalf of a Db
  94.  * created directly (without a parent DbEnv), and the Db is
  95.  * being closed.  We'll zero out the pointer to the DB_ENV,
  96.  * since it is no longer valid, to prevent mistakes.
  97.  */
  98. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1notify_1db_1close
  99.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  100. {
  101. DB_ENV_JAVAINFO *dbenvinfo;
  103. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  104. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  105. if (dbenvinfo != NULL)
  106. dbjie_dealloc(dbenvinfo, jnienv);
  107. }
  109. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_feedback_1changed
  110.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbFeedback*/ jobject jfeedback)
  111. {
  112. DB_ENV *dbenv;
  113. DB_ENV_JAVAINFO *dbenvinfo;
  115. dbenv = get_DB_ENV(jnienv, jthis);
  116. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  117. if (!verify_non_null(jnienv, dbenv) ||
  118.     !verify_non_null(jnienv, dbenvinfo))
  119. return;
  121. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  122. dbjie_set_feedback_object(dbenvinfo, jnienv, dbenv, jfeedback);
  123. JAVADB_ENV_API_END(dbenv);
  124. }
  126. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1init
  127.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobject /*DbErrcall*/ jerrcall,
  128.    jint flags)
  129. {
  130. int err;
  131. DB_ENV *dbenv;
  133. err = db_env_create(&dbenv, flags);
  134. if (verify_return(jnienv, err, 0))
  135. DbEnv_initialize(jnienv, dbenv, jthis, jerrcall, 0);
  136. }
  138. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1init_1using_1db
  139.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobject /*DbErrcall*/ jerrcall,
  140.    /*Db*/ jobject jdb)
  141. {
  142. DB_ENV *dbenv;
  143. DB *db;
  145. db = get_DB(jnienv, jdb);
  146. dbenv = db->dbenv;
  147. DbEnv_initialize(jnienv, dbenv, jthis, jerrcall, 1);
  148. }
  150. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_open
  151.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring db_home,
  152.    jint flags, jint mode)
  153. {
  154. int err;
  155. DB_ENV *dbenv;
  156. JSTR j_home;
  157. DB_ENV_JAVAINFO *dbenvinfo;
  159. dbenv = get_DB_ENV(jnienv, jthis);
  160. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  161. if (!verify_non_null(jnienv, dbenv) ||
  162.     !verify_non_null(jnienv, dbenvinfo))
  163. return;
  164. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  165. if (jstr_lock(&j_home, jnienv, db_home) != 0)
  166. goto out;
  168. /* Java is assumed to be threaded. */
  169. flags |= DB_THREAD;
  171. err = dbenv->open(dbenv, j_home.string, flags, mode);
  172. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  173.  out:
  174. jstr_unlock(&j_home, jnienv);
  175. JAVADB_ENV_API_END(dbenv);
  176. }
  178. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_remove
  179.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring db_home, jint flags)
  180. {
  181. DB_ENV *dbenv;
  182. DB_ENV_JAVAINFO *dbenvinfo;
  183. JSTR j_home;
  184. int err = 0;
  186. dbenv = get_DB_ENV(jnienv, jthis);
  187. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  188. if (!verify_non_null(jnienv, dbenv))
  189. return;
  190. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  191. if (jstr_lock(&j_home, jnienv, db_home) != 0)
  192. goto out;
  194. err = dbenv->remove(dbenv, j_home.string, flags);
  195. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  197. if (dbenvinfo != NULL)
  198. dbjie_dealloc(dbenvinfo, jnienv);
  200. verify_return(jnienv, err, 0);
  201.  out:
  202. jstr_unlock(&j_home, jnienv);
  203. /* don't call JAVADB_ENV_API_END - env cannot be used */
  204. }
  206. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1close
  207.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  208. {
  209. int err;
  210. DB_ENV *dbenv;
  211. DB_ENV_JAVAINFO *dbenvinfo;
  213. dbenv = get_DB_ENV(jnienv, jthis);
  214. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  215. if (!verify_non_null(jnienv, dbenv))
  216. return;
  218. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  220. err = dbenv->close(dbenv, flags);
  221. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  223. if (dbenvinfo != NULL)
  224. dbjie_dealloc(dbenvinfo, jnienv);
  226. /* Throw an exception if the close failed. */
  227. verify_return(jnienv, err, 0);
  229. /* don't call JAVADB_ENV_API_END - env cannot be used */
  230. }
  232. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_err
  233.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint ecode, jstring msg)
  234. {
  235. JSTR msg_string;
  236. DB_ENV *dbenv;
  238. dbenv = get_DB_ENV(jnienv, jthis);
  239. if (!verify_non_null(jnienv, dbenv))
  240. return;
  242. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  244. if (jstr_lock(&msg_string, jnienv, msg) != 0)
  245. goto out;
  247. dbenv->err(dbenv, ecode, msg_string.string);
  248.  out:
  249. jstr_unlock(&msg_string, jnienv);
  250. JAVADB_ENV_API_END(dbenv);
  251. }
  253. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_errx
  254.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring msg)
  255. {
  256. JSTR msg_string;
  257. DB_ENV *dbenv;
  259. dbenv = get_DB_ENV(jnienv, jthis);
  260. if (!verify_non_null(jnienv, dbenv))
  261. return;
  263. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  265. if (jstr_lock(&msg_string, jnienv, msg) != 0)
  266. goto out;
  268. dbenv->errx(dbenv, msg_string.string);
  269.  out:
  270. jstr_unlock(&msg_string, jnienv);
  271. JAVADB_ENV_API_END(dbenv);
  272. }
  274. /*static*/
  275. JNIEXPORT jstring JNICALL Java_com_sleepycat_db_DbEnv_strerror
  276.   (JNIEnv *jnienv, jclass jthis_class, jint ecode)
  277. {
  278. const char *message;
  280. COMPQUIET(jthis_class, NULL);
  281. message = db_strerror(ecode);
  282. return (get_java_string(jnienv, message));
  283. }
  285. JNIEXPORT void JNICALL
  286.   Java_com_sleepycat_db_DbEnv_set_1cachesize
  287.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint gbytes, jint bytes,
  288.    jint ncaches)
  289. {
  290. DB_ENV *dbenv;
  291. int err;
  293. dbenv = get_DB_ENV(jnienv, jthis);
  294. if (verify_non_null(jnienv, dbenv)) {
  295. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  296. err = dbenv->set_cachesize(dbenv, gbytes, bytes, ncaches);
  297. verify_return(jnienv, err, 0);
  298. JAVADB_ENV_API_END(dbenv);
  299. }
  300. }
  302. JNIEXPORT void JNICALL
  303.   Java_com_sleepycat_db_DbEnv_set_1flags
  304.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags, jint onoff)
  305. {
  306. DB_ENV *dbenv;
  307. int err;
  309. dbenv = get_DB_ENV(jnienv, jthis);
  310. if (verify_non_null(jnienv, dbenv)) {
  311. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  312. err = dbenv->set_flags(dbenv, flags, onoff);
  313. verify_return(jnienv, err, 0);
  314. JAVADB_ENV_API_END(dbenv);
  315. }
  316. }
  318. JNIEXPORT void JNICALL
  319.   Java_com_sleepycat_db_DbEnv_set_1mp_1mmapsize
  320.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jlong value)
  321. {
  322. DB_ENV *dbenv;
  323. int err;
  325. dbenv = get_DB_ENV(jnienv, jthis);
  326. if (verify_non_null(jnienv, dbenv)) {
  327. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  328. err = dbenv->set_mp_mmapsize(dbenv, (size_t)value);
  329. verify_return(jnienv, err, 0);
  330. JAVADB_ENV_API_END(dbenv);
  331. }
  332. }
  334. /*static*/
  335. JNIEXPORT void JNICALL
  336.   Java_com_sleepycat_db_DbEnv_set_1pageyield
  337.   (JNIEnv *jnienv, jclass jthis_class, jint value)
  338. {
  339. int err;
  341. COMPQUIET(jthis_class, NULL);
  342. err = db_env_set_pageyield(value);
  343. verify_return(jnienv, err, 0);
  344. }
  346. /*static*/
  347. JNIEXPORT void JNICALL
  348.   Java_com_sleepycat_db_DbEnv_set_1panicstate
  349.   (JNIEnv *jnienv, jclass jthis_class, jint value)
  350. {
  351. int err;
  353. COMPQUIET(jthis_class, NULL);
  354. err = db_env_set_panicstate(value);
  355. verify_return(jnienv, err, 0);
  356. }
  358. /*static*/
  359. JNIEXPORT void JNICALL
  360.   Java_com_sleepycat_db_DbEnv_set_1region_1init
  361.   (JNIEnv *jnienv, jclass jthis_class, jint value)
  362. {
  363. int err;
  365. COMPQUIET(jthis_class, NULL);
  366. err = db_env_set_region_init(value);
  367. verify_return(jnienv, err, 0);
  368. }
  370. /*static*/
  371. JNIEXPORT void JNICALL
  372.   Java_com_sleepycat_db_DbEnv_set_1tas_1spins
  373.   (JNIEnv *jnienv, jclass jthis_class, jint value)
  374. {
  375. int err;
  377. COMPQUIET(jthis_class, NULL);
  378. err = db_env_set_tas_spins(value);
  379. verify_return(jnienv, err, 0);
  380. }
  382. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_recovery_1init_1changed
  383.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbRecoveryInit*/ jobject jrecoveryinit)
  384. {
  385. DB_ENV *dbenv;
  386. DB_ENV_JAVAINFO *dbenvinfo;
  388. dbenv = get_DB_ENV(jnienv, jthis);
  389. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  390. if (!verify_non_null(jnienv, dbenv) ||
  391.     !verify_non_null(jnienv, dbenv))
  392. return;
  394. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  395. dbjie_set_recovery_init_object(dbenvinfo, jnienv, dbenv, jrecoveryinit);
  396. JAVADB_ENV_API_END(dbenv);
  397. }
  399. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_set_1lk_1conflicts
  400.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobjectArray array)
  401. {
  402. DB_ENV *dbenv;
  403. DB_ENV_JAVAINFO *dbenvinfo;
  404. int err;
  405. jsize i, len;
  406. unsigned char *newarr;
  408. dbenv = get_DB_ENV(jnienv, jthis);
  409. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  410. if (!verify_non_null(jnienv, dbenv) ||
  411.     !verify_non_null(jnienv, dbenvinfo))
  412. return;
  414. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  416. len = (*jnienv)->GetArrayLength(jnienv, array);
  418. newarr = (unsigned char *)malloc(sizeof(unsigned char) * len * len);
  420. for (i=0; i<len; i++) {
  421. jobject subArray =
  422. (*jnienv)->GetObjectArrayElement(jnienv, array, i);
  423. (*jnienv)->GetByteArrayRegion(jnienv, (jbyteArray)subArray,
  424.       0, len,
  425.       (jbyte *)&newarr[i*len]);
  426. }
  427. dbjie_set_conflict(dbenvinfo, newarr);
  428. err = dbenv->set_lk_conflicts(dbenv, newarr, len);
  429. verify_return(jnienv, err, 0);
  430. JAVADB_ENV_API_END(dbenv);
  431. }
  433. JNIEXPORT void JNICALL
  434.   Java_com_sleepycat_db_DbEnv_set_1server
  435.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring jhost, jlong tsec,
  436.    jlong ssec, jint flags)
  437. {
  438. int err;
  439. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  440. const char *host = (*jnienv)->GetStringUTFChars(jnienv, jhost, NULL);
  442. if (verify_non_null(jnienv, dbenv)) {
  443. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  444. err = dbenv->set_server(dbenv, (char *)host,
  445. (long)tsec, (long)ssec, flags);
  447. /* Throw an exception if the call failed. */
  448. verify_return(jnienv, err, 0);
  449. JAVADB_ENV_API_END(dbenv);
  450. }
  451. }
  453. JNIEXPORT void JNICALL
  454.   Java_com_sleepycat_db_DbEnv_set_1shm_1key
  455.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jlong shm_key)
  456. {
  457. int err;
  458. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  460. if (verify_non_null(jnienv, dbenv)) {
  461. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  462. err = dbenv->set_shm_key(dbenv, (long)shm_key);
  464. /* Throw an exception if the call failed. */
  465. verify_return(jnienv, err, 0);
  466. JAVADB_ENV_API_END(dbenv);
  467. }
  468. }
  470. JNIEXPORT void JNICALL
  471.   Java_com_sleepycat_db_DbEnv__1set_1tx_1timestamp
  472.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jlong seconds)
  473. {
  474. int err;
  475. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  476. time_t time = seconds;
  478. if (verify_non_null(jnienv, dbenv)) {
  479. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  480. err = dbenv->set_tx_timestamp(dbenv, &time);
  482. /* Throw an exception if the call failed. */
  483. verify_return(jnienv, err, 0);
  484. JAVADB_ENV_API_END(dbenv);
  485. }
  486. }
  488. JNIEXPORT void JNICALL
  489.   Java_com_sleepycat_db_DbEnv_set_1verbose
  490.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint which, jint onoff)
  491. {
  492. int err;
  493. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  495. if (verify_non_null(jnienv, dbenv)) {
  496. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  497. err = dbenv->set_verbose(dbenv, which, onoff);
  499. /* Throw an exception if the call failed. */
  500. verify_return(jnienv, err, 0);
  501. JAVADB_ENV_API_END(dbenv);
  502. }
  503. }
  505. /*static*/
  506. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1major
  507.   (JNIEnv * jnienv, jclass this_class)
  508. {
  509. COMPQUIET(jnienv, NULL);
  510. COMPQUIET(this_class, NULL);
  512. return (DB_VERSION_MAJOR);
  513. }
  515. /*static*/
  516. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1minor
  517.   (JNIEnv * jnienv, jclass this_class)
  518. {
  519. COMPQUIET(jnienv, NULL);
  520. COMPQUIET(this_class, NULL);
  522. return (DB_VERSION_MINOR);
  523. }
  525. /*static*/
  526. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1patch
  527.   (JNIEnv * jnienv, jclass this_class)
  528. {
  529. COMPQUIET(jnienv, NULL);
  530. COMPQUIET(this_class, NULL);
  532. return (DB_VERSION_PATCH);
  533. }
  535. /*static*/
  536. JNIEXPORT jstring JNICALL Java_com_sleepycat_db_DbEnv_get_1version_1string
  537.   (JNIEnv *jnienv, jclass this_class)
  538. {
  539. COMPQUIET(this_class, NULL);
  541. return ((*jnienv)->NewStringUTF(jnienv, DB_VERSION_STRING));
  542. }
  544. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_lock_1id
  545.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  546. {
  547. int err;
  548. u_int32_t id;
  549. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  551. if (!verify_non_null(jnienv, dbenv))
  552. return (-1);
  553. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  554. err = lock_id(dbenv, &id);
  555. verify_return(jnienv, err, 0);
  556. JAVADB_ENV_API_END(dbenv);
  557. return (id);
  558. }
  560. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_lock_1stat
  561.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  562. {
  563. int err;
  564. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  565. DB_LOCK_STAT *statp = NULL;
  566. jobject retval = NULL;
  567. jclass dbclass;
  569. if (!verify_non_null(jnienv, dbenv))
  570. return (NULL);
  571. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  573. /* We cannot use the default allocator (on Win* platforms anyway)
  574.  * because it often causes problems when we free storage
  575.  * in a DLL that was allocated in another DLL.  Using
  576.  * our own allocator (ours just calls malloc!) ensures
  577.  * that there is no mismatch.
  578.  */
  579. err = lock_stat(dbenv, &statp, NULL);
  580. if (verify_return(jnienv, err, 0)) {
  581. retval = create_default_object(jnienv, name_DB_LOCK_STAT);
  582. dbclass = get_class(jnienv, name_DB_LOCK_STAT);
  584. /* Set the individual fields */
  585. set_int_field(jnienv, dbclass, retval,
  586.       "st_maxlocks", statp->st_maxlocks);
  587. set_int_field(jnienv, dbclass, retval,
  588.       "st_nmodes", statp->st_nmodes);
  589. set_int_field(jnienv, dbclass, retval,
  590.       "st_nlockers", statp->st_nlockers);
  591. set_int_field(jnienv, dbclass, retval,
  592.       "st_nconflicts", statp->st_nconflicts);
  593. set_int_field(jnienv, dbclass, retval,
  594.       "st_nrequests", statp->st_nrequests);
  595. set_int_field(jnienv, dbclass, retval,
  596.       "st_nreleases", statp->st_nreleases);
  597. set_int_field(jnienv, dbclass, retval,
  598.       "st_ndeadlocks", statp->st_ndeadlocks);
  599. set_int_field(jnienv, dbclass, retval,
  600.       "st_region_wait", statp->st_region_wait);
  601. set_int_field(jnienv, dbclass, retval,
  602.       "st_region_nowait", statp->st_region_nowait);
  603. set_int_field(jnienv, dbclass, retval,
  604.       "st_regsize", statp->st_regsize);
  606. free(statp);
  607. }
  608. JAVADB_ENV_API_END(dbenv);
  609. return (retval);
  610. }
  612. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_lock_1detect
  613.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint atype, jint flags)
  614. {
  615. int err;
  616. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  617. int aborted;
  619. if (!verify_non_null(jnienv, dbenv))
  620. return (0);
  621. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  622. err = lock_detect(dbenv, atype, flags, &aborted);
  623. verify_return(jnienv, err, 0);
  624. JAVADB_ENV_API_END(dbenv);
  625. return (aborted);
  626. }
  628. JNIEXPORT /*DbLock*/ jobject JNICALL Java_com_sleepycat_db_DbEnv_lock_1get
  629.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*u_int32_t*/ jint locker,
  630.    jint flags, /*const Dbt*/ jobject obj, /*db_lockmode_t*/ jint lock_mode)
  631. {
  632. int err;
  633. DB_ENV *dbenv;
  634. DB_LOCK *dblock;
  635. JDBT dbobj;
  636. /*DbLock*/ jobject retval;
  638. dbenv = get_DB_ENV(jnienv, jthis);
  639. if (!verify_non_null(jnienv, dbenv))
  640. return (NULL);
  642. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  643. dblock = (DB_LOCK*)malloc(sizeof(DB_LOCK));
  644. memset(dblock, 0, sizeof(DB_LOCK));
  645. err = 0;
  646. retval = NULL;
  647. if (jdbt_lock(&dbobj, jnienv, obj, inOp) != 0)
  648. goto out;
  650. err = lock_get(dbenv, locker, flags, &dbobj.dbt->dbt,
  651.        (db_lockmode_t)lock_mode, dblock);
  652. if (verify_return(jnienv, err, 0)) {
  653. retval = create_default_object(jnienv, name_DB_LOCK);
  654. set_private_dbobj(jnienv, name_DB_LOCK, retval, dblock);
  655. }
  656.  out:
  657. jdbt_unlock(&dbobj, jnienv);
  658. JAVADB_ENV_API_END(dbenv);
  659. return (retval);
  660. }
  662. JNIEXPORT jobjectArray JNICALL Java_com_sleepycat_db_DbEnv_log_1archive
  663.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint flags)
  664. {
  665. int err, len, i;
  666. char** ret;
  667. jclass stringClass;
  668. jobjectArray strarray;
  669. DB_ENV *dbenv;
  671. dbenv = get_DB_ENV(jnienv, jthis);
  672. strarray = NULL;
  673. if (!verify_non_null(jnienv, dbenv))
  674. return (0);
  675. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  676. err = log_archive(dbenv, &ret, flags, 0);
  677. if (!verify_return(jnienv, err, 0))
  678. return (0);
  680. if (ret != NULL) {
  681. len = 0;
  682. while (ret[len] != NULL)
  683. len++;
  684. stringClass = (*jnienv)->FindClass(jnienv, "java/lang/String");
  685. strarray = (*jnienv)->NewObjectArray(jnienv, len,
  686.      stringClass, 0);
  687. for (i=0; i<len; i++) {
  688. jstring str = (*jnienv)->NewStringUTF(jnienv, ret[i]);
  689. (*jnienv)->SetObjectArrayElement(jnienv, strarray,
  690.  i, str);
  691. }
  692. }
  693. JAVADB_ENV_API_END(dbenv);
  694. return (strarray);
  695. }
  697. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_log_1compare
  698.   (JNIEnv *jnienv, jclass jthis_class,
  699.    /*DbLsn*/ jobject lsn0, /*DbLsn*/ jobject lsn1)
  700. {
  701. DB_LSN *dblsn0;
  702. DB_LSN *dblsn1;
  704. COMPQUIET(jthis_class, NULL);
  705. dblsn0 = get_DB_LSN(jnienv, lsn0);
  706. dblsn1 = get_DB_LSN(jnienv, lsn1);
  708. return (log_compare(dblsn0, dblsn1));
  709. }
  711. JNIEXPORT jstring JNICALL Java_com_sleepycat_db_DbEnv_log_1file
  712.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbLsn*/ jobject lsn)
  713. {
  714. int err;
  715. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  716. DB_LSN *dblsn = get_DB_LSN(jnienv, lsn);
  717. char filename[FILENAME_MAX+1] = "";
  719. if (!verify_non_null(jnienv, dbenv))
  720. return (NULL);
  722. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  724. err = log_file(dbenv, dblsn, filename, FILENAME_MAX);
  725. verify_return(jnienv, err, 0);
  726. filename[FILENAME_MAX] = ''; /* just to be sure */
  727. JAVADB_ENV_API_END(dbenv);
  728. return (get_java_string(jnienv, filename));
  729. }
  731. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_log_1flush
  732.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbLsn*/ jobject lsn)
  733. {
  734. int err;
  735. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  736. DB_LSN *dblsn = get_DB_LSN(jnienv, lsn);
  738. if (!verify_non_null(jnienv, dbenv))
  739. return;
  741. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  743. err = log_flush(dbenv, dblsn);
  744. verify_return(jnienv, err, 0);
  745. JAVADB_ENV_API_END(dbenv);
  746. }
  748. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_log_1get
  749.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbLsn*/ jobject lsn,
  750.    /*DbDbt*/ jobject data, jint flags)
  751. {
  752. int err, retry;
  753. DB_ENV *dbenv;
  754. DB_LSN *dblsn;
  755. JDBT dbdata;
  757. dbenv = get_DB_ENV(jnienv, jthis);
  758. dblsn = get_DB_LSN(jnienv, lsn);
  760. if (!verify_non_null(jnienv, dbenv))
  761. return;
  763. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  765. if (jdbt_lock(&dbdata, jnienv, data, outOp) != 0)
  766. goto out;
  768. for (retry = 0; retry < 3; retry++) {
  769. err = log_get(dbenv, dblsn, &dbdata.dbt->dbt, flags);
  770. /* If we failed due to lack of memory in our DBT arrays,
  771.  * retry.
  772.  */
  773. if (err != ENOMEM)
  774. break;
  775. if (!jdbt_realloc(&dbdata, jnienv))
  776. break;
  777. }
  779. verify_return(jnienv, err, 0);
  781.  out:
  782. jdbt_unlock(&dbdata, jnienv);
  783. JAVADB_ENV_API_END(dbenv);
  784. }
  786. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_log_1put
  787.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbLsn*/ jobject lsn,
  788.    /*DbDbt*/ jobject data, jint flags)
  789. {
  790. int err;
  791. DB_ENV *dbenv;
  792. DB_LSN *dblsn;
  793. JDBT dbdata;
  795. dbenv = get_DB_ENV(jnienv, jthis);
  796. dblsn = get_DB_LSN(jnienv, lsn);
  797. if (!verify_non_null(jnienv, dbenv))
  798. return;
  800. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  802. if (jdbt_lock(&dbdata, jnienv, data, inOp) != 0)
  803. goto out;
  805. err = log_put(dbenv, dblsn, &dbdata.dbt->dbt, flags);
  806. verify_return(jnienv, err, 0);
  807.  out:
  808. jdbt_unlock(&dbdata, jnienv);
  809. JAVADB_ENV_API_END(dbenv);
  810. }
  812. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_log_1register
  813.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*Db*/ jobject dbp,
  814.    jstring name)
  815. {
  816. int err;
  817. DB_ENV *dbenv;
  818. DB *dbdb;
  819. JSTR dbname;
  821. dbenv = get_DB_ENV(jnienv, jthis);
  822. dbdb = get_DB(jnienv, dbp);
  823. if (!verify_non_null(jnienv, dbenv))
  824. return;
  826. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  828. if (jstr_lock(&dbname, jnienv, name) != 0)
  829. goto out;
  831. err = log_register(dbenv, dbdb, dbname.string);
  832. verify_return(jnienv, err, 0);
  833.  out:
  834. jstr_unlock(&dbname, jnienv);
  835. JAVADB_ENV_API_END(dbenv);
  836. }
  838. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_log_1unregister
  839.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*Db*/ jobject dbp)
  840. {
  841. int err;
  842. DB_ENV *dbenv;
  843. DB *dbdb;
  845. dbenv = get_DB_ENV(jnienv, jthis);
  846. dbdb = get_DB(jnienv, dbp);
  847. if (!verify_non_null(jnienv, dbenv))
  848. return;
  850. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  852. err = log_unregister(dbenv, dbdb);
  853. verify_return(jnienv, err, 0);
  854. JAVADB_ENV_API_END(dbenv);
  855. }
  857. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_log_1stat
  858.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  859. {
  860. int err;
  861. DB_ENV *dbenv;
  862. DB_LOG_STAT *statp;
  863. jobject retval;
  864. jclass dbclass;
  866. retval = NULL;
  867. statp = NULL;
  868. dbenv = get_DB_ENV(jnienv, jthis);
  869. if (!verify_non_null(jnienv, dbenv))
  870. return (NULL);
  872. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  874. /* We cannot use the default allocator (on Win* platforms anyway)
  875.  * because it often causes problems when we free storage
  876.  * in a DLL that was allocated in another DLL.  Using
  877.  * our own allocator (ours just calls malloc!) ensures
  878.  * that there is no mismatch.
  879.  */
  880. err = log_stat(dbenv, &statp, NULL);
  881. if (verify_return(jnienv, err, 0)) {
  882. retval = create_default_object(jnienv, name_DB_LOG_STAT);
  883. dbclass = get_class(jnienv, name_DB_LOG_STAT);
  885. /* Set the individual fields */
  886. set_int_field(jnienv, dbclass, retval,
  887.       "st_magic", statp->st_magic);
  888. set_int_field(jnienv, dbclass, retval,
  889.       "st_version", statp->st_version);
  890. set_int_field(jnienv, dbclass, retval,
  891.       "st_mode", statp->st_mode);
  892. set_int_field(jnienv, dbclass, retval,
  893.       "st_lg_max", statp->st_lg_max);
  894. set_int_field(jnienv, dbclass, retval,
  895.       "st_w_bytes", statp->st_w_bytes);
  896. set_int_field(jnienv, dbclass, retval,
  897.       "st_w_mbytes", statp->st_w_mbytes);
  898. set_int_field(jnienv, dbclass, retval,
  899.       "st_wc_bytes", statp->st_wc_bytes);
  900. set_int_field(jnienv, dbclass, retval,
  901.       "st_wc_mbytes", statp->st_wc_mbytes);
  902. set_int_field(jnienv, dbclass, retval,
  903.       "st_wcount", statp->st_wcount);
  904. set_int_field(jnienv, dbclass, retval,
  905.       "st_scount", statp->st_scount);
  906. set_int_field(jnienv, dbclass, retval,
  907.       "st_region_wait", statp->st_region_wait);
  908. set_int_field(jnienv, dbclass, retval,
  909.       "st_region_nowait", statp->st_region_nowait);
  910. set_int_field(jnienv, dbclass, retval,
  911.       "st_cur_file", statp->st_cur_file);
  912. set_int_field(jnienv, dbclass, retval,
  913.       "st_cur_offset", statp->st_cur_offset);
  914. set_int_field(jnienv, dbclass, retval,
  915.       "st_regsize", statp->st_regsize);
  917. free(statp);
  918. }
  919. JAVADB_ENV_API_END(dbenv);
  920. return (retval);
  921. }
  923. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_memp_1stat
  924.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  925. {
  926. int err;
  927. jclass dbclass;
  928. DB_ENV *dbenv;
  929. DB_MPOOL_STAT *statp;
  930. jobject retval;
  932. retval = NULL;
  933. statp = NULL;
  934. dbenv = get_DB_ENV(jnienv, jthis);
  935. if (!verify_non_null(jnienv, dbenv))
  936. return (NULL);
  938. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  940. /* We cannot use the default allocator (on Win* platforms anyway)
  941.  * because it often causes problems when we free storage
  942.  * in a DLL that was allocated in another DLL.  Using
  943.  * our own allocator (ours just calls malloc!) ensures
  944.  * that there is no mismatch.
  945.  */
  946. err = memp_stat(dbenv, &statp, 0, NULL);
  947. if (verify_return(jnienv, err, 0)) {
  948. retval = create_default_object(jnienv, name_DB_MPOOL_STAT);
  949. dbclass = get_class(jnienv, name_DB_MPOOL_STAT);
  951. set_int_field(jnienv, dbclass, retval, "st_cachesize", 0);
  952. set_int_field(jnienv, dbclass, retval,
  953.       "st_cache_hit", statp->st_cache_hit);
  954. set_int_field(jnienv, dbclass, retval,
  955.       "st_cache_miss", statp->st_cache_miss);
  956. set_int_field(jnienv, dbclass, retval,
  957.       "st_map", statp->st_map);
  958. set_int_field(jnienv, dbclass, retval,
  959.       "st_page_create", statp->st_page_create);
  960. set_int_field(jnienv, dbclass, retval,
  961.       "st_page_in", statp->st_page_in);
  962. set_int_field(jnienv, dbclass, retval,
  963.       "st_page_out", statp->st_page_out);
  964. set_int_field(jnienv, dbclass, retval,
  965.       "st_ro_evict", statp->st_ro_evict);
  966. set_int_field(jnienv, dbclass, retval,
  967.       "st_rw_evict", statp->st_rw_evict);
  968. set_int_field(jnienv, dbclass, retval,
  969.       "st_hash_buckets", statp->st_hash_buckets);
  970. set_int_field(jnienv, dbclass, retval,
  971.       "st_hash_searches", statp->st_hash_searches);
  972. set_int_field(jnienv, dbclass, retval,
  973.       "st_hash_longest", statp->st_hash_longest);
  974. set_int_field(jnienv, dbclass, retval,
  975.       "st_hash_examined", statp->st_hash_examined);
  976. set_int_field(jnienv, dbclass, retval,
  977.       "st_page_clean", statp->st_page_clean);
  978. set_int_field(jnienv, dbclass, retval,
  979.       "st_page_dirty", statp->st_page_dirty);
  980. set_int_field(jnienv, dbclass, retval,
  981.       "st_page_trickle", statp->st_page_trickle);
  982. set_int_field(jnienv, dbclass, retval,
  983.       "st_region_wait", statp->st_region_wait);
  984. set_int_field(jnienv, dbclass, retval,
  985.       "st_region_nowait", statp->st_region_nowait);
  986. set_int_field(jnienv, dbclass, retval,
  987.       "st_regsize", statp->st_regsize);
  989. free(statp);
  990. }
  991. JAVADB_ENV_API_END(dbenv);
  992. return (retval);
  993. }
  995. JNIEXPORT jobjectArray JNICALL Java_com_sleepycat_db_DbEnv_memp_1fstat
  996.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  997. {
  998. int err, i, len;
  999. jclass fstat_class;
  1000. DB_ENV *dbenv;
  1001. DB_MPOOL_FSTAT **fstatp;
  1002. jobjectArray retval;
  1003. jfieldID filename_id;
  1004. jstring jfilename;
  1006. fstatp = NULL;
  1007. retval = NULL;
  1008. dbenv = get_DB_ENV(jnienv, jthis);
  1009. if (!verify_non_null(jnienv, dbenv))
  1010. return (NULL);
  1012. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1014. /* We cannot use the default allocator (on Win* platforms anyway)
  1015.  * because it often causes problems when we free storage
  1016.  * in a DLL that was allocated in another DLL.  Using
  1017.  * our own allocator (ours just calls malloc!) ensures
  1018.  * that there is no mismatch.
  1019.  */
  1020. err = memp_stat(dbenv, 0, &fstatp, NULL);
  1021. if (verify_return(jnienv, err, 0)) {
  1022. len = 0;
  1023. while (fstatp[len])
  1024. len++;
  1025. fstat_class = get_class(jnienv, name_DB_MPOOL_FSTAT);
  1026. retval = (*jnienv)->NewObjectArray(jnienv, len,
  1027.    fstat_class, 0);
  1028. for (i=0; i<len; i++) {
  1029. jobject obj = create_default_object(jnienv,
  1030.     name_DB_MPOOL_FSTAT);
  1031. (*jnienv)->SetObjectArrayElement(jnienv, retval,
  1032.  i, obj);
  1034. /* Set the string field. */
  1035. filename_id =
  1036. (*jnienv)->GetFieldID(jnienv, fstat_class,
  1037.       "file_name",
  1038.       string_signature);
  1039. jfilename =
  1040. get_java_string(jnienv, fstatp[i]->file_name);
  1041. (*jnienv)->SetObjectField(jnienv, obj,
  1042.   filename_id, jfilename);
  1044. set_int_field(jnienv, fstat_class, obj,
  1045.       "st_pagesize", fstatp[i]->st_pagesize);
  1046. set_int_field(jnienv, fstat_class, obj,
  1047.       "st_cache_hit", fstatp[i]->st_cache_hit);
  1048. set_int_field(jnienv, fstat_class, obj,
  1049.       "st_cache_miss", fstatp[i]->st_cache_miss);
  1050. set_int_field(jnienv, fstat_class, obj,
  1051.       "st_map", fstatp[i]->st_map);
  1052. set_int_field(jnienv, fstat_class, obj,
  1053.       "st_page_create", fstatp[i]->st_page_create);
  1054. set_int_field(jnienv, fstat_class, obj,
  1055.       "st_page_in", fstatp[i]->st_page_in);
  1056. set_int_field(jnienv, fstat_class, obj,
  1057.       "st_page_out", fstatp[i]->st_page_out);
  1058. free(fstatp[i]);
  1059. }
  1060. free(fstatp);
  1061. }
  1062. JAVADB_ENV_API_END(dbenv);
  1063. return (retval);
  1064. }
  1066. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_memp_1trickle
  1067.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint pct)
  1068. {
  1069. int err;
  1070. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  1071. int result = 0;
  1073. if (verify_non_null(jnienv, dbenv)) {
  1074. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1075. err = memp_trickle(dbenv, pct, &result);
  1076. verify_return(jnienv, err, 0);
  1077. JAVADB_ENV_API_END(dbenv);
  1078. }
  1079. return (result);
  1080. }
  1082. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_txn_1begin
  1083.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbTxn*/ jobject pid, jint flags)
  1084. {
  1085. int err;
  1086. DB_TXN *dbpid, *result;
  1087. DB_ENV *dbenv;
  1089. dbenv = get_DB_ENV(jnienv, jthis);
  1090. if (!verify_non_null(jnienv, dbenv))
  1091. return (0);
  1093. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1095. dbpid = get_DB_TXN(jnienv, pid);
  1096. result = 0;
  1098. err = txn_begin(dbenv, dbpid, &result, flags);
  1099. if (!verify_return(jnienv, err, 0))
  1100. return (0);
  1101. JAVADB_ENV_API_END(dbenv);
  1102. return (get_DbTxn(jnienv, result));
  1103. }
  1105. JNIEXPORT jint JNICALL Java_com_sleepycat_db_DbEnv_txn_1checkpoint
  1106.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jint kbyte, jint min, jint flags)
  1107. {
  1108. int err;
  1109. DB_ENV *dbenv = get_DB_ENV(jnienv, jthis);
  1111. if (!verify_non_null(jnienv, dbenv))
  1112. return (0);
  1113. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1114. err = txn_checkpoint(dbenv, kbyte, min, flags);
  1115. if (err != DB_INCOMPLETE)
  1116. verify_return(jnienv, err, 0);
  1117. JAVADB_ENV_API_END(dbenv);
  1118. return (err);
  1119. }
  1121. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv_tx_1recover_1changed
  1122.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, /*DbFeedback*/ jobject jtxrecover)
  1123. {
  1124. DB_ENV *dbenv;
  1125. DB_ENV_JAVAINFO *dbenvinfo;
  1127. dbenv = get_DB_ENV(jnienv, jthis);
  1128. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1129. if (!verify_non_null(jnienv, dbenv) ||
  1130.     !verify_non_null(jnienv, dbenvinfo))
  1131. return;
  1133. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1134. dbjie_set_tx_recover_object(dbenvinfo, jnienv, dbenv, jtxrecover);
  1135. JAVADB_ENV_API_END(dbenv);
  1136. }
  1138. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_DbEnv_txn_1stat
  1139.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis)
  1140. {
  1141. int err;
  1142. DB_ENV *dbenv;
  1143. DB_TXN_STAT *statp;
  1144. jobject retval, obj;
  1145. jclass dbclass, active_class;
  1146. char active_signature[512];
  1147. jfieldID arrid;
  1148. jobjectArray actives;
  1149. unsigned int i;
  1151. retval = NULL;
  1152. statp = NULL;
  1153. dbenv = get_DB_ENV(jnienv, jthis);
  1154. if (!verify_non_null(jnienv, dbenv))
  1155. return (NULL);
  1157. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1159. /* We cannot use the default allocator (on Win* platforms anyway)
  1160.  * because it often causes problems when we free storage
  1161.  * in a DLL that was allocated in another DLL.  Using
  1162.  * our own allocator (ours just calls malloc!) ensures
  1163.  * that there is no mismatch.
  1164.  */
  1165. err = txn_stat(dbenv, &statp, NULL);
  1166. if (verify_return(jnienv, err, 0)) {
  1167. retval = create_default_object(jnienv, name_DB_TXN_STAT);
  1168. dbclass = get_class(jnienv, name_DB_TXN_STAT);
  1170. /* Set the individual fields */
  1172. set_lsn_field(jnienv, dbclass, retval,
  1173.       "st_last_ckp", statp->st_last_ckp);
  1174. set_lsn_field(jnienv, dbclass, retval,
  1175.       "st_pending_ckp", statp->st_pending_ckp);
  1176. set_long_field(jnienv, dbclass, retval,
  1177.        "st_time_ckp", statp->st_time_ckp);
  1178. set_int_field(jnienv, dbclass, retval,
  1179.       "st_last_txnid", statp->st_last_txnid);
  1180. set_int_field(jnienv, dbclass, retval,
  1181.       "st_maxtxns", statp->st_maxtxns);
  1182. set_int_field(jnienv, dbclass, retval,
  1183.       "st_naborts", statp->st_naborts);
  1184. set_int_field(jnienv, dbclass, retval,
  1185.       "st_nbegins", statp->st_nbegins);
  1186. set_int_field(jnienv, dbclass, retval,
  1187.       "st_ncommits", statp->st_ncommits);
  1188. set_int_field(jnienv, dbclass, retval,
  1189.       "st_nactive", statp->st_nactive);
  1190. set_int_field(jnienv, dbclass, retval,
  1191.       "st_maxnactive", statp->st_maxnactive);
  1193. active_class = get_class(jnienv, name_DB_TXN_STAT_ACTIVE);
  1194. actives =
  1195. (*jnienv)->NewObjectArray(jnienv, statp->st_nactive,
  1196.   active_class, 0);
  1198. /* Set the st_txnarray field.  This is a little more involved
  1199.  * than other fields, since the type is an array, so none
  1200.  * of our utility functions help.
  1201.  */
  1202. strncpy(active_signature, "[L", sizeof(active_signature));
  1203. strncat(active_signature, DB_PACKAGE_NAME,
  1204. sizeof(active_signature));
  1205. strncat(active_signature, name_DB_TXN_STAT_ACTIVE,
  1206. sizeof(active_signature));
  1207. strncat(active_signature, ";", sizeof(active_signature));
  1209. arrid = (*jnienv)->GetFieldID(jnienv, dbclass, "st_txnarray",
  1210.       active_signature);
  1211. (*jnienv)->SetObjectField(jnienv, retval, arrid, actives);
  1213. /* Now fill the in the elements of st_txnarray. */
  1214. for (i=0; i<statp->st_nactive; i++) {
  1215. obj = create_default_object(jnienv, name_DB_TXN_STAT_ACTIVE);
  1216. (*jnienv)->SetObjectArrayElement(jnienv, actives, i, obj);
  1218. set_int_field(jnienv, active_class, obj,
  1219.       "txnid", statp->st_txnarray[i].txnid);
  1220. set_int_field(jnienv, active_class, obj,
  1221.       "parentid", statp->st_txnarray[i].parentid);
  1222. set_lsn_field(jnienv, active_class, obj,
  1223.       "lsn", statp->st_txnarray[i].lsn);
  1224. }
  1225. set_int_field(jnienv, dbclass, retval,
  1226.       "st_region_wait", statp->st_region_wait);
  1227. set_int_field(jnienv, dbclass, retval,
  1228.       "st_region_nowait", statp->st_region_nowait);
  1229. set_int_field(jnienv, dbclass, retval,
  1230.       "st_regsize", statp->st_regsize);
  1232. free(statp);
  1233. }
  1234. JAVADB_ENV_API_END(dbenv);
  1235. return (retval);
  1236. }
  1238. /* See discussion on errpfx, errcall in DB_ENV_JAVAINFO */
  1239. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1set_1errcall
  1240.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jobject errcall)
  1241. {
  1242. DB_ENV *dbenv;
  1243. DB_ENV_JAVAINFO *dbenvinfo;
  1245. dbenv = get_DB_ENV(jnienv, jthis);
  1246. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1248. if (verify_non_null(jnienv, dbenv) &&
  1249.     verify_non_null(jnienv, dbenvinfo)) {
  1251. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1252. dbjie_set_errcall(dbenvinfo, jnienv, errcall);
  1253. JAVADB_ENV_API_END(dbenv);
  1254. }
  1255. }
  1257. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1set_1errpfx
  1258.   (JNIEnv *jnienv, /*DbEnv*/ jobject jthis, jstring str)
  1259. {
  1260. DB_ENV *dbenv;
  1261. DB_ENV_JAVAINFO *dbenvinfo;
  1263. dbenv = get_DB_ENV(jnienv, jthis);
  1264. dbenvinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1266. if (verify_non_null(jnienv, dbenv) &&
  1267.     verify_non_null(jnienv, dbenvinfo)) {
  1269. JAVADB_ENV_API_BEGIN(dbenv, jthis);
  1270. dbjie_set_errpfx(dbenvinfo, jnienv, str);
  1271. JAVADB_ENV_API_END(dbenv);
  1272. }
  1273. }
  1275. JNIEXPORT void JNICALL Java_com_sleepycat_db_DbEnv__1finalize
  1276.     (JNIEnv *jnienv, /*DbEnv*/ jobject jthis,
  1277.      jobject /*DbErrcall*/ errcall, jstring errpfx)
  1278. {
  1279. DB_ENV *dbenv;
  1280. DB_ENV_JAVAINFO *envinfo;
  1282. dbenv = get_DB_ENV(jnienv, jthis);
  1283. envinfo = get_DB_ENV_JAVAINFO(jnienv, jthis);
  1284. DB_ASSERT(envinfo != NULL);
  1286. /* Note:  We detect unclosed DbEnvs and report it.
  1287.  */
  1288. if (dbenv != NULL && envinfo != NULL && !dbjie_is_dbopen(envinfo)) {
  1290. /* If this error occurs, this object was never closed. */
  1291. report_errcall(jnienv, errcall, errpfx,
  1292.        "DbEnv.finalize: open DbEnv object destroyed");
  1293. }
  1295. /* Shouldn't see this object again, but just in case */
  1296. set_private_dbobj(jnienv, name_DB_ENV, jthis, 0);
  1297. set_private_info(jnienv, name_DB_ENV, jthis, 0);
  1299. dbjie_destroy(envinfo, jnienv);
  1300. }