You set properties for the Environment using
the EnvironmentConfig class. You can also set properties for a specific
Environment instance using EnvironmentMutableConfig.
The EnvironmentConfig class makes a
large number of fields and methods available to you. Describing all of these
tuning parameters is beyond the scope of this manual. However, there are a
few properties that you are likely to want to set. They are described
here.
Note that for each of the properties that you can commonly set, there is a
corresponding getter method. Also, you can always retrieve the
EnvironmentConfig object used by your environment
using the Environment.getConfig() method.
You set environment configuration parameters using the following methods on the
EnvironmentConfig class:
EnvironmentConfig.setAllowCreate()
If true, the database environment is created
when it is opened. If false, environment open fails if the environment
does not exist. This property has no meaning if the database
environment already exists. Default is false.
EnvironmentConfig.setReadOnly()
If true, then all databases opened in this
environment must be opened as read-only. If you are writing a
multi-process application, then all but one of your processes must set
this value to true. Default is false.
EnvironmentConfig.setTransactional()
If true, configures the database environment
to support transactions. Default is false.
For example:
package db.gettingStarted;
import com.sleepycat.db.DatabaseException;
import com.sleepycat.db.Environment;
import com.sleepycat.db.EnvironmentConfig;
import java.io.File;
import java.io.FileNotFoundException;
...
Environment myDatabaseEnvironment = null;
try {
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setAllowCreate(true);
envConfig.setTransactional(true);
myDatabaseEnvironment =
new Environment(new File("/export/dbEnv"), envConfig);
} catch (DatabaseException dbe) {
System.err.println(dbe.toString());
System.exit(1);
} catch (FileNotFoundException fnfe) {
System.err.println(fnfe.toString());
System.exit(-1);
}
EnvironmentMutableConfig manages properties that can be reset after the
Environment object has been constructed. In addition, EnvironmentConfig
extends EnvironmentMutableConfig, so you can set these mutable properties at
Environment construction time if necessary.
The EnvironmentMutableConfig class allows you to set the following
properties:
setCachePercent()
Determines the percentage of JVM memory available to the DB cache. See Selecting the Cache Size for more information.
setCacheSize()
Determines the total amount of memory available to the database cache. See Selecting the Cache Size for more information.
setTxnNoSync()
Determines whether change records created due to a transaction commit are written to the backing
log files on disk. A value of true causes
the data to not be flushed to
disk. See the
Getting Started with Transaction Processing for Java
guide for more information.
setTxnWriteNoSync()
Determines whether logs are flushed on transaction commit (the logs are still written, however).
By setting this value to true, you potentially gain better performance than if
you flush the logs on commit, but you do so by losing some of your transaction durability guarantees.
See the
Getting Started with Transaction Processing for Java
guide for more information.
There is also a corresponding getter method (getTxnNoSync()).
Moreover, you can always retrieve your environment's
EnvironmentMutableConfig object by
using the Environment.getMutableConfig() method.
For example:
package db.gettingStarted;
import com.sleepycat.db.DatabaseException;
import com.sleepycat.db.Environment;
import com.sleepycat.db.EnvironmentMutableConfig;
import java.io.File;
import java.io.FileNotFoundException;
...
try {
Environment myEnv = new Environment(new File("/export/dbEnv"), null);
EnvironmentMutableConfig envMutableConfig =
new EnvironmentMutableConfig();
envMutableConfig.setTxnNoSync(true);
myEnv.setMutableConfig(envMutableConfig);
} catch (DatabaseException dbe) {
// Exception handling goes here
} catch (FileNotFoundException fnfe) {
// Exception handling goes here
}