diff options
| author | Chris Toshok <toshok@src.gnome.org> | 2003-11-20 22:14:35 +0000 |
|---|---|---|
| committer | Chris Toshok <toshok@src.gnome.org> | 2003-11-20 22:14:35 +0000 |
| commit | 4215cc08ba70557434e95e8e7f2bd20b7e1465a0 (patch) | |
| tree | 1bb7571dae224c46db22641bfdd75b8b4a8c41ad /libdb/java | |
| parent | 744c34ac84eb0869f056602199ca48bc2b17da58 (diff) | |
| download | evolution-data-server-4215cc08ba70557434e95e8e7f2bd20b7e1465a0.tar.gz | |
Initial revision
Diffstat (limited to 'libdb/java')
52 files changed, 5194 insertions, 0 deletions
diff --git a/libdb/java/src/com/sleepycat/db/Db.java b/libdb/java/src/com/sleepycat/db/Db.java new file mode 100644 index 000000000..26461ecd6 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/Db.java @@ -0,0 +1,761 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +import java.io.OutputStream; +import java.io.FileNotFoundException; + +/** + * + * @author Donald D. Anderson + */ +public class Db +{ + // BEGIN-JAVA-SPECIAL-CONSTANTS + /* DO NOT EDIT: automatically built by dist/s_java. */ + public static final int DB_BTREE = 1; + public static final int DB_DONOTINDEX = -30999; + public static final int DB_HASH = 2; + public static final int DB_KEYEMPTY = -30998; + public static final int DB_KEYEXIST = -30997; + public static final int DB_LOCK_DEADLOCK = -30996; + public static final int DB_LOCK_NOTGRANTED = -30995; + public static final int DB_NOSERVER = -30994; + public static final int DB_NOSERVER_HOME = -30993; + public static final int DB_NOSERVER_ID = -30992; + public static final int DB_NOTFOUND = -30991; + public static final int DB_OLD_VERSION = -30990; + public static final int DB_PAGE_NOTFOUND = -30989; + public static final int DB_QUEUE = 4; + public static final int DB_RECNO = 3; + public static final int DB_REP_DUPMASTER = -30988; + public static final int DB_REP_HOLDELECTION = -30987; + public static final int DB_REP_NEWMASTER = -30986; + public static final int DB_REP_NEWSITE = -30985; + public static final int DB_REP_OUTDATED = -30984; + public static final int DB_RUNRECOVERY = -30982; + public static final int DB_SECONDARY_BAD = -30981; + public static final int DB_TXN_ABORT = 0; + public static final int DB_TXN_APPLY = 1; + public static final int DB_TXN_BACKWARD_ROLL = 3; + public static final int DB_TXN_FORWARD_ROLL = 4; + public static final int DB_TXN_PRINT = 8; + public static final int DB_UNKNOWN = 5; + public static final int DB_VERIFY_BAD = -30980; + public static final int DB_AFTER; + public static final int DB_AGGRESSIVE; + public static final int DB_APPEND; + public static final int DB_ARCH_ABS; + public static final int DB_ARCH_DATA; + public static final int DB_ARCH_LOG; + public static final int DB_AUTO_COMMIT; + public static final int DB_BEFORE; + public static final int DB_CACHED_COUNTS; + public static final int DB_CDB_ALLDB; + public static final int DB_CHKSUM_SHA1; + public static final int DB_CLIENT; + public static final int DB_CONSUME; + public static final int DB_CONSUME_WAIT; + public static final int DB_CREATE; + public static final int DB_CURRENT; + public static final int DB_CXX_NO_EXCEPTIONS; + public static final int DB_DBT_MALLOC; + public static final int DB_DBT_PARTIAL; + public static final int DB_DBT_REALLOC; + public static final int DB_DBT_USERMEM; + public static final int DB_DIRECT; + public static final int DB_DIRECT_DB; + public static final int DB_DIRECT_LOG; + public static final int DB_DIRTY_READ; + public static final int DB_DUP; + public static final int DB_DUPSORT; + public static final int DB_EID_BROADCAST; + public static final int DB_EID_INVALID; + public static final int DB_ENCRYPT; + public static final int DB_ENCRYPT_AES; + public static final int DB_EXCL; + public static final int DB_FAST_STAT; + public static final int DB_FIRST; + public static final int DB_FLUSH; + public static final int DB_FORCE; + public static final int DB_GET_BOTH; + public static final int DB_GET_BOTH_RANGE; + public static final int DB_GET_RECNO; + public static final int DB_INIT_CDB; + public static final int DB_INIT_LOCK; + public static final int DB_INIT_LOG; + public static final int DB_INIT_MPOOL; + public static final int DB_INIT_TXN; + public static final int DB_JOINENV; + public static final int DB_JOIN_ITEM; + public static final int DB_JOIN_NOSORT; + public static final int DB_KEYFIRST; + public static final int DB_KEYLAST; + public static final int DB_LAST; + public static final int DB_LOCKDOWN; + public static final int DB_LOCK_DEFAULT; + public static final int DB_LOCK_EXPIRE; + public static final int DB_LOCK_GET; + public static final int DB_LOCK_GET_TIMEOUT; + public static final int DB_LOCK_IREAD; + public static final int DB_LOCK_IWR; + public static final int DB_LOCK_IWRITE; + public static final int DB_LOCK_MAXLOCKS; + public static final int DB_LOCK_MINLOCKS; + public static final int DB_LOCK_MINWRITE; + public static final int DB_LOCK_NOWAIT; + public static final int DB_LOCK_OLDEST; + public static final int DB_LOCK_PUT; + public static final int DB_LOCK_PUT_ALL; + public static final int DB_LOCK_PUT_OBJ; + public static final int DB_LOCK_RANDOM; + public static final int DB_LOCK_READ; + public static final int DB_LOCK_TIMEOUT; + public static final int DB_LOCK_WRITE; + public static final int DB_LOCK_YOUNGEST; + public static final int DB_MULTIPLE; + public static final int DB_MULTIPLE_KEY; + public static final int DB_NEXT; + public static final int DB_NEXT_DUP; + public static final int DB_NEXT_NODUP; + public static final int DB_NODUPDATA; + public static final int DB_NOLOCKING; + public static final int DB_NOMMAP; + public static final int DB_NOORDERCHK; + public static final int DB_NOOVERWRITE; + public static final int DB_NOPANIC; + public static final int DB_NOSYNC; + public static final int DB_ODDFILESIZE; + public static final int DB_ORDERCHKONLY; + public static final int DB_OVERWRITE; + public static final int DB_PANIC_ENVIRONMENT; + public static final int DB_POSITION; + public static final int DB_PREV; + public static final int DB_PREV_NODUP; + public static final int DB_PRINTABLE; + public static final int DB_PRIORITY_DEFAULT; + public static final int DB_PRIORITY_HIGH; + public static final int DB_PRIORITY_LOW; + public static final int DB_PRIORITY_VERY_HIGH; + public static final int DB_PRIORITY_VERY_LOW; + public static final int DB_PRIVATE; + public static final int DB_RDONLY; + public static final int DB_RECNUM; + public static final int DB_RECORDCOUNT; + public static final int DB_RECOVER; + public static final int DB_RECOVER_FATAL; + public static final int DB_REGION_INIT; + public static final int DB_RENUMBER; + public static final int DB_REP_CLIENT; + public static final int DB_REP_LOGSONLY; + public static final int DB_REP_MASTER; + public static final int DB_REP_PERMANENT; + public static final int DB_REP_UNAVAIL; + public static final int DB_REVSPLITOFF; + public static final int DB_RMW; + public static final int DB_SALVAGE; + public static final int DB_SET; + public static final int DB_SET_LOCK_TIMEOUT; + public static final int DB_SET_RANGE; + public static final int DB_SET_RECNO; + public static final int DB_SET_TXN_TIMEOUT; + public static final int DB_SNAPSHOT; + public static final int DB_STAT_CLEAR; + public static final int DB_SYSTEM_MEM; + public static final int DB_THREAD; + public static final int DB_TRUNCATE; + public static final int DB_TXN_NOSYNC; + public static final int DB_TXN_NOWAIT; + public static final int DB_TXN_SYNC; + public static final int DB_TXN_WRITE_NOSYNC; + public static final int DB_UPGRADE; + public static final int DB_USE_ENVIRON; + public static final int DB_USE_ENVIRON_ROOT; + public static final int DB_VERB_CHKPOINT; + public static final int DB_VERB_DEADLOCK; + public static final int DB_VERB_RECOVERY; + public static final int DB_VERB_REPLICATION; + public static final int DB_VERB_WAITSFOR; + public static final int DB_VERIFY; + public static final int DB_VERSION_MAJOR; + public static final int DB_VERSION_MINOR; + public static final int DB_VERSION_PATCH; + public static final int DB_WRITECURSOR; + public static final int DB_XA_CREATE; + public static final int DB_XIDDATASIZE; + public static final int DB_YIELDCPU; + // END-JAVA-SPECIAL-CONSTANTS + + // Note: the env can be null + // + public Db(DbEnv env, int flags) + throws DbException + { + constructor_env_ = env; + _init(env, flags); + if (env == null) { + dbenv_ = new DbEnv(this); + } + else { + dbenv_ = env; + } + dbenv_._add_db(this); + } + + // + // Our parent DbEnv is notifying us that the environment is closing. + // + /*package*/ void _notify_dbenv_close() + { + dbenv_ = null; + _notify_internal(); + } + + private native void _init(DbEnv env, int flags) + throws DbException; + + private native void _notify_internal(); + + // methods + // + + public synchronized void associate(DbTxn txn, Db secondary, + DbSecondaryKeyCreate key_creator, + int flags) + throws DbException + { + secondary.secondary_key_create_ = key_creator; + _associate(txn, secondary, key_creator, flags); + } + + public native void _associate(DbTxn txn, Db secondary, + DbSecondaryKeyCreate key_creator, int flags) + throws DbException; + + public synchronized int close(int flags) + throws DbException + { + try { + dbenv_._remove_db(this); + return _close(flags); + } + finally { + if (constructor_env_ == null) { + dbenv_._notify_db_close(); + } + dbenv_ = null; + } + } + + public native int _close(int flags) + throws DbException; + + public native Dbc cursor(DbTxn txnid, int flags) + throws DbException; + + public native int del(DbTxn txnid, Dbt key, int flags) + throws DbException; + + public native void err(int errcode, String message); + + public native void errx(String message); + + public native int fd() + throws DbException; + + // overrides Object.finalize + protected void finalize() + throws Throwable + { + if (dbenv_ == null) + _finalize(null, null); + else + _finalize(dbenv_.errcall_, dbenv_.errpfx_); + } + + protected native void _finalize(DbErrcall errcall, String errpfx) + throws Throwable; + + // returns: 0, DB_NOTFOUND, or throws error + public native int get(DbTxn txnid, Dbt key, Dbt data, int flags) + throws DbException; + + public native boolean get_byteswapped(); + + public native /*DBTYPE*/ int get_type(); + + public native Dbc join(Dbc curslist[], int flags) + throws DbException; + + public native void key_range(DbTxn txnid, Dbt key, + DbKeyRange range, int flags) + throws DbException; + + public synchronized void open(DbTxn txnid, String file, + String database, /*DBTYPE*/ int type, + int flags, int mode) + throws DbException, FileNotFoundException + { + _open(txnid, file, database, type, flags, mode); + } + + // (Internal) + public native void _open(DbTxn txnid, String file, + String database, /*DBTYPE*/ int type, + int flags, int mode) + throws DbException, FileNotFoundException; + + + // returns: 0, DB_NOTFOUND, or throws error + public native int pget(DbTxn txnid, Dbt key, Dbt pkey, Dbt data, int flags) + throws DbException; + + // returns: 0, DB_KEYEXIST, or throws error + public native int put(DbTxn txnid, Dbt key, Dbt data, int flags) + throws DbException; + + public synchronized void rename(String file, String database, + String newname, int flags) + throws DbException, FileNotFoundException + { + try { + _rename(file, database, newname, flags); + } + finally { + if (constructor_env_ == null) { + dbenv_._notify_db_close(); + } + dbenv_ = null; + } + } + + public native void _rename(String file, String database, + String newname, int flags) + throws DbException, FileNotFoundException; + + + public synchronized void remove(String file, + String database, int flags) + throws DbException, FileNotFoundException + { + try { + _remove(file, database, flags); + } + finally { + if (constructor_env_ == null) { + dbenv_._notify_db_close(); + } + dbenv_ = null; + } + } + + public native void _remove(String file, String database, + int flags) + throws DbException, FileNotFoundException; + + // Comparison function. + public void set_append_recno(DbAppendRecno append_recno) + throws DbException + { + append_recno_ = append_recno; + append_recno_changed(append_recno); + } + + // (Internal) + private native void append_recno_changed(DbAppendRecno append_recno) + throws DbException; + + // Comparison function. + public void set_bt_compare(DbBtreeCompare bt_compare) + throws DbException + { + bt_compare_ = bt_compare; + bt_compare_changed(bt_compare); + } + + // (Internal) + private native void bt_compare_changed(DbBtreeCompare bt_compare) + throws DbException; + + // Maximum keys per page. + public native void set_bt_maxkey(int maxkey) + throws DbException; + + // Minimum keys per page. + public native void set_bt_minkey(int minkey) + throws DbException; + + // Prefix function. + public void set_bt_prefix(DbBtreePrefix bt_prefix) + throws DbException + { + bt_prefix_ = bt_prefix; + bt_prefix_changed(bt_prefix); + } + + // (Internal) + private native void bt_prefix_changed(DbBtreePrefix bt_prefix) + throws DbException; + + // Set cache size + public native void set_cachesize(int gbytes, int bytes, int ncaches) + throws DbException; + + // Set cache priority + public native void set_cache_priority(/* DB_CACHE_PRIORITY */ int priority) + throws DbException; + + // Duplication resolution + public void set_dup_compare(DbDupCompare dup_compare) + throws DbException + { + dup_compare_ = dup_compare; + dup_compare_changed(dup_compare); + } + + // (Internal) + private native void dup_compare_changed(DbDupCompare dup_compare) + throws DbException; + + // Encryption + public native void set_encrypt(String passwd, /*u_int32_t*/ int flags) + throws DbException; + + // Error message callback. + public void set_errcall(DbErrcall errcall) + { + if (dbenv_ != null) + dbenv_.set_errcall(errcall); + } + + // Error stream. + public void set_error_stream(OutputStream s) + { + DbOutputStreamErrcall errcall = new DbOutputStreamErrcall(s); + set_errcall(errcall); + } + + // Error message prefix. + public void set_errpfx(String errpfx) + { + if (dbenv_ != null) + dbenv_.set_errpfx(errpfx); + } + + + // Feedback + public void set_feedback(DbFeedback feedback) + throws DbException + { + feedback_ = feedback; + feedback_changed(feedback); + } + + // (Internal) + private native void feedback_changed(DbFeedback feedback) + throws DbException; + + // Flags. + public native void set_flags(/*u_int32_t*/ int flags) + throws DbException; + + // Internal - only intended for testing purposes in the Java RPC server + public native int get_flags_raw() + throws DbException; + + // Fill factor. + public native void set_h_ffactor(/*unsigned*/ int h_ffactor) + throws DbException; + + // Hash function. + public void set_h_hash(DbHash h_hash) + throws DbException + { + h_hash_ = h_hash; + hash_changed(h_hash); + } + + // (Internal) + private native void hash_changed(DbHash hash) + throws DbException; + + // Number of elements. + public native void set_h_nelem(/*unsigned*/ int h_nelem) + throws DbException; + + // Byte order. + public native void set_lorder(int lorder) + throws DbException; + + // Underlying page size. + public native void set_pagesize(/*size_t*/ long pagesize) + throws DbException; + + // Variable-length delimiting byte. + public native void set_re_delim(int re_delim) + throws DbException; + + // Length for fixed-length records. + public native void set_re_len(/*u_int32_t*/ int re_len) + throws DbException; + + // Fixed-length padding byte. + public native void set_re_pad(int re_pad) + throws DbException; + + // Source file name. + public native void set_re_source(String re_source) + throws DbException; + + // Extent size of Queue + public native void set_q_extentsize(/*u_int32_t*/ int extent_size) + throws DbException; + + // returns a DbBtreeStat or DbHashStat + public native Object stat(int flags) + throws DbException; + + public native void sync(int flags) + throws DbException; + + public native int truncate(DbTxn txnid, int flags) + throws DbException; + + public native void upgrade(String name, int flags) + throws DbException; + + public native void verify(String name, String subdb, + OutputStream outstr, int flags) + throws DbException; + + //////////////////////////////////////////////////////////////// + // + // private data + // + private long private_dbobj_ = 0; + private long private_info_ = 0; + private DbEnv dbenv_ = null; + private DbEnv constructor_env_ = null; + private DbFeedback feedback_ = null; + private DbAppendRecno append_recno_ = null; + private DbBtreeCompare bt_compare_ = null; + private DbBtreePrefix bt_prefix_ = null; + private DbDupCompare dup_compare_ = null; + private DbHash h_hash_ = null; + private DbSecondaryKeyCreate secondary_key_create_ = null; + + //////////////////////////////////////////////////////////////// + // + // static methods and data that implement + // loading the native library and doing any + // extra sanity checks on startup. + // + private static boolean already_loaded_ = false; + + public static void load_db() + { + if (already_loaded_) + return; + + // An alternate library name can be specified via a property. + // + String override; + + if ((override = System.getProperty("sleepycat.db.libfile")) != null) { + System.load(override); + } + else if ((override = System.getProperty("sleepycat.db.libname")) != null) { + System.loadLibrary(override); + } + else { + String os = System.getProperty("os.name"); + if (os != null && os.startsWith("Windows")) { + // library name is "libdb_java30.dll" (for example) on Win/* + System.loadLibrary("libdb_java" + + DbConstants.DB_VERSION_MAJOR + + DbConstants.DB_VERSION_MINOR); + } + else { + // library name is "libdb_java-3.0.so" (for example) on UNIX + // Note: "db_java" isn't good enough; + // some Unixes require us to use the explicit SONAME. + System.loadLibrary("db_java-" + + DbConstants.DB_VERSION_MAJOR + "." + + DbConstants.DB_VERSION_MINOR); + } + } + + already_loaded_ = true; + } + + static private native void one_time_init(); + + static private void check_constant(int c1, int c2) + { + if (c1 != c2) { + System.err.println("Db: constant mismatch"); + Thread.dumpStack(); + System.exit(1); + } + } + + static { + Db.load_db(); + + // BEGIN-JAVA-CONSTANT-INITIALIZATION + /* DO NOT EDIT: automatically built by dist/s_java. */ + DB_AFTER = DbConstants.DB_AFTER; + DB_AGGRESSIVE = DbConstants.DB_AGGRESSIVE; + DB_APPEND = DbConstants.DB_APPEND; + DB_ARCH_ABS = DbConstants.DB_ARCH_ABS; + DB_ARCH_DATA = DbConstants.DB_ARCH_DATA; + DB_ARCH_LOG = DbConstants.DB_ARCH_LOG; + DB_AUTO_COMMIT = DbConstants.DB_AUTO_COMMIT; + DB_BEFORE = DbConstants.DB_BEFORE; + DB_CACHED_COUNTS = DbConstants.DB_CACHED_COUNTS; + DB_CDB_ALLDB = DbConstants.DB_CDB_ALLDB; + DB_CHKSUM_SHA1 = DbConstants.DB_CHKSUM_SHA1; + DB_CLIENT = DbConstants.DB_CLIENT; + DB_CONSUME = DbConstants.DB_CONSUME; + DB_CONSUME_WAIT = DbConstants.DB_CONSUME_WAIT; + DB_CREATE = DbConstants.DB_CREATE; + DB_CURRENT = DbConstants.DB_CURRENT; + DB_CXX_NO_EXCEPTIONS = DbConstants.DB_CXX_NO_EXCEPTIONS; + DB_DBT_MALLOC = DbConstants.DB_DBT_MALLOC; + DB_DBT_PARTIAL = DbConstants.DB_DBT_PARTIAL; + DB_DBT_REALLOC = DbConstants.DB_DBT_REALLOC; + DB_DBT_USERMEM = DbConstants.DB_DBT_USERMEM; + DB_DIRECT = DbConstants.DB_DIRECT; + DB_DIRECT_DB = DbConstants.DB_DIRECT_DB; + DB_DIRECT_LOG = DbConstants.DB_DIRECT_LOG; + DB_DIRTY_READ = DbConstants.DB_DIRTY_READ; + DB_DUP = DbConstants.DB_DUP; + DB_DUPSORT = DbConstants.DB_DUPSORT; + DB_EID_BROADCAST = DbConstants.DB_EID_BROADCAST; + DB_EID_INVALID = DbConstants.DB_EID_INVALID; + DB_ENCRYPT = DbConstants.DB_ENCRYPT; + DB_ENCRYPT_AES = DbConstants.DB_ENCRYPT_AES; + DB_EXCL = DbConstants.DB_EXCL; + DB_FAST_STAT = DbConstants.DB_FAST_STAT; + DB_FIRST = DbConstants.DB_FIRST; + DB_FLUSH = DbConstants.DB_FLUSH; + DB_FORCE = DbConstants.DB_FORCE; + DB_GET_BOTH = DbConstants.DB_GET_BOTH; + DB_GET_BOTH_RANGE = DbConstants.DB_GET_BOTH_RANGE; + DB_GET_RECNO = DbConstants.DB_GET_RECNO; + DB_INIT_CDB = DbConstants.DB_INIT_CDB; + DB_INIT_LOCK = DbConstants.DB_INIT_LOCK; + DB_INIT_LOG = DbConstants.DB_INIT_LOG; + DB_INIT_MPOOL = DbConstants.DB_INIT_MPOOL; + DB_INIT_TXN = DbConstants.DB_INIT_TXN; + DB_JOINENV = DbConstants.DB_JOINENV; + DB_JOIN_ITEM = DbConstants.DB_JOIN_ITEM; + DB_JOIN_NOSORT = DbConstants.DB_JOIN_NOSORT; + DB_KEYFIRST = DbConstants.DB_KEYFIRST; + DB_KEYLAST = DbConstants.DB_KEYLAST; + DB_LAST = DbConstants.DB_LAST; + DB_LOCKDOWN = DbConstants.DB_LOCKDOWN; + DB_LOCK_DEFAULT = DbConstants.DB_LOCK_DEFAULT; + DB_LOCK_EXPIRE = DbConstants.DB_LOCK_EXPIRE; + DB_LOCK_GET = DbConstants.DB_LOCK_GET; + DB_LOCK_GET_TIMEOUT = DbConstants.DB_LOCK_GET_TIMEOUT; + DB_LOCK_IREAD = DbConstants.DB_LOCK_IREAD; + DB_LOCK_IWR = DbConstants.DB_LOCK_IWR; + DB_LOCK_IWRITE = DbConstants.DB_LOCK_IWRITE; + DB_LOCK_MAXLOCKS = DbConstants.DB_LOCK_MAXLOCKS; + DB_LOCK_MINLOCKS = DbConstants.DB_LOCK_MINLOCKS; + DB_LOCK_MINWRITE = DbConstants.DB_LOCK_MINWRITE; + DB_LOCK_NOWAIT = DbConstants.DB_LOCK_NOWAIT; + DB_LOCK_OLDEST = DbConstants.DB_LOCK_OLDEST; + DB_LOCK_PUT = DbConstants.DB_LOCK_PUT; + DB_LOCK_PUT_ALL = DbConstants.DB_LOCK_PUT_ALL; + DB_LOCK_PUT_OBJ = DbConstants.DB_LOCK_PUT_OBJ; + DB_LOCK_RANDOM = DbConstants.DB_LOCK_RANDOM; + DB_LOCK_READ = DbConstants.DB_LOCK_READ; + DB_LOCK_TIMEOUT = DbConstants.DB_LOCK_TIMEOUT; + DB_LOCK_WRITE = DbConstants.DB_LOCK_WRITE; + DB_LOCK_YOUNGEST = DbConstants.DB_LOCK_YOUNGEST; + DB_MULTIPLE = DbConstants.DB_MULTIPLE; + DB_MULTIPLE_KEY = DbConstants.DB_MULTIPLE_KEY; + DB_NEXT = DbConstants.DB_NEXT; + DB_NEXT_DUP = DbConstants.DB_NEXT_DUP; + DB_NEXT_NODUP = DbConstants.DB_NEXT_NODUP; + DB_NODUPDATA = DbConstants.DB_NODUPDATA; + DB_NOLOCKING = DbConstants.DB_NOLOCKING; + DB_NOMMAP = DbConstants.DB_NOMMAP; + DB_NOORDERCHK = DbConstants.DB_NOORDERCHK; + DB_NOOVERWRITE = DbConstants.DB_NOOVERWRITE; + DB_NOPANIC = DbConstants.DB_NOPANIC; + DB_NOSYNC = DbConstants.DB_NOSYNC; + DB_ODDFILESIZE = DbConstants.DB_ODDFILESIZE; + DB_ORDERCHKONLY = DbConstants.DB_ORDERCHKONLY; + DB_OVERWRITE = DbConstants.DB_OVERWRITE; + DB_PANIC_ENVIRONMENT = DbConstants.DB_PANIC_ENVIRONMENT; + DB_POSITION = DbConstants.DB_POSITION; + DB_PREV = DbConstants.DB_PREV; + DB_PREV_NODUP = DbConstants.DB_PREV_NODUP; + DB_PRINTABLE = DbConstants.DB_PRINTABLE; + DB_PRIORITY_DEFAULT = DbConstants.DB_PRIORITY_DEFAULT; + DB_PRIORITY_HIGH = DbConstants.DB_PRIORITY_HIGH; + DB_PRIORITY_LOW = DbConstants.DB_PRIORITY_LOW; + DB_PRIORITY_VERY_HIGH = DbConstants.DB_PRIORITY_VERY_HIGH; + DB_PRIORITY_VERY_LOW = DbConstants.DB_PRIORITY_VERY_LOW; + DB_PRIVATE = DbConstants.DB_PRIVATE; + DB_RDONLY = DbConstants.DB_RDONLY; + DB_RECNUM = DbConstants.DB_RECNUM; + DB_RECORDCOUNT = DbConstants.DB_RECORDCOUNT; + DB_RECOVER = DbConstants.DB_RECOVER; + DB_RECOVER_FATAL = DbConstants.DB_RECOVER_FATAL; + DB_REGION_INIT = DbConstants.DB_REGION_INIT; + DB_RENUMBER = DbConstants.DB_RENUMBER; + DB_REP_CLIENT = DbConstants.DB_REP_CLIENT; + DB_REP_LOGSONLY = DbConstants.DB_REP_LOGSONLY; + DB_REP_MASTER = DbConstants.DB_REP_MASTER; + DB_REP_PERMANENT = DbConstants.DB_REP_PERMANENT; + DB_REP_UNAVAIL = DbConstants.DB_REP_UNAVAIL; + DB_REVSPLITOFF = DbConstants.DB_REVSPLITOFF; + DB_RMW = DbConstants.DB_RMW; + DB_SALVAGE = DbConstants.DB_SALVAGE; + DB_SET = DbConstants.DB_SET; + DB_SET_LOCK_TIMEOUT = DbConstants.DB_SET_LOCK_TIMEOUT; + DB_SET_RANGE = DbConstants.DB_SET_RANGE; + DB_SET_RECNO = DbConstants.DB_SET_RECNO; + DB_SET_TXN_TIMEOUT = DbConstants.DB_SET_TXN_TIMEOUT; + DB_SNAPSHOT = DbConstants.DB_SNAPSHOT; + DB_STAT_CLEAR = DbConstants.DB_STAT_CLEAR; + DB_SYSTEM_MEM = DbConstants.DB_SYSTEM_MEM; + DB_THREAD = DbConstants.DB_THREAD; + DB_TRUNCATE = DbConstants.DB_TRUNCATE; + DB_TXN_NOSYNC = DbConstants.DB_TXN_NOSYNC; + DB_TXN_NOWAIT = DbConstants.DB_TXN_NOWAIT; + DB_TXN_SYNC = DbConstants.DB_TXN_SYNC; + DB_TXN_WRITE_NOSYNC = DbConstants.DB_TXN_WRITE_NOSYNC; + DB_UPGRADE = DbConstants.DB_UPGRADE; + DB_USE_ENVIRON = DbConstants.DB_USE_ENVIRON; + DB_USE_ENVIRON_ROOT = DbConstants.DB_USE_ENVIRON_ROOT; + DB_VERB_CHKPOINT = DbConstants.DB_VERB_CHKPOINT; + DB_VERB_DEADLOCK = DbConstants.DB_VERB_DEADLOCK; + DB_VERB_RECOVERY = DbConstants.DB_VERB_RECOVERY; + DB_VERB_REPLICATION = DbConstants.DB_VERB_REPLICATION; + DB_VERB_WAITSFOR = DbConstants.DB_VERB_WAITSFOR; + DB_VERIFY = DbConstants.DB_VERIFY; + DB_VERSION_MAJOR = DbConstants.DB_VERSION_MAJOR; + DB_VERSION_MINOR = DbConstants.DB_VERSION_MINOR; + DB_VERSION_PATCH = DbConstants.DB_VERSION_PATCH; + DB_WRITECURSOR = DbConstants.DB_WRITECURSOR; + DB_XA_CREATE = DbConstants.DB_XA_CREATE; + DB_XIDDATASIZE = DbConstants.DB_XIDDATASIZE; + DB_YIELDCPU = DbConstants.DB_YIELDCPU; + // END-JAVA-CONSTANT-INITIALIZATION + + one_time_init(); + } +} +// end of Db.java diff --git a/libdb/java/src/com/sleepycat/db/DbAppDispatch.java b/libdb/java/src/com/sleepycat/db/DbAppDispatch.java new file mode 100644 index 000000000..af0d9c7db --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbAppDispatch.java @@ -0,0 +1,22 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by DbEnv.set_app_dispatch() + * + */ +public interface DbAppDispatch +{ + // The value of recops is one of the Db.DB_TXN_* constants + public abstract int app_dispatch(DbEnv env, Dbt dbt, DbLsn lsn, int recops); +} + +// end of DbAppDispatch.java diff --git a/libdb/java/src/com/sleepycat/db/DbAppendRecno.java b/libdb/java/src/com/sleepycat/db/DbAppendRecno.java new file mode 100644 index 000000000..2e255576b --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbAppendRecno.java @@ -0,0 +1,22 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by Db.set_append_recno() + * + */ +public interface DbAppendRecno +{ + public abstract void db_append_recno(Db db, Dbt data, int recno) + throws DbException; +} + +// end of DbAppendRecno.java diff --git a/libdb/java/src/com/sleepycat/db/DbBtreeCompare.java b/libdb/java/src/com/sleepycat/db/DbBtreeCompare.java new file mode 100644 index 000000000..0f20e66a9 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbBtreeCompare.java @@ -0,0 +1,21 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by DbEnv.set_bt_compare() + * + */ +public interface DbBtreeCompare +{ + public abstract int bt_compare(Db db, Dbt dbt1, Dbt dbt2); +} + +// end of DbBtreeCompare.java diff --git a/libdb/java/src/com/sleepycat/db/DbBtreePrefix.java b/libdb/java/src/com/sleepycat/db/DbBtreePrefix.java new file mode 100644 index 000000000..8665dbe35 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbBtreePrefix.java @@ -0,0 +1,21 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by DbEnv.set_bt_prefix() + * + */ +public interface DbBtreePrefix +{ + public abstract int bt_prefix(Db db, Dbt dbt1, Dbt dbt2); +} + +// end of DbBtreePrefix.java diff --git a/libdb/java/src/com/sleepycat/db/DbBtreeStat.java b/libdb/java/src/com/sleepycat/db/DbBtreeStat.java new file mode 100644 index 000000000..669afcffc --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbBtreeStat.java @@ -0,0 +1,28 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbBtreeStat +{ + public int bt_magic; + public int bt_version; + public int bt_metaflags; + public int bt_nkeys; + public int bt_ndata; + public int bt_pagesize; + public int bt_maxkey; + public int bt_minkey; + public int bt_re_len; + public int bt_re_pad; + public int bt_levels; + public int bt_int_pg; + public int bt_leaf_pg; + public int bt_dup_pg; + public int bt_over_pg; + public int bt_free; + public int bt_int_pgfree; + public int bt_leaf_pgfree; + public int bt_dup_pgfree; + public int bt_over_pgfree; +} +// end of DbBtreeStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbClient.java b/libdb/java/src/com/sleepycat/db/DbClient.java new file mode 100644 index 000000000..29990fe5a --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbClient.java @@ -0,0 +1,21 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by DbEnv.set_rpc_server(). + * It is a placeholder for a future capability. + * + */ +public interface DbClient +{ +} + +// end of DbClient.java diff --git a/libdb/java/src/com/sleepycat/db/DbConstants.java b/libdb/java/src/com/sleepycat/db/DbConstants.java new file mode 100644 index 000000000..bad3442e2 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbConstants.java @@ -0,0 +1,151 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +class DbConstants +{ + static final int DB_AFTER = 1; + static final int DB_AGGRESSIVE = 0x000001; + static final int DB_APPEND = 2; + static final int DB_ARCH_ABS = 0x001; + static final int DB_ARCH_DATA = 0x002; + static final int DB_ARCH_LOG = 0x004; + static final int DB_AUTO_COMMIT = 0x00800000; + static final int DB_BEFORE = 3; + static final int DB_CACHED_COUNTS = 4; + static final int DB_CDB_ALLDB = 0x000800; + static final int DB_CHKSUM_SHA1 = 0x000001; + static final int DB_CLIENT = 0x000001; + static final int DB_CONSUME = 6; + static final int DB_CONSUME_WAIT = 7; + static final int DB_CREATE = 0x000001; + static final int DB_CURRENT = 8; + static final int DB_CXX_NO_EXCEPTIONS = 0x000002; + static final int DB_DBT_MALLOC = 0x004; + static final int DB_DBT_PARTIAL = 0x008; + static final int DB_DBT_REALLOC = 0x010; + static final int DB_DBT_USERMEM = 0x020; + static final int DB_DIRECT = 0x000800; + static final int DB_DIRECT_DB = 0x001000; + static final int DB_DIRECT_LOG = 0x002000; + static final int DB_DIRTY_READ = 0x01000000; + static final int DB_DUP = 0x000002; + static final int DB_DUPSORT = 0x000004; + static final int DB_EID_BROADCAST = -1; + static final int DB_EID_INVALID = -2; + static final int DB_ENCRYPT = 0x000008; + static final int DB_ENCRYPT_AES = 0x000001; + static final int DB_EXCL = 0x000800; + static final int DB_FAST_STAT = 9; + static final int DB_FIRST = 10; + static final int DB_FLUSH = 0x02000000; + static final int DB_FORCE = 0x000004; + static final int DB_GET_BOTH = 11; + static final int DB_GET_BOTH_RANGE = 13; + static final int DB_GET_RECNO = 14; + static final int DB_INIT_CDB = 0x000800; + static final int DB_INIT_LOCK = 0x001000; + static final int DB_INIT_LOG = 0x002000; + static final int DB_INIT_MPOOL = 0x004000; + static final int DB_INIT_TXN = 0x008000; + static final int DB_JOINENV = 0x010000; + static final int DB_JOIN_ITEM = 15; + static final int DB_JOIN_NOSORT = 0x000001; + static final int DB_KEYFIRST = 16; + static final int DB_KEYLAST = 17; + static final int DB_LAST = 18; + static final int DB_LOCKDOWN = 0x020000; + static final int DB_LOCK_DEFAULT = 1; + static final int DB_LOCK_EXPIRE = 2; + static final int DB_LOCK_GET = 1; + static final int DB_LOCK_GET_TIMEOUT = 2; + static final int DB_LOCK_IREAD = 5; + static final int DB_LOCK_IWR = 6; + static final int DB_LOCK_IWRITE = 4; + static final int DB_LOCK_MAXLOCKS = 3; + static final int DB_LOCK_MINLOCKS = 4; + static final int DB_LOCK_MINWRITE = 5; + static final int DB_LOCK_NOWAIT = 0x002; + static final int DB_LOCK_OLDEST = 6; + static final int DB_LOCK_PUT = 4; + static final int DB_LOCK_PUT_ALL = 5; + static final int DB_LOCK_PUT_OBJ = 6; + static final int DB_LOCK_RANDOM = 7; + static final int DB_LOCK_READ = 1; + static final int DB_LOCK_TIMEOUT = 8; + static final int DB_LOCK_WRITE = 2; + static final int DB_LOCK_YOUNGEST = 8; + static final int DB_MULTIPLE = 0x04000000; + static final int DB_MULTIPLE_KEY = 0x08000000; + static final int DB_NEXT = 19; + static final int DB_NEXT_DUP = 20; + static final int DB_NEXT_NODUP = 21; + static final int DB_NODUPDATA = 22; + static final int DB_NOLOCKING = 0x004000; + static final int DB_NOMMAP = 0x000008; + static final int DB_NOORDERCHK = 0x000002; + static final int DB_NOOVERWRITE = 23; + static final int DB_NOPANIC = 0x008000; + static final int DB_NOSYNC = 24; + static final int DB_ODDFILESIZE = 0x002000; + static final int DB_ORDERCHKONLY = 0x000004; + static final int DB_OVERWRITE = 0x010000; + static final int DB_PANIC_ENVIRONMENT = 0x020000; + static final int DB_POSITION = 25; + static final int DB_PREV = 27; + static final int DB_PREV_NODUP = 28; + static final int DB_PRINTABLE = 0x000020; + static final int DB_PRIORITY_DEFAULT = 3; + static final int DB_PRIORITY_HIGH = 4; + static final int DB_PRIORITY_LOW = 2; + static final int DB_PRIORITY_VERY_HIGH = 5; + static final int DB_PRIORITY_VERY_LOW = 1; + static final int DB_PRIVATE = 0x040000; + static final int DB_RDONLY = 0x000010; + static final int DB_RECNUM = 0x000010; + static final int DB_RECORDCOUNT = 29; + static final int DB_RECOVER = 0x000020; + static final int DB_RECOVER_FATAL = 0x080000; + static final int DB_REGION_INIT = 0x040000; + static final int DB_RENUMBER = 0x000020; + static final int DB_REP_CLIENT = 0x001; + static final int DB_REP_LOGSONLY = 0x002; + static final int DB_REP_MASTER = 0x004; + static final int DB_REP_PERMANENT = 0x0001; + static final int DB_REP_UNAVAIL = -30983; + static final int DB_REVSPLITOFF = 0x000040; + static final int DB_RMW = 0x40000000; + static final int DB_SALVAGE = 0x000040; + static final int DB_SET = 30; + static final int DB_SET_LOCK_TIMEOUT = 31; + static final int DB_SET_RANGE = 32; + static final int DB_SET_RECNO = 33; + static final int DB_SET_TXN_TIMEOUT = 35; + static final int DB_SNAPSHOT = 0x000080; + static final int DB_STAT_CLEAR = 0x000001; + static final int DB_SYSTEM_MEM = 0x100000; + static final int DB_THREAD = 0x000040; + static final int DB_TRUNCATE = 0x000080; + static final int DB_TXN_NOSYNC = 0x000100; + static final int DB_TXN_NOWAIT = 0x000800; + static final int DB_TXN_SYNC = 0x001000; + static final int DB_TXN_WRITE_NOSYNC = 0x080000; + static final int DB_UPGRADE = 0x000001; + static final int DB_USE_ENVIRON = 0x000200; + static final int DB_USE_ENVIRON_ROOT = 0x000400; + static final int DB_VERB_CHKPOINT = 0x0001; + static final int DB_VERB_DEADLOCK = 0x0002; + static final int DB_VERB_RECOVERY = 0x0004; + static final int DB_VERB_REPLICATION = 0x0008; + static final int DB_VERB_WAITSFOR = 0x0010; + static final int DB_VERIFY = 0x000002; + static final int DB_VERSION_MAJOR = 4; + static final int DB_VERSION_MINOR = 1; + static final int DB_VERSION_PATCH = 24; + static final int DB_WRITECURSOR = 37; + static final int DB_XA_CREATE = 0x000001; + static final int DB_XIDDATASIZE = 128; + static final int DB_YIELDCPU = 0x100000; +} + +// end of DbConstants.java diff --git a/libdb/java/src/com/sleepycat/db/DbDeadlockException.java b/libdb/java/src/com/sleepycat/db/DbDeadlockException.java new file mode 100644 index 000000000..2fdc53792 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbDeadlockException.java @@ -0,0 +1,28 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1999-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +public class DbDeadlockException extends DbException +{ + // methods + // + + public DbDeadlockException(String s) + { + super(s); + } + + public DbDeadlockException(String s, int errno) + { + super(s, errno); + } +} + +// end of DbDeadlockException.java diff --git a/libdb/java/src/com/sleepycat/db/DbDupCompare.java b/libdb/java/src/com/sleepycat/db/DbDupCompare.java new file mode 100644 index 000000000..880966537 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbDupCompare.java @@ -0,0 +1,21 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by DbEnv.set_dup_compare() + * + */ +public interface DbDupCompare +{ + public abstract int dup_compare(Db db, Dbt dbt1, Dbt dbt2); +} + +// end of DbDupCompare.java diff --git a/libdb/java/src/com/sleepycat/db/DbEnv.java b/libdb/java/src/com/sleepycat/db/DbEnv.java new file mode 100644 index 000000000..198e51fb1 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbEnv.java @@ -0,0 +1,430 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +import java.io.OutputStream; +import java.io.FileNotFoundException; +import java.util.Date; +import java.util.Enumeration; +import java.util.Vector; + +/** + * + * @author Donald D. Anderson + */ +public class DbEnv +{ + // methods + // + + // + // After using this constructor, set any parameters via + // the set_* access methods below, and finally open + // the environment by calling open(). + // + public DbEnv(int flags) throws DbException + { + constructor_flags_ = flags; + _init(errstream_, constructor_flags_); + } + + // + // This constructor is purposely not public. + // It is used internally to create a DbEnv wrapper + // when an underlying environment already exists. + // + /*package*/ DbEnv(Db db) + { + _init_using_db(errstream_, db); + } + + // + // When a Db is created, it is kept in a private list, + // so that Db's can be notified when the environment + // is closed. This allows us to detect and guard + // against the following situation: + // DbEnv env = new DbEnv(0); + // Db db = new Db(0); + // env.close(); + // db.close(); + // + // This *is* a programming error, but not protecting + // against it will crash the VM. + // + /*package*/ void _add_db(Db db) + { + dblist_.addElement(db); + } + + // + // Remove from the private list of Db's. + // + /*package*/ void _remove_db(Db db) + { + dblist_.removeElement(db); + } + + // + // Iterate all the Db's in the list, and + // notify them that the environment is closing, + // so they can clean up. + // + /*package*/ void _notify_dbs() + { + Enumeration enum = dblist_.elements(); + while (enum.hasMoreElements()) { + Db db = (Db)enum.nextElement(); + db._notify_dbenv_close(); + } + dblist_.removeAllElements(); + } + + // close discards any internal memory. + // After using close, the DbEnv can be reopened. + // + public synchronized void close(int flags) + throws DbException + { + _notify_dbs(); + _close(flags); + } + + // (Internal) + private native void _close(int flags) + throws DbException; + + public native void dbremove(DbTxn txn, String name, String subdb, + int flags) + throws DbException; + + public native void dbrename(DbTxn txn, String name, String subdb, + String newname, int flags) + throws DbException; + + public native void err(int errcode, String message); + + public native void errx(String message); + + // overrides Object.finalize + protected void finalize() + throws Throwable + { + _notify_dbs(); + _finalize(errcall_, errpfx_); + } + + // (Internal) + protected native void _finalize(DbErrcall errcall, String errpfx) + throws Throwable; + + // (Internal) + // called during constructor + private native void _init(DbErrcall errcall, int flags) throws DbException; + + // (Internal) + // called when DbEnv is constructed as part of Db constructor. + private native void _init_using_db(DbErrcall errcall, Db db); + + /*package*/ native void _notify_db_close(); + + public native void open(String db_home, int flags, int mode) + throws DbException, FileNotFoundException; + + // remove removes any files and discards any internal memory. + // (i.e. implicitly it does a close, if the environment is open). + // After using close, the DbEnv can no longer be used; + // create another one if needed. + // + public native synchronized void remove(String db_home, int flags) + throws DbException, FileNotFoundException; + + //////////////////////////////////////////////////////////////// + // simple get/set access methods + // + // If you are calling set_ methods, you need to + // use the constructor with one argument along with open(). + + public native void set_cachesize(int gbytes, int bytes, int ncaches) + throws DbException; + + // Encryption + public native void set_encrypt(String passwd, /*u_int32_t*/ int flags) + throws DbException; + + // Error message callback. + public void set_errcall(DbErrcall errcall) + { + errcall_ = errcall; + _set_errcall(errcall); + } + + public native void _set_errcall(DbErrcall errcall); + + // Error stream. + public void set_error_stream(OutputStream s) + { + DbOutputStreamErrcall errcall = new DbOutputStreamErrcall(s); + set_errcall(errcall); + } + + // Error message prefix. + public void set_errpfx(String errpfx) + { + errpfx_ = errpfx; + _set_errpfx(errpfx); + } + + private native void _set_errpfx(String errpfx); + + // Feedback + public void set_feedback(DbEnvFeedback feedback) + throws DbException + { + feedback_ = feedback; + feedback_changed(feedback); + } + + // (Internal) + private native void feedback_changed(DbEnvFeedback feedback) + throws DbException; + + // Generate debugging messages. + public native void set_verbose(int which, boolean onoff) + throws DbException; + + public native void set_data_dir(String data_dir) + throws DbException; + + // Log buffer size. + public native void set_lg_bsize(/*u_int32_t*/ int lg_bsize) + throws DbException; + + // Log directory. + public native void set_lg_dir(String lg_dir) + throws DbException; + + // Maximum log file size. + public native void set_lg_max(/*u_int32_t*/ int lg_max) + throws DbException; + + // Log region size. + public native void set_lg_regionmax(/*u_int32_t*/ int lg_regionmax) + throws DbException; + + // Two dimensional conflict matrix. + public native void set_lk_conflicts(byte[][] lk_conflicts) + throws DbException; + + // Deadlock detect on every conflict. + public native void set_lk_detect(/*u_int32_t*/ int lk_detect) + throws DbException; + + /** + * @deprecated DB 3.2.6, see the online documentation. + */ + // Maximum number of locks. + public native void set_lk_max(/*unsigned*/ int lk_max) + throws DbException; + + // Maximum number of lockers. + public native void set_lk_max_lockers(/*unsigned*/ int lk_max_lockers) + throws DbException; + + // Maximum number of locks. + public native void set_lk_max_locks(/*unsigned*/ int lk_max_locks) + throws DbException; + + // Maximum number of locked objects. + public native void set_lk_max_objects(/*unsigned*/ int lk_max_objects) + throws DbException; + + // Maximum file size for mmap. + public native void set_mp_mmapsize(/*size_t*/ long mmapsize) + throws DbException; + + public native void set_flags(int flags, boolean onoff) + throws DbException; + + public native void set_rep_limit(int gbytes, int bytes) throws DbException; + + public void set_rep_transport(int envid, DbRepTransport transport) + throws DbException + { + rep_transport_ = transport; + rep_transport_changed(envid, transport); + } + + // (Internal) + private native void rep_transport_changed(int envid, + DbRepTransport transport) + throws DbException; + + public native void set_rpc_server(DbClient client, String host, + long cl_timeout, long sv_timeout, + int flags) + throws DbException; + + public native void set_shm_key(long shm_key) + throws DbException; + + public native void set_tas_spins(int tas_spins) + throws DbException; + + public native void set_timeout(/*db_timeout_t*/ long timeout, + /*u_int32_t*/ int flags) + throws DbException; + + public native void set_tmp_dir(String tmp_dir) + throws DbException; + + // Feedback + public void set_app_dispatch(DbAppDispatch app_dispatch) + throws DbException + { + app_dispatch_ = app_dispatch; + app_dispatch_changed(app_dispatch); + } + + // (Internal) + private native void app_dispatch_changed(DbAppDispatch app_dispatch) + throws DbException; + + // Maximum number of transactions. + public native void set_tx_max(/*unsigned*/ int tx_max) + throws DbException; + + // Note: only the seconds (not milliseconds) of the timestamp + // are used in this API. + public void set_tx_timestamp(Date timestamp) + throws DbException + { + _set_tx_timestamp(timestamp.getTime()/1000); + } + + // (Internal) + private native void _set_tx_timestamp(long seconds) + throws DbException; + + // Versioning information + public native static int get_version_major(); + public native static int get_version_minor(); + public native static int get_version_patch(); + public native static String get_version_string(); + + // Convert DB error codes to strings + public native static String strerror(int errcode); + + public native int lock_detect(int flags, int atype) + throws DbException; + + public native DbLock lock_get(/*u_int32_t*/ int locker, + int flags, + Dbt obj, + /*db_lockmode_t*/ int lock_mode) + throws DbException; + + public native void lock_put(DbLock lock) + throws DbException; + + public native /*u_int32_t*/ int lock_id() + throws DbException; + + public native void lock_id_free(/*u_int32_t*/ int id) + throws DbException; + + public native DbLockStat lock_stat(/*u_int32_t*/ int flags) + throws DbException; + + public native void lock_vec(/*u_int32_t*/ int locker, + int flags, + DbLockRequest[] list, + int offset, + int count) + throws DbException; + + public native String[] log_archive(int flags) + throws DbException; + + public native static int log_compare(DbLsn lsn0, DbLsn lsn1); + + public native DbLogc log_cursor(int flags) + throws DbException; + + public native String log_file(DbLsn lsn) + throws DbException; + + public native void log_flush(DbLsn lsn) + throws DbException; + + public native void log_put(DbLsn lsn, Dbt data, int flags) + throws DbException; + + public native DbLogStat log_stat(/*u_int32_t*/ int flags) + throws DbException; + + public native DbMpoolStat memp_stat(/*u_int32_t*/ int flags) + throws DbException; + + public native DbMpoolFStat[] memp_fstat(/*u_int32_t*/ int flags) + throws DbException; + + public native int memp_trickle(int pct) + throws DbException; + + public native int rep_elect(int nsites, int pri, int timeout) + throws DbException; + + public static class RepProcessMessage { + public int envid; + } + public native int rep_process_message(Dbt control, Dbt rec, + RepProcessMessage result) + throws DbException; + + public native void rep_start(Dbt cookie, int flags) + throws DbException; + + public native DbRepStat rep_stat(/*u_int32_t*/ int flags) + throws DbException; + + public native DbTxn txn_begin(DbTxn pid, int flags) + throws DbException; + + public native void txn_checkpoint(int kbyte, int min, int flags) + throws DbException; + + public native DbPreplist[] txn_recover(int count, int flags) + throws DbException; + + public native DbTxnStat txn_stat(/*u_int32_t*/ int flags) + throws DbException; + + //////////////////////////////////////////////////////////////// + // + // private data + // + private long private_dbobj_ = 0; + private long private_info_ = 0; + private int constructor_flags_ = 0; + private Vector dblist_ = new Vector(); // Db's that are open + private DbEnvFeedback feedback_ = null; + private DbRepTransport rep_transport_ = null; + private DbAppDispatch app_dispatch_ = null; + private DbOutputStreamErrcall errstream_ = + new DbOutputStreamErrcall(System.err); + /*package*/ DbErrcall errcall_ = errstream_; + /*package*/ String errpfx_; + + static { + Db.load_db(); + } +} + +// end of DbEnv.java diff --git a/libdb/java/src/com/sleepycat/db/DbEnvFeedback.java b/libdb/java/src/com/sleepycat/db/DbEnvFeedback.java new file mode 100644 index 000000000..236b90922 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbEnvFeedback.java @@ -0,0 +1,19 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1999-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +public interface DbEnvFeedback +{ + // methods + // + public abstract void feedback(DbEnv env, int opcode, int pct); +} + +// end of DbFeedback.java diff --git a/libdb/java/src/com/sleepycat/db/DbErrcall.java b/libdb/java/src/com/sleepycat/db/DbErrcall.java new file mode 100644 index 000000000..440914202 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbErrcall.java @@ -0,0 +1,23 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public interface DbErrcall +{ + // methods + // + public abstract void errcall(String prefix, String buffer); +} + +// end of DbErrcall.java diff --git a/libdb/java/src/com/sleepycat/db/DbException.java b/libdb/java/src/com/sleepycat/db/DbException.java new file mode 100644 index 000000000..58d39c763 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbException.java @@ -0,0 +1,56 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbException extends Exception +{ + // methods + // + + public DbException(String s) + { + super(s); + } + + public DbException(String s, int errno) + { + super(s); + this.errno_ = errno; + } + + public String toString() + { + String s = super.toString(); + if (errno_ == 0) + return s; + else + return s + ": " + DbEnv.strerror(errno_); + + } + + // get/set methods + // + + public int get_errno() + { + return errno_; + } + + // private data + // + + private int errno_ = 0; +} + +// end of DbException.java diff --git a/libdb/java/src/com/sleepycat/db/DbFeedback.java b/libdb/java/src/com/sleepycat/db/DbFeedback.java new file mode 100644 index 000000000..54909ba7b --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbFeedback.java @@ -0,0 +1,23 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public interface DbFeedback +{ + // methods + // + public abstract void feedback(Db db, int opcode, int pct); +} + +// end of DbFeedback.java diff --git a/libdb/java/src/com/sleepycat/db/DbHash.java b/libdb/java/src/com/sleepycat/db/DbHash.java new file mode 100644 index 000000000..e911a2095 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbHash.java @@ -0,0 +1,21 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2000-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This interface is used by DbEnv.set_bt_compare() + * + */ +public interface DbHash +{ + public abstract int hash(Db db, byte[] data, int len); +} + +// end of DbHash.java diff --git a/libdb/java/src/com/sleepycat/db/DbHashStat.java b/libdb/java/src/com/sleepycat/db/DbHashStat.java new file mode 100644 index 000000000..97de6127a --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbHashStat.java @@ -0,0 +1,24 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbHashStat +{ + public int hash_magic; + public int hash_version; + public int hash_metaflags; + public int hash_nkeys; + public int hash_ndata; + public int hash_pagesize; + public int hash_ffactor; + public int hash_buckets; + public int hash_free; + public int hash_bfree; + public int hash_bigpages; + public int hash_big_bfree; + public int hash_overflows; + public int hash_ovfl_free; + public int hash_dup; + public int hash_dup_free; +} +// end of DbHashStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbKeyRange.java b/libdb/java/src/com/sleepycat/db/DbKeyRange.java new file mode 100644 index 000000000..c85c6ee03 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbKeyRange.java @@ -0,0 +1,23 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbKeyRange +{ + public double less; + public double equal; + public double greater; +} + +// end of DbKeyRange.java diff --git a/libdb/java/src/com/sleepycat/db/DbLock.java b/libdb/java/src/com/sleepycat/db/DbLock.java new file mode 100644 index 000000000..0c14c0018 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLock.java @@ -0,0 +1,33 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbLock +{ + protected native void finalize() + throws Throwable; + + // get/set methods + // + + // private data + // + private long private_dbobj_ = 0; + + static { + Db.load_db(); + } +} + +// end of DbLock.java diff --git a/libdb/java/src/com/sleepycat/db/DbLockNotGrantedException.java b/libdb/java/src/com/sleepycat/db/DbLockNotGrantedException.java new file mode 100644 index 000000000..5142becb0 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLockNotGrantedException.java @@ -0,0 +1,57 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +public class DbLockNotGrantedException extends DbException { + public DbLockNotGrantedException(String message, + int op, int mode, Dbt obj, + DbLock lock, int index) + { + super(message, Db.DB_LOCK_NOTGRANTED); + this.op = op; + this.mode = mode; + this.obj = obj; + this.lock = lock; + this.index = index; + } + + public int get_op() + { + return op; + } + + public int get_mode() + { + return mode; + } + + public Dbt get_obj() + { + return obj; + } + + public DbLock get_lock() + { + return lock; + } + + public int get_index() + { + return index; + } + + private int op; + private int mode; + private Dbt obj; + private DbLock lock; + private int index; + +} + diff --git a/libdb/java/src/com/sleepycat/db/DbLockRequest.java b/libdb/java/src/com/sleepycat/db/DbLockRequest.java new file mode 100644 index 000000000..d9eb49c0f --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLockRequest.java @@ -0,0 +1,67 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +public class DbLockRequest +{ + public DbLockRequest(int op, int mode, Dbt obj, DbLock lock) + { + this.op = op; + this.mode = mode; + this.obj = obj; + this.lock = lock; + } + + public int get_op() + { + return op; + } + + public void set_op(int op) + { + this.op = op; + } + + public int get_mode() + { + return mode; + } + + public void set_mode(int mode) + { + this.mode = mode; + } + + public Dbt get_obj() + { + return obj; + } + + public void set_obj(Dbt obj) + { + this.obj = obj; + } + + public DbLock get_lock() + { + return lock; + } + + public void set_lock(DbLock lock) + { + this.lock = lock; + } + + private /* db_lockop_t */ int op; + private /* db_lockmode_t */ int mode; + private /* db_timeout_t */ int timeout; + private Dbt obj; + private DbLock lock; +} diff --git a/libdb/java/src/com/sleepycat/db/DbLockStat.java b/libdb/java/src/com/sleepycat/db/DbLockStat.java new file mode 100644 index 000000000..f0903f061 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLockStat.java @@ -0,0 +1,32 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbLockStat +{ + public int st_id; + public int st_cur_maxid; + public int st_maxlocks; + public int st_maxlockers; + public int st_maxobjects; + public int st_nmodes; + public int st_nlocks; + public int st_maxnlocks; + public int st_nlockers; + public int st_maxnlockers; + public int st_nobjects; + public int st_maxnobjects; + public int st_nconflicts; + public int st_nrequests; + public int st_nreleases; + public int st_nnowaits; + public int st_ndeadlocks; + public int st_locktimeout; + public int st_nlocktimeouts; + public int st_txntimeout; + public int st_ntxntimeouts; + public int st_region_wait; + public int st_region_nowait; + public int st_regsize; +} +// end of DbLockStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbLogStat.java b/libdb/java/src/com/sleepycat/db/DbLogStat.java new file mode 100644 index 000000000..19e5be25c --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLogStat.java @@ -0,0 +1,29 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbLogStat +{ + public int st_magic; + public int st_version; + public int st_mode; + public int st_lg_bsize; + public int st_lg_size; + public int st_w_bytes; + public int st_w_mbytes; + public int st_wc_bytes; + public int st_wc_mbytes; + public int st_wcount; + public int st_wcount_fill; + public int st_scount; + public int st_region_wait; + public int st_region_nowait; + public int st_cur_file; + public int st_cur_offset; + public int st_disk_file; + public int st_disk_offset; + public int st_regsize; + public int st_maxcommitperflush; + public int st_mincommitperflush; +} +// end of DbLogStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbLogc.java b/libdb/java/src/com/sleepycat/db/DbLogc.java new file mode 100644 index 000000000..f9d0e4f67 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLogc.java @@ -0,0 +1,39 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbLogc +{ + // methods + // + public native void close(int flags) + throws DbException; + + // returns: 0, DB_NOTFOUND, or throws error + public native int get(DbLsn lsn, Dbt data, int flags) + throws DbException; + + protected native void finalize() + throws Throwable; + + // private data + // + private long private_dbobj_ = 0; + + static { + Db.load_db(); + } +} + +// end of DbLogc.java diff --git a/libdb/java/src/com/sleepycat/db/DbLsn.java b/libdb/java/src/com/sleepycat/db/DbLsn.java new file mode 100644 index 000000000..eeec1dc1f --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbLsn.java @@ -0,0 +1,42 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbLsn +{ + // methods + // + public DbLsn() + { + init_lsn(); + } + + protected native void finalize() + throws Throwable; + + private native void init_lsn(); + + // get/set methods + // + + // private data + // + private long private_dbobj_ = 0; + + static { + Db.load_db(); + } +} + +// end of DbLsn.java diff --git a/libdb/java/src/com/sleepycat/db/DbMemoryException.java b/libdb/java/src/com/sleepycat/db/DbMemoryException.java new file mode 100644 index 000000000..a99667818 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMemoryException.java @@ -0,0 +1,49 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1999-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +public class DbMemoryException extends DbException +{ + // methods + // + + public DbMemoryException(String s) + { + super(s); + } + + public DbMemoryException(String s, int errno) + { + super(s, errno); + } + + public void set_dbt(Dbt dbt) + { + this.dbt = dbt; + } + + public Dbt get_dbt() + { + return dbt; + } + + /* Override of DbException.toString(): + * the extra verbage that comes from DbEnv.strerror(ENOMEM) + * is not helpful. + */ + public String toString() + { + return getMessage(); + } + + Dbt dbt = null; +} + +// end of DbMemoryException.java diff --git a/libdb/java/src/com/sleepycat/db/DbMpoolFStat.java b/libdb/java/src/com/sleepycat/db/DbMpoolFStat.java new file mode 100644 index 000000000..cc03b568f --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMpoolFStat.java @@ -0,0 +1,16 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbMpoolFStat +{ + public String file_name; + public int st_pagesize; + public int st_map; + public int st_cache_hit; + public int st_cache_miss; + public int st_page_create; + public int st_page_in; + public int st_page_out; +} +// end of DbMpoolFStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbMpoolStat.java b/libdb/java/src/com/sleepycat/db/DbMpoolStat.java new file mode 100644 index 000000000..03fc2d186 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMpoolStat.java @@ -0,0 +1,38 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This is filled in and returned by the + * DbMpool.stat() method. + */ +public class DbMpoolStat +{ + public int st_cache_hit; // Pages found in the cache. + public int st_cache_miss; // Pages not found in the cache. + public int st_map; // Pages from mapped files. + public int st_page_create; // Pages created in the cache. + public int st_page_in; // Pages read in. + public int st_page_out; // Pages written out. + public int st_ro_evict; // Clean pages forced from the cache. + public int st_rw_evict; // Dirty pages forced from the cache. + public int st_hash_buckets; // Number of hash buckets. + public int st_hash_searches; // Total hash chain searches. + public int st_hash_longest; // Longest hash chain searched. + public int st_hash_examined; // Total hash entries searched. + public int st_page_clean; // Clean pages. + public int st_page_dirty; // Dirty pages. + public int st_page_trickle; // Pages written by memp_trickle. + public int st_region_wait; // Region lock granted after wait. + public int st_region_nowait; // Region lock granted without wait. + public int st_regsize; // Region size. +} + +// end of DbMpoolStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbMultipleDataIterator.java b/libdb/java/src/com/sleepycat/db/DbMultipleDataIterator.java new file mode 100644 index 000000000..cbfbe9164 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMultipleDataIterator.java @@ -0,0 +1,46 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2001-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author David M. Krinsky + */ +public class DbMultipleDataIterator extends DbMultipleIterator +{ + // public methods + public DbMultipleDataIterator(Dbt data) + { + super(data); + } + + public boolean next(Dbt data) + { + int dataoff = DbUtil.array2int(buf, pos); + + // crack out the data offset and length. + if (dataoff < 0) { + return (false); + } + + pos -= int32sz; + int datasz = DbUtil.array2int(buf, pos); + + pos -= int32sz; + + data.set_data(buf); + data.set_size(datasz); + data.set_offset(dataoff); + + return (true); + } +} + +// end of DbMultipleDataIterator.java diff --git a/libdb/java/src/com/sleepycat/db/DbMultipleIterator.java b/libdb/java/src/com/sleepycat/db/DbMultipleIterator.java new file mode 100644 index 000000000..c81ecf9d7 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMultipleIterator.java @@ -0,0 +1,51 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2001-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author David M. Krinsky + */ +// DbMultipleIterator is a shared package-private base class for the three +// types of bulk-return Iterator; it should never be instantiated directly, +// but it handles the functionality shared by its subclasses. +class DbMultipleIterator +{ + // Package-private methods and members: used by our subclasses. + + // Called implicitly by the subclass + DbMultipleIterator(Dbt data) + { + buf = data.get_data(); + size = data.get_ulen(); + // The offset will always be zero from the front of the buffer + // DB returns, and the buffer is opaque, so don't bother + // handling an offset. + + // The initial position is pointing at the last u_int32_t + // in the buffer. + pos = size - int32sz; + } + + // The C macros use sizeof(u_int32_t). Fortunately, java ints + // are always four bytes. Make this a constant just for form's sake. + static final int int32sz = 4; + + // Current position within the buffer; equivalent to "pointer" + // in the DB_MULTIPLE macros. + int pos; + + // A reference to the encoded buffer returned from the original + // Db/Dbc.get call on the data Dbt, and its size. + byte[] buf; + int size; +} + +// end of DbMultipleIterator.java diff --git a/libdb/java/src/com/sleepycat/db/DbMultipleKeyDataIterator.java b/libdb/java/src/com/sleepycat/db/DbMultipleKeyDataIterator.java new file mode 100644 index 000000000..3085c114e --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMultipleKeyDataIterator.java @@ -0,0 +1,56 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2001-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author David M. Krinsky + */ +public class DbMultipleKeyDataIterator extends DbMultipleIterator +{ + // public methods + public DbMultipleKeyDataIterator(Dbt data) + { + super(data); + } + + public boolean next(Dbt key, Dbt data) + { + int keyoff = DbUtil.array2int(buf, pos); + + // crack out the key and data offsets and lengths. + if (keyoff < 0) { + return (false); + } + + pos -= int32sz; + int keysz = DbUtil.array2int(buf, pos); + + pos -= int32sz; + int dataoff = DbUtil.array2int(buf, pos); + + pos -= int32sz; + int datasz = DbUtil.array2int(buf, pos); + + pos -= int32sz; + + key.set_data(buf); + key.set_size(keysz); + key.set_offset(keyoff); + + data.set_data(buf); + data.set_size(datasz); + data.set_offset(dataoff); + + return (true); + } +} + +// end of DbMultipleKeyDataIterator.java diff --git a/libdb/java/src/com/sleepycat/db/DbMultipleRecnoDataIterator.java b/libdb/java/src/com/sleepycat/db/DbMultipleRecnoDataIterator.java new file mode 100644 index 000000000..761166401 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbMultipleRecnoDataIterator.java @@ -0,0 +1,51 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2001-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author David M. Krinsky + */ +public class DbMultipleRecnoDataIterator extends DbMultipleIterator +{ + // public methods + public DbMultipleRecnoDataIterator(Dbt data) + { + super(data); + } + + public boolean next(Dbt key, Dbt data) + { + int keyoff = DbUtil.array2int(buf, pos); + + // crack out the key offset and the data offset and length. + if (keyoff < 0) { + return (false); + } + + pos -= int32sz; + int dataoff = DbUtil.array2int(buf, pos); + + pos -= int32sz; + int datasz = DbUtil.array2int(buf, pos); + + pos -= int32sz; + + key.set_recno_key_from_buffer(buf, keyoff); + + data.set_data(buf); + data.set_size(datasz); + data.set_offset(dataoff); + + return (true); + } +} + +// end of DbMultipleRecnoDataIterator.java diff --git a/libdb/java/src/com/sleepycat/db/DbOutputStreamErrcall.java b/libdb/java/src/com/sleepycat/db/DbOutputStreamErrcall.java new file mode 100644 index 000000000..b2a472e90 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbOutputStreamErrcall.java @@ -0,0 +1,58 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; +import java.io.OutputStream; +import java.io.IOException; + +/** + * + * @author Donald D. Anderson + * + * This class is not public, as it is only used internally + * by Db to implement a default error handler. + */ + +/*package*/ class DbOutputStreamErrcall implements DbErrcall +{ + DbOutputStreamErrcall(OutputStream stream) + { + this.stream_ = stream; + } + + // errcall implements DbErrcall + // + public void errcall(String prefix, String buffer) + { + try { + if (prefix != null) { + stream_.write(prefix.getBytes()); + stream_.write((new String(": ")).getBytes()); + } + stream_.write(buffer.getBytes()); + stream_.write((new String("\n")).getBytes()); + } + catch (IOException e) { + + // well, we tried. + // Do our best to report the problem by other means. + // + System.err.println("DbOutputStreamErrcall Exception: " + e); + if (prefix != null) + System.err.print(prefix + ": "); + System.err.println(buffer + "\n"); + } + } + + // private data + // + private OutputStream stream_; +} + +// end of DbOutputStreamErrcall.java diff --git a/libdb/java/src/com/sleepycat/db/DbPreplist.java b/libdb/java/src/com/sleepycat/db/DbPreplist.java new file mode 100644 index 000000000..477d248c7 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbPreplist.java @@ -0,0 +1,22 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1999-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This is filled in and returned by the + * DbEnv.txn_recover() method. + */ +public class DbPreplist +{ + public DbTxn txn; + public byte gid[]; +} + +// end of DbPreplist.java diff --git a/libdb/java/src/com/sleepycat/db/DbQueueStat.java b/libdb/java/src/com/sleepycat/db/DbQueueStat.java new file mode 100644 index 000000000..67d229ab8 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbQueueStat.java @@ -0,0 +1,21 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbQueueStat +{ + public int qs_magic; + public int qs_version; + public int qs_metaflags; + public int qs_nkeys; + public int qs_ndata; + public int qs_pagesize; + public int qs_extentsize; + public int qs_pages; + public int qs_re_len; + public int qs_re_pad; + public int qs_pgfree; + public int qs_first_recno; + public int qs_cur_recno; +} +// end of DbQueueStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbRepStat.java b/libdb/java/src/com/sleepycat/db/DbRepStat.java new file mode 100644 index 000000000..953d10edd --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbRepStat.java @@ -0,0 +1,43 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbRepStat +{ + public int st_status; + public DbLsn st_next_lsn; + public DbLsn st_waiting_lsn; + public int st_dupmasters; + public int st_env_id; + public int st_env_priority; + public int st_gen; + public int st_log_duplicated; + public int st_log_queued; + public int st_log_queued_max; + public int st_log_queued_total; + public int st_log_records; + public int st_log_requested; + public int st_master; + public int st_master_changes; + public int st_msgs_badgen; + public int st_msgs_processed; + public int st_msgs_recover; + public int st_msgs_send_failures; + public int st_msgs_sent; + public int st_newsites; + public int st_nsites; + public int st_nthrottles; + public int st_outdated; + public int st_txns_applied; + public int st_elections; + public int st_elections_won; + public int st_election_cur_winner; + public int st_election_gen; + public DbLsn st_election_lsn; + public int st_election_nsites; + public int st_election_priority; + public int st_election_status; + public int st_election_tiebreaker; + public int st_election_votes; +} +// end of DbRepStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbRepTransport.java b/libdb/java/src/com/sleepycat/db/DbRepTransport.java new file mode 100644 index 000000000..d2c71c03c --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbRepTransport.java @@ -0,0 +1,19 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2001-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This is used as a callback by DbEnv.set_rep_transport. + */ +public interface DbRepTransport +{ + public int send(DbEnv env, Dbt control, Dbt rec, int flags, int envid) + throws DbException; +} diff --git a/libdb/java/src/com/sleepycat/db/DbRunRecoveryException.java b/libdb/java/src/com/sleepycat/db/DbRunRecoveryException.java new file mode 100644 index 000000000..76e9a6399 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbRunRecoveryException.java @@ -0,0 +1,32 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbRunRecoveryException extends DbException +{ + // methods + // + + public DbRunRecoveryException(String s) + { + super(s); + } + + public DbRunRecoveryException(String s, int errno) + { + super(s, errno); + } +} + +// end of DbRunRecoveryException.java diff --git a/libdb/java/src/com/sleepycat/db/DbSecondaryKeyCreate.java b/libdb/java/src/com/sleepycat/db/DbSecondaryKeyCreate.java new file mode 100644 index 000000000..f8b817965 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbSecondaryKeyCreate.java @@ -0,0 +1,22 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1999-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/* + * This is used as a callback by Db.associate. + */ +public interface DbSecondaryKeyCreate +{ + public int secondary_key_create(Db secondary, Dbt key, + Dbt data, Dbt result) + throws DbException; +} + +// end of DbSecondaryKeyCreate.java diff --git a/libdb/java/src/com/sleepycat/db/DbTxn.java b/libdb/java/src/com/sleepycat/db/DbTxn.java new file mode 100644 index 000000000..01db938f1 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbTxn.java @@ -0,0 +1,77 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class DbTxn +{ + // methods + // + public native void abort() + throws DbException; + + public native void commit(int flags) + throws DbException; + + public native void discard(int flags) + throws DbException; + + public native /*u_int32_t*/ int id() + throws DbException; + + public native void prepare(byte[] gid) + throws DbException; + + public native void set_timeout(/*db_timeout_t*/ long timeout, + /*u_int32_t*/ int flags) + throws DbException; + + // We override Object.equals because it is possible for + // the Java API to create multiple DbTxns that reference + // the same underlying object. This can happen for example + // during DbEnv.txn_recover(). + // + public boolean equals(Object obj) + { + if (this == obj) + return true; + + if (obj != null && (obj instanceof DbTxn)) { + DbTxn that = (DbTxn)obj; + return (this.private_dbobj_ == that.private_dbobj_); + } + return false; + } + + // We must override Object.hashCode whenever we override + // Object.equals() to enforce the maxim that equal objects + // have the same hashcode. + // + public int hashCode() + { + return ((int)private_dbobj_ ^ (int)(private_dbobj_ >> 32)); + } + + // get/set methods + // + + // private data + // + private long private_dbobj_ = 0; + + static { + Db.load_db(); + } +} + +// end of DbTxn.java diff --git a/libdb/java/src/com/sleepycat/db/DbTxnStat.java b/libdb/java/src/com/sleepycat/db/DbTxnStat.java new file mode 100644 index 000000000..78794aea5 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbTxnStat.java @@ -0,0 +1,27 @@ +/* DO NOT EDIT: automatically built by dist/s_java. */ + +package com.sleepycat.db; + +public class DbTxnStat +{ + public static class Active { + public int txnid; + public int parentid; + public DbLsn lsn; + }; + public DbLsn st_last_ckp; + public long st_time_ckp; + public int st_last_txnid; + public int st_maxtxns; + public int st_naborts; + public int st_nbegins; + public int st_ncommits; + public int st_nactive; + public int st_nrestores; + public int st_maxnactive; + public Active st_txnarray[]; + public int st_region_wait; + public int st_region_nowait; + public int st_regsize; +} +// end of DbTxnStat.java diff --git a/libdb/java/src/com/sleepycat/db/DbUtil.java b/libdb/java/src/com/sleepycat/db/DbUtil.java new file mode 100644 index 000000000..86af711b4 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/DbUtil.java @@ -0,0 +1,98 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2001-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author David M. Krinsky + */ + +// DbUtil is a simple, package-private wrapper class that holds a few +// static utility functions other parts of the package share and that don't +// have a good home elsewhere. (For now, that's limited to byte-array-to-int +// conversion and back.) + +class DbUtil +{ + // Get the u_int32_t stored beginning at offset "offset" into + // array "arr". We have to do the conversion manually since it's + // a C-native int, and we're not really supposed to make this kind of + // cast in Java. + static int array2int(byte[] arr, int offset) + { + int b1, b2, b3, b4; + int pos = offset; + + // Get the component bytes; b4 is most significant, b1 least. + if (big_endian) { + b4 = arr[pos++]; + b3 = arr[pos++]; + b2 = arr[pos++]; + b1 = arr[pos]; + } else { + b1 = arr[pos++]; + b2 = arr[pos++]; + b3 = arr[pos++]; + b4 = arr[pos]; + } + + // Bytes are signed. Convert [-128, -1] to [128, 255]. + if (b1 < 0) { b1 += 256; } + if (b2 < 0) { b2 += 256; } + if (b3 < 0) { b3 += 256; } + if (b4 < 0) { b4 += 256; } + + // Put the bytes in their proper places in an int. + b2 <<= 8; + b3 <<= 16; + b4 <<= 24; + + // Return their sum. + return (b1 + b2 + b3 + b4); + } + + // Store the specified u_int32_t, with endianness appropriate + // to the platform we're running on, into four consecutive bytes of + // the specified byte array, starting from the specified offset. + static void int2array(int n, byte[] arr, int offset) + { + int b1, b2, b3, b4; + int pos = offset; + + b1 = n & 0xff; + b2 = (n >> 8) & 0xff; + b3 = (n >> 16) & 0xff; + b4 = (n >> 24) & 0xff; + + // Bytes are signed. Convert [128, 255] to [-128, -1]. + if (b1 >= 128) { b1 -= 256; } + if (b2 >= 128) { b2 -= 256; } + if (b3 >= 128) { b3 -= 256; } + if (b4 >= 128) { b4 -= 256; } + + // Put the bytes in the appropriate place in the array. + if (big_endian) { + arr[pos++] = (byte)b4; + arr[pos++] = (byte)b3; + arr[pos++] = (byte)b2; + arr[pos] = (byte)b1; + } else { + arr[pos++] = (byte)b1; + arr[pos++] = (byte)b2; + arr[pos++] = (byte)b3; + arr[pos] = (byte)b4; + } + } + + private static final boolean big_endian = is_big_endian(); + private static native boolean is_big_endian(); +} + +// end of DbUtil.java diff --git a/libdb/java/src/com/sleepycat/db/Dbc.java b/libdb/java/src/com/sleepycat/db/Dbc.java new file mode 100644 index 000000000..6d3e207c8 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/Dbc.java @@ -0,0 +1,60 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +/** + * + * @author Donald D. Anderson + */ +public class Dbc +{ + // methods + // + public native void close() + throws DbException; + + public native int count(int flags) + throws DbException; + + // returns: 0, DB_KEYEMPTY, or throws error + public native int del(int flags) + throws DbException; + + public native Dbc dup(int flags) + throws DbException; + + // returns: 0, DB_NOTFOUND, or throws error + public native int get(Dbt key, Dbt data, int flags) + throws DbException; + + // returns: 0, DB_NOTFOUND, or throws error + public native int pget(Dbt key, Dbt pkey, Dbt data, int flags) + throws DbException; + + // returns: 0, DB_KEYEXIST, or throws error + public native int put(Dbt key, Dbt data, int flags) + throws DbException; + + protected native void finalize() + throws Throwable; + + // get/set methods + // + + // private data + // + private long private_dbobj_ = 0; + + static { + Db.load_db(); + } +} + +// end of Dbc.java diff --git a/libdb/java/src/com/sleepycat/db/Dbt.java b/libdb/java/src/com/sleepycat/db/Dbt.java new file mode 100644 index 000000000..ed4fac11c --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/Dbt.java @@ -0,0 +1,230 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +/** + * + * @author Donald D. Anderson + */ +public class Dbt +{ + // methods + // + + public Dbt(byte[] data) + { + init(); + this.data = data; + if (data != null) { + this.size = data.length; + } + } + + public Dbt(byte[] data, int off, int len) + { + init(); + this.data = data; + this.offset = off; + this.size = len; + } + + public Dbt() + { + init(); + } + + public Dbt(Object serialobj) throws java.io.IOException + { + init(); + this.set_object(serialobj); + } + + protected native void finalize() + throws Throwable; + + // get/set methods + // + + // key/data + public byte[] get_data() + { + // In certain circumstances, like callbacks to + // user code that have Dbt args, we do not create + // data arrays until the user explicitly does a get_data. + // This saves us from needlessly creating objects + // (potentially large arrays) that may never be accessed. + // + if (must_create_data) { + data = create_data(); + must_create_data = false; + } + return data; + } + + public void set_data(byte[] data) + { + this.data = data; + this.must_create_data = false; + } + + + // get_offset/set_offset is unique to the Java portion + // of the DB APIs. They can be used to get/set the offset + // into the attached byte array. + // + public int get_offset() + { + return offset; + } + + public void set_offset(int offset) + { + this.offset = offset; + } + + // key/data length + public /*u_int32_t*/ int get_size() + { + return size; + } + + public void set_size(/*u_int32_t*/ int size) + { + this.size = size; + } + + // RO: length of user buffer. + public /*u_int32_t*/ int get_ulen() + { + return ulen; + } + + public void set_ulen(/*u_int32_t*/ int ulen) + { + this.ulen = ulen; + } + + + // RO: get/put record length. + public /*u_int32_t*/ int get_dlen() + { + return dlen; + } + + public void set_dlen(/*u_int32_t*/ int dlen) + { + this.dlen = dlen; + } + + // RO: get/put record offset. + public /*u_int32_t*/ int get_doff() + { + return doff; + } + + public void set_doff(/*u_int32_t*/ int doff) + { + this.doff = doff; + } + + // flags + public /*u_int32_t*/ int get_flags() + { + return flags; + } + + public void set_flags(/*u_int32_t*/ int flags) + { + this.flags = flags; + } + + // Helper methods to get/set a Dbt from a serializable object. + public Object get_object() throws java.io.IOException, + java.lang.ClassNotFoundException + { + ByteArrayInputStream bytestream = new ByteArrayInputStream(get_data()); + ObjectInputStream ois = new ObjectInputStream(bytestream); + Object serialobj = ois.readObject(); + ois.close(); + bytestream.close(); + return (serialobj); + } + + public void set_object(Object serialobj) throws java.io.IOException + { + ByteArrayOutputStream bytestream = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(bytestream); + oos.writeObject(serialobj); + oos.close(); + byte[] buf = bytestream.toByteArray(); + bytestream.close(); + set_data(buf); + set_offset(0); + set_size(buf.length); + } + + // These are not in the original DB interface. + // They can be used to set the recno key for a Dbt. + // Note: if data is less than (offset + 4) bytes, these + // methods may throw an ArrayIndexException. get_recno_key_data() + // will additionally throw a NullPointerException if data is null. + public void set_recno_key_data(int recno) + { + if (data == null) { + data = new byte[4]; + size = 4; + offset = 0; + } + DbUtil.int2array(recno, data, offset); + } + + public int get_recno_key_data() + { + return (DbUtil.array2int(data, offset)); + } + + // Used internally by DbMultipleRecnoIterator + // + /*package*/ void set_recno_key_from_buffer(byte[] data, int offset) + { + this.data = data; + this.offset = offset; + this.size = 4; + } + + static { + Db.load_db(); + } + + // private methods + // + private native void init(); + private native byte[] create_data(); + + // private data + // + private long private_dbobj_ = 0; + + private byte[] data = null; + private int offset = 0; + private int size = 0; + private int ulen = 0; + private int dlen = 0; + private int doff = 0; + private int flags = 0; + private boolean must_create_data = false; +} + +// end of Dbt.java diff --git a/libdb/java/src/com/sleepycat/db/xa/DbXAResource.java b/libdb/java/src/com/sleepycat/db/xa/DbXAResource.java new file mode 100644 index 000000000..26bbdb5a4 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/xa/DbXAResource.java @@ -0,0 +1,190 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db.xa; + +import com.sleepycat.db.Db; +import com.sleepycat.db.DbEnv; +import com.sleepycat.db.DbTxn; +import javax.transaction.xa.XAResource; +import javax.transaction.xa.XAException; +import javax.transaction.xa.Xid; + +public class DbXAResource implements XAResource +{ + public DbXAResource(String home, int rmid, int flags) + throws XAException + { + this.home = home; + this.rmid = rmid; + + // We force single-threading for calls to _init/_close. + // This makes our internal code much easier, and + // should not be a performance burden. + synchronized (DbXAResource.class) { + _init(home, rmid, flags); + } + } + + // + // Alternate constructor for convenience. + // Uses an rmid that is unique within this JVM, + // numbered started at 0. + // + public DbXAResource(String home) + throws XAException + { + this(home, get_unique_rmid(), 0); + } + + private native void _init(String home, int rmid, int flags); + + public void close(int flags) + throws XAException + { + // We force single-threading for calls to _init/_close. + // This makes our internal code much easier, and + // should not be a performance burden. + synchronized (DbXAResource.class) { + _close(home, rmid, flags); + } + } + + private native void _close(String home, int rmid, int flags); + + public void commit(Xid xid, boolean onePhase) + throws XAException + { + _commit(xid, rmid, onePhase); + } + + private native void _commit(Xid xid, int rmid, boolean onePhase); + + public void end(Xid xid, int flags) + throws XAException + { + _end(xid, rmid, flags); + } + + private native void _end(Xid xid, int rmid, int flags); + + public void forget(Xid xid) + throws XAException + { + _forget(xid, rmid); + } + + private native void _forget(Xid xid, int rmid); + + public int getTransactionTimeout() + throws XAException + { + return transactionTimeout; + } + + public boolean isSameRM(XAResource xares) + throws XAException + { + if (!(xares instanceof DbXAResource)) + return false; + return (this.rmid == ((DbXAResource)xares).rmid); + } + + public int prepare(Xid xid) + throws XAException + { + return _prepare(xid, rmid); + } + + private native int _prepare(Xid xid, int rmid); + + public Xid [] recover(int flag) + throws XAException + { + return _recover(rmid, flag); + } + + private native Xid[] _recover(int rmid, int flags); + + public void rollback(Xid xid) + throws XAException + { + _rollback(xid, rmid); + System.err.println("DbXAResource.rollback returned"); + } + + private native void _rollback(Xid xid, int rmid); + + public boolean setTransactionTimeout(int seconds) + throws XAException + { + // XXX we are not using the transaction timeout. + transactionTimeout = seconds; + return true; + } + + public void start(Xid xid, int flags) + throws XAException + { + _start(xid, rmid, flags); + } + + private native void _start(Xid xid, int rmid, int flags); + + private static synchronized int get_unique_rmid() + { + return unique_rmid++; + } + + public interface DbAttach + { + public DbEnv get_env(); + public DbTxn get_txn(); + } + + protected static class DbAttachImpl implements DbAttach + { + private DbEnv env; + private DbTxn txn; + + DbAttachImpl(DbEnv env, DbTxn txn) + { + this.env = env; + this.txn = txn; + } + + public DbTxn get_txn() + { + return txn; + } + + public DbEnv get_env() + { + return env; + } + } + + public static native DbAttach xa_attach(Xid xid, Integer rmid); + + //////////////////////////////////////////////////////////////// + // + // private data + // + private long private_dbobj_ = 0; + private int transactionTimeout = 0; + private String home; + private int rmid; + + private static int unique_rmid = 0; + + static + { + Db.load_db(); + } +} diff --git a/libdb/java/src/com/sleepycat/db/xa/DbXid.java b/libdb/java/src/com/sleepycat/db/xa/DbXid.java new file mode 100644 index 000000000..64a246941 --- /dev/null +++ b/libdb/java/src/com/sleepycat/db/xa/DbXid.java @@ -0,0 +1,49 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.db.xa; + +import com.sleepycat.db.DbException; +import com.sleepycat.db.DbTxn; +import javax.transaction.xa.XAException; +import javax.transaction.xa.Xid; + +public class DbXid implements Xid +{ + public DbXid(int formatId, byte[] gtrid, byte[] bqual) + throws XAException + { + this.formatId = formatId; + this.gtrid = gtrid; + this.bqual = bqual; + } + + public int getFormatId() + { + return formatId; + } + + public byte[] getGlobalTransactionId() + { + return gtrid; + } + + public byte[] getBranchQualifier() + { + return bqual; + } + + //////////////////////////////////////////////////////////////// + // + // private data + // + private byte[] gtrid; + private byte[] bqual; + private int formatId; +} diff --git a/libdb/java/src/com/sleepycat/examples/AccessExample.java b/libdb/java/src/com/sleepycat/examples/AccessExample.java new file mode 100644 index 000000000..858cb4d33 --- /dev/null +++ b/libdb/java/src/com/sleepycat/examples/AccessExample.java @@ -0,0 +1,181 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.examples; + +import com.sleepycat.db.*; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.PrintStream; + +class AccessExample +{ + private static final String FileName = "access.db"; + + public AccessExample() + { + } + + public static void main(String argv[]) + { + try + { + AccessExample app = new AccessExample(); + app.run(); + } + catch (DbException dbe) + { + System.err.println("AccessExample: " + dbe.toString()); + System.exit(1); + } + catch (FileNotFoundException fnfe) + { + System.err.println("AccessExample: " + fnfe.toString()); + System.exit(1); + } + System.exit(0); + } + + // Prompts for a line, and keeps prompting until a non blank + // line is returned. Returns null on error. + // + static public String askForLine(InputStreamReader reader, + PrintStream out, String prompt) + { + String result = ""; + while (result != null && result.length() == 0) { + out.print(prompt); + out.flush(); + result = getLine(reader); + } + return result; + } + + // Not terribly efficient, but does the job. + // Works for reading a line from stdin or a file. + // Returns null on EOF. If EOF appears in the middle + // of a line, returns that line, then null on next call. + // + static public String getLine(InputStreamReader reader) + { + StringBuffer b = new StringBuffer(); + int c; + try { + while ((c = reader.read()) != -1 && c != '\n') { + if (c != '\r') + b.append((char)c); + } + } + catch (IOException ioe) { + c = -1; + } + + if (c == -1 && b.length() == 0) + return null; + else + return b.toString(); + } + + public void run() + throws DbException, FileNotFoundException + { + // Remove the previous database. + new File(FileName).delete(); + + // Create the database object. + // There is no environment for this simple example. + Db table = new Db(null, 0); + table.set_error_stream(System.err); + table.set_errpfx("AccessExample"); + table.open(null, FileName, null, Db.DB_BTREE, Db.DB_CREATE, 0644); + + // + // Insert records into the database, where the key is the user + // input and the data is the user input in reverse order. + // + InputStreamReader reader = new InputStreamReader(System.in); + + for (;;) { + String line = askForLine(reader, System.out, "input> "); + if (line == null) + break; + + String reversed = (new StringBuffer(line)).reverse().toString(); + + // See definition of StringDbt below + // + StringDbt key = new StringDbt(line); + StringDbt data = new StringDbt(reversed); + + try + { + int err; + if ((err = table.put(null, + key, data, Db.DB_NOOVERWRITE)) == Db.DB_KEYEXIST) { + System.out.println("Key " + line + " already exists."); + } + } + catch (DbException dbe) + { + System.out.println(dbe.toString()); + } + System.out.println(""); + } + + // Acquire an iterator for the table. + Dbc iterator; + iterator = table.cursor(null, 0); + + // Walk through the table, printing the key/data pairs. + // See class StringDbt defined below. + // + StringDbt key = new StringDbt(); + StringDbt data = new StringDbt(); + while (iterator.get(key, data, Db.DB_NEXT) == 0) + { + System.out.println(key.getString() + " : " + data.getString()); + } + iterator.close(); + table.close(0); + } + + // Here's an example of how you can extend a Dbt in a straightforward + // way to allow easy storage/retrieval of strings, or whatever + // kind of data you wish. We've declared it as a static inner + // class, but it need not be. + // + static /*inner*/ + class StringDbt extends Dbt + { + StringDbt() + { + set_flags(Db.DB_DBT_MALLOC); // tell Db to allocate on retrieval + } + + StringDbt(String value) + { + setString(value); + set_flags(Db.DB_DBT_MALLOC); // tell Db to allocate on retrieval + } + + void setString(String value) + { + byte[] data = value.getBytes(); + set_data(data); + set_size(data.length); + } + + String getString() + { + return new String(get_data(), 0, get_size()); + } + } +} diff --git a/libdb/java/src/com/sleepycat/examples/BtRecExample.java b/libdb/java/src/com/sleepycat/examples/BtRecExample.java new file mode 100644 index 000000000..74938b1fd --- /dev/null +++ b/libdb/java/src/com/sleepycat/examples/BtRecExample.java @@ -0,0 +1,340 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.examples; + +import com.sleepycat.db.*; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.PrintStream; + +public class BtRecExample +{ + static final String progname = "BtRecExample"; // Program name. + static final String database = "access.db"; + static final String wordlist = "../test/wordlist"; + + BtRecExample(BufferedReader reader) + throws DbException, IOException, FileNotFoundException + { + int ret; + + // Remove the previous database. + File f = new File(database); + f.delete(); + + dbp = new Db(null, 0); + + dbp.set_error_stream(System.err); + dbp.set_errpfx(progname); + dbp.set_pagesize(1024); // 1K page sizes. + + dbp.set_flags(Db.DB_RECNUM); // Record numbers. + dbp.open(null, database, null, Db.DB_BTREE, Db.DB_CREATE, 0664); + + // + // Insert records into the database, where the key is the word + // preceded by its record number, and the data is the same, but + // in reverse order. + // + + for (int cnt = 1; cnt <= 1000; ++cnt) { + String numstr = String.valueOf(cnt); + while (numstr.length() < 4) + numstr = "0" + numstr; + String buf = numstr + '_' + reader.readLine(); + StringBuffer rbuf = new StringBuffer(buf).reverse(); + + StringDbt key = new StringDbt(buf); + StringDbt data = new StringDbt(rbuf.toString()); + + if ((ret = dbp.put(null, key, data, Db.DB_NOOVERWRITE)) != 0) { + if (ret != Db.DB_KEYEXIST) + throw new DbException("Db.put failed" + ret); + } + } + } + + void run() + throws DbException + { + int recno; + int ret; + + // Acquire a cursor for the database. + dbcp = dbp.cursor(null, 0); + + // + // Prompt the user for a record number, then retrieve and display + // that record. + // + InputStreamReader reader = new InputStreamReader(System.in); + + for (;;) { + // Get a record number. + String line = askForLine(reader, System.out, "recno #> "); + if (line == null) + break; + + try { + recno = Integer.parseInt(line); + } + catch (NumberFormatException nfe) { + System.err.println("Bad record number: " + nfe); + continue; + } + + // + // Start with a fresh key each time, the dbp.get() routine returns + // the key and data pair, not just the key! + // + RecnoStringDbt key = new RecnoStringDbt(recno, 100); + RecnoStringDbt data = new RecnoStringDbt(100); + + if ((ret = dbcp.get(key, data, Db.DB_SET_RECNO)) != 0) { + throw new DbException("Dbc.get failed", ret); + } + + // Display the key and data. + show("k/d\t", key, data); + + // Move the cursor a record forward. + if ((ret = dbcp.get(key, data, Db.DB_NEXT)) != 0) { + throw new DbException("Dbc.get failed", ret); + } + + // Display the key and data. + show("next\t", key, data); + + RecnoStringDbt datano = new RecnoStringDbt(100); + + // + // Retrieve the record number for the following record into + // local memory. + // + if ((ret = dbcp.get(key, datano, Db.DB_GET_RECNO)) != 0) { + if (ret != Db.DB_NOTFOUND && ret != Db.DB_KEYEMPTY) { + throw new DbException("Dbc.get failed", ret); + } + } + else { + recno = datano.getRecno(); + System.out.println("retrieved recno: " + recno); + } + } + + dbcp.close(); + dbcp = null; + } + + // + // Print out the number of records in the database. + // + void stats() + throws DbException + { + DbBtreeStat statp; + + statp = (DbBtreeStat)dbp.stat(0); + System.out.println(progname + ": database contains " + + statp.bt_ndata + " records"); + } + + void show(String msg, RecnoStringDbt key, RecnoStringDbt data) + throws DbException + { + System.out.println(msg + key.getString() + ": " + data.getString()); + } + + public void shutdown() + throws DbException + { + if (dbcp != null) { + dbcp.close(); + dbcp = null; + } + if (dbp != null) { + dbp.close(0); + dbp = null; + } + } + + public static void main(String argv[]) + { + + try { + // Open the word database. + FileReader freader = new FileReader(wordlist); + + BtRecExample app = new BtRecExample(new BufferedReader(freader)); + + // Close the word database. + freader.close(); + freader = null; + + app.stats(); + app.run(); + } catch (FileNotFoundException fnfe) { + System.err.println(progname + ": unexpected open error " + fnfe); + System.exit (1); + } catch (IOException ioe) { + System.err.println(progname + ": open " + wordlist + ": " + ioe); + System.exit (1); + } catch (DbException dbe) { + System.err.println("Exception: " + dbe); + System.exit(dbe.get_errno()); + } + + System.exit(0); + } + + // Prompts for a line, and keeps prompting until a non blank + // line is returned. Returns null on error. + // + static public String askForLine(InputStreamReader reader, + PrintStream out, String prompt) + { + String result = ""; + while (result != null && result.length() == 0) { + out.print(prompt); + out.flush(); + result = getLine(reader); + } + return result; + } + + // Not terribly efficient, but does the job. + // Works for reading a line from stdin or a file. + // Returns null on EOF. If EOF appears in the middle + // of a line, returns that line, then null on next call. + // + static public String getLine(InputStreamReader reader) + { + StringBuffer b = new StringBuffer(); + int c; + try { + while ((c = reader.read()) != -1 && c != '\n') { + if (c != '\r') + b.append((char)c); + } + } + catch (IOException ioe) { + c = -1; + } + + if (c == -1 && b.length() == 0) + return null; + else + return b.toString(); + } + + private Dbc dbcp; + private Db dbp; + + // Here's an example of how you can extend a Dbt in a straightforward + // way to allow easy storage/retrieval of strings. + // We've declared it as a static inner class, but it need not be. + // + static /*inner*/ + class StringDbt extends Dbt + { + StringDbt(byte[] arr) + { + set_flags(Db.DB_DBT_USERMEM); + set_data(arr); + set_size(arr.length); + } + + StringDbt() + { + set_flags(Db.DB_DBT_MALLOC); // tell Db to allocate on retrieval + } + + StringDbt(String value) + { + setString(value); + set_flags(Db.DB_DBT_MALLOC); // tell Db to allocate on retrieval + } + + void setString(String value) + { + byte[] data = value.getBytes(); + set_data(data); + set_size(data.length); + // must set ulen because sometimes a string is returned + set_ulen(data.length); + } + + String getString() + { + return new String(get_data(), 0, get_size()); + } + } + + // Here's an example of how you can extend a Dbt to store + // (potentially) both recno's and strings in the same + // structure. + // + static /*inner*/ + class RecnoStringDbt extends Dbt + { + RecnoStringDbt(int maxsize) + { + this(0, maxsize); // let other constructor do most of the work + } + + RecnoStringDbt(int value, int maxsize) + { + set_flags(Db.DB_DBT_USERMEM); // do not allocate on retrieval + arr = new byte[maxsize]; + set_data(arr); // use our local array for data + set_ulen(maxsize); // size of return storage + setRecno(value); + } + + RecnoStringDbt(String value, int maxsize) + { + set_flags(Db.DB_DBT_USERMEM); // do not allocate on retrieval + arr = new byte[maxsize]; + set_data(arr); // use our local array for data + set_ulen(maxsize); // size of return storage + setString(value); + } + + void setRecno(int value) + { + set_recno_key_data(value); + set_size(arr.length); + } + + void setString(String value) + { + byte[] data = value.getBytes(); + set_data(data); + set_size(data.length); + } + + int getRecno() + { + return get_recno_key_data(); + } + + String getString() + { + return new String(get_data(), 0, get_size()); + } + + byte arr[]; + } +} diff --git a/libdb/java/src/com/sleepycat/examples/BulkAccessExample.java b/libdb/java/src/com/sleepycat/examples/BulkAccessExample.java new file mode 100644 index 000000000..8d2254b96 --- /dev/null +++ b/libdb/java/src/com/sleepycat/examples/BulkAccessExample.java @@ -0,0 +1,198 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.examples; + +import com.sleepycat.db.*; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.PrintStream; + +class BulkAccessExample +{ + private static final String FileName = "access.db"; + + public BulkAccessExample() + { + } + + public static void main(String argv[]) + { + try + { + BulkAccessExample app = new BulkAccessExample(); + app.run(); + } + catch (DbException dbe) + { + System.err.println("BulkAccessExample: " + dbe.toString()); + System.exit(1); + } + catch (FileNotFoundException fnfe) + { + System.err.println("BulkAccessExample: " + fnfe.toString()); + System.exit(1); + } + System.exit(0); + } + + // Prompts for a line, and keeps prompting until a non blank + // line is returned. Returns null on error. + // + static public String askForLine(InputStreamReader reader, + PrintStream out, String prompt) + { + String result = ""; + while (result != null && result.length() == 0) { + out.print(prompt); + out.flush(); + result = getLine(reader); + } + return result; + } + + // Not terribly efficient, but does the job. + // Works for reading a line from stdin or a file. + // Returns null on EOF. If EOF appears in the middle + // of a line, returns that line, then null on next call. + // + static public String getLine(InputStreamReader reader) + { + StringBuffer b = new StringBuffer(); + int c; + try { + while ((c = reader.read()) != -1 && c != '\n') { + if (c != '\r') + b.append((char)c); + } + } + catch (IOException ioe) { + c = -1; + } + + if (c == -1 && b.length() == 0) + return null; + else + return b.toString(); + } + + public void run() + throws DbException, FileNotFoundException + { + // Remove the previous database. + new File(FileName).delete(); + + // Create the database object. + // There is no environment for this simple example. + Db table = new Db(null, 0); + table.set_error_stream(System.err); + table.set_errpfx("BulkAccessExample"); + table.open(null, FileName, null, Db.DB_BTREE, Db.DB_CREATE, 0644); + + // + // Insert records into the database, where the key is the user + // input and the data is the user input in reverse order. + // + InputStreamReader reader = new InputStreamReader(System.in); + + for (;;) { + String line = askForLine(reader, System.out, "input> "); + if (line == null) + break; + + String reversed = (new StringBuffer(line)).reverse().toString(); + + // See definition of StringDbt below + // + StringDbt key = new StringDbt(line); + StringDbt data = new StringDbt(reversed); + + try + { + int err; + if ((err = table.put(null, + key, data, Db.DB_NOOVERWRITE)) == Db.DB_KEYEXIST) { + System.out.println("Key " + line + " already exists."); + } + } + catch (DbException dbe) + { + System.out.println(dbe.toString()); + } + System.out.println(""); + } + + // Acquire a cursor for the table and two Dbts. + Dbc dbc = table.cursor(null, 0); + Dbt foo = new Dbt(); + foo.set_flags(Db.DB_DBT_MALLOC); + + Dbt bulk_data = new Dbt(); + + // Set Db.DB_DBT_USERMEM on the data Dbt; Db.DB_MULTIPLE_KEY requires + // it. Then allocate a byte array of a reasonable size; we'll + // go through the database in chunks this big. + bulk_data.set_flags(Db.DB_DBT_USERMEM); + bulk_data.set_data(new byte[1000000]); + bulk_data.set_ulen(1000000); + + + // Walk through the table, printing the key/data pairs. + // + while (dbc.get(foo, bulk_data, Db.DB_NEXT | Db.DB_MULTIPLE_KEY) == 0) + { + DbMultipleKeyDataIterator iterator; + iterator = new DbMultipleKeyDataIterator(bulk_data); + + StringDbt key, data; + key = new StringDbt(); + data = new StringDbt(); + + while (iterator.next(key, data)) { + System.out.println(key.getString() + " : " + data.getString()); + } + } + dbc.close(); + table.close(0); + } + + // Here's an example of how you can extend a Dbt in a straightforward + // way to allow easy storage/retrieval of strings, or whatever + // kind of data you wish. We've declared it as a static inner + // class, but it need not be. + // + static /*inner*/ + class StringDbt extends Dbt + { + StringDbt() + { + set_flags(Db.DB_DBT_MALLOC); // tell Db to allocate on retrieval + } + + StringDbt(String value) + { + setString(value); + set_flags(Db.DB_DBT_MALLOC); // tell Db to allocate on retrieval + } + + void setString(String value) + { + byte[] data = value.getBytes(); + set_data(data); + set_size(data.length); + } + + String getString() + { + return new String(get_data(), get_offset(), get_size()); + } + } +} diff --git a/libdb/java/src/com/sleepycat/examples/EnvExample.java b/libdb/java/src/com/sleepycat/examples/EnvExample.java new file mode 100644 index 000000000..e7ead010c --- /dev/null +++ b/libdb/java/src/com/sleepycat/examples/EnvExample.java @@ -0,0 +1,128 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.examples; + +import com.sleepycat.db.*; +import java.io.FileNotFoundException; +import java.io.OutputStream; + +/* + * An example of a program using DbEnv to configure its DB + * environment. + * + * For comparison purposes, this example uses a similar structure + * as examples/ex_env.c and examples_cxx/EnvExample.cpp. + */ +public class EnvExample +{ + private static final String progname = "EnvExample"; + private static final String DATABASE_HOME = "/tmp/database"; + + private static void db_application() + throws DbException + { + // Do something interesting... + // Your application goes here. + } + + private static void db_setup(String home, String data_dir, + OutputStream errs) + throws DbException, FileNotFoundException + { + // + // Create an environment object and initialize it for error + // reporting. + // + DbEnv dbenv = new DbEnv(0); + dbenv.set_error_stream(errs); + dbenv.set_errpfx(progname); + + // + // We want to specify the shared memory buffer pool cachesize, + // but everything else is the default. + // + dbenv.set_cachesize(0, 64 * 1024, 0); + + // Databases are in a subdirectory. + dbenv.set_data_dir(data_dir); + + // Open the environment with full transactional support. + // + // open() will throw a DbException if there is an error. + // + // open is declared to throw a FileNotFoundException, which normally + // shouldn't occur with the DB_CREATE option. + // + dbenv.open(DATABASE_HOME, + Db.DB_CREATE | Db.DB_INIT_LOCK | Db.DB_INIT_LOG | + Db.DB_INIT_MPOOL | Db.DB_INIT_TXN, 0); + + try { + + // Start your application. + db_application(); + + } + finally { + + // Close the environment. Doing this in the + // finally block ensures it is done, even if + // an error is thrown. + // + dbenv.close(0); + } + } + + private static void db_teardown(String home, String data_dir, + OutputStream errs) + throws DbException, FileNotFoundException + { + // Remove the shared database regions. + + DbEnv dbenv = new DbEnv(0); + + dbenv.set_error_stream(errs); + dbenv.set_errpfx(progname); + dbenv.set_data_dir(data_dir); + dbenv.remove(home, 0); + } + + public static void main(String[] args) + { + // + // All of the shared database files live in /tmp/database, + // but data files live in /database. + // + // Using Berkeley DB in C/C++, we need to allocate two elements + // in the array and set config[1] to NULL. This is not + // necessary in Java. + // + String home = DATABASE_HOME; + String config = "/database/files"; + + try { + System.out.println("Setup env"); + db_setup(home, config, System.err); + + System.out.println("Teardown env"); + db_teardown(home, config, System.err); + } + catch (DbException dbe) { + System.err.println(progname + ": environment open: " + dbe.toString()); + System.exit (1); + } + catch (FileNotFoundException fnfe) { + System.err.println(progname + + ": unexpected open environment error " + fnfe); + System.exit (1); + } + } + +} diff --git a/libdb/java/src/com/sleepycat/examples/LockExample.java b/libdb/java/src/com/sleepycat/examples/LockExample.java new file mode 100644 index 000000000..181da86ea --- /dev/null +++ b/libdb/java/src/com/sleepycat/examples/LockExample.java @@ -0,0 +1,235 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.examples; + +import com.sleepycat.db.*; +import java.io.FileNotFoundException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.PrintStream; +import java.util.Vector; + +// +// An example of a program using DbLock and related classes. +// +class LockExample extends DbEnv +{ + private static final String progname = "LockExample"; + private static final String LOCK_HOME = "TESTDIR"; + + public LockExample(String home, int maxlocks, boolean do_unlink) + throws DbException, FileNotFoundException + { + super(0); + if (do_unlink) { + remove(home, Db.DB_FORCE); + } + else { + set_error_stream(System.err); + set_errpfx("LockExample"); + if (maxlocks != 0) + set_lk_max_locks(maxlocks); + open(home, Db.DB_CREATE|Db.DB_INIT_LOCK, 0); + } + } + + // Prompts for a line, and keeps prompting until a non blank + // line is returned. Returns null on error. + // + static public String askForLine(InputStreamReader reader, + PrintStream out, String prompt) + { + String result = ""; + while (result != null && result.length() == 0) { + out.print(prompt); + out.flush(); + result = getLine(reader); + } + return result; + } + + // Not terribly efficient, but does the job. + // Works for reading a line from stdin or a file. + // Returns null on EOF. If EOF appears in the middle + // of a line, returns that line, then null on next call. + // + static public String getLine(InputStreamReader reader) + { + StringBuffer b = new StringBuffer(); + int c; + try { + while ((c = reader.read()) != -1 && c != '\n') { + if (c != '\r') + b.append((char)c); + } + } + catch (IOException ioe) { + c = -1; + } + + if (c == -1 && b.length() == 0) + return null; + else + return b.toString(); + } + + public void run() + throws DbException + { + long held; + int len = 0, locker; + int ret; + boolean did_get = false; + int lockid = 0; + InputStreamReader in = new InputStreamReader(System.in); + Vector locks = new Vector(); + + // + // Accept lock requests. + // + locker = lock_id(); + for (held = 0;;) { + String opbuf = askForLine(in, System.out, + "Operation get/release [get]> "); + if (opbuf == null) + break; + + try { + if (opbuf.equals("get")) { + // Acquire a lock. + String objbuf = askForLine(in, System.out, + "input object (text string) to lock> "); + if (objbuf == null) + break; + + String lockbuf; + do { + lockbuf = askForLine(in, System.out, + "lock type read/write [read]> "); + if (lockbuf == null) + break; + len = lockbuf.length(); + } while (len >= 1 && + !lockbuf.equals("read") && + !lockbuf.equals("write")); + + int lock_type; + if (len <= 1 || lockbuf.equals("read")) + lock_type = Db.DB_LOCK_READ; + else + lock_type = Db.DB_LOCK_WRITE; + + Dbt dbt = new Dbt(objbuf.getBytes()); + + DbLock lock; + did_get = true; + lock = lock_get(locker, Db.DB_LOCK_NOWAIT, + dbt, lock_type); + lockid = locks.size(); + locks.addElement(lock); + } else { + // Release a lock. + String objbuf; + objbuf = askForLine(in, System.out, + "input lock to release> "); + if (objbuf == null) + break; + + lockid = Integer.parseInt(objbuf, 16); + if (lockid < 0 || lockid >= locks.size()) { + System.out.println("Lock #" + lockid + " out of range"); + continue; + } + did_get = false; + DbLock lock = (DbLock)locks.elementAt(lockid); + lock_put(lock); + } + System.out.println("Lock #" + lockid + " " + + (did_get ? "granted" : "released")); + held += did_get ? 1 : -1; + } + catch (DbException dbe) { + switch (dbe.get_errno()) { + case Db.DB_LOCK_NOTGRANTED: + System.out.println("Lock not granted"); + break; + case Db.DB_LOCK_DEADLOCK: + System.err.println("LockExample: lock_" + + (did_get ? "get" : "put") + + ": returned DEADLOCK"); + break; + default: + System.err.println("LockExample: lock_get: " + dbe.toString()); + } + } + } + System.out.println(); + System.out.println("Closing lock region " + String.valueOf(held) + + " locks held"); + } + + private static void usage() + { + System.err.println("usage: LockExample [-u] [-h home] [-m maxlocks]"); + System.exit(1); + } + + public static void main(String argv[]) + { + String home = LOCK_HOME; + boolean do_unlink = false; + int maxlocks = 0; + + for (int i = 0; i < argv.length; ++i) { + if (argv[i].equals("-h")) { + if (++i >= argv.length) + usage(); + home = argv[i]; + } + else if (argv[i].equals("-m")) { + if (++i >= argv.length) + usage(); + + try { + maxlocks = Integer.parseInt(argv[i]); + } + catch (NumberFormatException nfe) { + usage(); + } + } + else if (argv[i].equals("-u")) { + do_unlink = true; + } + else { + usage(); + } + } + + try { + if (do_unlink) { + // Create an environment that immediately + // removes all files. + LockExample tmp = new LockExample(home, maxlocks, do_unlink); + } + + LockExample app = new LockExample(home, maxlocks, do_unlink); + app.run(); + app.close(0); + } + catch (DbException dbe) { + System.err.println(progname + ": " + dbe.toString()); + } + catch (Throwable t) { + System.err.println(progname + ": " + t.toString()); + } + System.out.println("LockExample completed"); + } +} diff --git a/libdb/java/src/com/sleepycat/examples/TpcbExample.java b/libdb/java/src/com/sleepycat/examples/TpcbExample.java new file mode 100644 index 000000000..a7b785b95 --- /dev/null +++ b/libdb/java/src/com/sleepycat/examples/TpcbExample.java @@ -0,0 +1,843 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1997-2002 + * Sleepycat Software. All rights reserved. + * + * $Id$ + */ + +package com.sleepycat.examples; + +import com.sleepycat.db.*; +import java.io.FileNotFoundException; +import java.util.Calendar; +import java.util.Date; +import java.util.Random; +import java.util.GregorianCalendar; +import java.math.BigDecimal; + +// +// This program implements a basic TPC/B driver program. To create the +// TPC/B database, run with the -i (init) flag. The number of records +// with which to populate the account, history, branch, and teller tables +// is specified by the a, s, b, and t flags respectively. To run a TPC/B +// test, use the n flag to indicate a number of transactions to run (note +// that you can run many of these processes in parallel to simulate a +// multiuser test run). +// +class TpcbExample extends DbEnv +{ + public static final int TELLERS_PER_BRANCH = 10; + public static final int ACCOUNTS_PER_TELLER = 10000; + public static final int HISTORY_PER_BRANCH = 2592000; + + // + // The default configuration that adheres to TPCB scaling rules requires + // nearly 3 GB of space. To avoid requiring that much space for testing, + // we set the parameters much lower. If you want to run a valid 10 TPS + // configuration, uncomment the VALID_SCALING configuration + // + + // VALID_SCALING configuration + /* + public static final int ACCOUNTS = 1000000; + public static final int BRANCHES = 10; + public static final int TELLERS = 100; + public static final int HISTORY = 25920000; + */ + + // TINY configuration + /* + public static final int ACCOUNTS = 1000; + public static final int BRANCHES = 10; + public static final int TELLERS = 100; + public static final int HISTORY = 10000; + */ + + // Default configuration + public static final int ACCOUNTS = 100000; + public static final int BRANCHES = 10; + public static final int TELLERS = 100; + public static final int HISTORY = 259200; + + public static final int HISTORY_LEN = 100; + public static final int RECLEN = 100; + public static final int BEGID = 1000000; + + // used by random_id() + public static final int ACCOUNT = 0; + public static final int BRANCH = 1; + public static final int TELLER = 2; + + private static boolean verbose = false; + private static final String progname = "TpcbExample"; // Program name. + + public TpcbExample(String home, int cachesize, + boolean initializing, int flags) + throws DbException, FileNotFoundException + { + super(0); + set_error_stream(System.err); + set_errpfx(progname); + set_cachesize(0, cachesize == 0 ? 4 * 1024 * 1024 : cachesize, 0); + + if ((flags & (Db.DB_TXN_NOSYNC)) != 0) + set_flags(Db.DB_TXN_NOSYNC, true); + flags &= ~(Db.DB_TXN_NOSYNC); + + int local_flags = flags | Db.DB_CREATE; + if (initializing) + local_flags |= Db.DB_INIT_MPOOL; + else + local_flags |= Db.DB_INIT_TXN | Db.DB_INIT_LOCK | + Db.DB_INIT_LOG | Db.DB_INIT_MPOOL; + + open(home, local_flags, 0); // may throw DbException + } + + // + // Initialize the database to the specified number of accounts, branches, + // history records, and tellers. + // + // Note: num_h was unused in the original ex_tpcb.c example. + // + public void + populate(int num_a, int num_b, int num_h, int num_t) + { + Db dbp = null; + + int err; + int balance, idnum; + int end_anum, end_bnum, end_tnum; + int start_anum, start_bnum, start_tnum; + int h_nelem; + + idnum = BEGID; + balance = 500000; + + h_nelem = num_a; + + try { + dbp = new Db(this, 0); + dbp.set_h_nelem(h_nelem); + dbp.open(null, "account", null, Db.DB_HASH, + Db.DB_CREATE | Db.DB_TRUNCATE, 0644); + } + // can be DbException or FileNotFoundException + catch (Exception e1) { + errExit(e1, "Open of account file failed"); + } + + start_anum = idnum; + populateTable(dbp, idnum, balance, h_nelem, "account"); + idnum += h_nelem; + end_anum = idnum - 1; + try { + dbp.close(0); + } + catch (DbException e2) { + errExit(e2, "Account file close failed"); + } + + if (verbose) + System.out.println("Populated accounts: " + + String.valueOf(start_anum) + " - " + String.valueOf(end_anum)); + + // + // Since the number of branches is very small, we want to use very + // small pages and only 1 key per page. This is the poor-man's way + // of getting key locking instead of page locking. + // + h_nelem = (int)num_b; + + try { + dbp = new Db(this, 0); + + dbp.set_h_nelem(h_nelem); + dbp.set_h_ffactor(1); + dbp.set_pagesize(512); + + dbp.open(null, "branch", null, Db.DB_HASH, + Db.DB_CREATE | Db.DB_TRUNCATE, 0644); + } + // can be DbException or FileNotFoundException + catch (Exception e3) { + errExit(e3, "Branch file create failed"); + } + start_bnum = idnum; + populateTable(dbp, idnum, balance, h_nelem, "branch"); + idnum += h_nelem; + end_bnum = idnum - 1; + + try { + dbp.close(0); + } + catch (DbException dbe4) { + errExit(dbe4, "Close of branch file failed"); + } + + if (verbose) + System.out.println("Populated branches: " + + String.valueOf(start_bnum) + " - " + String.valueOf(end_bnum)); + + // + // In the case of tellers, we also want small pages, but we'll let + // the fill factor dynamically adjust itself. + // + h_nelem = (int)num_t; + + try { + + dbp = new Db(this, 0); + + dbp.set_h_nelem(h_nelem); + dbp.set_h_ffactor(0); + dbp.set_pagesize(512); + + dbp.open(null, "teller", null, Db.DB_HASH, + Db.DB_CREATE | Db.DB_TRUNCATE, 0644); + } + // can be DbException or FileNotFoundException + catch (Exception e5) { + errExit(e5, "Teller file create failed"); + } + + start_tnum = idnum; + populateTable(dbp, idnum, balance, h_nelem, "teller"); + idnum += h_nelem; + end_tnum = idnum - 1; + + try { + dbp.close(0); + } + catch (DbException e6) { + errExit(e6, "Close of teller file failed"); + } + + if (verbose) + System.out.println("Populated tellers: " + + String.valueOf(start_tnum) + " - " + String.valueOf(end_tnum)); + + try { + dbp = new Db(this, 0); + dbp.set_re_len(HISTORY_LEN); + dbp.open(null, "history", null, Db.DB_RECNO, + Db.DB_CREATE | Db.DB_TRUNCATE, 0644); + } + // can be DbException or FileNotFoundException + catch (Exception e7) { + errExit(e7, "Create of history file failed"); + } + + populateHistory(dbp, num_h, num_a, num_b, num_t); + + try { + dbp.close(0); + } + catch (DbException e8) { + errExit(e8, "Close of history file failed"); + } + } + + public void + populateTable(Db dbp, + int start_id, int balance, + int nrecs, String msg) + { + Defrec drec = new Defrec(); + + Dbt kdbt = new Dbt(drec.data); + kdbt.set_size(4); // sizeof(int) + Dbt ddbt = new Dbt(drec.data); + ddbt.set_size(drec.data.length); // uses whole array + + try { + for (int i = 0; i < nrecs; i++) { + kdbt.set_recno_key_data(start_id + (int)i); + drec.set_balance(balance); + dbp.put(null, kdbt, ddbt, Db.DB_NOOVERWRITE); + } + } + catch (DbException dbe) { + System.err.println("Failure initializing " + msg + " file: " + + dbe.toString()); + System.exit(1); + } + } + + public void + populateHistory(Db dbp, int nrecs, + int anum, int bnum, int tnum) + { + Histrec hrec = new Histrec(); + hrec.set_amount(10); + + byte arr[] = new byte[4]; // sizeof(int) + int i; + Dbt kdbt = new Dbt(arr); + kdbt.set_size(arr.length); + Dbt ddbt = new Dbt(hrec.data); + ddbt.set_size(hrec.data.length); + + try { + for (i = 1; i <= nrecs; i++) { + kdbt.set_recno_key_data(i); + + hrec.set_aid(random_id(ACCOUNT, anum, bnum, tnum)); + hrec.set_bid(random_id(BRANCH, anum, bnum, tnum)); + hrec.set_tid(random_id(TELLER, anum, bnum, tnum)); + + dbp.put(null, kdbt, ddbt, Db.DB_APPEND); + } + } + catch (DbException dbe) { + errExit(dbe, "Failure initializing history file"); + } + } + + static Random rand = new Random(); + + public static int + random_int(int lo, int hi) + { + int ret; + int t; + + t = rand.nextInt(); + if (t < 0) + t = -t; + ret = (int)(((double)t / ((double)(Integer.MAX_VALUE) + 1)) * + (hi - lo + 1)); + ret += lo; + return (ret); + } + + public static int + random_id(int type, int accounts, int branches, int tellers) + { + int min, max, num; + + max = min = BEGID; + num = accounts; + switch(type) { + case TELLER: + min += branches; + num = tellers; + // Fallthrough + case BRANCH: + if (type == BRANCH) + num = branches; + min += accounts; + // Fallthrough + case ACCOUNT: + max = min + num - 1; + } + return (random_int(min, max)); + } + + public void + run(int n, int accounts, int branches, int tellers) + { + Db adb = null; + Db bdb = null; + Db hdb = null; + Db tdb = null; + double gtps, itps; + int failed, ifailed, ret, txns; + long starttime, curtime, lasttime; + + // + // Open the database files. + // + int err; + try { + adb = new Db(this, 0); + adb.open(null, "account", null, Db.DB_UNKNOWN, + Db.DB_AUTO_COMMIT, 0); + bdb = new Db(this, 0); + bdb.open(null, "branch", null, Db.DB_UNKNOWN, + Db.DB_AUTO_COMMIT, 0); + tdb = new Db(this, 0); + tdb.open(null, "teller", null, Db.DB_UNKNOWN, + Db.DB_AUTO_COMMIT, 0); + hdb = new Db(this, 0); + hdb.open(null, "history", null, Db.DB_UNKNOWN, + Db.DB_AUTO_COMMIT, 0); + } + catch (DbException dbe) { + errExit(dbe, "Open of db files failed"); + } + catch (FileNotFoundException fnfe) { + errExit(fnfe, "Open of db files failed, missing file"); + } + + txns = failed = ifailed = 0; + starttime = (new Date()).getTime(); + lasttime = starttime; + while (n-- > 0) { + txns++; + ret = txn(adb, bdb, tdb, hdb, accounts, branches, tellers); + if (ret != 0) { + failed++; + ifailed++; + } + if (n % 5000 == 0) { + curtime = (new Date()).getTime(); + gtps = (double)(txns - failed) / + ((curtime - starttime) / 1000.0); + itps = (double)(5000 - ifailed) / + ((curtime - lasttime) / 1000.0); + System.out.print(String.valueOf(txns) + " txns " + + String.valueOf(failed) + " failed "); + System.out.println(showRounded(gtps, 2) + " TPS (gross) " + + showRounded(itps, 2) + " TPS (interval)"); + lasttime = curtime; + ifailed = 0; + } + } + + try { + adb.close(0); + bdb.close(0); + tdb.close(0); + hdb.close(0); + } + catch (DbException dbe2) { + errExit(dbe2, "Close of db files failed"); + } + + System.out.println((long)txns + " transactions begun " + + String.valueOf(failed) + " failed"); + + } + + // + // XXX Figure out the appropriate way to pick out IDs. + // + public int + txn(Db adb, Db bdb, Db tdb, Db hdb, + int anum, int bnum, int tnum) + { + Dbc acurs = null; + Dbc bcurs = null; + Dbc hcurs = null; + Dbc tcurs = null; + DbTxn t = null; + + Defrec rec = new Defrec(); + Histrec hrec = new Histrec(); + int account, branch, teller; + + Dbt d_dbt = new Dbt(); + Dbt d_histdbt = new Dbt(); + Dbt k_dbt = new Dbt(); + Dbt k_histdbt = new Dbt(); + + account = random_id(ACCOUNT, anum, bnum, tnum); + branch = random_id(BRANCH, anum, bnum, tnum); + teller = random_id(TELLER, anum, bnum, tnum); + + // The history key will not actually be retrieved, + // but it does need to be set to something. + byte hist_key[] = new byte[4]; + k_histdbt.set_data(hist_key); + k_histdbt.set_size(4 /* == sizeof(int)*/); + + byte key_bytes[] = new byte[4]; + k_dbt.set_data(key_bytes); + k_dbt.set_size(4 /* == sizeof(int)*/); + + d_dbt.set_flags(Db.DB_DBT_USERMEM); + d_dbt.set_data(rec.data); + d_dbt.set_ulen(rec.length()); + + hrec.set_aid(account); + hrec.set_bid(branch); + hrec.set_tid(teller); + hrec.set_amount(10); + // Request 0 bytes since we're just positioning. + d_histdbt.set_flags(Db.DB_DBT_PARTIAL); + + // START TIMING + + try { + t = txn_begin(null, 0); + + acurs = adb.cursor(t, 0); + bcurs = bdb.cursor(t, 0); + tcurs = tdb.cursor(t, 0); + hcurs = hdb.cursor(t, 0); + + // Account record + k_dbt.set_recno_key_data(account); + if (acurs.get(k_dbt, d_dbt, Db.DB_SET) != 0) + throw new TpcbException("acurs get failed"); + rec.set_balance(rec.get_balance() + 10); + acurs.put(k_dbt, d_dbt, Db.DB_CURRENT); + + // Branch record + k_dbt.set_recno_key_data(branch); + if (bcurs.get(k_dbt, d_dbt, Db.DB_SET) != 0) + throw new TpcbException("bcurs get failed"); + rec.set_balance(rec.get_balance() + 10); + bcurs.put(k_dbt, d_dbt, Db.DB_CURRENT); + + // Teller record + k_dbt.set_recno_key_data(teller); + if (tcurs.get(k_dbt, d_dbt, Db.DB_SET) != 0) + throw new TpcbException("ccurs get failed"); + rec.set_balance(rec.get_balance() + 10); + tcurs.put(k_dbt, d_dbt, Db.DB_CURRENT); + + // History record + d_histdbt.set_flags(0); + d_histdbt.set_data(hrec.data); + d_histdbt.set_ulen(hrec.length()); + if (hdb.put(t, k_histdbt, d_histdbt, Db.DB_APPEND) != 0) + throw(new DbException("put failed")); + + acurs.close(); + bcurs.close(); + tcurs.close(); + hcurs.close(); + + // null out t in advance; if the commit fails, + // we don't want to abort it in the catch clause. + DbTxn tmptxn = t; + t = null; + tmptxn.commit(0); + + // END TIMING + return (0); + + } + catch (Exception e) { + try { + if (acurs != null) + acurs.close(); + if (bcurs != null) + bcurs.close(); + if (tcurs != null) + tcurs.close(); + if (hcurs != null) + hcurs.close(); + if (t != null) + t.abort(); + } + catch (DbException dbe) { + // not much we can do here. + } + + if (verbose) { + System.out.println("Transaction A=" + String.valueOf(account) + + " B=" + String.valueOf(branch) + + " T=" + String.valueOf(teller) + " failed"); + System.out.println("Reason: " + e.toString()); + } + return (-1); + } + } + + static void errExit(Exception err, String s) + { + System.err.print(progname + ": "); + if (s != null) { + System.err.print(s + ": "); + } + System.err.println(err.toString()); + System.exit(1); + } + + public static void main(String argv[]) + { + long seed; + int accounts, branches, tellers, history; + boolean iflag, txn_no_sync; + int mpool, ntxns; + String home, endarg; + + home = "TESTDIR"; + accounts = branches = history = tellers = 0; + txn_no_sync = false; + mpool = ntxns = 0; + verbose = false; + iflag = false; + seed = (new GregorianCalendar()).get(Calendar.SECOND); + + for (int i = 0; i < argv.length; ++i) + { + if (argv[i].equals("-a")) { + // Number of account records + if ((accounts = Integer.parseInt(argv[++i])) <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-b")) { + // Number of branch records + if ((branches = Integer.parseInt(argv[++i])) <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-c")) { + // Cachesize in bytes + if ((mpool = Integer.parseInt(argv[++i])) <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-f")) { + // Fast mode: no txn sync. + txn_no_sync = true; + } + else if (argv[i].equals("-h")) { + // DB home. + home = argv[++i]; + } + else if (argv[i].equals("-i")) { + // Initialize the test. + iflag = true; + } + else if (argv[i].equals("-n")) { + // Number of transactions + if ((ntxns = Integer.parseInt(argv[++i])) <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-S")) { + // Random number seed. + seed = Long.parseLong(argv[++i]); + if (seed <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-s")) { + // Number of history records + if ((history = Integer.parseInt(argv[++i])) <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-t")) { + // Number of teller records + if ((tellers = Integer.parseInt(argv[++i])) <= 0) + invarg(argv[i]); + } + else if (argv[i].equals("-v")) { + // Verbose option. + verbose = true; + } + else + { + usage(); + } + } + + rand.setSeed((int)seed); + + TpcbExample app = null; + + // Initialize the database environment. + // Must be done in within a try block. + // + try { + app = new TpcbExample(home, mpool, iflag, + txn_no_sync ? Db.DB_TXN_NOSYNC : 0); + } + catch (Exception e1) { + errExit(e1, "initializing environment failed"); + } + + accounts = accounts == 0 ? ACCOUNTS : accounts; + branches = branches == 0 ? BRANCHES : branches; + tellers = tellers == 0 ? TELLERS : tellers; + history = history == 0 ? HISTORY : history; + + if (verbose) + System.out.println((long)accounts + " Accounts, " + + String.valueOf(branches) + " Branches, " + + String.valueOf(tellers) + " Tellers, " + + String.valueOf(history) + " History"); + + if (iflag) { + if (ntxns != 0) + usage(); + app.populate(accounts, branches, history, tellers); + } + else { + if (ntxns == 0) + usage(); + app.run(ntxns, accounts, branches, tellers); + } + + // Shut down the application. + + try { + app.close(0); + } + catch (DbException dbe2) { + errExit(dbe2, "appexit failed"); + } + + System.exit(0); + } + + private static void invarg(String str) + { + System.err.println("TpcbExample: invalid argument: " + str); + System.exit(1); + } + + private static void usage() + { + System.err.println( + "usage: TpcbExample [-fiv] [-a accounts] [-b branches]\n" + + " [-c cachesize] [-h home] [-n transactions ]\n" + + " [-S seed] [-s history] [-t tellers]"); + System.exit(1); + } + + // round 'd' to 'scale' digits, and return result as string + private String showRounded(double d, int scale) + { + return new BigDecimal(d). + setScale(scale, BigDecimal.ROUND_HALF_DOWN).toString(); + } + + // The byte order is our choice. + // + static long get_int_in_array(byte[] array, int offset) + { + return + ((0xff & array[offset+0]) << 0) | + ((0xff & array[offset+1]) << 8) | + ((0xff & array[offset+2]) << 16) | + ((0xff & array[offset+3]) << 24); + } + + // Note: Value needs to be long to avoid sign extension + static void set_int_in_array(byte[] array, int offset, long value) + { + array[offset+0] = (byte)((value >> 0) & 0x0ff); + array[offset+1] = (byte)((value >> 8) & 0x0ff); + array[offset+2] = (byte)((value >> 16) & 0x0ff); + array[offset+3] = (byte)((value >> 24) & 0x0ff); + } + +}; + +// Simulate the following C struct: +// struct Defrec { +// u_int32_t id; +// u_int32_t balance; +// u_int8_t pad[RECLEN - sizeof(int) - sizeof(int)]; +// }; + +class Defrec +{ + public Defrec() + { + data = new byte[TpcbExample.RECLEN]; + } + + public int length() + { + return TpcbExample.RECLEN; + } + + public long get_id() + { + return TpcbExample.get_int_in_array(data, 0); + } + + public void set_id(long value) + { + TpcbExample.set_int_in_array(data, 0, value); + } + + public long get_balance() + { + return TpcbExample.get_int_in_array(data, 4); + } + + public void set_balance(long value) + { + TpcbExample.set_int_in_array(data, 4, value); + } + + static { + Defrec d = new Defrec(); + d.set_balance(500000); + } + + public byte[] data; +} + +// Simulate the following C struct: +// struct Histrec { +// u_int32_t aid; +// u_int32_t bid; +// u_int32_t tid; +// u_int32_t amount; +// u_int8_t pad[RECLEN - 4 * sizeof(u_int32_t)]; +// }; + +class Histrec +{ + public Histrec() + { + data = new byte[TpcbExample.RECLEN]; + } + + public int length() + { + return TpcbExample.RECLEN; + } + + public long get_aid() + { + return TpcbExample.get_int_in_array(data, 0); + } + + public void set_aid(long value) + { + TpcbExample.set_int_in_array(data, 0, value); + } + + public long get_bid() + { + return TpcbExample.get_int_in_array(data, 4); + } + + public void set_bid(long value) + { + TpcbExample.set_int_in_array(data, 4, value); + } + + public long get_tid() + { + return TpcbExample.get_int_in_array(data, 8); + } + + public void set_tid(long value) + { + TpcbExample.set_int_in_array(data, 8, value); + } + + public long get_amount() + { + return TpcbExample.get_int_in_array(data, 12); + } + + public void set_amount(long value) + { + TpcbExample.set_int_in_array(data, 12, value); + } + + public byte[] data; +} + +class TpcbException extends Exception +{ + TpcbException() + { + super(); + } + + TpcbException(String s) + { + super(s); + } +} |