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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
java_Db.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：24k
源码类别：

MySQL数据库

开发平台：

Visual C++

java_Db.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  9. #ifndef lint
  10. static const char revid[] = "$Id: java_Db.c,v 11.80 2002/08/29 14:22:23 margo Exp $";
  11. #endif /* not lint */
  13. #include <jni.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  17. #include "db_int.h"
  18. #include "dbinc/db_page.h"
  19. #include "dbinc/btree.h"
  20. #include "dbinc_auto/db_ext.h"
  21. #include "java_util.h"
  22. #include "java_stat_auto.h"
  23. #include "com_sleepycat_db_Db.h"
  25. /* This struct is used in Db.verify and its callback */
  26. struct verify_callback_struct {
  27. JNIEnv *env;
  28. jobject streamobj;
  29. jbyteArray bytes;
  30. int nbytes;
  31. jmethodID writemid;
  32. };
  34. JAVADB_GET_FLD(Db, jint, flags_1raw, DB, flags)
  36. JAVADB_SET_METH(Db, jint, flags, DB, flags)
  37. JAVADB_SET_METH(Db, jint, h_1ffactor, DB, h_ffactor)
  38. JAVADB_SET_METH(Db, jint, h_1nelem, DB, h_nelem)
  39. JAVADB_SET_METH(Db, jint, lorder, DB, lorder)
  40. JAVADB_SET_METH(Db, jint, re_1delim, DB, re_delim)
  41. JAVADB_SET_METH(Db, jint, re_1len, DB, re_len)
  42. JAVADB_SET_METH(Db, jint, re_1pad, DB, re_pad)
  43. JAVADB_SET_METH(Db, jint, q_1extentsize, DB, q_extentsize)
  44. JAVADB_SET_METH(Db, jint, bt_1maxkey, DB, bt_maxkey)
  45. JAVADB_SET_METH(Db, jint, bt_1minkey, DB, bt_minkey)
  47. /*
  48.  * This only gets called once ever, at the beginning of execution
  49.  * and can be used to initialize unchanging methodIds, fieldIds, etc.
  50.  */
  51. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_one_1time_1init
  52.   (JNIEnv *jnienv,  /*Db.class*/ jclass jthisclass)
  53. {
  54. COMPQUIET(jthisclass, NULL);
  56. one_time_init(jnienv);
  57. }
  59. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1init
  60.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbEnv*/ jobject jdbenv, jint flags)
  61. {
  62. int err;
  63. DB *db;
  64. DB_JAVAINFO *dbinfo;
  65. DB_ENV *dbenv;
  67. dbenv = get_DB_ENV(jnienv, jdbenv);
  68. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  69. DB_ASSERT(dbinfo == NULL);
  71. err = db_create(&db, dbenv, flags);
  72. if (verify_return(jnienv, err, 0)) {
  73. set_private_dbobj(jnienv, name_DB, jthis, db);
  74. dbinfo = dbji_construct(jnienv, jthis, flags);
  75. set_private_info(jnienv, name_DB, jthis, dbinfo);
  76. db->api_internal = dbinfo;
  77. }
  78. }
  80. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1associate
  81.     (JNIEnv *jnienv, /*Db*/ jobject jthis, /* DbTxn */ jobject jtxn,
  82.      /*Db*/ jobject jsecondary, /*DbSecondaryKeyCreate*/ jobject jcallback,
  83.      jint flags)
  84. {
  85. DB *db, *secondary;
  86. DB_JAVAINFO *second_info;
  87. DB_TXN *txn;
  89. db = get_DB(jnienv, jthis);
  90. txn = get_DB_TXN(jnienv, jtxn);
  91. secondary = get_DB(jnienv, jsecondary);
  93. second_info = (DB_JAVAINFO*)secondary->api_internal;
  94. dbji_set_assoc_object(second_info, jnienv, db, txn, secondary,
  95.       jcallback, flags);
  97. }
  99. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db__1close
  100.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jint flags)
  101. {
  102. int err;
  103. DB *db;
  104. DB_JAVAINFO *dbinfo;
  106. db = get_DB(jnienv, jthis);
  107. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  108. if (!verify_non_null(jnienv, db))
  109. return (0);
  111. /*
  112.  * Null out the private data to indicate the DB is invalid.
  113.  * We do this in advance to help guard against multithreading
  114.  * issues.
  115.  */
  116. set_private_dbobj(jnienv, name_DB, jthis, 0);
  118. err = db->close(db, flags);
  119. verify_return(jnienv, err, 0);
  120. dbji_dealloc(dbinfo, jnienv);
  122. return (err);
  123. }
  125. /*
  126.  * We are being notified that the parent DbEnv has closed.
  127.  * Zero out the pointer to the DB, since it is no longer
  128.  * valid, to prevent mistakes.  The user will get a null
  129.  * pointer exception if they try to use this Db again.
  130.  */
  131. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1notify_1internal
  132.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  133. {
  134. set_private_dbobj(jnienv, name_DB, jthis, 0);
  135. }
  137. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_append_1recno_1changed
  138.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbAppendRecno*/ jobject jcallback)
  139. {
  140. DB *db;
  141. DB_JAVAINFO *dbinfo;
  143. db = get_DB(jnienv, jthis);
  144. if (!verify_non_null(jnienv, db))
  145. return;
  147. dbinfo = (DB_JAVAINFO*)db->api_internal;
  148. dbji_set_append_recno_object(dbinfo, jnienv, db, jcallback);
  149. }
  151. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_bt_1compare_1changed
  152.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbBtreeCompare*/ jobject jbtcompare)
  153. {
  154. DB *db;
  155. DB_JAVAINFO *dbinfo;
  157. db = get_DB(jnienv, jthis);
  158. if (!verify_non_null(jnienv, db))
  159. return;
  161. dbinfo = (DB_JAVAINFO*)db->api_internal;
  162. dbji_set_bt_compare_object(dbinfo, jnienv, db, jbtcompare);
  163. }
  165. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_bt_1prefix_1changed
  166.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbBtreePrefix*/ jobject jbtprefix)
  167. {
  168. DB *db;
  169. DB_JAVAINFO *dbinfo;
  171. db = get_DB(jnienv, jthis);
  172. if (!verify_non_null(jnienv, db))
  173. return;
  175. dbinfo = (DB_JAVAINFO*)db->api_internal;
  176. dbji_set_bt_prefix_object(dbinfo, jnienv, db, jbtprefix);
  177. }
  179. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_Db_cursor
  180.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid, jint flags)
  181. {
  182. int err;
  183. DBC *dbc;
  184. DB *db = get_DB(jnienv, jthis);
  185. DB_TXN *dbtxnid = get_DB_TXN(jnienv, txnid);
  187. if (!verify_non_null(jnienv, db))
  188. return (NULL);
  189. err = db->cursor(db, dbtxnid, &dbc, flags);
  190. verify_return(jnienv, err, 0);
  191. return (get_Dbc(jnienv, dbc));
  192. }
  194. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_del
  195.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  196.    /*Dbt*/ jobject key, jint dbflags)
  197. {
  198. int err;
  199. DB_TXN *dbtxnid;
  200. DB *db;
  201. LOCKED_DBT lkey;
  203. err = 0;
  204. db = get_DB(jnienv, jthis);
  205. if (!verify_non_null(jnienv, db))
  206. return (0);
  208. dbtxnid = get_DB_TXN(jnienv, txnid);
  209. if (locked_dbt_get(&lkey, jnienv, db->dbenv, key, inOp) != 0)
  210. goto out;
  212. err = db->del(db, dbtxnid, &lkey.javainfo->dbt, dbflags);
  213. if (!DB_RETOK_DBDEL(err))
  214. verify_return(jnienv, err, 0);
  216.  out:
  217. locked_dbt_put(&lkey, jnienv, db->dbenv);
  218. return (err);
  219. }
  221. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_dup_1compare_1changed
  222.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbDupCompare*/ jobject jdupcompare)
  223. {
  224. DB *db;
  225. DB_JAVAINFO *dbinfo;
  227. db = get_DB(jnienv, jthis);
  228. if (!verify_non_null(jnienv, db))
  229. return;
  231. dbinfo = (DB_JAVAINFO*)db->api_internal;
  232. dbji_set_dup_compare_object(dbinfo, jnienv, db, jdupcompare);
  233. }
  235. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_err
  236.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jint ecode, jstring msg)
  237. {
  238. DB *db;
  239. LOCKED_STRING ls_msg;
  241. if (locked_string_get(&ls_msg, jnienv, msg) != 0)
  242. goto out;
  243. db = get_DB(jnienv, jthis);
  244. if (!verify_non_null(jnienv, db))
  245. goto out;
  247. db->err(db, ecode, "%s", ls_msg.string);
  249.  out:
  250. locked_string_put(&ls_msg, jnienv);
  251. }
  253. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_errx
  254.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring msg)
  255. {
  256. LOCKED_STRING ls_msg;
  257. DB *db = get_DB(jnienv, jthis);
  259. if (locked_string_get(&ls_msg, jnienv, msg) != 0)
  260. goto out;
  261. if (!verify_non_null(jnienv, db))
  262. goto out;
  264. db->errx(db, "%s", ls_msg.string);
  266.  out:
  267. locked_string_put(&ls_msg, jnienv);
  268. }
  270. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_fd
  271.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  272. {
  273. int err;
  274. int return_value = 0;
  275. DB *db = get_DB(jnienv, jthis);
  277. if (!verify_non_null(jnienv, db))
  278. return (0);
  280. err = db->fd(db, &return_value);
  281. verify_return(jnienv, err, 0);
  283. return (return_value);
  284. }
  286. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_set_1encrypt
  287.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring jpasswd, jint flags)
  288. {
  289. int err;
  290. DB *db;
  291. LOCKED_STRING ls_passwd;
  293. db = get_DB(jnienv, jthis);
  294. if (!verify_non_null(jnienv, db))
  295. return;
  296. if (locked_string_get(&ls_passwd, jnienv, jpasswd) != 0)
  297. goto out;
  299. err = db->set_encrypt(db, ls_passwd.string, flags);
  300. verify_return(jnienv, err, 0);
  302. out: locked_string_put(&ls_passwd, jnienv);
  303. }
  305. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_feedback_1changed
  306.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbFeedback*/ jobject jfeedback)
  307. {
  308. DB *db;
  309. DB_JAVAINFO *dbinfo;
  311. db = get_DB(jnienv, jthis);
  312. if (!verify_non_null(jnienv, db))
  313. return;
  315. dbinfo = (DB_JAVAINFO*)db->api_internal;
  316. dbji_set_feedback_object(dbinfo, jnienv, db, jfeedback);
  317. }
  319. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_get
  320.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  321.    /*Dbt*/ jobject key, /*Dbt*/ jobject data, jint flags)
  322. {
  323. int err, op_flags, retry;
  324. DB *db;
  325. DB_ENV *dbenv;
  326. OpKind keyop, dataop;
  327. DB_TXN *dbtxnid;
  328. LOCKED_DBT lkey, ldata;
  330. err = 0;
  331. db = get_DB(jnienv, jthis);
  332. if (!verify_non_null(jnienv, db))
  333. goto out3;
  334. dbenv = db->dbenv;
  336. /* Depending on flags, the key may be input/output. */
  337. keyop = inOp;
  338. dataop = outOp;
  339. op_flags = flags & DB_OPFLAGS_MASK;
  340. if (op_flags == DB_SET_RECNO) {
  341. keyop = inOutOp;
  342. }
  343. else if (op_flags == DB_GET_BOTH) {
  344. keyop = inOutOp;
  345. dataop = inOutOp;
  346. }
  348. dbtxnid = get_DB_TXN(jnienv, txnid);
  350. if (locked_dbt_get(&lkey, jnienv, dbenv, key, keyop) != 0)
  351. goto out2;
  352. if (locked_dbt_get(&ldata, jnienv, dbenv, data, dataop) != 0)
  353. goto out1;
  354. for (retry = 0; retry < 3; retry++) {
  355. err = db->get(db,
  356.     dbtxnid, &lkey.javainfo->dbt, &ldata.javainfo->dbt, flags);
  358. /*
  359.  * If we failed due to lack of memory in our DBT arrays,
  360.  * retry.
  361.  */
  362. if (err != ENOMEM)
  363. break;
  364. if (!locked_dbt_realloc(&lkey, jnienv, dbenv) &&
  365.     !locked_dbt_realloc(&ldata, jnienv, dbenv))
  366. break;
  367. }
  368.  out1:
  369. locked_dbt_put(&ldata, jnienv, dbenv);
  370.  out2:
  371. locked_dbt_put(&lkey, jnienv, dbenv);
  372.  out3:
  373. if (!DB_RETOK_DBGET(err)) {
  374. if (verify_dbt(jnienv, err, &lkey) &&
  375.     verify_dbt(jnienv, err, &ldata))
  376. verify_return(jnienv, err, 0);
  377. }
  378. return (err);
  379. }
  381. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_hash_1changed
  382.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbHash*/ jobject jhash)
  383. {
  384. DB *db;
  385. DB_JAVAINFO *dbinfo;
  387. db = get_DB(jnienv, jthis);
  388. if (!verify_non_null(jnienv, db))
  389. return;
  391. dbinfo = (DB_JAVAINFO*)db->api_internal;
  392. dbji_set_h_hash_object(dbinfo, jnienv, db, jhash);
  393. }
  395. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_Db_join
  396.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*Dbc[]*/ jobjectArray curslist,
  397.    jint flags)
  398. {
  399. int err;
  400. DB *db;
  401. int count;
  402. DBC **newlist;
  403. DBC *dbc;
  404. int i;
  405. int size;
  407. db = get_DB(jnienv, jthis);
  408. count = (*jnienv)->GetArrayLength(jnienv, curslist);
  409. size = sizeof(DBC *) * (count+1);
  410. if ((err = __os_malloc(db->dbenv, size, &newlist)) != 0) {
  411. if (!verify_return(jnienv, err, 0))
  412. return (NULL);
  413. }
  415. /* Convert the java array of Dbc's to a C array of DBC's. */
  416. for (i = 0; i < count; i++) {
  417. jobject jobj =
  418.     (*jnienv)->GetObjectArrayElement(jnienv, curslist, i);
  419. if (jobj == 0) {
  420. /*
  421.  * An embedded null in the array is treated
  422.  * as an endpoint.
  423.  */
  424. newlist[i] = 0;
  425. break;
  426. }
  427. else {
  428. newlist[i] = get_DBC(jnienv, jobj);
  429. }
  430. }
  431. newlist[count] = 0;
  433. if (!verify_non_null(jnienv, db))
  434. return (NULL);
  436. err = db->join(db, newlist, &dbc, flags);
  437. verify_return(jnienv, err, 0);
  438. __os_free(db->dbenv, newlist);
  440. return (get_Dbc(jnienv, dbc));
  441. }
  443. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_key_1range
  444.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  445.    /*Dbt*/ jobject jkey, jobject /*DbKeyRange*/ range, jint flags)
  446. {
  447. int err;
  448. DB *db;
  449. DB_TXN *dbtxnid;
  450. LOCKED_DBT lkey;
  451. DB_KEY_RANGE result;
  452. jfieldID fid;
  453. jclass krclass;
  455. db = get_DB(jnienv, jthis);
  456. dbtxnid = get_DB_TXN(jnienv, txnid);
  457. if (!verify_non_null(jnienv, db))
  458. return;
  459. if (!verify_non_null(jnienv, range))
  460. return;
  461. if (locked_dbt_get(&lkey, jnienv, db->dbenv, jkey, inOp) != 0)
  462. goto out;
  463. err = db->key_range(db, dbtxnid, &lkey.javainfo->dbt, &result, flags);
  464. if (verify_return(jnienv, err, 0)) {
  465. /* fill in the values of the DbKeyRange structure */
  466. if ((krclass = get_class(jnienv, "DbKeyRange")) == NULL)
  467. return; /* An exception has been posted. */
  468. fid = (*jnienv)->GetFieldID(jnienv, krclass, "less", "D");
  469. (*jnienv)->SetDoubleField(jnienv, range, fid, result.less);
  470. fid = (*jnienv)->GetFieldID(jnienv, krclass, "equal", "D");
  471. (*jnienv)->SetDoubleField(jnienv, range, fid, result.equal);
  472. fid = (*jnienv)->GetFieldID(jnienv, krclass, "greater", "D");
  473. (*jnienv)->SetDoubleField(jnienv, range, fid, result.greater);
  474. }
  475.  out:
  476. locked_dbt_put(&lkey, jnienv, db->dbenv);
  477. }
  479. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_pget
  480.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  481.    /*Dbt*/ jobject key, /*Dbt*/ jobject rkey, /*Dbt*/ jobject data, jint flags)
  482. {
  483. int err, op_flags, retry;
  484. DB *db;
  485. DB_ENV *dbenv;
  486. OpKind keyop, rkeyop, dataop;
  487. DB_TXN *dbtxnid;
  488. LOCKED_DBT lkey, lrkey, ldata;
  490. err = 0;
  491. db = get_DB(jnienv, jthis);
  492. if (!verify_non_null(jnienv, db))
  493. goto out4;
  494. dbenv = db->dbenv;
  496. /* Depending on flags, the key may be input/output. */
  497. keyop = inOp;
  498. rkeyop = outOp;
  499. dataop = outOp;
  500. op_flags = flags & DB_OPFLAGS_MASK;
  501. if (op_flags == DB_SET_RECNO) {
  502. keyop = inOutOp;
  503. }
  504. else if (op_flags == DB_GET_BOTH) {
  505. keyop = inOutOp;
  506. rkeyop = inOutOp;
  507. dataop = inOutOp;
  508. }
  510. dbtxnid = get_DB_TXN(jnienv, txnid);
  512. if (locked_dbt_get(&lkey, jnienv, dbenv, key, keyop) != 0)
  513. goto out3;
  514. if (locked_dbt_get(&lrkey, jnienv, dbenv, rkey, rkeyop) != 0)
  515. goto out2;
  516. if (locked_dbt_get(&ldata, jnienv, dbenv, data, dataop) != 0)
  517. goto out1;
  518. for (retry = 0; retry < 3; retry++) {
  519. err = db->pget(db, dbtxnid, &lkey.javainfo->dbt,
  520.     &lrkey.javainfo->dbt, &ldata.javainfo->dbt, flags);
  522. /*
  523.  * If we failed due to lack of memory in our DBT arrays,
  524.  * retry.
  525.  */
  526. if (err != ENOMEM)
  527. break;
  528. if (!locked_dbt_realloc(&lkey, jnienv, dbenv) &&
  529.     !locked_dbt_realloc(&lrkey, jnienv, dbenv) &&
  530.     !locked_dbt_realloc(&ldata, jnienv, dbenv))
  531. break;
  532. }
  533.  out1:
  534. locked_dbt_put(&ldata, jnienv, dbenv);
  535.  out2:
  536. locked_dbt_put(&lrkey, jnienv, dbenv);
  537.  out3:
  538. locked_dbt_put(&lkey, jnienv, dbenv);
  539.  out4:
  540. if (!DB_RETOK_DBGET(err)) {
  541. if (verify_dbt(jnienv, err, &lkey) &&
  542.     verify_dbt(jnienv, err, &lrkey) &&
  543.     verify_dbt(jnienv, err, &ldata))
  544. verify_return(jnienv, err, 0);
  545. }
  546. return (err);
  547. }
  549. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_put
  550.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  551.    /*Dbt*/ jobject key, /*Dbt*/ jobject data, jint flags)
  552. {
  553. int err;
  554. DB *db;
  555. DB_ENV *dbenv;
  556. DB_TXN *dbtxnid;
  557. LOCKED_DBT lkey, ldata;
  558. OpKind keyop;
  560. err = 0;
  561. db = get_DB(jnienv, jthis);
  562. dbtxnid = get_DB_TXN(jnienv, txnid);
  563. if (!verify_non_null(jnienv, db))
  564. return (0);   /* error will be thrown, retval doesn't matter */
  565. dbenv = db->dbenv;
  567. /*
  568.  * For DB_APPEND, the key may be output-only;  for all other flags,
  569.  * it's input-only.
  570.  */
  571. if ((flags & DB_OPFLAGS_MASK) == DB_APPEND)
  572. keyop = outOp;
  573. else
  574. keyop = inOp;
  576. if (locked_dbt_get(&lkey, jnienv, dbenv, key, keyop) != 0)
  577. goto out2;
  578. if (locked_dbt_get(&ldata, jnienv, dbenv, data, inOp) != 0)
  579. goto out1;
  581. if (!verify_non_null(jnienv, db))
  582. goto out1;
  584. err = db->put(db,
  585.     dbtxnid, &lkey.javainfo->dbt, &ldata.javainfo->dbt, flags);
  586. if (!DB_RETOK_DBPUT(err))
  587. verify_return(jnienv, err, 0);
  589.  out1:
  590. locked_dbt_put(&ldata, jnienv, dbenv);
  591.  out2:
  592. locked_dbt_put(&lkey, jnienv, dbenv);
  593. return (err);
  594. }
  596. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1remove
  597.   (JNIEnv *jnienv, /*Db*/ jobject jthis,
  598.    jstring file, jstring database, jint flags)
  599. {
  600. int err;
  601. DB *db;
  602. DB_JAVAINFO *dbinfo;
  603. LOCKED_STRING ls_file;
  604. LOCKED_STRING ls_database;
  606. db = get_DB(jnienv, jthis);
  607. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  609. if (!verify_non_null(jnienv, db))
  610. return;
  611. if (locked_string_get(&ls_file, jnienv, file) != 0)
  612. goto out2;
  613. if (locked_string_get(&ls_database, jnienv, database) != 0)
  614. goto out1;
  615. err = db->remove(db, ls_file.string, ls_database.string, flags);
  617. set_private_dbobj(jnienv, name_DB, jthis, 0);
  618. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  620.  out1:
  621. locked_string_put(&ls_database, jnienv);
  622.  out2:
  623. locked_string_put(&ls_file, jnienv);
  625. dbji_dealloc(dbinfo, jnienv);
  626. }
  628. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1rename
  629.   (JNIEnv *jnienv, /*Db*/ jobject jthis,
  630.    jstring file, jstring database, jstring newname, jint flags)
  631. {
  632. int err;
  633. DB *db;
  634. DB_JAVAINFO *dbinfo;
  635. LOCKED_STRING ls_file;
  636. LOCKED_STRING ls_database;
  637. LOCKED_STRING ls_newname;
  639. db = get_DB(jnienv, jthis);
  640. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  641. if (!verify_non_null(jnienv, db))
  642. return;
  643. if (locked_string_get(&ls_file, jnienv, file) != 0)
  644. goto out3;
  645. if (locked_string_get(&ls_database, jnienv, database) != 0)
  646. goto out2;
  647. if (locked_string_get(&ls_newname, jnienv, newname) != 0)
  648. goto out1;
  650. err = db->rename(db, ls_file.string, ls_database.string,
  651.  ls_newname.string, flags);
  653. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  654. set_private_dbobj(jnienv, name_DB, jthis, 0);
  656.  out1:
  657. locked_string_put(&ls_newname, jnienv);
  658.  out2:
  659. locked_string_put(&ls_database, jnienv);
  660.  out3:
  661. locked_string_put(&ls_file, jnienv);
  663. dbji_dealloc(dbinfo, jnienv);
  664. }
  666. JAVADB_METHOD(Db_set_1pagesize, (JAVADB_ARGS, jlong pagesize), DB,
  667.     set_pagesize, (c_this, (u_int32_t)pagesize))
  668. JAVADB_METHOD(Db_set_1cachesize,
  669.     (JAVADB_ARGS, jint gbytes, jint bytes, jint ncaches), DB,
  670.     set_cachesize, (c_this, gbytes, bytes, ncaches))
  671. JAVADB_METHOD(Db_set_1cache_1priority, (JAVADB_ARGS, jint priority), DB,
  672.     set_cache_priority, (c_this, (DB_CACHE_PRIORITY)priority))
  674. JNIEXPORT void JNICALL
  675.   Java_com_sleepycat_db_Db_set_1re_1source
  676.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring re_source)
  677. {
  678. int err;
  679. DB *db;
  681. db = get_DB(jnienv, jthis);
  682. if (verify_non_null(jnienv, db)) {
  684. /* XXX does the string from get_c_string ever get freed? */
  685. if (re_source != NULL)
  686. err = db->set_re_source(db,
  687.     get_c_string(jnienv, re_source));
  688. else
  689. err = db->set_re_source(db, 0);
  691. verify_return(jnienv, err, 0);
  692. }
  693. }
  695. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_Db_stat
  696.   (JNIEnv *jnienv, jobject jthis, jint flags)
  697. {
  698. DB *db;
  699. DB_BTREE_STAT *bstp;
  700. DB_HASH_STAT *hstp;
  701. DB_QUEUE_STAT *qstp;
  702. DBTYPE dbtype;
  703. jobject retval;
  704. jclass dbclass;
  705. size_t bytesize;
  706. void *statp;
  708. bytesize = 0;
  709. retval = NULL;
  710. statp = NULL;
  712. db = get_DB(jnienv, jthis);
  713. if (!verify_non_null(jnienv, db))
  714. return (NULL);
  716. if (verify_return(jnienv, db->stat(db, &statp, flags), 0) &&
  717.     verify_return(jnienv, db->get_type(db, &dbtype), 0)) {
  718. switch (dbtype) {
  719. /* Btree and recno share the same stat structure */
  720. case DB_BTREE:
  721. case DB_RECNO:
  722. bstp = (DB_BTREE_STAT *)statp;
  723. bytesize = sizeof(DB_BTREE_STAT);
  724. retval = create_default_object(jnienv,
  725.        name_DB_BTREE_STAT);
  726. if ((dbclass =
  727.     get_class(jnienv, name_DB_BTREE_STAT)) == NULL)
  728. break; /* An exception has been posted. */
  730. __jv_fill_bt_stat(jnienv, dbclass, retval, bstp);
  731. break;
  733. /* Hash stat structure */
  734. case DB_HASH:
  735. hstp = (DB_HASH_STAT *)statp;
  736. bytesize = sizeof(DB_HASH_STAT);
  737. retval = create_default_object(jnienv,
  738.        name_DB_HASH_STAT);
  739. if ((dbclass =
  740.     get_class(jnienv, name_DB_HASH_STAT)) == NULL)
  741. break; /* An exception has been posted. */
  743. __jv_fill_h_stat(jnienv, dbclass, retval, hstp);
  744. break;
  746. case DB_QUEUE:
  747. qstp = (DB_QUEUE_STAT *)statp;
  748. bytesize = sizeof(DB_QUEUE_STAT);
  749. retval = create_default_object(jnienv,
  750.        name_DB_QUEUE_STAT);
  751. if ((dbclass =
  752.     get_class(jnienv, name_DB_QUEUE_STAT)) == NULL)
  753. break; /* An exception has been posted. */
  755. __jv_fill_qam_stat(jnienv, dbclass, retval, qstp);
  756. break;
  758. /* That's all the database types we're aware of! */
  759. default:
  760. report_exception(jnienv,
  761.  "Db.stat not implemented for types"
  762.  " other than BTREE, HASH, QUEUE,"
  763.  " and RECNO",
  764.  EINVAL, 0);
  765. break;
  766. }
  767. if (bytesize != 0)
  768. __os_ufree(db->dbenv, statp);
  769. }
  770. return (retval);
  771. }
  773. JAVADB_METHOD(Db_sync, (JAVADB_ARGS, jint flags), DB,
  774.     sync, (c_this, flags))
  776. JNIEXPORT jboolean JNICALL Java_com_sleepycat_db_Db_get_1byteswapped
  777.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  778. {
  779. DB *db;
  780. int err, isbyteswapped;
  782. /* This value should never be seen, because of the exception. */
  783. isbyteswapped = 0;
  785. db = get_DB(jnienv, jthis);
  786. if (!verify_non_null(jnienv, db))
  787. return (0);
  789. err = db->get_byteswapped(db, &isbyteswapped);
  790. (void)verify_return(jnienv, err, 0);
  792. return ((jboolean)isbyteswapped);
  793. }
  795. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_get_1type
  796.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  797. {
  798. DB *db;
  799. int err;
  800. DBTYPE dbtype;
  802. /* This value should never be seen, because of the exception. */
  803. dbtype = DB_UNKNOWN;
  805. db = get_DB(jnienv, jthis);
  806. if (!verify_non_null(jnienv, db))
  807. return (0);
  809. err = db->get_type(db, &dbtype);
  810. (void)verify_return(jnienv, err, 0);
  812. return ((jint)dbtype);
  813. }
  815. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1open
  816.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  817.    jstring file, jstring database, jint type, jint flags, jint mode)
  818. {
  819. int err;
  820. DB *db;
  821. DB_TXN *dbtxnid;
  822. LOCKED_STRING ls_file;
  823. LOCKED_STRING ls_database;
  825. /* Java is assumed to be threaded */
  826. flags |= DB_THREAD;
  828. db = get_DB(jnienv, jthis);
  830. dbtxnid = get_DB_TXN(jnienv, txnid);
  831. if (locked_string_get(&ls_file, jnienv, file) != 0)
  832. goto out2;
  833. if (locked_string_get(&ls_database, jnienv, database) != 0)
  834. goto out1;
  835. if (verify_non_null(jnienv, db)) {
  836. err = db->open(db, dbtxnid, ls_file.string, ls_database.string,
  837.        (DBTYPE)type, flags, mode);
  838. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  839. }
  840.  out1:
  841. locked_string_put(&ls_database, jnienv);
  842.  out2:
  843. locked_string_put(&ls_file, jnienv);
  844. }
  846. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_truncate
  847.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject jtxnid, jint flags)
  848. {
  849. int err;
  850. DB *db;
  851. u_int32_t count;
  852. DB_TXN *dbtxnid;
  854. db = get_DB(jnienv, jthis);
  855. dbtxnid = get_DB_TXN(jnienv, jtxnid);
  856. count = 0;
  857. if (verify_non_null(jnienv, db)) {
  858. err = db->truncate(db, dbtxnid, &count, flags);
  859. verify_return(jnienv, err, 0);
  860. }
  861. return (jint)count;
  862. }
  864. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_upgrade
  865.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring name,
  866.    jint flags)
  867. {
  868. int err;
  869. DB *db = get_DB(jnienv, jthis);
  870. LOCKED_STRING ls_name;
  872. if (verify_non_null(jnienv, db)) {
  873. if (locked_string_get(&ls_name, jnienv, name) != 0)
  874. goto out;
  875. err = db->upgrade(db, ls_name.string, flags);
  876. verify_return(jnienv, err, 0);
  877. }
  878.  out:
  879. locked_string_put(&ls_name, jnienv);
  880. }
  882. static int java_verify_callback(void *handle, const void *str_arg)
  883. {
  884. char *str;
  885. struct verify_callback_struct *vc;
  886. int len;
  887. JNIEnv *jnienv;
  889. str = (char *)str_arg;
  890. vc = (struct verify_callback_struct *)handle;
  891. jnienv = vc->env;
  892. len = strlen(str)+1;
  893. if (len > vc->nbytes) {
  894. vc->nbytes = len;
  895. vc->bytes = (*jnienv)->NewByteArray(jnienv, len);
  896. }
  898. if (vc->bytes != NULL) {
  899. (*jnienv)->SetByteArrayRegion(jnienv, vc->bytes, 0, len,
  900.     (jbyte*)str);
  901. (*jnienv)->CallVoidMethod(jnienv, vc->streamobj,
  902.     vc->writemid, vc->bytes, 0, len-1);
  903. }
  905. if ((*jnienv)->ExceptionOccurred(jnienv) != NULL)
  906. return (EIO);
  908. return (0);
  909. }
  911. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_verify
  912.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring name,
  913.    jstring subdb, jobject stream, jint flags)
  914. {
  915. int err;
  916. DB *db;
  917. LOCKED_STRING ls_name;
  918. LOCKED_STRING ls_subdb;
  919. struct verify_callback_struct vcs;
  920. jclass streamclass;
  922. db = get_DB(jnienv, jthis);
  923. if (!verify_non_null(jnienv, db))
  924. return;
  925. if (locked_string_get(&ls_name, jnienv, name) != 0)
  926. goto out2;
  927. if (locked_string_get(&ls_subdb, jnienv, subdb) != 0)
  928. goto out1;
  930. /* set up everything we need for the callbacks */
  931. vcs.env = jnienv;
  932. vcs.streamobj = stream;
  933. vcs.nbytes = 100;
  934. if ((vcs.bytes = (*jnienv)->NewByteArray(jnienv, vcs.nbytes)) == NULL)
  935. goto out1;
  937. /* get the method ID for OutputStream.write(byte[], int, int); */
  938. streamclass = (*jnienv)->FindClass(jnienv, "java/io/OutputStream");
  939. vcs.writemid = (*jnienv)->GetMethodID(jnienv, streamclass,
  940.       "write", "([BII)V");
  942. /* invoke verify - this will invoke the callback repeatedly. */
  943. err = __db_verify_internal(db, ls_name.string, ls_subdb.string,
  944.    &vcs, java_verify_callback, flags);
  945. verify_return(jnienv, err, 0);
  947. out1:
  948. locked_string_put(&ls_subdb, jnienv);
  949. out2:
  950. locked_string_put(&ls_name, jnienv);
  951. }
  953. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1finalize
  954.     (JNIEnv *jnienv, jobject jthis,
  955.      jobject /*DbErrcall*/ errcall, jstring errpfx)
  956. {
  957. DB_JAVAINFO *dbinfo;
  958. DB *db;
  960. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  961. db = get_DB(jnienv, jthis);
  962. DB_ASSERT(dbinfo != NULL);
  964. /*
  965.  * Note: We can never be sure if the underlying DB is attached to
  966.  * a DB_ENV that was already closed.  Sure, that's a user error,
  967.  * but it shouldn't crash the VM.  Therefore, we cannot just
  968.  * automatically close if the handle indicates we are not yet
  969.  * closed.  The best we can do is detect this and report it.
  970.  */
  971. if (db != NULL) {
  972. /* If this error occurs, this object was never closed. */
  973. report_errcall(jnienv, errcall, errpfx,
  974.        "Db.finalize: open Db object destroyed");
  975. }
  977. /* Shouldn't see this object again, but just in case */
  978. set_private_dbobj(jnienv, name_DB, jthis, 0);
  979. set_private_info(jnienv, name_DB, jthis, 0);
  981. dbji_destroy(dbinfo, jnienv);
  982. }