Category

Development Platform
Home > SourceCode/Document > Database system > MySQL > View Code
java_Db.c
Package: mysql-3.23.35.tar.gz　[view]
Upload User: tsgydb
Upload Date: 2007-04-14
Package Size: 10674k
Code Size: 25k
Category:

MySQL

Development Platform:

Visual C++

java_Db.c：Code Content
  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_Db.c,v 11.34 2000/11/30 00:58:38 ubell 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 "db_page.h"
  20. #include "db_ext.h"
  21. #include "java_util.h"
  22. #include "com_sleepycat_db_Db.h"
  24. /* This struct is used in Db.verify and its callback */
  25. struct verify_callback_struct {
  26. JNIEnv *env;
  27. jobject streamobj;
  28. jbyteArray bytes;
  29. int nbytes;
  30. jmethodID writemid;
  31. };
  33. JAVADB_WO_ACCESS_METHOD(Db, jint, flags, DB, flags)
  34. JAVADB_WO_ACCESS_METHOD(Db, jint, h_1ffactor, DB, h_ffactor)
  35. JAVADB_WO_ACCESS_METHOD(Db, jint, h_1nelem, DB, h_nelem)
  36. JAVADB_WO_ACCESS_METHOD(Db, jint, lorder, DB, lorder)
  37. JAVADB_WO_ACCESS_METHOD(Db, jint, re_1delim, DB, re_delim)
  38. JAVADB_WO_ACCESS_METHOD(Db, jint, re_1len, DB, re_len)
  39. JAVADB_WO_ACCESS_METHOD(Db, jint, re_1pad, DB, re_pad)
  40. JAVADB_WO_ACCESS_METHOD(Db, jint, q_1extentsize, DB, q_extentsize)
  41. JAVADB_WO_ACCESS_METHOD(Db, jint, bt_1maxkey, DB, bt_maxkey)
  42. JAVADB_WO_ACCESS_METHOD(Db, jint, bt_1minkey, DB, bt_minkey)
  44. /* This only gets called once ever, at the beginning of execution
  45.  * and can be used to initialize unchanging methodIds, fieldIds, etc.
  46.  */
  47. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_one_1time_1init
  48.   (JNIEnv *jnienv,  /*Db.class*/ jclass jthisclass)
  49. {
  50. COMPQUIET(jnienv, NULL);
  51. COMPQUIET(jthisclass, NULL);
  52. }
  54. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1init
  55.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbEnv*/ jobject jdbenv, jint flags)
  56. {
  57. int err;
  58. DB *db;
  59. DB_JAVAINFO *dbinfo;
  60. DB_ENV *dbenv;
  62. dbenv = get_DB_ENV(jnienv, jdbenv);
  63. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  64. DB_ASSERT(dbinfo == NULL);
  66. err = db_create(&db, dbenv, flags);
  67. if (verify_return(jnienv, err, 0)) {
  68. set_private_dbobj(jnienv, name_DB, jthis, db);
  69. dbinfo = dbji_construct(jnienv, flags);
  70. set_private_info(jnienv, name_DB, jthis, dbinfo);
  71. db->cj_internal = dbinfo;
  72. }
  73. }
  75. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db__1close
  76.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jint flags)
  77. {
  78. int err;
  79. DB *db;
  80. DB_JAVAINFO *dbinfo;
  82. db = get_DB(jnienv, jthis);
  83. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  84. if (!verify_non_null(jnienv, db))
  85. return (0);
  87. JAVADB_API_BEGIN(db, jthis);
  89. /* Null out the private data to indicate the DB is invalid.
  90.  * We do this in advance to help guard against multithreading
  91.  * issues.
  92.  */
  93. set_private_dbobj(jnienv, name_DB, jthis, 0);
  95. err = db->close(db, flags);
  96. if (err != DB_INCOMPLETE)
  97. verify_return(jnienv, err, 0);
  98. dbji_dealloc(dbinfo, jnienv);
  100. /* don't call JAVADB_API_END - db cannot be used */
  101. return (err);
  102. }
  104. /* We are being notified that the parent DbEnv has closed.
  105.  * Zero out the pointer to the DB, since it is no longer
  106.  * valid, to prevent mistakes.  The user will get a null
  107.  * pointer exception if they try to use this Db again.
  108.  */
  109. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1notify_1internal
  110.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  111. {
  112. set_private_dbobj(jnienv, name_DB, jthis, 0);
  113. }
  115. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_append_1recno_1changed
  116.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbAppendRecno*/ jobject jcallback)
  117. {
  118. DB *db;
  119. DB_JAVAINFO *dbinfo;
  121. db = get_DB(jnienv, jthis);
  122. if (!verify_non_null(jnienv, db))
  123. return;
  125. JAVADB_API_BEGIN(db, jthis);
  126. dbinfo = (DB_JAVAINFO*)db->cj_internal;
  127. dbji_set_append_recno_object(dbinfo, jnienv, db, jcallback);
  128. JAVADB_API_END(db);
  129. }
  131. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_bt_1compare_1changed
  132.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbBtreeCompare*/ jobject jbtcompare)
  133. {
  134. DB *db;
  135. DB_JAVAINFO *dbinfo;
  137. db = get_DB(jnienv, jthis);
  138. if (!verify_non_null(jnienv, db))
  139. return;
  141. JAVADB_API_BEGIN(db, jthis);
  142. dbinfo = (DB_JAVAINFO*)db->cj_internal;
  143. dbji_set_bt_compare_object(dbinfo, jnienv, db, jbtcompare);
  144. JAVADB_API_END(db);
  145. }
  147. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_bt_1prefix_1changed
  148.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbBtreePrefix*/ jobject jbtprefix)
  149. {
  150. DB *db;
  151. DB_JAVAINFO *dbinfo;
  153. db = get_DB(jnienv, jthis);
  154. if (!verify_non_null(jnienv, db))
  155. return;
  157. JAVADB_API_BEGIN(db, jthis);
  158. dbinfo = (DB_JAVAINFO*)db->cj_internal;
  159. dbji_set_bt_prefix_object(dbinfo, jnienv, db, jbtprefix);
  160. JAVADB_API_END(db);
  161. }
  163. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_Db_cursor
  164.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid, jint flags)
  165. {
  166. int err;
  167. DBC *dbc;
  168. DB *db = get_DB(jnienv, jthis);
  169. DB_TXN *dbtxnid = get_DB_TXN(jnienv, txnid);
  171. if (!verify_non_null(jnienv, db))
  172. return (NULL);
  173. err = db->cursor(db, dbtxnid, &dbc, flags);
  174. verify_return(jnienv, err, 0);
  175. return (get_Dbc(jnienv, dbc));
  176. }
  178. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_del
  179.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  180.    /*Dbt*/ jobject key, jint dbflags)
  181. {
  182. int err;
  183. DB_TXN *dbtxnid;
  184. DB *db;
  185. JDBT dbkey;
  187. err = 0;
  188. db = get_DB(jnienv, jthis);
  189. if (!verify_non_null(jnienv, db))
  190. return (0);
  192. JAVADB_API_BEGIN(db, jthis);
  193. dbtxnid = get_DB_TXN(jnienv, txnid);
  194. if (jdbt_lock(&dbkey, jnienv, key, inOp) != 0)
  195. goto out;
  197. err = db->del(db, dbtxnid, &dbkey.dbt->dbt, dbflags);
  198. if (err != DB_NOTFOUND) {
  199. verify_return(jnienv, err, 0);
  200. }
  202.  out:
  203. jdbt_unlock(&dbkey, jnienv);
  204. JAVADB_API_END(db);
  205. return (err);
  206. }
  208. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_dup_1compare_1changed
  209.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbDupCompare*/ jobject jdupcompare)
  210. {
  211. DB *db;
  212. DB_JAVAINFO *dbinfo;
  214. db = get_DB(jnienv, jthis);
  215. if (!verify_non_null(jnienv, db))
  216. return;
  218. JAVADB_API_BEGIN(db, jthis);
  219. dbinfo = (DB_JAVAINFO*)db->cj_internal;
  220. dbji_set_dup_compare_object(dbinfo, jnienv, db, jdupcompare);
  221. JAVADB_API_END(db);
  222. }
  224. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_err
  225.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jint ecode, jstring msg)
  226. {
  227. DB *db;
  228. JSTR msg_string;
  230. if (jstr_lock(&msg_string, jnienv, msg) != 0)
  231. goto out;
  232. db = get_DB(jnienv, jthis);
  233. if (!verify_non_null(jnienv, db))
  234. goto out;
  236. JAVADB_API_BEGIN(db, jthis);
  237. db->err(db, ecode, msg_string.string);
  238. JAVADB_API_END(db);
  240.  out:
  241. jstr_unlock(&msg_string, jnienv);
  242. }
  244. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_errx
  245.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring msg)
  246. {
  247. JSTR msg_string;
  248. DB *db = get_DB(jnienv, jthis);
  250. if (jstr_lock(&msg_string, jnienv, msg) != 0)
  251. goto out;
  252. if (!verify_non_null(jnienv, db))
  253. goto out;
  255. JAVADB_API_BEGIN(db, jthis);
  256. db->errx(db, msg_string.string);
  257. JAVADB_API_END(db);
  259.  out:
  260. jstr_unlock(&msg_string, jnienv);
  261. }
  263. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_fd
  264.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  265. {
  266. int err;
  267. int return_value = 0;
  268. DB *db = get_DB(jnienv, jthis);
  270. if (!verify_non_null(jnienv, db))
  271. return (0);
  273. JAVADB_API_BEGIN(db, jthis);
  274. err = db->fd(db, &return_value);
  275. verify_return(jnienv, err, 0);
  276. JAVADB_API_END(db);
  278. return (return_value);
  279. }
  281. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_feedback_1changed
  282.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbFeedback*/ jobject jfeedback)
  283. {
  284. DB *db;
  285. DB_JAVAINFO *dbinfo;
  287. db = get_DB(jnienv, jthis);
  288. if (!verify_non_null(jnienv, db))
  289. return;
  291. JAVADB_API_BEGIN(db, jthis);
  292. dbinfo = (DB_JAVAINFO*)db->cj_internal;
  293. dbji_set_feedback_object(dbinfo, jnienv, db, jfeedback);
  294. JAVADB_API_END(db);
  295. }
  297. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_get
  298.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  299.    /*Dbt*/ jobject key, /*Dbt*/ jobject data, jint flags)
  300. {
  301. int err, op_flags, retry;
  302. DB *db;
  303. OpKind keyop, dataop;
  304. DB_TXN *dbtxnid;
  305. JDBT dbkey, dbdata;
  307. err = 0;
  308. db = get_DB(jnienv, jthis);
  309. if (!verify_non_null(jnienv, db))
  310. goto out3;
  312. JAVADB_API_BEGIN(db, jthis);
  314. /* Depending on flags, the key may be input/output. */
  315. keyop = inOp;
  316. dataop = outOp;
  317. op_flags = flags & DB_OPFLAGS_MASK;
  318. if (op_flags == DB_SET_RECNO) {
  319. keyop = inOutOp;
  320. }
  321. else if (op_flags == DB_GET_BOTH) {
  322. keyop = inOutOp;
  323. dataop = inOutOp;
  324. }
  326. dbtxnid = get_DB_TXN(jnienv, txnid);
  328. if (jdbt_lock(&dbkey, jnienv, key, keyop) != 0)
  329. goto out2;
  330. if (jdbt_lock(&dbdata, jnienv, data, dataop) != 0)
  331. goto out1;
  332. for (retry = 0; retry < 3; retry++) {
  333. err = db->get(db, dbtxnid, &dbkey.dbt->dbt, &dbdata.dbt->dbt, flags);
  335. /* If we failed due to lack of memory in our DBT arrays,
  336.  * retry.
  337.  */
  338. if (err != ENOMEM)
  339. break;
  340. if (!jdbt_realloc(&dbdata, jnienv))
  341. break;
  342. }
  343. if (err != DB_NOTFOUND) {
  344. verify_return(jnienv, err, 0);
  345. }
  346.  out1:
  347. jdbt_unlock(&dbdata, jnienv);
  348.  out2:
  349. jdbt_unlock(&dbkey, jnienv);
  350.  out3:
  351. JAVADB_API_END(db);
  352. return (err);
  353. }
  355. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_hash_1changed
  356.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbHash*/ jobject jhash)
  357. {
  358. DB *db;
  359. DB_JAVAINFO *dbinfo;
  361. db = get_DB(jnienv, jthis);
  362. if (!verify_non_null(jnienv, db))
  363. return;
  365. JAVADB_API_BEGIN(db, jthis);
  366. dbinfo = (DB_JAVAINFO*)db->cj_internal;
  367. dbji_set_h_hash_object(dbinfo, jnienv, db, jhash);
  368. JAVADB_API_END(db);
  369. }
  371. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_Db_join
  372.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*Dbc[]*/ jobjectArray curslist,
  373.    jint flags)
  374. {
  375. int err;
  376. DB *db = get_DB(jnienv, jthis);
  377. int count = (*jnienv)->GetArrayLength(jnienv, curslist);
  378. DBC **newlist = (DBC **)malloc(sizeof(DBC *) * (count+1));
  379. DBC *dbc;
  380. int i;
  382. /* Convert the java array of Dbc's to a C array of DBC's. */
  383. for (i=0; i<count; i++) {
  384. jobject jobj = (*jnienv)->GetObjectArrayElement(jnienv, curslist, i);
  385. if (jobj == 0) {
  386. /*
  387.  * An embedded null in the array is treated
  388.  * as an endpoint.
  389.  */
  390. newlist[i] = 0;
  391. break;
  392. }
  393. else {
  394. newlist[i] = get_DBC(jnienv, jobj);
  395. }
  396. }
  397. newlist[count] = 0;
  399. if (!verify_non_null(jnienv, db))
  400. return (NULL);
  401. JAVADB_API_BEGIN(db, jthis);
  403. err = db->join(db, newlist, &dbc, flags);
  404. free(newlist);
  405. verify_return(jnienv, err, 0);
  407. JAVADB_API_END(db);
  408. return (get_Dbc(jnienv, dbc));
  409. }
  411. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_key_1range
  412.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject jtxn,
  413.    /*Dbt*/ jobject jkey, jobject /*DbKeyRange*/ range, jint flags)
  414. {
  415. int err;
  416. DB *db = get_DB(jnienv, jthis);
  417. DB_TXN *txn = get_DB_TXN(jnienv, jtxn);
  418. JDBT dbkey;
  419. DB_KEY_RANGE result;
  420. jfieldID fid;
  421. jclass krclass;
  423. if (!verify_non_null(jnienv, db))
  424. return;
  425. JAVADB_API_BEGIN(db, jthis);
  426. if (!verify_non_null(jnienv, range))
  427. return;
  428. if (jdbt_lock(&dbkey, jnienv, jkey, inOp) != 0)
  429. goto out;
  430. err = db->key_range(db, txn, &dbkey.dbt->dbt, &result, flags);
  431. if (verify_return(jnienv, err, 0)) {
  432. /* fill in the values of the DbKeyRange structure */
  433. krclass = get_class(jnienv, "DbKeyRange");
  434. fid = (*jnienv)->GetFieldID(jnienv, krclass, "less", "D");
  435. (*jnienv)->SetDoubleField(jnienv, range, fid, result.less);
  436. fid = (*jnienv)->GetFieldID(jnienv, krclass, "equal", "D");
  437. (*jnienv)->SetDoubleField(jnienv, range, fid, result.equal);
  438. fid = (*jnienv)->GetFieldID(jnienv, krclass, "greater", "D");
  439. (*jnienv)->SetDoubleField(jnienv, range, fid, result.greater);
  440. }
  441.  out:
  442. jdbt_unlock(&dbkey, jnienv);
  443. JAVADB_API_END(db);
  444. }
  446. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_put
  447.   (JNIEnv *jnienv, /*Db*/ jobject jthis, /*DbTxn*/ jobject txnid,
  448.    /*Dbt*/ jobject key, /*Dbt*/ jobject data, jint flags)
  449. {
  450. int err;
  451. DB *db;
  452. DB_TXN *dbtxnid;
  453. JDBT dbkey, dbdata;
  455. err = 0;
  456. db = get_DB(jnienv, jthis);
  457. dbtxnid = get_DB_TXN(jnienv, txnid);
  458. if (!verify_non_null(jnienv, db))
  459. return (0);    /* error will be thrown, retval doesn't matter */
  460. JAVADB_API_BEGIN(db, jthis);
  462. if (jdbt_lock(&dbkey, jnienv, key, inOp) != 0)
  463. goto out2;
  464. if (jdbt_lock(&dbdata, jnienv, data, inOp) != 0)
  465. goto out1;
  467. if (!verify_non_null(jnienv, db))
  468. goto out1;
  469. err = db->put(db, dbtxnid, &dbkey.dbt->dbt, &dbdata.dbt->dbt, flags);
  470. if (err != DB_KEYEXIST) {
  471. verify_return(jnienv, err, 0);
  472. }
  473.  out1:
  474. jdbt_unlock(&dbdata, jnienv);
  475.  out2:
  476. jdbt_unlock(&dbkey, jnienv);
  477. JAVADB_API_END(db);
  478. return (err);
  479. }
  481. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_rename
  482.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring file,
  483.    jstring database, jstring newname, jint flags)
  484. {
  485. int err;
  486. DB *db;
  487. DB_JAVAINFO *dbinfo;
  488. JSTR j_file;
  489. JSTR j_database;
  490. JSTR j_newname;
  492. db = get_DB(jnienv, jthis);
  493. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  494. if (!verify_non_null(jnienv, db))
  495. return;
  496. JAVADB_API_BEGIN(db, jthis);
  497. if (jstr_lock(&j_file, jnienv, file) != 0)
  498. goto out3;
  499. if (jstr_lock(&j_database, jnienv, database) != 0)
  500. goto out2;
  501. if (jstr_lock(&j_newname, jnienv, newname) != 0)
  502. goto out1;
  504. err = db->rename(db, j_file.string, j_database.string,
  505.  j_newname.string, flags);
  507. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  508. dbji_dealloc(dbinfo, jnienv);
  509. set_private_dbobj(jnienv, name_DB, jthis, 0);
  511.  out1:
  512. jstr_unlock(&j_newname, jnienv);
  513.  out2:
  514. jstr_unlock(&j_database, jnienv);
  515.  out3:
  516. jstr_unlock(&j_file, jnienv);
  517. /* don't call JAVADB_API_END - db cannot be used */
  518. }
  520. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_remove
  521.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring file,
  522.    jstring database, jint flags)
  523. {
  524. int err;
  525. DB *db = get_DB(jnienv, jthis);
  526. DB_JAVAINFO *dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  527. JSTR j_file;
  528. JSTR j_database;
  530. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  531. if (!verify_non_null(jnienv, db))
  532. return;
  533. JAVADB_API_BEGIN(db, jthis);
  534. if (jstr_lock(&j_file, jnienv, file) != 0)
  535. goto out2;
  536. if (jstr_lock(&j_database, jnienv, database) != 0)
  537. goto out1;
  538. err = db->remove(db, j_file.string, j_database.string, flags);
  540. set_private_dbobj(jnienv, name_DB, jthis, 0);
  541. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  542. dbji_dealloc(dbinfo, jnienv);
  544.  out1:
  545. jstr_unlock(&j_database, jnienv);
  546.  out2:
  547. jstr_unlock(&j_file, jnienv);
  548. /* don't call JAVADB_API_END - db cannot be used */
  549. }
  551. JNIEXPORT void JNICALL
  552.   Java_com_sleepycat_db_Db_set_1pagesize
  553.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jlong value)
  554. {
  555. int err;
  556. DB *db;
  558. db = get_DB(jnienv, jthis);
  559. if (verify_non_null(jnienv, db)) {
  560. JAVADB_API_BEGIN(db, jthis);
  561. err = db->set_pagesize(db, (u_int32_t)value);
  562. verify_return(jnienv, err, 0);
  563. JAVADB_API_END(db);
  564. }
  565. }
  567. JNIEXPORT void JNICALL
  568.   Java_com_sleepycat_db_Db_set_1cachesize
  569.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jint gbytes, jint bytes,
  570.    jint ncaches)
  571. {
  572. int err;
  573. DB *db;
  575. db = get_DB(jnienv, jthis);
  576. if (verify_non_null(jnienv, db)) {
  577. JAVADB_API_BEGIN(db, jthis);
  578. err = db->set_cachesize(db, gbytes, bytes, ncaches);
  579. verify_return(jnienv, err, 0);
  580. JAVADB_API_END(db);
  581. }
  582. }
  584. JNIEXPORT void JNICALL
  585.   Java_com_sleepycat_db_Db_set_1re_1source
  586.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring re_source)
  587. {
  588. int err;
  589. DB *db;
  591. db = get_DB(jnienv, jthis);
  592. if (verify_non_null(jnienv, db)) {
  593. JAVADB_API_BEGIN(db, jthis);
  595. /* XXX does the string from get_c_string ever get freed? */
  596. if (re_source != NULL)
  597. err = db->set_re_source(db, get_c_string(jnienv, re_source));
  598. else
  599. err = db->set_re_source(db, 0);
  601. verify_return(jnienv, err, 0);
  602. JAVADB_API_END(db);
  603. }
  604. }
  606. JNIEXPORT jobject JNICALL Java_com_sleepycat_db_Db_stat
  607.   (JNIEnv *jnienv, jobject jthis, jint flags)
  608. {
  609. int err;
  610. DB *db = get_DB(jnienv, jthis);
  611. jobject retval = NULL;
  612. jclass dbclass;
  613. void *statp = 0;
  614. DB_BTREE_STAT *bstp;
  615. DB_HASH_STAT *hstp;
  616. DB_QUEUE_STAT *qstp;
  618. if (!verify_non_null(jnienv, db))
  619. return (NULL);
  621. JAVADB_API_BEGIN(db, jthis);
  623. err = db->stat(db, &statp, NULL, flags);
  624. if (verify_return(jnienv, err, 0)) {
  625. DBTYPE dbtype = db->get_type(db);
  626. switch (dbtype) {
  628. /* Btree and recno share the same stat structure */
  629. case DB_BTREE:
  630. case DB_RECNO:
  631. bstp = (DB_BTREE_STAT *)statp;
  632. retval = create_default_object(jnienv,
  633.        name_DB_BTREE_STAT);
  634. dbclass = get_class(jnienv, name_DB_BTREE_STAT);
  636. /* Set the individual fields */
  637. set_int_field(jnienv, dbclass, retval,
  638.       "bt_magic", bstp->bt_magic);
  639. set_int_field(jnienv, dbclass, retval,
  640.       "bt_version", bstp->bt_version);
  641. set_int_field(jnienv, dbclass, retval,
  642.       "bt_metaflags", bstp->bt_metaflags);
  643. set_int_field(jnienv, dbclass, retval,
  644.       "bt_nkeys", bstp->bt_nkeys);
  645. set_int_field(jnienv, dbclass, retval,
  646.       "bt_ndata", bstp->bt_ndata);
  647. set_int_field(jnienv, dbclass, retval,
  648.       "bt_pagesize", bstp->bt_pagesize);
  649. set_int_field(jnienv, dbclass, retval,
  650.       "bt_maxkey", bstp->bt_maxkey);
  651. set_int_field(jnienv, dbclass, retval,
  652.       "bt_minkey", bstp->bt_minkey);
  653. set_int_field(jnienv, dbclass, retval,
  654.       "bt_re_len", bstp->bt_re_len);
  655. set_int_field(jnienv, dbclass, retval,
  656.       "bt_re_pad", bstp->bt_re_pad);
  657. set_int_field(jnienv, dbclass, retval,
  658.       "bt_levels", bstp->bt_levels);
  659. set_int_field(jnienv, dbclass, retval,
  660.       "bt_int_pg", bstp->bt_int_pg);
  661. set_int_field(jnienv, dbclass, retval,
  662.       "bt_leaf_pg", bstp->bt_leaf_pg);
  663. set_int_field(jnienv, dbclass, retval,
  664.       "bt_dup_pg", bstp->bt_dup_pg);
  665. set_int_field(jnienv, dbclass, retval,
  666.       "bt_over_pg", bstp->bt_over_pg);
  667. set_int_field(jnienv, dbclass, retval,
  668.       "bt_free", bstp->bt_free);
  669. set_int_field(jnienv, dbclass, retval,
  670.       "bt_int_pgfree", bstp->bt_int_pgfree);
  671. set_int_field(jnienv, dbclass, retval,
  672.       "bt_leaf_pgfree", bstp->bt_leaf_pgfree);
  673. set_int_field(jnienv, dbclass, retval,
  674.       "bt_dup_pgfree", bstp->bt_dup_pgfree);
  675. set_int_field(jnienv, dbclass, retval,
  676.       "bt_over_pgfree", bstp->bt_over_pgfree);
  678. break;
  680. /* Hash stat structure */
  681. case DB_HASH:
  682. hstp = (DB_HASH_STAT *)statp;
  683. retval = create_default_object(jnienv,
  684.        name_DB_HASH_STAT);
  685. dbclass = get_class(jnienv, name_DB_HASH_STAT);
  687. /* Set the individual fields */
  688. set_int_field(jnienv, dbclass, retval,
  689.       "hash_magic", hstp->hash_magic);
  690. set_int_field(jnienv, dbclass, retval,
  691.       "hash_version", hstp->hash_version);
  692. set_int_field(jnienv, dbclass, retval,
  693.       "hash_metaflags", hstp->hash_metaflags);
  694. set_int_field(jnienv, dbclass, retval,
  695.       "hash_nkeys", hstp->hash_nkeys);
  696. set_int_field(jnienv, dbclass, retval,
  697.       "hash_ndata", hstp->hash_ndata);
  698. set_int_field(jnienv, dbclass, retval,
  699.       "hash_pagesize", hstp->hash_pagesize);
  700. set_int_field(jnienv, dbclass, retval,
  701.       "hash_nelem", hstp->hash_nelem);
  702. set_int_field(jnienv, dbclass, retval,
  703.       "hash_ffactor", hstp->hash_ffactor);
  704. set_int_field(jnienv, dbclass, retval,
  705.       "hash_buckets", hstp->hash_buckets);
  706. set_int_field(jnienv, dbclass, retval,
  707.       "hash_free", hstp->hash_free);
  708. set_int_field(jnienv, dbclass, retval,
  709.       "hash_bfree", hstp->hash_bfree);
  710. set_int_field(jnienv, dbclass, retval,
  711.       "hash_bigpages", hstp->hash_bigpages);
  712. set_int_field(jnienv, dbclass, retval,
  713.       "hash_big_bfree", hstp->hash_big_bfree);
  714. set_int_field(jnienv, dbclass, retval,
  715.       "hash_overflows", hstp->hash_overflows);
  716. set_int_field(jnienv, dbclass, retval,
  717.       "hash_ovfl_free", hstp->hash_ovfl_free);
  718. set_int_field(jnienv, dbclass, retval,
  719.       "hash_dup", hstp->hash_dup);
  720. set_int_field(jnienv, dbclass, retval,
  721.       "hash_dup_free", hstp->hash_dup_free);
  723. break;
  725. case DB_QUEUE:
  726. qstp = (DB_QUEUE_STAT *)statp;
  727. retval = create_default_object(jnienv,
  728.        name_DB_QUEUE_STAT);
  729. dbclass = get_class(jnienv, name_DB_QUEUE_STAT);
  731. /* Set the individual fields */
  732. set_int_field(jnienv, dbclass, retval,
  733.       "qs_magic", qstp->qs_magic);
  734. set_int_field(jnienv, dbclass, retval,
  735.       "qs_version", qstp->qs_version);
  736. set_int_field(jnienv, dbclass, retval,
  737.       "qs_metaflags", qstp->qs_metaflags);
  738. set_int_field(jnienv, dbclass, retval,
  739.       "qs_nkeys", qstp->qs_nkeys);
  740. set_int_field(jnienv, dbclass, retval,
  741.       "qs_ndata", qstp->qs_ndata);
  742. set_int_field(jnienv, dbclass, retval,
  743.       "qs_pagesize", qstp->qs_pagesize);
  744. set_int_field(jnienv, dbclass, retval,
  745.       "qs_pages", qstp->qs_pages);
  746. set_int_field(jnienv, dbclass, retval,
  747.       "qs_re_len", qstp->qs_re_len);
  748. set_int_field(jnienv, dbclass, retval,
  749.       "qs_re_pad", qstp->qs_re_pad);
  750. set_int_field(jnienv, dbclass, retval,
  751.       "qs_pgfree", qstp->qs_pgfree);
  752. set_int_field(jnienv, dbclass, retval,
  753.       "qs_first_recno", qstp->qs_first_recno);
  754. set_int_field(jnienv, dbclass, retval,
  755.       "qs_cur_recno", qstp->qs_cur_recno);
  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 HASH, BTREE and RECNO",
  763.  EINVAL, 0);
  764. break;
  765. }
  766. free(statp);
  767. }
  768. JAVADB_API_END(db);
  769. return (retval);
  770. }
  772. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_sync
  773.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jint flags)
  774. {
  775. int err;
  776. DB *db = get_DB(jnienv, jthis);
  778. if (!verify_non_null(jnienv, db))
  779. return (0);
  780. JAVADB_API_BEGIN(db, jthis);
  781. err = db->sync(db, flags);
  782. if (err != DB_INCOMPLETE)
  783. verify_return(jnienv, err, 0);
  784. JAVADB_API_END(db);
  785. return (err);
  786. }
  788. JNIEXPORT jboolean JNICALL Java_com_sleepycat_db_Db_get_1byteswapped
  789.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  790. {
  791. DB *db;
  792. jboolean retval;
  794. db = get_DB(jnienv, jthis);
  795. if (!verify_non_null(jnienv, db))
  796. return (0);
  798. JAVADB_API_BEGIN(db, jthis);
  799. retval = db->get_byteswapped(db) ? 1 : 0;
  800. JAVADB_API_END(db);
  801. return (retval);
  802. }
  804. JNIEXPORT jint JNICALL Java_com_sleepycat_db_Db_get_1type
  805.   (JNIEnv *jnienv, /*Db*/ jobject jthis)
  806. {
  807. DB *db;
  809. db = get_DB(jnienv, jthis);
  810. if (!verify_non_null(jnienv, db))
  811. return (0);
  813. return ((jint)db->type);
  814. }
  816. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1open
  817.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring file, jstring database,
  818.    jint type, jint flags, jint mode)
  819. {
  820. int err;
  821. DB *db;
  822. JSTR dbfile;
  823. JSTR dbdatabase;
  825. /* Java is assumed to be threaded. */
  826. flags |= DB_THREAD;
  828. db = get_DB(jnienv, jthis);
  829. if (jstr_lock(&dbfile, jnienv, file) != 0)
  830. goto out2;
  831. if (jstr_lock(&dbdatabase, jnienv, database) != 0)
  832. goto out1;
  833. if (verify_non_null(jnienv, db)) {
  834. JAVADB_API_BEGIN(db, jthis);
  835. err = db->open(db, dbfile.string, dbdatabase.string,
  836.        (DBTYPE)type, flags, mode);
  837. verify_return(jnienv, err, EXCEPTION_FILE_NOT_FOUND);
  838. JAVADB_API_END(db);
  839. }
  840.  out1:
  841. jstr_unlock(&dbdatabase, jnienv);
  842.  out2:
  843. jstr_unlock(&dbfile, jnienv);
  844. }
  846. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_upgrade
  847.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring name,
  848.    jint flags)
  849. {
  850. int err;
  851. DB *db = get_DB(jnienv, jthis);
  852. JSTR j_name;
  854. if (verify_non_null(jnienv, db)) {
  855. JAVADB_API_BEGIN(db, jthis);
  856. if (jstr_lock(&j_name, jnienv, name) != 0)
  857. goto out;
  858. err = db->upgrade(db, j_name.string, flags);
  859. verify_return(jnienv, err, 0);
  860. JAVADB_API_END(db);
  861. }
  862.  out:
  863. jstr_unlock(&j_name, jnienv);
  864. }
  866. static int java_verify_callback(void *handle, const void *str_arg)
  867. {
  868. char *str;
  869. struct verify_callback_struct *vc;
  870. int len;
  871. jthrowable except;
  872. JNIEnv *jnienv;
  874. str = (char *)str_arg;
  875. vc = (struct verify_callback_struct *)handle;
  876. jnienv = vc->env;
  877. len = strlen(str)+1;
  878. if (len > vc->nbytes) {
  879. vc->nbytes = len;
  880. vc->bytes = (*jnienv)->NewByteArray(jnienv, len);
  881. }
  882. (*jnienv)->SetByteArrayRegion(jnienv, vc->bytes, 0, len, (jbyte*)str);
  883. (*jnienv)->CallVoidMethod(jnienv, vc->streamobj,
  884.   vc->writemid, vc->bytes, 0, len-1);
  886. if ((except = (*jnienv)->ExceptionOccurred(jnienv)) != NULL)
  887. return (EIO);
  889. return (0);
  890. }
  892. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db_verify
  893.   (JNIEnv *jnienv, /*Db*/ jobject jthis, jstring name,
  894.    jstring subdb, jobject stream, jint flags)
  895. {
  896. int err;
  897. DB *db;
  898. JSTR j_name;
  899. JSTR j_subdb;
  900. struct verify_callback_struct vcs;
  901. jclass streamclass;
  903. db = get_DB(jnienv, jthis);
  904. if (!verify_non_null(jnienv, db))
  905. return;
  906. JAVADB_API_BEGIN(db, jthis);
  908. if (jstr_lock(&j_name, jnienv, name) != 0)
  909. goto out2;
  910. if (jstr_lock(&j_subdb, jnienv, subdb) != 0)
  911. goto out1;
  913. /* set up everything we need for the callbacks */
  914. vcs.env = jnienv;
  915. vcs.streamobj = stream;
  916. vcs.nbytes = 100;
  917. vcs.bytes = (*jnienv)->NewByteArray(jnienv, vcs.nbytes);
  919. /* get the method ID for OutputStream.write(byte[], int, int); */
  920. streamclass = (*jnienv)->FindClass(jnienv, "java/io/OutputStream");
  921. vcs.writemid = (*jnienv)->GetMethodID(jnienv, streamclass,
  922.       "write", "([BII)V");
  924. /* invoke verify - this will invoke the callback repeatedly. */
  925. err = __db_verify_internal(db, j_name.string, j_subdb.string,
  926.    &vcs, java_verify_callback, flags);
  927. verify_return(jnienv, err, 0);
  929. out1:
  930. jstr_unlock(&j_subdb, jnienv);
  931. out2:
  932. jstr_unlock(&j_name, jnienv);
  933. JAVADB_API_END(db);
  934. }
  936. JNIEXPORT void JNICALL Java_com_sleepycat_db_Db__1finalize
  937.     (JNIEnv *jnienv, jobject jthis,
  938.      jobject /*DbErrcall*/ errcall, jstring errpfx)
  939. {
  940. DB_JAVAINFO *dbinfo;
  941. DB *db;
  943. dbinfo = get_DB_JAVAINFO(jnienv, jthis);
  944. db = get_DB(jnienv, jthis);
  945. DB_ASSERT(dbinfo != NULL);
  947. /* Note: We can never be sure if the underlying DB is attached to
  948.  * a DB_ENV that was already closed.  Sure, that's a user error,
  949.  * but it shouldn't crash the VM.  Therefore, we cannot just
  950.  * automatically close if the handle indicates we are not yet
  951.  * closed.  The best we can do is detect this and report it.
  952.  */
  953. if (db != NULL) {
  954. /* If this error occurs, this object was never closed. */
  955. report_errcall(jnienv, errcall, errpfx,
  956.        "Db.finalize: open Db object destroyed");
  957. }
  959. /* Shouldn't see this object again, but just in case */
  960. set_private_dbobj(jnienv, name_DB, jthis, 0);
  961. set_private_info(jnienv, name_DB, jthis, 0);
  963. dbji_destroy(dbinfo, jnienv);
  964. }