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

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

MySQL数据库

开发平台：

Visual C++

java_info.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_info.c,v 11.18 2000/10/28 13:09:39 dda Exp $";
  11. #endif /* not lint */
  13. #include <jni.h>
  14. #include <errno.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  18. #include "db.h"
  19. #include "db_int.h"
  20. #include "java_util.h"
  22. /****************************************************************
  23.  *
  24.  * Callback functions
  25.  *
  26.  */
  28. static void Db_feedback_callback(DB *db, int opcode, int percent)
  29. {
  30. DB_JAVAINFO *dbinfo;
  32. DB_ASSERT(db != NULL);
  33. dbinfo = (DB_JAVAINFO *)db->cj_internal;
  34. dbji_call_feedback(dbinfo, db, dbinfo->jdbref_, opcode, percent);
  35. }
  37. static int Db_append_recno_callback(DB *db, DBT *dbt, db_recno_t recno)
  38. {
  39. DB_JAVAINFO *dbinfo;
  41. dbinfo = (DB_JAVAINFO *)db->cj_internal;
  42. return (dbji_call_append_recno(dbinfo, db, dbinfo->jdbref_, dbt, recno));
  43. }
  45. static int Db_bt_compare_callback(DB *db, const DBT *dbt1, const DBT *dbt2)
  46. {
  47. DB_JAVAINFO *dbinfo;
  49. dbinfo = (DB_JAVAINFO *)db->cj_internal;
  50. return (dbji_call_bt_compare(dbinfo, db, dbinfo->jdbref_, dbt1, dbt2));
  51. }
  53. static size_t Db_bt_prefix_callback(DB *db, const DBT *dbt1, const DBT *dbt2)
  54. {
  55. DB_JAVAINFO *dbinfo;
  57. dbinfo = (DB_JAVAINFO *)db->cj_internal;
  58. return (dbji_call_bt_prefix(dbinfo, db, dbinfo->jdbref_, dbt1, dbt2));
  59. }
  61. static int Db_dup_compare_callback(DB *db, const DBT *dbt1, const DBT *dbt2)
  62. {
  63. DB_JAVAINFO *dbinfo;
  65. dbinfo = (DB_JAVAINFO *)db->cj_internal;
  66. return (dbji_call_dup_compare(dbinfo, db, dbinfo->jdbref_, dbt1, dbt2));
  67. }
  69. static u_int32_t Db_h_hash_callback(DB *db, const void *data, u_int32_t len)
  70. {
  71. DB_JAVAINFO *dbinfo;
  73. dbinfo = (DB_JAVAINFO *)db->cj_internal;
  74. return (dbji_call_h_hash(dbinfo, db, dbinfo->jdbref_, data, len));
  75. }
  77. static void DbEnv_feedback_callback(DB_ENV *dbenv, int opcode, int percent)
  78. {
  79. DB_ENV_JAVAINFO *dbinfo;
  81. DB_ASSERT(dbenv != NULL);
  82. dbinfo = (DB_ENV_JAVAINFO *)dbenv->cj_internal;
  83. dbjie_call_feedback(dbinfo, dbenv, dbinfo->jenvref_, opcode, percent);
  84. }
  86. static int DbEnv_recovery_init_callback(DB_ENV *dbenv)
  87. {
  88. DB_ENV_JAVAINFO *dbinfo;
  90. dbinfo = (DB_ENV_JAVAINFO *)dbenv->cj_internal;
  91. return (dbjie_call_recovery_init(dbinfo, dbenv, dbinfo->jenvref_));
  92. }
  94. static int DbEnv_tx_recover_callback(DB_ENV *dbenv, DBT *dbt,
  95.      DB_LSN *lsn, db_recops recops)
  96. {
  97. DB_ENV_JAVAINFO *dbinfo;
  99. DB_ASSERT(dbenv != NULL);
  100. dbinfo = (DB_ENV_JAVAINFO *)dbenv->cj_internal;
  101. return dbjie_call_tx_recover(dbinfo, dbenv, dbinfo->jenvref_, dbt,
  102.      lsn, recops);
  103. }
  105. /****************************************************************
  106.  *
  107.  * Implementation of class DBT_javainfo
  108.  *
  109.  */
  110. DBT_JAVAINFO *
  111. dbjit_construct()
  112. {
  113. DBT_JAVAINFO *dbjit;
  115. dbjit = (DBT_JAVAINFO *)malloc(sizeof(DBT_JAVAINFO));
  116. memset(dbjit, 0, sizeof(DBT_JAVAINFO));
  117. return (dbjit);
  118. }
  120. void dbjit_destroy(DBT_JAVAINFO *dbjit)
  121. {
  122. /* Sanity check:
  123.  * We cannot delete the global ref because we don't have a JNIEnv.
  124.  */
  125. if (dbjit->array_ != NULL) {
  126. fprintf(stderr, "object is not freedn");
  127. }
  129. /* Extra paranoia */
  130. memset(dbjit, 0, sizeof(DB_JAVAINFO));
  131. free(dbjit);
  132. }
  134. void dbjit_release(DBT_JAVAINFO *dbjit, JNIEnv *jnienv)
  135. {
  136. if (dbjit->array_ != NULL) {
  137. DELETE_GLOBAL_REF(jnienv, dbjit->array_);
  138. dbjit->array_ = NULL;
  139. }
  140. }
  142. /****************************************************************
  143.  *
  144.  * Implementation of class DB_ENV_JAVAINFO
  145.  *
  146.  */
  148. /* create/initialize an object */
  149. DB_ENV_JAVAINFO *
  150. dbjie_construct(JNIEnv *jnienv,
  151. jobject default_errcall,
  152. int is_dbopen)
  153. {
  154. DB_ENV_JAVAINFO *dbjie;
  156. dbjie = (DB_ENV_JAVAINFO *)malloc(sizeof(DB_ENV_JAVAINFO));
  157. memset(dbjie, 0, sizeof(DB_ENV_JAVAINFO));
  158. dbjie->is_dbopen_ = is_dbopen;
  160. if ((*jnienv)->GetJavaVM(jnienv, &dbjie->javavm_) != 0) {
  161. free(dbjie);
  162. report_exception(jnienv, "cannot get Java VM", 0, 0);
  163. return (NULL);
  164. }
  166. /* The default error call just prints to the 'System.err'
  167.  * stream.  If the user does set_errcall to null, we'll
  168.  * want to have a reference to set it back to.
  169.  *
  170.  * Why do we have always set db_errcall to our own callback?
  171.  * Because it makes the interaction between setting the
  172.  * error prefix, error stream, and user's error callback
  173.  * that much easier.
  174.  */
  175. dbjie->default_errcall_ = NEW_GLOBAL_REF(jnienv, default_errcall);
  176. dbjie->errcall_ = NEW_GLOBAL_REF(jnienv, default_errcall);
  177. return (dbjie);
  178. }
  180. /* release all objects held by this this one */
  181. void dbjie_dealloc(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv)
  182. {
  183. if (dbjie->recovery_init_ != NULL) {
  184. DELETE_GLOBAL_REF(jnienv, dbjie->recovery_init_);
  185. dbjie->recovery_init_ = NULL;
  186. }
  187. if (dbjie->feedback_ != NULL) {
  188. DELETE_GLOBAL_REF(jnienv, dbjie->feedback_);
  189. dbjie->feedback_ = NULL;
  190. }
  191. if (dbjie->tx_recover_ != NULL) {
  192. DELETE_GLOBAL_REF(jnienv, dbjie->tx_recover_);
  193. dbjie->tx_recover_ = NULL;
  194. }
  195. if (dbjie->errcall_ != NULL) {
  196. DELETE_GLOBAL_REF(jnienv, dbjie->errcall_);
  197. dbjie->errcall_ = NULL;
  198. }
  199. if (dbjie->default_errcall_ != NULL) {
  200. DELETE_GLOBAL_REF(jnienv, dbjie->default_errcall_);
  201. dbjie->default_errcall_ = NULL;
  202. }
  204. if (dbjie->conflict_ != NULL) {
  205. free(dbjie->conflict_);
  206. dbjie->conflict_ = NULL;
  207. }
  208. if (dbjie->errpfx_ != NULL) {
  209. free(dbjie->errpfx_);
  210. dbjie->errpfx_ = NULL;
  211. }
  212. }
  214. /* free this object, releasing anything allocated on its behalf */
  215. void dbjie_destroy(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv)
  216. {
  217. dbjie_dealloc(dbjie, jnienv);
  219. /* Extra paranoia */
  220. memset(dbjie, 0, sizeof(DB_ENV_JAVAINFO));
  221. free(dbjie);
  222. }
  224. /* Attach to the current thread that is running and
  225.  * return that.  We use the java virtual machine
  226.  * that we saved in the constructor.
  227.  */
  228. JNIEnv *
  229. dbjie_get_jnienv(DB_ENV_JAVAINFO *dbjie)
  230. {
  231. /* Note:
  232.  * Different versions of the JNI disagree on the signature
  233.  * for AttachCurrentThread.  The most recent documentation
  234.  * seems to say that (JNIEnv **) is correct, but newer
  235.  * JNIs seem to use (void **), oddly enough.
  236.  */
  237. #ifdef JNI_VERSION_1_2
  238. void *attachret = 0;
  239. #else
  240. JNIEnv *attachret = 0;
  241. #endif
  243. /* This should always succeed, as we are called via
  244.  * some Java activity.  I think therefore I am (a thread).
  245.  */
  246. if ((*dbjie->javavm_)->AttachCurrentThread(dbjie->javavm_, &attachret, 0) != 0)
  247. return (0);
  249. return ((JNIEnv *)attachret);
  250. }
  252. jstring
  253. dbjie_get_errpfx(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv)
  254. {
  255. return (get_java_string(jnienv, dbjie->errpfx_));
  256. }
  258. void
  259. dbjie_set_errcall(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv, jobject new_errcall)
  260. {
  261. /* If the new_errcall is null, we'll set the error call
  262.  * to the default one.
  263.  */
  264. if (new_errcall == NULL)
  265. new_errcall = dbjie->default_errcall_;
  267. DELETE_GLOBAL_REF(jnienv, dbjie->errcall_);
  268. dbjie->errcall_ = NEW_GLOBAL_REF(jnienv, new_errcall);
  269. }
  271. void
  272. dbjie_set_errpfx(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv, jstring errpfx)
  273. {
  274. if (dbjie->errpfx_ != NULL)
  275. free(dbjie->errpfx_);
  277. if (errpfx)
  278. dbjie->errpfx_ = get_c_string(jnienv, errpfx);
  279. else
  280. dbjie->errpfx_ = NULL;
  281. }
  283. void
  284. dbjie_set_conflict(DB_ENV_JAVAINFO *dbjie, unsigned char *newarr)
  285. {
  286. if (dbjie->conflict_)
  287. free(dbjie->conflict_);
  288. dbjie->conflict_ = newarr;
  289. }
  291. void dbjie_set_feedback_object(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv,
  292.        DB_ENV *dbenv, jobject jfeedback)
  293. {
  294. int err;
  296. if (dbjie->feedback_ != NULL) {
  297. DELETE_GLOBAL_REF(jnienv, dbjie->feedback_);
  298. }
  299. if (jfeedback == NULL) {
  300. if ((err = dbenv->set_feedback(dbenv, NULL)) != 0)
  301. report_exception(jnienv, "set_feedback failed",
  302.  err, 0);
  303. }
  304. else {
  305. if ((err = dbenv->set_feedback(dbenv,
  306.        DbEnv_feedback_callback)) != 0)
  307. report_exception(jnienv, "set_feedback failed",
  308.  err, 0);
  309. }
  311. dbjie->feedback_ = NEW_GLOBAL_REF(jnienv, jfeedback);
  312. }
  314. void dbjie_call_feedback(DB_ENV_JAVAINFO *dbjie, DB_ENV *dbenv, jobject jenv,
  315.  int opcode, int percent)
  316. {
  317. JNIEnv *jnienv;
  318. jclass feedback_class;
  319. jmethodID id;
  321. COMPQUIET(dbenv, NULL);
  322. jnienv = dbjie_get_jnienv(dbjie);
  323. if (jnienv == NULL) {
  324. fprintf(stderr, "Cannot attach to current thread!n");
  325. return;
  326. }
  328. feedback_class = get_class(jnienv, name_DbEnvFeedback);
  329. id = (*jnienv)->GetMethodID(jnienv, feedback_class,
  330.     "feedback",
  331.     "(Lcom/sleepycat/db/DbEnv;II)V");
  332. if (!id) {
  333. fprintf(stderr, "Cannot find callback classn");
  334. return;
  335. }
  337. (*jnienv)->CallVoidMethod(jnienv, dbjie->feedback_, id,
  338.   jenv, (jint)opcode, (jint)percent);
  339. }
  341. void dbjie_set_recovery_init_object(DB_ENV_JAVAINFO *dbjie,
  342.     JNIEnv *jnienv, DB_ENV *dbenv,
  343.     jobject jrecovery_init)
  344. {
  345. int err;
  347. if (dbjie->recovery_init_ != NULL) {
  348. DELETE_GLOBAL_REF(jnienv, dbjie->recovery_init_);
  349. }
  350. if (jrecovery_init == NULL) {
  351. if ((err = dbenv->set_recovery_init(dbenv, NULL)) != 0)
  352. report_exception(jnienv, "set_recovery_init failed",
  353.  err, 0);
  354. }
  355. else {
  356. if ((err = dbenv->set_recovery_init(dbenv,
  357. DbEnv_recovery_init_callback)) != 0)
  358. report_exception(jnienv, "set_recovery_init failed",
  359.  err, 0);
  360. }
  362. dbjie->recovery_init_ = NEW_GLOBAL_REF(jnienv, jrecovery_init);
  363. }
  365. int dbjie_call_recovery_init(DB_ENV_JAVAINFO *dbjie, DB_ENV *dbenv,
  366.      jobject jenv)
  367. {
  368. JNIEnv *jnienv;
  369. jclass recovery_init_class;
  370. jmethodID id;
  372. COMPQUIET(dbenv, NULL);
  373. jnienv = dbjie_get_jnienv(dbjie);
  374. if (jnienv == NULL) {
  375. fprintf(stderr, "Cannot attach to current thread!n");
  376. return (EINVAL);
  377. }
  379. recovery_init_class = get_class(jnienv, name_DbRecoveryInit);
  380. id = (*jnienv)->GetMethodID(jnienv, recovery_init_class,
  381.     "recovery_init",
  382.     "(Lcom/sleepycat/db/DbEnv;)V");
  383. if (!id) {
  384. fprintf(stderr, "Cannot find callback classn");
  385. return (EINVAL);
  386. }
  387. return (*jnienv)->CallIntMethod(jnienv, dbjie->recovery_init_,
  388. id, jenv);
  389. }
  391. void dbjie_set_tx_recover_object(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv,
  392.  DB_ENV *dbenv, jobject jtx_recover)
  393. {
  394. int err;
  396. if (dbjie->tx_recover_ != NULL) {
  397. DELETE_GLOBAL_REF(jnienv, dbjie->tx_recover_);
  398. }
  399. if (jtx_recover == NULL) {
  400. if ((err = dbenv->set_tx_recover(dbenv, NULL)) != 0)
  401. report_exception(jnienv, "set_tx_recover failed",
  402.  err, 0);
  403. }
  404. else {
  405. if ((err = dbenv->set_tx_recover(dbenv,
  406.  DbEnv_tx_recover_callback)) != 0)
  407. report_exception(jnienv, "set_tx_recover failed",
  408.  err, 0);
  409. }
  411. dbjie->tx_recover_ = NEW_GLOBAL_REF(jnienv, jtx_recover);
  412. }
  414. int dbjie_call_tx_recover(DB_ENV_JAVAINFO *dbjie, DB_ENV *dbenv, jobject jenv,
  415.   DBT *dbt, DB_LSN *lsn, int recops)
  416. {
  417. JNIEnv *jnienv;
  418. jclass tx_recover_class;
  419. jmethodID id;
  420. jobject jdbt;
  421. jobject jlsn;
  423. COMPQUIET(dbenv, NULL);
  424. jnienv = dbjie_get_jnienv(dbjie);
  425. if (jnienv == NULL) {
  426. fprintf(stderr, "Cannot attach to current thread!n");
  427. return (0);
  428. }
  430. tx_recover_class = get_class(jnienv, name_DbTxnRecover);
  431. id = (*jnienv)->GetMethodID(jnienv, tx_recover_class,
  432.     "tx_recover",
  433.     "(Lcom/sleepycat/db/DbEnv;"
  434.     "Lcom/sleepycat/db/Dbt;"
  435.     "Lcom/sleepycat/db/DbLsn;"
  436.     "I)I");
  437. if (!id) {
  438. fprintf(stderr, "Cannot find callback classn");
  439. return (0);
  440. }
  442. if (dbt == NULL)
  443. jdbt = NULL;
  444. else
  445. jdbt = get_Dbt(jnienv, dbt);
  447. if (lsn == NULL)
  448. jlsn = NULL;
  449. else
  450. jlsn = get_DbLsn(jnienv, *lsn);
  452. return (*jnienv)->CallIntMethod(jnienv, dbjie->tx_recover_, id, jenv,
  453. jdbt, jlsn, recops);
  454. }
  456. jobject dbjie_get_errcall(DB_ENV_JAVAINFO *dbjie)
  457. {
  458. return (dbjie->errcall_);
  459. }
  461. int dbjie_is_dbopen(DB_ENV_JAVAINFO *dbjie)
  462. {
  463. return (dbjie->is_dbopen_);
  464. }
  466. /****************************************************************
  467.  *
  468.  * Implementation of class DB_JAVAINFO
  469.  *
  470.  */
  472. DB_JAVAINFO *dbji_construct(JNIEnv *jnienv, jint flags)
  473. {
  474. DB_JAVAINFO *dbji;
  476. dbji = (DB_JAVAINFO *)malloc(sizeof(DB_JAVAINFO));
  477. memset(dbji, 0, sizeof(DB_JAVAINFO));
  479. if ((*jnienv)->GetJavaVM(jnienv, &dbji->javavm_) != 0) {
  480. report_exception(jnienv, "cannot get Java VM", 0, 0);
  481. free(dbji);
  482. return (NULL);
  483. }
  484. dbji->construct_flags_ = flags;
  485. return (dbji);
  486. }
  488. void
  489. dbji_dealloc(DB_JAVAINFO *dbji, JNIEnv *jnienv)
  490. {
  491. if (dbji->append_recno_ != NULL) {
  492. DELETE_GLOBAL_REF(jnienv, dbji->append_recno_);
  493. dbji->append_recno_ = NULL;
  494. }
  495. if (dbji->bt_compare_ != NULL) {
  496. DELETE_GLOBAL_REF(jnienv, dbji->bt_compare_);
  497. dbji->bt_compare_ = NULL;
  498. }
  499. if (dbji->bt_prefix_ != NULL) {
  500. DELETE_GLOBAL_REF(jnienv, dbji->bt_prefix_);
  501. dbji->bt_prefix_ = NULL;
  502. }
  503. if (dbji->dup_compare_ != NULL) {
  504. DELETE_GLOBAL_REF(jnienv, dbji->dup_compare_);
  505. dbji->dup_compare_ = NULL;
  506. }
  507. if (dbji->feedback_ != NULL) {
  508. DELETE_GLOBAL_REF(jnienv, dbji->feedback_);
  509. dbji->feedback_ = NULL;
  510. }
  511. if (dbji->h_hash_ != NULL) {
  512. DELETE_GLOBAL_REF(jnienv, dbji->h_hash_);
  513. dbji->h_hash_ = NULL;
  514. }
  515. }
  517. void
  518. dbji_destroy(DB_JAVAINFO *dbji, JNIEnv *jnienv)
  519. {
  520. dbji_dealloc(dbji, jnienv);
  521. free(dbji);
  522. }
  524. JNIEnv *dbji_get_jnienv(DB_JAVAINFO *dbji)
  525. {
  526. /* Note:
  527.  * Different versions of the JNI disagree on the signature
  528.  * for AttachCurrentThread.  The most recent documentation
  529.  * seems to say that (JNIEnv **) is correct, but newer
  530.  * JNIs seem to use (void **), oddly enough.
  531.  */
  532. #ifdef JNI_VERSION_1_2
  533. void *attachret = 0;
  534. #else
  535. JNIEnv *attachret = 0;
  536. #endif
  538. /* This should always succeed, as we are called via
  539.  * some Java activity.  I think therefore I am (a thread).
  540.  */
  541. if ((*dbji->javavm_)->AttachCurrentThread(dbji->javavm_, &attachret, 0) != 0)
  542. return (0);
  544. return ((JNIEnv *)attachret);
  545. }
  547. jint dbji_get_flags(DB_JAVAINFO *dbji)
  548. {
  549. return (dbji->construct_flags_);
  550. }
  552. void dbji_set_feedback_object(DB_JAVAINFO *dbji, JNIEnv *jnienv,
  553.       DB *db, jobject jfeedback)
  554. {
  555. jclass feedback_class;
  557. if (dbji->feedback_method_id_ == NULL) {
  558. feedback_class = get_class(jnienv, name_DbFeedback);
  559. dbji->feedback_method_id_ =
  560. (*jnienv)->GetMethodID(jnienv, feedback_class,
  561.        "feedback",
  562.        "(Lcom/sleepycat/db/Db;II)V");
  563. if (dbji->feedback_method_id_ != NULL) {
  564. /* XXX
  565.  * We should really have a better way
  566.  * to translate this to a Java exception class.
  567.  * In theory, it shouldn't happen.
  568.  */
  569. report_exception(jnienv, "Cannot find callback method",
  570.  EFAULT, 0);
  571. return;
  572. }
  573. }
  575. if (dbji->feedback_ != NULL) {
  576. DELETE_GLOBAL_REF(jnienv, dbji->feedback_);
  577. }
  578. if (jfeedback == NULL) {
  579. db->set_feedback(db, NULL);
  580. }
  581. else {
  582. db->set_feedback(db, Db_feedback_callback);
  583. }
  585. dbji->feedback_ = NEW_GLOBAL_REF(jnienv, jfeedback);
  587. }
  589. void dbji_call_feedback(DB_JAVAINFO *dbji, DB *db, jobject jdb,
  590. int opcode, int percent)
  591. {
  592. JNIEnv *jnienv;
  594. COMPQUIET(db, NULL);
  595. jnienv = dbji_get_jnienv(dbji);
  596. if (jnienv == NULL) {
  597. fprintf(stderr, "Cannot attach to current thread!n");
  598. return;
  599. }
  601. DB_ASSERT(dbji->feedback_method_id_ != NULL);
  602. (*jnienv)->CallVoidMethod(jnienv, dbji->feedback_,
  603.   dbji->feedback_method_id_,
  604.   jdb, (jint)opcode, (jint)percent);
  605. }
  607. void dbji_set_append_recno_object(DB_JAVAINFO *dbji, JNIEnv *jnienv,
  608.   DB *db, jobject jcallback)
  609. {
  610. jclass append_recno_class;
  612. if (dbji->append_recno_method_id_ == NULL) {
  613. append_recno_class = get_class(jnienv, name_DbAppendRecno);
  614. dbji->append_recno_method_id_ =
  615. (*jnienv)->GetMethodID(jnienv, append_recno_class,
  616.        "db_append_recno",
  617.        "(Lcom/sleepycat/db/Db;"
  618.        "Lcom/sleepycat/db/Dbt;I)V");
  619. if (dbji->append_recno_method_id_ == NULL) {
  620. /* XXX
  621.  * We should really have a better way
  622.  * to translate this to a Java exception class.
  623.  * In theory, it shouldn't happen.
  624.  */
  625. report_exception(jnienv, "Cannot find callback method",
  626.  EFAULT, 0);
  627. return;
  628. }
  629. }
  631. if (dbji->append_recno_ != NULL) {
  632. DELETE_GLOBAL_REF(jnienv, dbji->append_recno_);
  633. }
  634. if (jcallback == NULL) {
  635. db->set_append_recno(db, NULL);
  636. }
  637. else {
  638. db->set_append_recno(db, Db_append_recno_callback);
  639. }
  641. dbji->append_recno_ = NEW_GLOBAL_REF(jnienv, jcallback);
  642. }
  644. extern int dbji_call_append_recno(DB_JAVAINFO *dbji, DB *db, jobject jdb,
  645.   DBT *dbt, jint recno)
  646. {
  647. JNIEnv *jnienv;
  648. jobject jdbt;
  649. DBT_JAVAINFO *dbtji;
  650. jbyteArray arr;
  651. unsigned int arraylen;
  652. unsigned char *data;
  654. COMPQUIET(db, NULL);
  655. jnienv = dbji_get_jnienv(dbji);
  656. if (jnienv == NULL) {
  657. fprintf(stderr, "Cannot attach to current thread!n");
  658. return (0);
  659. }
  661. /* XXX
  662.  * We should have a pool of Dbt objects used for this purpose
  663.  * instead of creating new ones each time.  Because of
  664.  * multithreading, we may need an arbitrary number (more than two).
  665.  * We might also have a byte arrays that grow as needed,
  666.  * so we don't need to allocate those either.
  667.  *
  668.  * Note, we do not set the 'create_array_' flag as on other
  669.  * callbacks as we are creating the array here.
  670.  */
  671. jdbt = create_default_object(jnienv, name_DBT);
  672. dbtji = get_DBT_JAVAINFO(jnienv, jdbt);
  673. memcpy(&dbtji->dbt, dbt, sizeof(DBT));
  674. dbtji->dbt.data = NULL;
  675. arr = (*jnienv)->NewByteArray(jnienv, dbt->size);
  676. (*jnienv)->SetByteArrayRegion(jnienv, arr, 0, dbt->size,
  677.       (jbyte *)dbt->data);
  678. dbtji->array_ = (jbyteArray)NEW_GLOBAL_REF(jnienv, arr);
  680. DB_ASSERT(dbji->append_recno_method_id_ != NULL);
  681. (*jnienv)->CallVoidMethod(jnienv, dbji->append_recno_,
  682.   dbji->append_recno_method_id_,
  683.   jdb, jdbt, recno);
  685. /* The underlying C API requires that an errno be returned
  686.  * on error.  Java users know nothing of errnos, so we
  687.  * allow them to throw exceptions instead.  We leave the
  688.  * exception in place and return DB_JAVA_CALLBACK to the C API
  689.  * that called us.  Eventually the DB->get will fail and
  690.  * when java prepares to throw an exception in
  691.  * report_exception(), this will be spotted as a special case,
  692.  * and the original exception will be preserved.
  693.  *
  694.  * Note: we have sometimes noticed strange behavior with
  695.  * exceptions under Linux 1.1.7 JVM.  (i.e. multiple calls
  696.  * to ExceptionOccurred() may report different results).
  697.  * Currently we don't know of any problems related to this
  698.  * in our code, but if it pops up in the future, users are
  699.  * encouranged to get a more recent JVM.
  700.  */
  701. if ((*jnienv)->ExceptionOccurred(jnienv) != NULL)
  702. return (DB_JAVA_CALLBACK);
  704. if (dbtji->array_ == NULL) {
  705. report_exception(jnienv, "Dbt.data is null", 0, 0);
  706. return (EFAULT);
  707. }
  709. arraylen = (*jnienv)->GetArrayLength(jnienv, dbtji->array_);
  710. if (dbtji->offset_ < 0 ) {
  711. report_exception(jnienv, "Dbt.offset illegal", 0, 0);
  712. return (EFAULT);
  713. }
  714. if (dbt->ulen + dbtji->offset_ > arraylen) {
  715. report_exception(jnienv,
  716.    "Dbt.ulen + Dbt.offset greater than array length", 0, 0);
  717. return (EFAULT);
  718. }
  720. data = (*jnienv)->GetByteArrayElements(jnienv, dbtji->array_,
  721.        (jboolean *)0);
  722. dbt->data = data + dbtji->offset_;
  723. return (0);
  724. }
  726. void dbji_set_bt_compare_object(DB_JAVAINFO *dbji, JNIEnv *jnienv,
  727. DB *db, jobject jcompare)
  728. {
  729. jclass bt_compare_class;
  731. if (dbji->bt_compare_method_id_ == NULL) {
  732. bt_compare_class = get_class(jnienv, name_DbBtreeCompare);
  733. dbji->bt_compare_method_id_ =
  734. (*jnienv)->GetMethodID(jnienv, bt_compare_class,
  735.        "bt_compare",
  736.        "(Lcom/sleepycat/db/Db;"
  737.        "Lcom/sleepycat/db/Dbt;"
  738.        "Lcom/sleepycat/db/Dbt;)I");
  739. if (dbji->bt_compare_method_id_ == NULL) {
  740. /* XXX
  741.  * We should really have a better way
  742.  * to translate this to a Java exception class.
  743.  * In theory, it shouldn't happen.
  744.  */
  745. report_exception(jnienv, "Cannot find callback method",
  746.  EFAULT, 0);
  747. return;
  748. }
  749. }
  751. if (dbji->bt_compare_ != NULL) {
  752. DELETE_GLOBAL_REF(jnienv, dbji->bt_compare_);
  753. }
  754. if (jcompare == NULL) {
  755. db->set_bt_compare(db, NULL);
  756. }
  757. else {
  758. db->set_bt_compare(db, Db_bt_compare_callback);
  759. }
  761. dbji->bt_compare_ = NEW_GLOBAL_REF(jnienv, jcompare);
  762. }
  764. int dbji_call_bt_compare(DB_JAVAINFO *dbji, DB *db, jobject jdb,
  765.  const DBT *dbt1, const DBT *dbt2)
  766. {
  767. JNIEnv *jnienv;
  768. jobject jdbt1, jdbt2;
  769. DBT_JAVAINFO *dbtji1, *dbtji2;
  771. COMPQUIET(db, NULL);
  772. jnienv = dbji_get_jnienv(dbji);
  773. if (jnienv == NULL) {
  774. fprintf(stderr, "Cannot attach to current thread!n");
  775. return (0);
  776. }
  778. /* XXX
  779.  * We should have a pool of Dbt objects used for this purpose
  780.  * instead of creating new ones each time.  Because of
  781.  * multithreading, we may need an arbitrary number (more than two).
  782.  * We might also have a byte arrays that grow as needed,
  783.  * so we don't need to allocate those either.
  784.  */
  785. jdbt1 = create_default_object(jnienv, name_DBT);
  786. jdbt2 = create_default_object(jnienv, name_DBT);
  787. dbtji1 = get_DBT_JAVAINFO(jnienv, jdbt1);
  788. memcpy(&dbtji1->dbt, dbt1, sizeof(DBT));
  789. dbtji1->create_array_ = 1;
  790. dbtji2 = get_DBT_JAVAINFO(jnienv, jdbt2);
  791. memcpy(&dbtji2->dbt, dbt2, sizeof(DBT));
  792. dbtji2->create_array_ = 1;
  794. DB_ASSERT(dbji->bt_compare_method_id_ != NULL);
  795. return (*jnienv)->CallIntMethod(jnienv, dbji->bt_compare_,
  796. dbji->bt_compare_method_id_,
  797. jdb, jdbt1, jdbt2);
  798. }
  800. void dbji_set_bt_prefix_object(DB_JAVAINFO *dbji, JNIEnv *jnienv,
  801. DB *db, jobject jprefix)
  802. {
  803. jclass bt_prefix_class;
  805. if (dbji->bt_prefix_method_id_ == NULL) {
  806. bt_prefix_class = get_class(jnienv, name_DbBtreePrefix);
  807. dbji->bt_prefix_method_id_ =
  808. (*jnienv)->GetMethodID(jnienv, bt_prefix_class,
  809.        "bt_prefix",
  810.        "(Lcom/sleepycat/db/Db;"
  811.        "Lcom/sleepycat/db/Dbt;"
  812.        "Lcom/sleepycat/db/Dbt;)I");
  813. if (dbji->bt_prefix_method_id_ == NULL) {
  814. /* XXX
  815.  * We should really have a better way
  816.  * to translate this to a Java exception class.
  817.  * In theory, it shouldn't happen.
  818.  */
  819. report_exception(jnienv, "Cannot find callback method",
  820.  EFAULT, 0);
  821. return;
  822. }
  823. }
  825. if (dbji->bt_prefix_ != NULL) {
  826. DELETE_GLOBAL_REF(jnienv, dbji->bt_prefix_);
  827. }
  828. if (jprefix == NULL) {
  829. db->set_bt_prefix(db, NULL);
  830. }
  831. else {
  832. db->set_bt_prefix(db, Db_bt_prefix_callback);
  833. }
  835. dbji->bt_prefix_ = NEW_GLOBAL_REF(jnienv, jprefix);
  836. }
  838. size_t dbji_call_bt_prefix(DB_JAVAINFO *dbji, DB *db, jobject jdb,
  839.    const DBT *dbt1, const DBT *dbt2)
  840. {
  841. JNIEnv *jnienv;
  842. jobject jdbt1, jdbt2;
  843. DBT_JAVAINFO *dbtji1, *dbtji2;
  845. COMPQUIET(db, NULL);
  846. jnienv = dbji_get_jnienv(dbji);
  847. if (jnienv == NULL) {
  848. fprintf(stderr, "Cannot attach to current thread!n");
  849. return (0);
  850. }
  852. /* XXX
  853.  * We should have a pool of Dbt objects used for this purpose
  854.  * instead of creating new ones each time.  Because of
  855.  * multithreading, we may need an arbitrary number (more than two).
  856.  * We might also have a byte arrays that grow as needed,
  857.  * so we don't need to allocate those either.
  858.  */
  859. jdbt1 = create_default_object(jnienv, name_DBT);
  860. jdbt2 = create_default_object(jnienv, name_DBT);
  861. dbtji1 = get_DBT_JAVAINFO(jnienv, jdbt1);
  862. memcpy(&dbtji1->dbt, dbt1, sizeof(DBT));
  863. dbtji1->create_array_ = 1;
  864. dbtji2 = get_DBT_JAVAINFO(jnienv, jdbt2);
  865. memcpy(&dbtji2->dbt, dbt2, sizeof(DBT));
  866. dbtji2->create_array_ = 1;
  868. DB_ASSERT(dbji->bt_prefix_method_id_ != NULL);
  869. return (size_t)(*jnienv)->CallIntMethod(jnienv, dbji->bt_prefix_,
  870. dbji->bt_prefix_method_id_,
  871. jdb, jdbt1, jdbt2);
  872. }
  874. void dbji_set_dup_compare_object(DB_JAVAINFO *dbji, JNIEnv *jnienv,
  875. DB *db, jobject jcompare)
  876. {
  877. jclass dup_compare_class;
  879. if (dbji->dup_compare_method_id_ == NULL) {
  880. dup_compare_class = get_class(jnienv, name_DbDupCompare);
  881. dbji->dup_compare_method_id_ =
  882. (*jnienv)->GetMethodID(jnienv, dup_compare_class,
  883.        "dup_compare",
  884.        "(Lcom/sleepycat/db/Db;"
  885.        "Lcom/sleepycat/db/Dbt;"
  886.        "Lcom/sleepycat/db/Dbt;)I");
  887. if (dbji->dup_compare_method_id_ == NULL) {
  888. /* XXX
  889.  * We should really have a better way
  890.  * to translate this to a Java exception class.
  891.  * In theory, it shouldn't happen.
  892.  */
  893. report_exception(jnienv, "Cannot find callback method",
  894.  EFAULT, 0);
  895. return;
  896. }
  897. }
  899. if (dbji->dup_compare_ != NULL)
  900. DELETE_GLOBAL_REF(jnienv, dbji->dup_compare_);
  902. if (jcompare == NULL)
  903. db->set_dup_compare(db, NULL);
  904. else
  905. db->set_dup_compare(db, Db_dup_compare_callback);
  907. dbji->dup_compare_ = NEW_GLOBAL_REF(jnienv, jcompare);
  908. }
  910. int dbji_call_dup_compare(DB_JAVAINFO *dbji, DB *db, jobject jdb,
  911.  const DBT *dbt1, const DBT *dbt2)
  912. {
  913. JNIEnv *jnienv;
  914. jobject jdbt1, jdbt2;
  915. DBT_JAVAINFO *dbtji1, *dbtji2;
  917. COMPQUIET(db, NULL);
  918. jnienv = dbji_get_jnienv(dbji);
  919. if (jnienv == NULL) {
  920. fprintf(stderr, "Cannot attach to current thread!n");
  921. return (0);
  922. }
  924. /* XXX
  925.  * We should have a pool of Dbt objects used for this purpose
  926.  * instead of creating new ones each time.  Because of
  927.  * multithreading, we may need an arbitrary number (more than two).
  928.  * We might also have a byte arrays that grow as needed,
  929.  * so we don't need to allocate those either.
  930.  */
  931. jdbt1 = create_default_object(jnienv, name_DBT);
  932. jdbt2 = create_default_object(jnienv, name_DBT);
  933. dbtji1 = get_DBT_JAVAINFO(jnienv, jdbt1);
  934. memcpy(&dbtji1->dbt, dbt1, sizeof(DBT));
  935. dbtji1->create_array_ = 1;
  936. dbtji2 = get_DBT_JAVAINFO(jnienv, jdbt2);
  937. memcpy(&dbtji2->dbt, dbt2, sizeof(DBT));
  938. dbtji2->create_array_ = 1;
  940. DB_ASSERT(dbji->dup_compare_method_id_ != NULL);
  941. return (*jnienv)->CallIntMethod(jnienv, dbji->dup_compare_,
  942. dbji->dup_compare_method_id_,
  943. jdb, jdbt1, jdbt2);
  944. }
  946. void dbji_set_h_hash_object(DB_JAVAINFO *dbji, JNIEnv *jnienv,
  947. DB *db, jobject jhash)
  948. {
  949. jclass h_hash_class;
  951. if (dbji->h_hash_method_id_ == NULL) {
  952. h_hash_class = get_class(jnienv, name_DbHash);
  953. dbji->h_hash_method_id_ =
  954. (*jnienv)->GetMethodID(jnienv, h_hash_class,
  955.        "hash",
  956.        "(Lcom/sleepycat/db/Db;"
  957.        "[BI)I");
  958. if (dbji->h_hash_method_id_ == NULL) {
  959. /* XXX
  960.  * We should really have a better way
  961.  * to translate this to a Java exception class.
  962.  * In theory, it shouldn't happen.
  963.  */
  964. report_exception(jnienv, "Cannot find callback method",
  965.  EFAULT, 0);
  966. return;
  967. }
  968. }
  970. if (dbji->h_hash_ != NULL)
  971. DELETE_GLOBAL_REF(jnienv, dbji->h_hash_);
  973. if (jhash == NULL)
  974. db->set_h_hash(db, NULL);
  975. else
  976. db->set_h_hash(db, Db_h_hash_callback);
  978. dbji->h_hash_ = NEW_GLOBAL_REF(jnienv, jhash);
  979. }
  981. int dbji_call_h_hash(DB_JAVAINFO *dbji, DB *db, jobject jdb,
  982.      const void *data, int len)
  983. {
  984. JNIEnv *jnienv;
  985. jbyteArray jarray;
  987. COMPQUIET(db, NULL);
  988. jnienv = dbji_get_jnienv(dbji);
  989. if (jnienv == NULL) {
  990. fprintf(stderr, "Cannot attach to current thread!n");
  991. return (0);
  992. }
  994. DB_ASSERT(dbji->h_hash_method_id_ != NULL);
  996. jarray = (*jnienv)->NewByteArray(jnienv, len);
  997. (*jnienv)->SetByteArrayRegion(jnienv, jarray, 0, len, (void *)data);
  998. return (*jnienv)->CallIntMethod(jnienv, dbji->h_hash_,
  999. dbji->h_hash_method_id_,
  1000. jdb, jarray, len);
  1001. }