Berkeley DB Tutorial and Reference Guide, Version 4.1.25
- Introduction
    - An introduction to data management
    
- Mapping the terrain: theory and practice
    
- What is Berkeley DB?
    
- What Berkeley DB is 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
    
- A Simple Access Method 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
    
- Database open
    
- Opening multiple databases in a single file
    
- Retrieving records
    
- Storing records
    
- Deleting records
    
- Database statistics
    
- Database truncation
    
- Database upgrade
    
- Database verification and salvage
    
- Flushing the database cache
    
- Database close
    
- Secondary indices
    
- Cursor operations
	
	- Retrieving records with a cursor
	
- Storing records with a cursor
	
- Deleting records with a cursor
	
- Duplicating a cursor
	
- Equality join
	
- Data item count
	
- Cursor close
	
 
- Access Method Wrapup
    - Data alignment
    
- Retrieving records in bulk
    
- Partial record storage and retrieval
    
- Storing C/C++ structures/objects
    
- Retrieved key/data permanence for C/C++
    
- Error support
    
- Cursor stability
    
- Database limits
    
- Disk space requirements
    
- Access method tuning
    
- Access method FAQ
    
- Berkeley DB Architecture
    - The big picture
    
- Programming model
    
- Programmatic APIs
    
- Scripting languages
    
- Supporting utilities
    
- The Berkeley DB Environment
    - Introduction
    
- Creating a database environment
    
- Opening databases within the environment
    
- Error support
    
- DB_CONFIG configuration file
    
- File naming
    
- Shared memory regions
    
- Security
    
- Encryption
    
- Remote filesystems
    
- Environment FAQ
    
- Berkeley DB Concurrent Data Store Applications
    - Berkeley DB Concurrent Data Store applications
    
- Berkeley DB Transactional Data Store Applications
    - Berkeley DB Transactional Data Store applications
    
- Why transactions?
    
- Terminology
    
- Application structure
    
- Opening the environment
    
- Opening the databases
    
- Recoverability and deadlock handling
    
- Atomicity
    
- Isolation
    
- Degrees of isolation
    
- Transactional cursors
    
- Nested transactions
    
- Environment infrastructure
    
- Deadlock detection
    
- Checkpoints
    
- Database and log file archival
    
- Log file removal
    
- Recovery procedures
    
- Hot failover
    
- Recovery and filesystem operations
    
- Berkeley DB recoverability
    
- Transaction tuning
    
- Transaction throughput
    
- Transaction FAQ
    
- Berkeley DB Replication
    - Introduction
    
- Replication environment IDs
    
- Replication environment priorities
    
- Building replicated applications
    
- Building the communications infrastructure
    
- Connecting to a new site
    
- Initializing a new site
    
- Elections
    
- Log file only clients
    
- Transactional guarantees
    
- Network partitions
    
- Replication FAQ
    
- Ex_repquote: a replication example
    
- Ex_repquote: a TCP/IP based communication infrastructure
    
- Ex_repquote: putting it all together
    
- Distributed Transactions
    - Introduction
    
- Building a Global Transaction Manager
    
- XA Introduction
    
- Configuring Berkeley DB with the Tuxedo System
    
- Frequently Asked Questions
    
- Application Specific Logging and Recovery
    - Introduction
    
- Defining application-specific log records
    
- Automatically generated functions
    
- Application configuration
    
- Programmer Notes
    - Signal handling
    
- Error returns to applications
    
- Environmental variables
    
- Multithreaded applications
    
- Berkeley DB handles
    
- Name spaces
    
- Disk drive caches
    
- Copying databases
    
- Compatibility with historic UNIX interfaces
    
- Run-time configuration
    
- Programmer notes FAQ
    
- The Locking Subsystem
    - Berkeley DB and locking
    
- Configuring locking
    
- Configuring locking: sizing the system
    
- Standard lock modes
    
- Deadlock detection
    
- Deadlock detection using timers
    
- Deadlock debugging
    
- Locking granularity
    
- Locking without transactions
    
- Locking with transactions: two-phase locking
    
- Berkeley DB Concurrent Data Store locking conventions
    
- Berkeley DB Transactional Data Store locking conventions
    
- 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
    
- Configuring transactions
    
- Transaction limits
    
- RPC Client/Server
    - Introduction
    
- Client program
    
- Server program
    
- RPC FAQ
    
- Java API
    - Java configuration
    
- Compatibility
    
- Java 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
    
- Building with multiple versions of Berkeley DB
    
- Building RPM distribution packages
    
- Debugging Applications
    - Introduction
    
- Compile-time configuration
    
- Run-time error information
    
- Reviewing Berkeley DB log files
    
- Common errors
    
- Berkeley DB for UNIX/POSIX 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,
	Embedix,
	FreeBSD,
	HP-UX,
	IRIX,
	Linux,
	Mac OS X,
	OSF/1,
	QNX,
	SCO,
	Solaris,
	SunOS,
	Ultrix
- Berkeley DB for Win32 platforms
    - Building for Win32
    
- Running the test suite under Windows
    
- Windows notes
    
- Windows FAQ
    
- Berkeley DB for VxWorks systems
    - Building for VxWorks 5.4
    
- Building for VxWorks AE
    
- VxWorks notes
    
- VxWorks FAQ
    
- Upgrading Berkeley DB Applications
    - Library version information
    
- 
	    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
    
- 
	    Upgrading Berkeley DB 3.2.X applications to Berkeley DB 3.3
    
- 
	    Upgrading Berkeley DB 3.3.X applications to Berkeley DB 4.0
    
- 
	    Upgrading Berkeley DB 4.0.X applications to Berkeley DB 4.1
    
- Test Suite
    - Running the test suite
    
- Test suite FAQ
    
- Distribution
    - Porting Berkeley DB to new architectures
    
- Source code layout
    
- Additional References
    - Additional references