Oracle Berkeley DB编程者参考指南版本4.8说明书

Oracle Berkeley DB Programmer’s Reference
Guide
Release 4.8
Legal Notice
This documentation is distributed under an open source license. You may review the terms of this license at:
/technology/software/products/berkeley-db/htdocs/oslicense.html
Oracle, Berkeley DB, and Sleepycat are trademarks or registered trademarks of Oracle. All rights to these marks are reserved. No third-party use is permitted without the express prior written consent of Oracle.
To obtain a copy of this document's original source code, please submit a request to the Oracle Technology Network forum at: /forums/forum.jspa?forumID=271
Published 4/12/2010
Table of Contents
Preface (xx)
Conventions Used in this Book (xx)
For More Information (xx)
1. Introduction (1)
An introduction to data management (1)
Mapping the terrain: theory and practice (1)
Data access and data management (2)
Relational databases (3)
Object-oriented databases (4)
Network databases (4)
Clients and servers (5)
What is Berkeley DB? (6)
Data Access Services (7)
Data management services (7)
Design (8)
What Berkeley DB is not (8)
Not a relational database (9)
Not an object-oriented database (10)
Not a network database (10)
Not a database server (10)
Do you need Berkeley DB? (11)
What other services does Berkeley DB provide? (11)
What does the Berkeley DB distribution include? (12)
Where does Berkeley DB run? (12)
The Berkeley DB products (13)
Berkeley DB Data Store (13)
Berkeley DB Concurrent Data Store (13)
Berkeley DB Transactional Data Store (13)
Berkeley DB High Availability (14)
2. Access Method Configuration (15)
What are the available access methods? (15)
Btree (15)
Hash (15)
Queue (15)
Recno (15)
Selecting an access method (15)
Hash or Btree? (16)
Queue or Recno? (17)
Logical record numbers (17)
General access method configuration (19)
Selecting a page size (19)
Selecting a cache size (20)
Selecting a byte order (21)
Duplicate data items (22)
Non-local memory allocation (23)
Btree access method specific configuration (23)
4/12/2010
DB Reference Guide
Page ii
Btree comparison (23)
Btree prefix comparison (25)
Minimum keys per page (26)
Retrieving Btree records by logical record number (26)
Compression (28)
Custom compression (29)
Programmer Notes (32)
Hash access method specific configuration (33)
Page fill factor (33)
Specifying a database hash (33)
Hash table size (33)
Queue and Recno access method specific configuration (34)
Managing record-based databases (34)
Record Delimiters (34)
Record Length (34)
Record Padding Byte Value (34)
Selecting a Queue extent size (35)
Flat-text backing files (35)
Logically renumbering records (36)
3. Access Method Operations (38)
Database open (39)
Opening multiple databases in a single file (40)
Configuring databases sharing a file (41)
Caching databases sharing a file (41)
Locking in databases based on sharing a file (41)
Partitioning databases (42)
Specifying partition keys (42)
Partitioning callback (44)
Placing partition files (45)
Retrieving records (46)
Storing records (46)
Deleting records (47)
Database statistics (47)
Database truncation (47)
Database upgrade (47)
Database verification and salvage (48)
Flushing the database cache (48)
Database close (49)
Secondary indexes (49)
Foreign key indexes (53)
Cursor operations (57)
Retrieving records with a cursor (57)
Cursor position flags (57)
Retrieving specific key/data pairs (58)
Retrieving based on record numbers (58)
Special-purpose flags (58)
Storing records with a cursor (60)
Deleting records with a cursor (61)
Duplicating a cursor (62)
4/12/2010
DB Reference Guide
Page iii
Equality Join (62)
Example (63)
Data item count (65)
Cursor close (66)
4. Access Method Wrapup (67)
Data alignment (67)
Retrieving and updating records in bulk (67)
Bulk retrieval (67)
Bulk updates (69)
Bulk deletes (69)
Partial record storage and retrieval (70)
Storing C/C++ structures/objects (72)
Retrieved key/data permanence for C/C++ (74)
Error support (74)
Cursor stability (75)
Database limits (76)
Disk space requirements (76)
Btree (76)
Hash (77)
Specifying a Berkeley DB schema using SQL DDL (79)
Access method tuning (79)
Access method FAQ (81)
5. Java API (84)
Java configuration (84)
Compatibility (85)
Java programming notes (85)
Java FAQ (86)
6. C# API (89)
Compatibility (89)
7. Standard Template Library API (90)
Dbstl introduction (90)
Standards compatible (90)
Performance overhead (90)
Portability (90)
Dbstl typical use cases (91)
Dbstl examples (91)
Berkeley DB configuration (93)
Registering database and environment handles (94)
Truncate requirements (94)
Auto commit support (95)
Database and environment identity checks (95)
Products, constructors and configurations (95)
Using advanced Berkeley DB features with dbstl (96)
Using bulk retrieval iterators (96)
Using the DB_RMW flag (97)
Using secondary index database and secondary containers (97)
Using transactions in dbstl (97)
Using dbstl in multithreaded applications (98)
Working with primitive types (99)
4/12/2010
DB Reference Guide
Page iv
Storing strings (100)
Store and Retrieve data or objects of complex types (101)
Storing varying length objects (101)
Storing by marshaling objects (101)
Using a DbstlDbt wrapper object (102)
Storing arbitrary sequences (103)
The SequenceLenFunct function (104)
The SequenceCopyFunct function (104)
Notes (104)
Dbstl persistence (105)
Direct database get (105)
Change persistence (106)
Object life time and persistence (107)
Dbstl container specific notes (108)
db_vector specific notes (108)
Associative container specific notes (109)
Using dbstl efficiently (109)
Using iterators efficiently (109)
Using containers efficiently (110)
Dbstl memory management (111)
Freeing memory (111)
Type specific notes (111)
DbEnv/Db (111)
DbstlDbt (112)
Dbstl miscellaneous notes (112)
Special notes about trivial methods (112)
Using correct container and iterator public types (113)
Dbstl known issues (113)
8. Berkeley DB Architecture (115)
The big picture (115)
Programming model (118)
Programmatic APIs (118)
C (118)
C++ (118)
STL (119)
Java (119)
Dbm/Ndbm, Hsearch (120)
Scripting languages (120)
Perl (120)
PHP (120)
Tcl (120)
Supporting utilities (120)
9. The Berkeley DB Environment (122)
Database environment introduction (122)
Creating a database environment (123)
Opening databases within the environment (125)
Error support (127)
DB_CONFIG configuration file (128)
File naming (128)
4/12/2010
DB Reference Guide
Page v
Specifying file naming to Berkeley DB (129)
Filename resolution in Berkeley DB (129)
Examples (130)
Shared memory regions (131)
Security (132)
Encryption (133)
Remote filesystems (134)
Environment FAQ (135)
10. Berkeley DB Concurrent Data Store Applications (136)
Concurrent Data Store introduction (136)
Handling failure in Data Store and Concurrent Data Store applications (138)
Architecting Data Store and Concurrent Data Store applications (139)
11. Berkeley DB Transactional Data Store Applications (143)
Transactional Data Store introduction (143)
Why transactions? (143)
Terminology (143)
Handling failure in Transactional Data Store applications (145)
Architecting Transactional Data Store applications (146)
Opening the environment (150)
Opening the databases (153)
Recoverability and deadlock handling (156)
Atomicity (159)
Isolation (160)
Degrees of isolation (163)
Snapshot Isolation (164)
Transactional cursors (165)
Nested transactions (168)
Environment infrastructure (169)
Deadlock detection (169)
Checkpoints (171)
Database and log file archival (173)
Log file removal (176)
Recovery procedures (176)
Hot failover (178)
Recovery and filesystem operations (179)
Berkeley DB recoverability (180)
Transaction tuning (182)
Transaction throughput (185)
Transaction FAQ (187)
12. Berkeley DB Replication (190)
Replication introduction (190)
Replication environment IDs (192)
Replication environment priorities (192)
Building replicated applications (193)
Replication Manager methods (194)
Base API Methods (196)
Building the communications infrastructure (197)
Connecting to a new site (198)
Running Replication Manager in multiple processes (199)
4/12/2010
DB Reference Guide
Page vi
One replication process and multiple subordinate processes (199)
Persistence of network address configuration (199)
Programming considerations (200)
Handling failure (200)
Other miscellaneous rules (200)
Elections (201)
Synchronizing with a master (203)
Delaying client synchronization (203)
Client-to-client synchronization (203)
Blocked client operations (204)
Clients too far out-of-date to synchronize (204)
Initializing a new site (205)
Bulk transfer (205)
Transactional guarantees (206)
Master Leases (210)
Clock Skew (212)
Network partitions (213)
Replication FAQ (214)
Ex_rep: a replication example (216)
Ex_rep_base: a TCP/IP based communication infrastructure (217)
Ex_rep_base: putting it all together (219)
13. Application Specific Logging and Recovery (220)
Introduction to application specific logging and recovery (220)
Defining application-specific log records (221)
Automatically generated functions (223)
Application configuration (226)
14. Programmer Notes (229)
Signal handling (229)
Error returns to applications (229)
Environment variables (231)
Multithreaded applications (231)
Berkeley DB handles (232)
Name spaces (234)
C Language Name Space (234)
Filesystem Name Space (234)
Memory-only or Flash configurations (234)
Disk drive caches (237)
Copying or moving databases (237)
Compatibility with historic UNIX interfaces (238)
Run-time configuration (238)
Programmer notes FAQ (239)
15. The Locking Subsystem (241)
Introduction to the locking subsystem (241)
Configuring locking (242)
Configuring locking: sizing the system (243)
Standard lock modes (245)
Deadlock detection (246)
Deadlock detection using timers (247)
Deadlock debugging (248)
4/12/2010
DB Reference Guide
Page vii
Locking granularity (250)
Locking without transactions (251)
Locking with transactions: two-phase locking (252)
Berkeley DB Concurrent Data Store locking conventions (252)
Berkeley DB Transactional Data Store locking conventions (253)
Locking and non-Berkeley DB applications (255)
16. The Logging Subsystem (256)
Introduction to the logging subsystem (256)
Configuring logging (257)
Log file limits (258)
17. The Memory Pool Subsystem (259)
Introduction to the memory pool subsystem (259)
Configuring the memory pool (261)
18. The Transaction Subsystem (262)
Introduction to the transaction subsystem (262)
Configuring transactions (263)
Transaction limits (264)
Transaction IDs (264)
Cursors (264)
Multiple Threads of Control (264)
19. Sequences (265)
Introduction to sequences (265)
20. Berkeley DB Extensions: Tcl (266)
Loading Berkeley DB with Tcl (266)
Installing as a Tcl Package (266)
Loading Berkeley DB with Tcl (266)
Using Berkeley DB with Tcl (267)
Tcl API programming notes (267)
Tcl error handling (268)
Tcl FAQ (269)
21. Berkeley DB Extensions (270)
Using Berkeley DB with Apache (270)
Using Berkeley DB with Perl (271)
Using Berkeley DB with PHP (271)
22. Dumping and Reloading Databases (274)
The db_dump and db_load utilities (274)
Dump output formats (274)
Loading text into databases (275)
23. System Installation Notes (276)
File utility /etc/magic information (276)
Building with multiple versions of Berkeley DB (276)
24. Debugging Applications (278)
Introduction to debugging (278)
Compile-time configuration (278)
Run-time error information (279)
Reviewing Berkeley DB log files (279)
Augmenting the Log for Debugging (283)
Extracting Committed Transactions and Transaction Status (283)
Extracting Transaction Histories (283)
4/12/2010
DB Reference Guide
Page viii
Extracting File Histories (283)
Extracting Page Histories (283)
Other log processing tools (284)
25. Building Berkeley DB for the BREW simulator (285)
Building a BREW applet with Berkeley DB library (286)
Building a BREW applet for the physical device (286)
26. Building Berkeley DB for S60 (287)
Building Berkeley DB for the S60 Emulator (287)
Building Berkeley DB Library for the Device (287)
Building a S60 application with the Berkeley DB library (288)
S60 notes (288)
27. Building Berkeley DB for UNIX/POSIX (289)
Building for UNIX/POSIX (289)
Configuring Berkeley DB (290)
Building a small memory footprint library (294)
Changing compile or load options (295)
Installing Berkeley DB (296)
Dynamic shared libraries (297)
Running the test suite under UNIX (298)
Architecture independent FAQ (299)
AIX (302)
FreeBSD (303)
HP-UX (303)
IRIX (305)
Linux (305)
Mac OS X (306)
OSF/1 (307)
QNX (307)
SCO (308)
Solaris (308)
SunOS (310)
Ultrix (310)
28. Building Berkeley DB for Windows (311)
Building Berkeley DB for 32 bit Windows (311)
Visual C++ .NET 2008 (311)
Visual C++ .NET 2005 (311)
Visual C++ .NET or Visual C++ .NET 2003 (312)
Visual C++ 6.0 (312)
Build results (312)
Building Berkeley DB for 64-bit Windows (312)
x64 build with Visual Studio 2005 or newer (313)
x64 build with Visual Studio .NET 2003 or earlier (313)
Building Berkeley DB with Cygwin (313)
Building the C++ API (313)
Building the C++ STL API (313)
Building the Java API (314)
Building Java with Visual C++ .NET or above (314)
Building Java with Visual C++ 6.0 (314)
Building the C# API (315)
4/12/2010
DB Reference Guide
Page ix
Building C# with Visual Studio 2005 (315)
Building the Tcl API (315)
Building Tcl with Visual C++ .NET or above (316)
Building Tcl with Visual C++ 6.0 (316)
Distributing DLLs (317)
Building a small memory footprint library (317)
Running the test suite under Windows (318)
Building the software needed by the tests (318)
Visual Studio 2005 or newer (318)
Visual Studio 2003 .NET or earlier (318)
Running the test suite under Windows (318)
Windows notes (319)
Windows FAQ (320)
29. Building Berkeley DB for Windows CE (322)
Building for Windows CE (322)
Building Berkeley DB for Windows CE (322)
eMbedded Visual C++ 4.0 (322)
Build results (322)
Building Berkeley DB for different target CPU architectures (322)
eMbedded Visual C++ 4.0 (323)
Windows CE notes (323)
Windows CE/Mobile FAQ (324)
30. Building Berkeley DB for VxWorks (326)
Building for VxWorks 5.4 and 5.5 (326)
Building With Tornado 2.0 or Tornado 2.2 (326)
Building for VxWorks 6.x (327)
Building With Wind River Workbench using the Makefile (327)
VxWorks notes (328)
Building and Running the Demo Program (328)
Building and Running the Utility Programs (328)
VxWorks 5.4/5.5: shared memory (329)
VxWorks 5.4/5.5: building a small memory footprint library (329)
VxWorks FAQ (329)
31. Upgrading from previous versions of Berkeley DB (332)
Library version information (332)
Upgrading Berkeley DB installations (332)
32. Upgrading Berkeley DB 1.85 or 1.86 applications to Berkeley DB 2.0 (337)
Release 2.0: introduction (337)
Release 2.0: system integration (337)
Release 2.0: converting applications (338)
Release 2.0: Upgrade Requirements (339)
33. Upgrading Berkeley DB 2.X applications to Berkeley DB 3.0 (340)
Release 3.0: introduction (340)
Release 3.0: environment open/close/unlink (340)
Release 3.0: function arguments (343)
Release 3.0: the DB_ENV structure (344)
Release 3.0: database open/close (345)
Release 3.0: db_xa_open (346)
Release 3.0: the DB structure (346)
4/12/2010
DB Reference Guide
Page x
Release 3.0: the DBINFO structure (347)
Release 3.0: DB->join (349)
Release 3.0: DB->stat (349)
Release 3.0: DB->sync and DB->close (349)
Release 3.0: lock_put (349)
Release 3.0: lock_detect (349)
Release 3.0: lock_stat (349)
Release 3.0: log_register (350)
Release 3.0: log_stat (350)
Release 3.0: memp_stat (350)
Release 3.0: txn_begin (350)
Release 3.0: txn_commit (350)
Release 3.0: txn_stat (350)
Release 3.0: DB_RMW (350)
Release 3.0: DB_LOCK_NOTHELD (351)
Release 3.0: EAGAIN (351)
Release 3.0: EACCES (351)
Release 3.0: db_jump_set (351)
Release 3.0: db_value_set (352)
Release 3.0: the DbEnv class for C++ and Java (353)
Release 3.0: the Db class for C++ and Java (354)
Release 3.0: additional C++ changes (355)
Release 3.0: additional Java changes (355)
Release 3.0: Upgrade Requirements (355)
34. Upgrading Berkeley DB 3.0 applications to Berkeley DB 3.1 (356)
Release 3.1: introduction (356)
Release 3.1: DB_ENV->open, DB_ENV->remove (356)
Release 3.1: DB_ENV->set_tx_recover (356)
Release 3.1: DB_ENV->set_feedback, DB->set_feedback (357)
Release 3.1: DB_ENV->set_paniccall, DB->set_paniccall (357)
Release 3.1: DB->put (357)
Release 3.1: identical duplicate data items (358)
Release 3.1: DB->stat (358)
Release 3.1: DB_SYSTEM_MEM (359)
Release 3.1: log_register (359)
Release 3.1: memp_register (359)
Release 3.1: txn_checkpoint (359)
Release 3.1: environment configuration (359)
Release 3.1: Tcl API (360)
Release 3.1: DB_TMP_DIR (360)
Release 3.1: log file pre-allocation (361)
Release 3.1: Upgrade Requirements (361)
35. Upgrading Berkeley DB 3.1 applications to Berkeley DB 3.2 (362)
Release 3.2: introduction (362)
Release 3.2: DB_ENV->set_flags (362)
Release 3.2: DB callback functions, app_private field (362)
Release 3.2: Logically renumbering records (362)
Release 3.2: DB_INCOMPLETE (363)
Release 3.2: DB_ENV->set_tx_recover (363)
4/12/2010
DB Reference Guide
Page xi
Release 3.2: DB_ENV->set_mutexlocks (363)
Release 3.2: Java and C++ object reuse (364)
Release 3.2: Java java.io.FileNotFoundException (364)
Release 3.2: db_dump (364)
Release 3.2: Upgrade Requirements (364)
36. Upgrading Berkeley DB 3.2 applications to Berkeley DB 3.3 (365)
Release 3.3: introduction (365)
Release 3.3: DB_ENV->set_server (365)
Release 3.3: DB->get_type (365)
Release 3.3: DB->get_byteswapped (365)
Release 3.3: DB->set_malloc, DB->set_realloc (365)
Release 3.3: DB_LOCK_CONFLICT (366)
Release 3.3: memp_fget, EIO (367)
Release 3.3: txn_prepare (367)
Release 3.3: --enable-dynamic, --enable-shared (367)
Release 3.3: --disable-bigfile (367)
Release 3.3: Upgrade Requirements (367)
37. Upgrading Berkeley DB 3.3 applications to Berkeley DB 4.0 (368)
Release 4.0: Introduction (368)
Release 4.0: db_deadlock (368)
Release 4.0: lock_XXX (368)
Release 4.0: log_XXX (368)
Release 4.0: memp_XXX (369)
Release 4.0: txn_XXX (370)
Release 4.0: db_env_set_XXX (371)
Release 4.0: DB_ENV->set_server (372)
Release 4.0: DB_ENV->set_lk_max (372)
Release 4.0: DB_ENV->lock_id_free (372)
Release 4.0: Java CLASSPATH environment variable (372)
Release 4.0: C++ ostream objects (373)
Release 4.0: application-specific recovery (373)
Release 4.0: Upgrade Requirements (374)
4.0.14 Change Log (374)
Major New Features: (374)
General Environment Changes: (374)
General Access Method Changes: (375)
Btree Access Method Changes: (375)
Hash Access Method Changes: (375)
Queue Access Method Changes: (375)
Recno Access Method Changes: (375)
C++ API Changes: (375)
Java API Changes: (375)
Tcl API Changes: (376)
RPC Client/Server Changes: (376)
XA Resource Manager Changes: (376)
Locking Subsystem Changes: (376)
Logging Subsystem Changes: (376)
Memory Pool Subsystem Changes: (376)
Transaction Subsystem Changes: (377)
4/12/2010
DB Reference Guide
Page xii
Utility Changes: (377)
Database or Log File On-Disk Format Changes: (377)
Configuration, Documentation, Portability and Build Changes: (377)
38. Upgrading Berkeley DB 4.0 applications to Berkeley DB 4.1 (379)
Release 4.1: Introduction (379)
Release 4.1: DB_EXCL (379)
Release 4.1: DB->associate, DB->open, DB->remove, DB->rename (379)
Release 4.1: DB_ENV->log_register (381)
Release 4.1: st_flushcommit (381)
Release 4.1: DB_CHECKPOINT, DB_CURLSN (381)
Release 4.1: DB_INCOMPLETE (382)
Release 4.1: DB_ENV->memp_sync (382)
Release 4.1: DB->stat.hash_nelem (382)
Release 4.1: Java exceptions (382)
Release 4.1: C++ exceptions (382)
Release 4.1: Application-specific logging and recovery (383)
Release 4.1: Upgrade Requirements (383)
Berkeley DB 4.1.24 and 4.1.25 Change Log (383)
Database or Log File On-Disk Format Changes: (383)
Major New Features: (384)
General Environment Changes: (384)
General Access Method Changes: (385)
Btree Access Method Changes: (386)
Hash Access Method Changes: (386)
Queue Access Method Changes: (387)
Recno Access Method Changes: (387)
C++-specific API Changes: (387)
Java-specific API Changes: (388)
Tcl-specific API Changes: (388)
RPC-specific Client/Server Changes: (388)
Replication Changes: (388)
XA Resource Manager Changes: (388)
Locking Subsystem Changes: (389)
Logging Subsystem Changes: (389)
Memory Pool Subsystem Changes: (389)
Transaction Subsystem Changes: (390)
Utility Changes: (390)
Configuration, Documentation, Portability and Build Changes: (390)
Berkeley DB 4.1.25 Change Log (392)
39. Upgrading Berkeley DB 4.1 applications to Berkeley DB 4.2 (393)
Release 4.2: Introduction (393)
Release 4.2: Java (393)
Release 4.2: Queue access method (394)
Release 4.2: DB_CHKSUM_SHA1 (395)
Release 4.2: DB_CLIENT (395)
Release 4.2: DB->del (395)
Release 4.2: DB->set_cache_priority (395)
Release 4.2: DB->verify (396)
Release 4.2: DB_LOCK_NOTGRANTED (396)
4/12/2010
DB Reference Guide
Page xiii
Release 4.2: Replication (396)
Replication initialization (396)
Database methods and replication clients (397)
DB_ENV->rep_process_message() (397)
Release 4.2: Client replication environments (397)
Release 4.2: Tcl API (397)
Release 4.2: Upgrade Requirements (397)
Berkeley DB 4.2.52 Change Log (397)
Database or Log File On-Disk Format Changes: (397)
New Features: (398)
Database Environment Changes: (398)
Concurrent Data Store Changes: (400)
General Access Method Changes: (400)
Btree Access Method Changes: (402)
Hash Access Method Changes: (402)
Queue Access Method Changes: (403)
Recno Access Method Changes: (404)
C++-specific API Changes: (404)
Java-specific API Changes: (405)
Tcl-specific API Changes: (406)
RPC-specific Client/Server Changes: (406)
Replication Changes: (406)
XA Resource Manager Changes: (409)
Locking Subsystem Changes: (409)
Logging Subsystem Changes: (410)
Memory Pool Subsystem Changes: (411)
Transaction Subsystem Changes: (412)
Utility Changes: (412)
Configuration, Documentation, Portability and Build Changes: (413)
40. Upgrading Berkeley DB 4.2 applications to Berkeley DB 4.3 (416)
Release 4.3: Introduction (416)
Release 4.3: Java (416)
Release 4.3: DB_ENV->set_errcall, DB->set_errcall (417)
Release 4.3: DBcursor->c_put (417)
Release 4.3: DB->stat (417)
Release 4.3: DB_ENV->set_verbose (417)
Release 4.3: Logging (418)
Release 4.3: DB_FILEOPEN (418)
Release 4.3: ENOMEM and DbMemoryException (418)
Release 4.3: Replication (419)
Release 4.3: Run-time configuration (419)
Release 4.3: Upgrade Requirements (419)
Berkeley DB 4.3.29 Change Log (419)
Database or Log File On-Disk Format Changes: (419)
New Features: (419)
Database Environment Changes: (420)
Concurrent Data Store Changes: (421)
General Access Method Changes: (421)
Btree Access Method Changes: (422)
4/12/2010
DB Reference Guide
Page xiv
Hash Access Method Changes: (423)
Queue Access Method Changes: (423)
Recno Access Method Changes (424)
C++-specific API Changes: (424)
Java-specific API Changes: (424)
Tcl-specific API Changes: (425)
RPC-specific Client/Server Changes: (425)
Replication Changes: (425)
XA Resource Manager Changes: (427)
Locking Subsystem Changes: (427)
Logging Subsystem Changes: (427)
Memory Pool Subsystem Changes: (428)
Transaction Subsystem Changes: (428)
Utility Changes: (428)
Configuration, Documentation, Portability and Build Changes: (429)
41. Upgrading Berkeley DB 4.3 applications to Berkeley DB 4.4 (431)
Release 4.4: Introduction (431)
Release 4.4: DB_AUTO_COMMIT (431)
Release 4.4: DB_DEGREE_2, DB_DIRTY_READ (431)
Release 4.4: DB_JOINENV (431)
Release 4.4: mutexes (432)
Release 4.4: DB_MPOOLFILE->set_clear_len (432)
Release 4.4: lock statistics (433)
Release 4.4: Upgrade Requirements (433)
Berkeley DB 4.4.16 Change Log (433)
Database or Log File On-Disk Format Changes: (433)
New Features: (433)
Database Environment Changes: (434)
Concurrent Data Store Changes: (435)
General Access Method Changes: (435)
Btree Access Method Changes: (436)
Hash Access Method Changes: (436)
Queue Access Method Changes: (436)
Recno Access Method Changes (436)
C++-specific API Changes: (437)
Java-specific API Changes: (437)
Java collections and bind API Changes: (437)
Tcl-specific API Changes: (438)
RPC-specific Client/Server Changes: (438)
Replication Changes: (438)
XA Resource Manager Changes: (439)
Locking Subsystem Changes: (439)
Logging Subsystem Changes: (439)
Memory Pool Subsystem Changes: (440)
Transaction Subsystem Changes: (440)
Utility Changes: (441)
Configuration, Documentation, Portability and Build Changes: (441)
Berkeley DB 4.4.20 Change Log (442)
Changes since Berkeley DB 4.4.16: (442)
4/12/2010
DB Reference Guide
Page xv
42. Upgrading Berkeley DB 4.4 applications to Berkeley DB 4.5 (444)
Release 4.5: Introduction (444)
Release 4.5: deprecated interfaces (444)
Release 4.5: DB->set_isalive (444)
Release 4.5: DB_ENV->rep_elect (444)
Release 4.5: Replication method naming (445)
Release 4.5: Replication events (445)
Release 4.5: Memory Pool API (445)
Release 4.5: DB_ENV->set_paniccall (445)
Release 4.5: DB->set_pagesize (446)
Release 4.5: Collections API (446)
Release 4.5: --enable-pthread_self (446)
Release 4.5: Recno backing text source files (446)
Release 4.5: Application-specific logging (447)
Release 4.5: Upgrade Requirements (447)
Berkeley DB 4.5.20 Change Log (447)
Database or Log File On-Disk Format Changes: (447)
New Features: (447)
Database Environment Changes: (447)
Concurrent Data Store Changes: (448)
General Access Method Changes: (448)
Btree Access Method Changes: (449)
Hash Access Method Changes: (449)
Queue Access Method Changes: (449)
Recno Access Method Changes: (449)
C++-specific API Changes: (449)
Java-specific API Changes: (450)
Java collections and bind API Changes: (450)
Tcl-specific API Changes: (450)
RPC-specific Client/Server Changes: (450)
Replication Changes: (450)
XA Resource Manager Changes: (451)
Locking Subsystem Changes: (451)
Logging Subsystem Changes: (451)
Memory Pool Subsystem Changes: (451)
Transaction Subsystem Changes: (451)
Utility Changes: (452)
Configuration, Documentation, Portability and Build Changes: (452)
43. Upgrading Berkeley DB 4.5 applications to Berkeley DB 4.6 (454)
Release 4.6: Introduction (454)
Release 4.6: C API cursor handle method names (454)
Release 4.6: DB_MPOOLFILE->put (454)
Release 4.6: DB_MPOOLFILE->set (455)
Release 4.6: Replication Events (455)
Release 4.6: DB_REP_FULL_ELECTION (455)
Release 4.6: Verbose Output (456)
Release 4.6: DB_VERB_REPLICATION (456)
Release 4.6: Windows 9X (456)
Release 4.6: Upgrade Requirements (456)
4/12/2010
DB Reference Guide
Page xvi。