ag/cpython-source-deps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import BSDDB 4.7.25 (as of svn r89086)

Browse Source
This commit is contained in:
Zachary Ware
2017-09-04 13:40:25 -05:00
parent 4b29e0458f
commit 8f590873d0
4781 changed files with 2241032 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
docs/gsg_txn/JAVA/txn_ccursor.html Normal file
View File

@@ -0,0 +1,244 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Transactional Cursors and Concurrent Applications</title>
<link rel="stylesheet" href="gettingStarted.css" type="text/css" />
<meta name="generator" content="DocBook XSL Stylesheets V1.62.4" />
<link rel="home" href="index.html" title="Getting Started with Berkeley DB Transaction Processing" />
<link rel="up" href="txnconcurrency.html" title="Chapter 4. Concurrency" />
<link rel="previous" href="isolation.html" title="Isolation" />
<link rel="next" href="readmodifywrite.html" title="Read/Modify/Write" />
</head>
<body>
<div class="navheader">
<table width="100%" summary="Navigation header">
<tr>
<th colspan="3" align="center">Transactional Cursors and Concurrent Applications</th>
</tr>
<tr>
<td width="20%" align="left"><a accesskey="p" href="isolation.html">Prev</a> </td>
<th width="60%" align="center">Chapter 4. Concurrency</th>
<td width="20%" align="right"> <a accesskey="n" href="readmodifywrite.html">Next</a></td>
</tr>
</table>
<hr />
</div>
<div class="sect1" lang="en" xml:lang="en">
<div class="titlepage">
<div>
<div>
<h2 class="title" style="clear: both"><a id="txn_ccursor"></a>Transactional Cursors and Concurrent Applications</h2>
</div>
</div>
<div></div>
</div>
<p>
When you use transactional cursors with a concurrent application, remember that
in the event of a deadlock you must make sure that you close your cursor before you abort and retry your
transaction. <span>This is true of both
base API and DPL cursors.</span>
</p>
<p>
Also, remember that when you are using the default isolation level,
every time your cursor reads a record it locks
that record until the encompassing transaction is resolved. This
means that walking your database with a transactional cursor
increases the chance of lock contention.
</p>
<p>
For this reason, if you must routinely walk your database with a
transactional cursor, consider using a reduced isolation level
such as read committed. <span>This is
true of both base API and DPL cursors.</span>
</p>
<div class="sect2" lang="en" xml:lang="en">
<div class="titlepage">
<div>
<div>
<h3 class="title"><a id="cursordirtyreads"></a>Using Cursors with Uncommitted Data</h3>
</div>
</div>
<div></div>
</div>
<p>
As described in <a href="isolation.html#dirtyreads">Reading Uncommitted Data</a>
above, it is possible to relax your transaction's isolation
level such that it can read data modified but not yet committed
by another transaction. You can configure this when you create
your transaction handle, and when you do so then all cursors opened
inside that transaction will automatically use uncommitted reads.
</p>
<p>
You can also do this when you create a cursor handle from within
a serializable transaction. When you do this, only those
cursors configured for uncommitted reads uses uncommitted reads.
</p>
<p>
Either way, you must first configure your database
<span>or store</span> handle to support
uncommitted reads before you can configure your transactions or
your cursors to use them.
</p>
<p>
The following example shows how to configure an individual cursor handle
to read uncommitted data from within a serializable (full isolation) transaction.
For an example of
configuring a transaction to perform uncommitted reads in
general, see <a href="isolation.html#dirtyreads">Reading Uncommitted Data</a>.
</p>
<pre class="programlisting">package db.txn;
import com.sleepycat.db.Cursor;
import com.sleepycat.db.CursorConfig;
import com.sleepycat.db.Database;
import com.sleepycat.db.DatabaseConfig;
import com.sleepycat.db.Environment;
import com.sleepycat.db.EnvironmentConfig;
import java.io.File;
...
Database myDatabase = null;
Environment myEnv = null;
try {
EnvironmentConfig myEnvConfig = new EnvironmentConfig();
myEnvConfig.setTransactional(true);
myEnvConfig.setInitializeCache(true);
myEnvConfig.setInitializeLocking(true);
myEnvConfig.setInitializeLogging(true);
myEnv = new Environment(new File("/my/env/home"),
myEnvConfig);
// Open the database.
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setType(DatabaseType.BTREE);
dbConfig.setReadUncommitted(true); // Enable uncommitted reads.
myDatabase = myEnv.openDatabase(null, // txn handle
"sampleDatabase", // db file name
null, // db name
dbConfig);
// Open the transaction. Note that this is a degree 3
// transaction.
Transaction txn = myEnv.beginTransaction(null, null);
Cursor cursor = null;
try {
// Use the transaction handle here
// Get our cursor. Note that we pass the transaction
// handle here. Note also that we cause the cursor
// to perform uncommitted reads.
CursorConfig cconfig = new CursorConfig();
cconfig.setReadUncommitted(true);
cursor = db.openCursor(txn, cconfig);
// From here, you perform your cursor reads and writes
// as normal, committing and aborting the transactions as
// is necessary, and testing for deadlock exceptions as
// normal (omitted for brevity).
... </pre>
<p>
If you are using the DPL:
</p>
<pre class="programlisting">package persist.txn;
import com.sleepycat.db.CursorConfig;
import com.sleepycat.db.DatabaseConfig;
import com.sleepycat.db.Environment;
import com.sleepycat.db.EnvironmentConfig;
import com.sleepycat.persist.EntityCursor;
import com.sleepycat.persist.EntityStore;
import com.sleepycat.persist.PrimaryIndex;
import com.sleepycat.persist.StoreConfig;
import java.util.Iterator;
import java.io.File;
...
EntityStore myStore = null;
Environment myEnv = null;
PrimaryIndex&lt;String,AnEntityClass&gt; pKey;
try {
EnvironmentConfig myEnvConfig = new EnvironmentConfig();
myEnvConfig.setTransactional(true);
myEnvConfig.setInitializeCache(true);
myEnvConfig.setInitializeLocking(true);
myEnvConfig.setInitializeLogging(true);
myEnv = new Environment(new File("/my/env/home"),
myEnvConfig);
// Set up the entity store
StoreConfig myStoreConfig = new StoreConfig();
myStoreConfig.setAllowCreate(true);
myStoreConfig.setTransactional(true);
// Configure uncommitted reads
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setTransactional(true);
dbConfig.setType(DatabaseType.BTREE);
dbConfig.setAllowCreate(true);
dbConfig.setReadUncommitted(true); // Enable uncommitted reads.
// Instantiate the store
myStore = new EntityStore(myEnv, storeName, myStoreConfig);
// Set the DatabaseConfig object, so that the underlying
// database is configured for uncommitted reads.
myStore.setPrimaryConfig(AnEntityClass.class, myDbConfig);
// Open the transaction. Note that this is a degree 3
// transaction.
Transaction txn = myEnv.beginTransaction(null, null);
//Configure our cursor for uncommitted reads.
CursorConfig cconfig = new CursorConfig();
cconfig.setReadUncommitted(true);
// Get our cursor. Note that we pass the transaction
// handle here. Note also that we cause the cursor
// to perform uncommitted reads.
EntityCursor&lt;AnEntityClass&gt; cursor = pKey.entities(txn, cconfig);
try {
// From here, you perform your cursor reads and writes
// as normal, committing and aborting the transactions as
// is necessary, and testing for deadlock exceptions as
// normal (omitted for brevity).
... </pre>
</div>
</div>
<div class="navfooter">
<hr />
<table width="100%" summary="Navigation footer">
<tr>
<td width="40%" align="left"><a accesskey="p" href="isolation.html">Prev</a> </td>
<td width="20%" align="center">
<a accesskey="u" href="txnconcurrency.html">Up</a>
</td>
<td width="40%" align="right"> <a accesskey="n" href="readmodifywrite.html">Next</a></td>
</tr>
<tr>
<td width="40%" align="left" valign="top">Isolation </td>
<td width="20%" align="center">
<a accesskey="h" href="index.html">Home</a>
</td>
<td width="40%" align="right" valign="top"> Read/Modify/Write</td>
</tr>
</table>
</div>
</body>
</html>