Reference Guide Table of Contents
- Introduction
    - An introduction to data management
    
- Mapping the terrain: theory and practice
    
- What is Berkeley DB?
    
- What is Berkeley DB not?
    
- Do you need Berkeley DB?
    
- What other services does Berkeley DB provide?
    
- What does the Berkeley DB distribution include?
    
- Where does Berkeley DB run?
    
- Sleepycat Software's Berkeley DB products
    
- Getting Started: A Simple Tutorial
    - Introduction
    
- Key/data pairs
    
- Object handles
    
- Error returns
    
- Opening a database
    
- Adding elements to a database
    
- Retrieving elements from a database
    
- Removing elements from a database
    
- Closing a database
    
- Access Method Configuration
    - What are the available access methods?
    
- Selecting an access method
    
- Logical record numbers
    
- General access method configuration
	
	- Selecting a page size
	
- Selecting a cache size
	
- Selecting a byte order
	
- Duplicate data items
	
- Non-local memory allocation
	
 
- Btree access method specific configuration
	
	- Btree comparison
	
- Btree prefix comparison
	
- Minimum keys per page
	
- Retrieving Btree records by logical record number
	
 
- Hash access method specific configuration
	
	- Page fill factor
	
- Specifying a database hash
	
- Hash table size
	
 
- Queue and Recno access method specific configuration
	
	- Managing record-based databases
	
- Selecting a Queue extent size
	
- Flat-text backing files
	
- Logically renumbering records
	
 
- Access Method Operations
    - Access method operations
    
- Opening a database
    
- Opening multiple databases in a single file
    
- Upgrading databases
    
- Retrieving records
    
- Storing records
    
- Deleting records
    
- Flushing the database cache
    
- Database statistics
    
- Closing a database
    
- Database cursors
	
	- Retrieving records with a cursor
	
- Storing records with a cursor
	
- Deleting records with a cursor
	
- Duplicating a cursor
	
- Logical join
	
- Data item count
	
- Closing a cursor
	
- Cursor stability
	
 
- Partial record storage and retrieval
    
- Database verification and salvage
    
- Error support
    
- Berkeley DB Architecture
    - The big picture
    
- Programming model
    
- Programmatic APIs
    
- Scripting languages
    
- Supporting utilities
    
- The Berkeley DB Environment
    - Introduction
    
- Creating an environment
    
- File naming
    
- Security
    
- Shared memory regions
    
- Remote filesystems
    
- Opening databases within the environment
    
- Error support
    
- Berkeley DB Concurrent Data Store Applications
    - Building Berkeley DB Concurrent Data Store applications
    
- Berkeley DB Transactional Data Store Applications
    - Building Berkeley DB Transactional Data Store applications
    
- Why transactions?
    
- Terminology
    
- Application structure
    
- Opening the environment
    
- Opening the databases
    
- Recoverability and deadlock avoidance
    
- Atomicity
    
- Repeatable reads
    
- Transactional cursors
    
- Environment infrastructure
    
- Deadlock detection
    
- Checkpoints
    
- Database and log file archival
    
- Log file removal
    
- Recovery procedures
    
- Recovery and filesystem operations
    
- Berkeley DB recoverability
    
- Transaction throughput
    
- XA Resource Manager
    - Introduction
    
- Configuring Berkeley DB with The Tuxedo System
    
- Frequently Asked Questions
    
- Programmer Notes
    - Application signal handling
    
- Error returns to applications
    
- Environmental variables
    
- Building multi-threaded applications
    
- Berkeley DB handles
    
- Name spaces
    
- Copying databases
    
- Library version information
    
- Database limits
    
- Byte ordering
    
- Disk space requirements
    
- Compatibility with historic interfaces
    
- Recovery implementation
    
- Application-specific logging and recovery
    
- Run-time configuration
    
- The Locking Subsystem
    - Berkeley DB and locking
    
- Page locks
	
	- Standard lock modes
	
- Locking without transactions
	
- Locking with transactions: two-phase locking
	
 
- Access method locking conventions
    
- Berkeley DB Concurrent Data Store locking conventions
    
- Deadlocks and deadlock avoidance
    
- Configuring locking
    
- Configuring locking: sizing the system
    
- Locking and non-Berkeley DB applications
    
- The Logging Subsystem
    - Berkeley DB and logging
    
- Configuring logging
    
- Log file limits
    
- The Memory Pool Subsystem
    - Berkeley DB and the memory pool
    
- Configuring the memory pool
    
- The Transaction Subsystem
    - Berkeley DB and transactions
    
- Nested transactions
    
- Transaction limits
    
- Configuring transactions
    
- Transactions and non-Berkeley DB applications
    
- RPC Client/Server
    - Introduction
    
- Client program
    
- Server program
    
- Java API
    - Configuration
    
- Compatibility
    
- Programming notes
    
- Java FAQ
    
- Perl API
    - Using Berkeley DB with Perl
    
- Tcl API
    - Loading Berkeley DB with Tcl
    
- Using Berkeley DB with Tcl
    
- Tcl API programming notes
    
- Tcl error handling
    
- Tcl FAQ
    
- Sendmail
    - Using Berkeley DB with Sendmail
    
- Dumping and Reloading Databases
    - The db_dump and db_load utilities
    
- Dump output formats
    
- Loading text into databases
    
- System Installation Notes
    - File utility /etc/magic information
    
- Debugging Applications
    - Introduction
    
- Compile-time configuration
    
- Run-time error information
    
- Reviewing Berkeley DB log files
    
- Common errors
    
- Building Berkeley DB for UNIX and QNX systems
    - Building for UNIX
    
- Configuring Berkeley DB
    
- Changing compile or load options
    
- Installing Berkeley DB
    
- Dynamic shared libraries
    
- Running the test suite under UNIX
    
- Architecture independent FAQ
    
- Architecture specific FAQs
	
	- AIX
	
- FreeBSD
	
- HP-UX
	
- IRIX
	
- Linux
	
- OSF/1
	
- QNX
	
- SCO
	
- Solaris
	
- SunOS
	
- Ultrix
	
 
- Building Berkeley DB for Win32 platforms
    - Building for Win32
    
- Running the test suite under Windows
    
- Windows notes
    
- Windows FAQ
    
- Building Berkeley DB for VxWorks systems
    - Building for VxWorks
    
- VxWorks notes
    
- VxWorks FAQ
    
- Upgrading Berkeley DB Applications
    - Upgrading Berkeley DB installations
    
- Upgrading Berkeley DB 1.XX applications to Berkeley DB 2.0
    
- Upgrading Berkeley DB 2.X.X applications to Berkeley DB 3.0
    
- Upgrading Berkeley DB 3.0.X applications to Berkeley DB 3.1
    
- Upgrading Berkeley DB 3.1.X applications to Berkeley DB 3.2
    
- Test Suite
    - Running the test suite
    
- Test suite FAQ
    
- Distribution
    - Source code layout
    
- Additional References
    - Additional references
    
Copyright Sleepycat Software