diff --git a/db/docs/ref/toc-4.3.14.html b/db/docs/ref/toc-4.3.14.html new file mode 100644 index 000000000..08b79f417 --- /dev/null +++ b/db/docs/ref/toc-4.3.14.html @@ -0,0 +1,365 @@ + + + +Berkeley DB Reference Guide (Version: 4.3.14) + + + + + +
+

Berkeley DB Reference Guide, Version 4.3.14

+
+ +
    +
  1. Introduction +
      +
    1. An introduction to data management +
    2. Mapping the terrain: theory and practice +
    3. What is Berkeley DB? +
    4. What Berkeley DB is not +
    5. Do you need Berkeley DB? +
    6. What other services does Berkeley DB provide? +
    7. What does the Berkeley DB distribution include? +
    8. Where does Berkeley DB run? +
    9. Sleepycat Software's Berkeley DB products +
    +
  2. Access Method Configuration +
      +
    1. What are the available access methods? +
    2. Selecting an access method +
    3. Logical record numbers +
    4. General access method configuration +
        +
      1. Selecting a page size +
      2. Selecting a cache size +
      3. Selecting a byte order +
      4. Duplicate data items +
      5. Non-local memory allocation +
      +
    5. Btree access method specific configuration +
        +
      1. Btree comparison +
      2. Btree prefix comparison +
      3. Minimum keys per page +
      4. + Retrieving Btree records by logical record number +
      +
    6. Hash access method specific configuration +
        +
      1. Page fill factor +
      2. Specifying a database hash +
      3. Hash table size +
      +
    7. Queue and Recno access method specific configuration +
        +
      1. Managing record-based databases +
      2. Selecting a Queue extent size +
      3. Flat-text backing files +
      4. Logically renumbering records +
      +
    +
  3. Access Method Operations +
      +
    1. Access method operations +
    2. Database open +
    3. Opening multiple databases in a single file +
    4. Retrieving records +
    5. Storing records +
    6. Deleting records +
    7. Database statistics +
    8. Database truncation +
    9. Database upgrade +
    10. Database verification and salvage +
    11. Flushing the database cache +
    12. Database close +
    13. Secondary indices +
    14. Cursor operations +
        +
      1. Retrieving records with a cursor +
      2. Storing records with a cursor +
      3. Deleting records with a cursor +
      4. Duplicating a cursor +
      5. Equality join +
      6. Data item count +
      7. Cursor close +
      +
    +
  4. Access Method Wrapup +
      +
    1. Data alignment +
    2. Retrieving records in bulk +
    3. Partial record storage and retrieval +
    4. Storing C/C++ structures/objects +
    5. Retrieved key/data permanence for C/C++ +
    6. Error support +
    7. Cursor stability +
    8. Database limits +
    9. Disk space requirements +
    10. Access method tuning +
    11. Access method FAQ +
    +
  5. Java API +
      +
    1. Java configuration +
    2. Compatibility +
    3. Java programming notes +
    4. Java FAQ +
    +
  6. Berkeley DB Architecture +
      +
    1. The big picture +
    2. Programming model +
    3. Programmatic APIs +
    4. Scripting languages +
    5. Supporting utilities +
    +
  7. The Berkeley DB Environment +
      +
    1. Database environment introduction +
    2. Creating a database environment +
    3. Opening databases within the environment +
    4. Error support +
    5. DB_CONFIG configuration file +
    6. File naming +
    7. Shared memory regions +
    8. Security +
    9. Encryption +
    10. Remote filesystems +
    11. Environment FAQ +
    +
  8. Berkeley DB Concurrent Data Store Applications +
      +
    1. Berkeley DB Concurrent Data Store applications +
    2. Architecting Data Store and Concurrent Data Store applications +
    +
  9. Berkeley DB Transactional Data Store Applications +
      +
    1. Berkeley DB Transactional Data Store applications +
    2. Why transactions? +
    3. Terminology +
    4. Architecting Transactional Data Store applications +
    5. Opening the environment +
    6. Opening the databases +
    7. Recoverability and deadlock handling +
    8. Atomicity +
    9. Isolation +
    10. Degrees of isolation +
    11. Transactional cursors +
    12. Nested transactions +
    13. Environment infrastructure +
    14. Deadlock detection +
    15. Checkpoints +
    16. Database and log file archival +
    17. Log file removal +
    18. Recovery procedures +
    19. Hot failover +
    20. Recovery and filesystem operations +
    21. Berkeley DB recoverability +
    22. Transaction tuning +
    23. Transaction throughput +
    24. Transaction FAQ +
    +
  10. Berkeley DB Replication +
      +
    1. Introduction +
    2. Replication environment IDs +
    3. Replication environment priorities +
    4. Building replicated applications +
    5. Building the communications infrastructure +
    6. Connecting to a new site +
    7. Elections +
    8. Transactional guarantees +
    9. Network partitions +
    10. Replication FAQ +
    11. Ex_repquote: a replication example +
    12. Ex_repquote: a TCP/IP based communication infrastructure +
    13. Ex_repquote: putting it all together +
    +
  11. Distributed Transactions +
      +
    1. Introduction +
    2. Building a Global Transaction Manager +
    3. XA Introduction +
    4. Configuring Berkeley DB with the Tuxedo System +
    5. Frequently Asked Questions +
    +
  12. Application Specific Logging and Recovery +
      +
    1. Introduction +
    2. Defining application-specific log records +
    3. Automatically generated functions +
    4. Application configuration +
    +
  13. Programmer Notes +
      +
    1. Signal handling +
    2. Error returns to applications +
    3. Environmental variables +
    4. Multithreaded applications +
    5. Berkeley DB handles +
    6. Name spaces +
    7. Memory-only configurations +
    8. Disk drive caches +
    9. Copying databases +
    10. Compatibility with historic UNIX interfaces +
    11. Run-time configuration +
    12. Programmer notes FAQ +
    +
  14. The Locking Subsystem +
      +
    1. Berkeley DB and locking +
    2. Configuring locking +
    3. Configuring locking: sizing the system +
    4. Standard lock modes +
    5. Deadlock detection +
    6. Deadlock detection using timers +
    7. Deadlock debugging +
    8. Locking granularity +
    9. Locking without transactions +
    10. Locking with transactions: two-phase locking +
    11. Berkeley DB Concurrent Data Store locking conventions +
    12. Berkeley DB Transactional Data Store locking conventions +
    13. Locking and non-Berkeley DB applications +
    +
  15. The Logging Subsystem +
      +
    1. Berkeley DB and logging +
    2. Configuring logging +
    3. Log file limits +
    +
  16. The Memory Pool Subsystem +
      +
    1. Berkeley DB and the memory pool +
    2. Configuring the memory pool +
    +
  17. The Transaction Subsystem +
      +
    1. Berkeley DB and transactions +
    2. Configuring transactions +
    3. Transaction limits +
    +
  18. Sequences +
      +
    1. Sequences +
    +
  19. RPC Client/Server +
      +
    1. Introduction +
    2. Client program +
    3. Server program +
    4. RPC FAQ +
    +
  20. Tcl API +
      +
    1. Loading Berkeley DB with Tcl +
    2. Using Berkeley DB with Tcl +
    3. Tcl API programming notes +
    4. Tcl error handling +
    5. Tcl FAQ +
    +
  21. Berkeley DB Extensions +
      +
    1. Using Berkeley DB with Apache +
    2. Using Berkeley DB with Perl +
    3. Using Berkeley DB with PHP +
    +
  22. Dumping and Reloading Databases +
      +
    1. The db_dump and db_load utilities +
    2. Dump output formats +
    3. Loading text into databases +
    +
  23. System Installation Notes +
      +
    1. File utility /etc/magic information +
    2. Building with multiple versions of Berkeley DB +
    +
  24. Debugging Applications +
      +
    1. Introduction +
    2. Compile-time configuration +
    3. Run-time error information +
    4. Reviewing Berkeley DB log files +
    5. Troubleshooting common Berkeley DB problems +
    +
  25. Building Berkeley DB for UNIX/POSIX systems +
      +
    1. Building for UNIX +
    2. Configuring Berkeley DB +
    3. Building a small memory footprint library +
    4. Changing compile or load options +
    5. Installing Berkeley DB +
    6. Dynamic shared libraries +
    7. Running the test suite under UNIX +
    8. Architecture independent FAQ +
    9. Architecture specific FAQs:
      + AIX, + FreeBSD, + HP-UX, + IRIX, + Linux, + OSF/1, + QNX, + SCO, + Solaris, + SunOS, + Ultrix +
    +
  26. Building Berkeley DB for Win32 systems +
      +
    1. Building for Win32 +
    2. Unicode support +
    3. Building a small memory footprint library +
    4. Running the test suite under Windows +
    5. Windows notes +
    6. Windows FAQ +
    +
  27. Building Berkeley DB for VxWorks systems +
      +
    1. Building for VxWorks 5.4 +
    2. VxWorks notes +
    3. VxWorks FAQ +
    +
  28. Upgrading Berkeley DB Applications +
      +
    1. Library version information +
    2. + Upgrading Berkeley DB installations +
    3. + Upgrading Berkeley DB 1.XX applications to Berkeley DB 2.0 +
    4. + Upgrading Berkeley DB 2.X.X applications to Berkeley DB 3.0 +
    5. + Upgrading Berkeley DB 3.0.X applications to Berkeley DB 3.1 +
    6. + Upgrading Berkeley DB 3.1.X applications to Berkeley DB 3.2 +
    7. + Upgrading Berkeley DB 3.2.X applications to Berkeley DB 3.3 +
    8. + Upgrading Berkeley DB 3.3.X applications to Berkeley DB 4.0 +
    9. + Upgrading Berkeley DB 4.0.X applications to Berkeley DB 4.1 +
    10. + Upgrading Berkeley DB 4.1.X applications to Berkeley DB 4.2 +
    11. + Upgrading Berkeley DB 4.2.X applications to Berkeley DB 4.3 +
    +
  29. Test Suite +
      +
    1. Running the test suite +
    2. Test suite FAQ +
    +
  30. Distribution +
      +
    1. Porting Berkeley DB to new architectures +
    2. Source code layout +
    +
  31. Additional References +
      +
    1. Additional references +
    +
+ + + diff --git a/db/java/src/com/sleepycat/db/DbMultipleIterator.java b/db/java/src/com/sleepycat/db/DbMultipleIterator.java deleted file mode 100644 index beb820ef9..000000000 --- a/db/java/src/com/sleepycat/db/DbMultipleIterator.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * - - * See the file LICENSE for redistribution information. - * - * Copyright (c) 2001-2003 - * Sleepycat Software. All rights reserved. - * - * $Id: DbMultipleIterator.java,v 1.13 2003/11/28 18:35:45 bostic Exp $ - */ -package com.sleepycat.db; - -/** - * The {@link com.sleepycat.db.DbMultipleIterator 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. - */ - final static 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; -}