All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.sleepycat.persist.EntityStore Maven / Gradle / Ivy

Go to download

Berkeley DB Java Edition is a open source, transactional storage solution for Java applications. The Direct Persistence Layer (DPL) API is faster and easier to develop, deploy, and manage than serialized object files or ORM-based Java persistence solutions. The Collections API enhances the standard java.util.collections classes allowing them to be persisted to a local file system and accessed concurrently while protected by ACID transactions. Data is stored by serializing objects and managing class and instance data separately so as not to waste space. Berkeley DB Java Edition is the reliable drop-in solution for complex, fast, and scalable storage. Source for this release is in 'je-4.0.92-sources.jar', the Javadoc is located at 'http://download.oracle.com/berkeley-db/docs/je/4.0.92/'.

There is a newer version: 5.0.73
Show newest version
/*-
 * Copyright (C) 2002, 2018, Oracle and/or its affiliates. All rights reserved.
 *
 * This file was distributed by Oracle as part of a version of Oracle Berkeley
 * DB Java Edition made available at:
 *
 * http://www.oracle.com/technetwork/database/database-technologies/berkeleydb/downloads/index.html
 *
 * Please see the LICENSE file included in the top-level directory of the
 * appropriate version of Oracle Berkeley DB Java Edition for a copy of the
 * license and additional information.
 */

package com.sleepycat.persist;

import java.io.Closeable;
import java.util.Set;

import com.sleepycat.je.Database; // for javadoc
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
/*  */
import com.sleepycat.je.EnvironmentFailureException ; // for javadoc
import com.sleepycat.je.OperationFailureException ; // for javadoc
/*  */
import com.sleepycat.je.SecondaryConfig;
import com.sleepycat.je.Sequence;
import com.sleepycat.je.SequenceConfig;
import com.sleepycat.je.Transaction;
import com.sleepycat.persist.evolve.EvolveConfig;
import com.sleepycat.persist.evolve.EvolveStats;
import com.sleepycat.persist.evolve.IncompatibleClassException;
import com.sleepycat.persist.evolve.Mutations;
import com.sleepycat.persist.impl.Store;
import com.sleepycat.persist.model.DeleteAction;
import com.sleepycat.persist.model.Entity; // for javadoc
import com.sleepycat.persist.model.EntityModel;
import com.sleepycat.persist.model.PrimaryKey;
import com.sleepycat.persist.model.SecondaryKey;

/**
 * A store for managing persistent entity objects.
 *
 * 

{@code EntityStore} objects are thread-safe. Multiple threads may safely * call the methods of a shared {@code EntityStore} object.

* *

See the package * summary example for an example of using an {@code EntityStore}.

* *

Before creating an EntityStore you must create an {@link * Environment} object using the Berkeley DB engine API. The environment may * contain any number of entity stores and their associated databases, as well * as other databases not associated with an entity store.

* *

An entity store is based on an {@link EntityModel}: a data model which * defines persistent classes (entity classes), primary keys, * secondary keys, and relationships between entities. A primary index is * created for each entity class. An associated secondary index is created for * each secondary key. The {@link Entity}, {@link PrimaryKey} and {@link * SecondaryKey} annotations may be used to define entities and keys.

* *

To use an EntityStore, first obtain {@link PrimaryIndex} and * {@link SecondaryIndex} objects by calling {@link #getPrimaryIndex * getPrimaryIndex} and {@link #getSecondaryIndex getSecondaryIndex}. Then use * these indices to store and access entity records by key.

* *

Although not normally needed, you can also use the entity store along * with the {@link com.sleepycat.je Base API}. Methods in the {@link * PrimaryIndex} and {@link SecondaryIndex} classes may be used to obtain * databases and bindings. The databases may be used directly for accessing * entity records. The bindings should be called explicitly to translate * between {@link com.sleepycat.je.DatabaseEntry} objects and entity model * objects.

* *

Each primary and secondary index is associated internally with a {@link * Database}. With any of the above mentioned use cases, methods are provided * that may be used for database performance tuning. The {@link * #setPrimaryConfig setPrimaryConfig} and {@link #setSecondaryConfig * setSecondaryConfig} methods may be called anytime before a database is * opened via {@link #getPrimaryIndex getPrimaryIndex} or {@link * #getSecondaryIndex getSecondaryIndex}. The {@link #setSequenceConfig * setSequenceConfig} method may be called anytime before {@link #getSequence * getSequence} is called or {@link #getPrimaryIndex getPrimaryIndex} is called * for a primary index associated with that sequence.

* * *

Database Names

* *

The database names of primary and secondary indices are designed to be * unique within the environment and identifiable for debugging and use with * tools such as {@link com.sleepycat.je.util.DbDump} and {@link * com.sleepycat.je.util.DbLoad}.

* *

The syntax of a primary index database name is:

*
   persist#STORE_NAME#ENTITY_CLASS
*

Where STORE_NAME is the name parameter passed to {@link #EntityStore * EntityStore} and ENTITY_CLASS is name of the class passed to {@link * #getPrimaryIndex getPrimaryIndex}.

* *

The syntax of a secondary index database name is:

*
   persist#STORE_NAME#ENTITY_CLASS#KEY_NAME
*

Where KEY_NAME is the secondary key name passed to {@link * #getSecondaryIndex getSecondaryIndex}.

* *

Although you should never have to construct these names manually, * understanding their syntax is useful for several reasons:

*
    *
  • Exception messages sometimes contain the database name, from which you * can identify the entity class and secondary key.
  • *
  • If you create other databases in the same environment that are not * part of an EntityStore, to avoid naming conflicts the other * database names should not begin with "persist#".
  • *
  • If you are using {@link com.sleepycat.je.util.DbDump} or {@link * com.sleepycat.je.util.DbLoad} to perform a backup or copy databases between * environments, knowing the database names can be useful. Normally you will * dump or load all database names starting with * "persist#STORE_NAME#".
  • *
* *

If you are copying all databases in a store as mentioned in the last * point above, there is one further consideration. There are two internal * databases that must be kept with the other databases in the store in order * for the store to be used. These contain the data formats and sequences for * the store:

*
   persist#STORE_NAME#com.sleepycat.persist.formats
*
   persist#STORE_NAME#com.sleepycat.persist.sequences
*

These databases must normally be included with copies of other databases * in the store. They should not be modified by the application.

* *

For example, the following code snippet removes all databases for a given * store in a single transaction.

*
 *  Environment env = ...
 *  EntityStore store = ...
 *  Transaction txn = env.beginTransaction(null, null);
 *  String prefix = "persist#" + store.getStoreName() + "#";
 *  for (String dbName : env.getDatabaseNames()) {
 *      if (dbName.startsWith(prefix)) {
 *          env.removeDatabase(txn, dbName);
 *      }
 *  }
 *  txn.commit();
* * * * @author Mark Hayes */ public class EntityStore /* */ implements Closeable /* */ { private Store store; /** * Opens an entity store in a given environment. * * @param env an open Berkeley DB Environment. * * @param storeName the name of the entity store within the given * environment. An empty string is allowed. Named stores may be used to * distinguish multiple sets of persistent entities for the same entity * classes in a single environment. Underlying database names are prefixed * with the store name. * * @param config the entity store configuration, or null to use default * configuration properties. * * @throws StoreExistsException when the {@link * StoreConfig#setExclusiveCreate ExclusiveCreate} configuration parameter * is true and the store's internal catalog database already exists. * * @throws StoreNotFoundException when when the {@link * StoreConfig#setAllowCreate AllowCreate} configuration parameter is false * and the store's internal catalog database does not exist. * * @throws IncompatibleClassException if an incompatible class change has * been made and mutations are not configured for handling the change. See * {@link com.sleepycat.persist.evolve Class Evolution} for more * information. * * * @throws OperationFailureException if one of the Read Operation * Failures occurs. If the store does not exist and the {@link * StoreConfig#setAllowCreate AllowCreate} parameter is true, then one of * the Write * Operation Failures may also occur. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. */ public EntityStore(Environment env, String storeName, StoreConfig config) throws StoreExistsException, StoreNotFoundException, IncompatibleClassException, DatabaseException { store = new Store(env, storeName, config, false /*rawAccess*/); } /** * Returns the environment associated with this store. * * @return the environment. */ public Environment getEnvironment() { return store.getEnvironment(); } /** * Returns a copy of the entity store configuration. * * @return the config. */ public StoreConfig getConfig() { return store.getConfig(); } /** * Returns the name of this store. * * @return the name. */ public String getStoreName() { return store.getStoreName(); } /* */ /** * Returns the names of all entity stores in the given environment. * * @return the store names. An empty set is returned if no stores are * present. * * @throws OperationFailureException if one of the Read Operation * Failures occurs. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * @throws DatabaseException the base class for all BDB exceptions. */ public static Set getStoreNames(Environment env) throws DatabaseException { return Store.getStoreNames(env); } /* */ /* */ /** * @hidden * For internal use only. */ public boolean isReplicaUpgradeMode() { return store.isReplicaUpgradeMode(); } /* */ /** * Returns the current entity model for this store. The current model is * derived from the configured entity model and the live entity class * definitions. * * @return the model. */ public EntityModel getModel() { return store.getModel(); } /** * Returns the set of mutations that were configured when the store was * opened, or if none were configured, the set of mutations that were * configured and stored previously. * * @return the mutations. */ public Mutations getMutations() { return store.getMutations(); } /** * Returns the primary index for a given entity class, opening it if * necessary. * *

If they are not already open, the primary and secondary databases for * the entity class are created/opened together in a single internal * transaction. When the secondary indices are opened, that can cascade to * open other related primary indices.

* * @param primaryKeyClass the class of the entity's primary key field, or * the corresponding primitive wrapper class if the primary key field type * is a primitive. * * @param entityClass the entity class for which to open the primary index. * * @param the primary key class. * * @param the entity class. * * @return the primary index. * * @throws IllegalArgumentException if the entity class or classes * referenced by it are not persistent, or the primary key class does not * match the entity's primary key field, or if metadata for the entity or * primary key is invalid. * * * @throws IndexNotAvailableException in a replicated environment if this * Replica's persistent classes have been upgraded to define a new index, * but the Master has not yet been upgraded. * * @throws OperationFailureException if one of the Read Operation * Failures occurs. If the index does not exist and the {@link * StoreConfig#setReadOnly ReadOnly} parameter is false, then one of the Write * Operation Failures may also occur. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. */ public PrimaryIndex getPrimaryIndex(Class primaryKeyClass, Class entityClass) throws DatabaseException { try { return store.getPrimaryIndex (primaryKeyClass, primaryKeyClass.getName(), entityClass, entityClass.getName()); } catch (IndexNotAvailableException e) { if (!store.attemptRefresh()) { throw e; } return store.getPrimaryIndex (primaryKeyClass, primaryKeyClass.getName(), entityClass, entityClass.getName()); } } /** * Returns a secondary index for a given primary index and secondary key, * opening it if necessary. * *

NOTE: If the secondary key field is declared in a subclass * of the entity class, use {@link #getSubclassIndex} instead.

* *

If a {@link SecondaryKey#relatedEntity} is used and the primary index * for the related entity is not already open, it will be opened by this * method. That will, in turn, open its secondary indices, which can * cascade to open other primary indices.

* * @param primaryIndex the primary index associated with the returned * secondary index. The entity class of the primary index, or one of its * superclasses, must contain a secondary key with the given secondary key * class and key name. * * @param keyClass the class of the secondary key field, or the * corresponding primitive wrapper class if the secondary key field type is * a primitive. * * @param keyName the name of the secondary key field, or the {@link * SecondaryKey#name} if this name annotation property was specified. * * @param the secondary key class. * * @param the primary key class. * * @param the entity class. * * @return the secondary index. * * @throws IllegalArgumentException if the entity class or one of its * superclasses does not contain a key field of the given key class and key * name, or if the metadata for the secondary key is invalid. * * * @throws IndexNotAvailableException in a replicated environment if this * Replica's persistent classes have been upgraded to define a new index, * but the Master has not yet been upgraded. * * @throws OperationFailureException if one of the Read Operation * Failures occurs. If the index does not exist and the {@link * StoreConfig#setReadOnly ReadOnly} parameter is false, then one of the Write * Operation Failures may also occur. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. */ public SecondaryIndex getSecondaryIndex(PrimaryIndex primaryIndex, Class keyClass, String keyName) throws DatabaseException { try { return store.getSecondaryIndex (primaryIndex, primaryIndex.getEntityClass(), primaryIndex.getEntityClass().getName(), keyClass, keyClass.getName(), keyName); } catch (IndexNotAvailableException e) { if (!store.attemptRefresh()) { throw e; } return store.getSecondaryIndex (primaryIndex, primaryIndex.getEntityClass(), primaryIndex.getEntityClass().getName(), keyClass, keyClass.getName(), keyName); } } /** * Returns a secondary index for a secondary key in an entity subclass, * opening it if necessary. * *

If a {@link SecondaryKey#relatedEntity} is used and the primary index * for the related entity is not already open, it will be opened by this * method. That will, in turn, open its secondary indices, which can * cascade to open other primary indices.

* * @param primaryIndex the primary index associated with the returned * secondary index. The entity class of the primary index, or one of its * superclasses, must contain a secondary key with the given secondary key * class and key name. * * @param entitySubclass a subclass of the entity class for the primary * index. The entity subclass must contain a secondary key with the given * secondary key class and key name. * * @param keyClass the class of the secondary key field, or the * corresponding primitive wrapper class if the secondary key field type is * a primitive. * * @param keyName the name of the secondary key field, or the {@link * SecondaryKey#name} if this name annotation property was specified. * * @param the secondary key class. * * @param the primary key class. * * @param the entity class. * * @param the entity sub-class. * * @return the secondary index. * * @throws IllegalArgumentException if the given entity subclass does not * contain a key field of the given key class and key name, or if the * metadata for the secondary key is invalid. * * * @throws IndexNotAvailableException in a replicated environment if this * Replica's persistent classes have been upgraded to define a new index, * but the Master has not yet been upgraded. * * @throws OperationFailureException if one of the Read Operation * Failures occurs. If the index does not exist and the {@link * StoreConfig#setReadOnly ReadOnly} parameter is false, then one of the Write * Operation Failures may also occur. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. */ public SecondaryIndex getSubclassIndex(PrimaryIndex primaryIndex, Class entitySubclass, Class keyClass, String keyName) throws DatabaseException { /* Make subclass metadata available before getting the index. */ getModel().getClassMetadata(entitySubclass.getName()); try { return store.getSecondaryIndex (primaryIndex, entitySubclass, primaryIndex.getEntityClass().getName(), keyClass, keyClass.getName(), keyName); } catch (IndexNotAvailableException e) { if (!store.attemptRefresh()) { throw e; } return store.getSecondaryIndex (primaryIndex, entitySubclass, primaryIndex.getEntityClass().getName(), keyClass, keyClass.getName(), keyName); } } /** * Performs conversion of unevolved objects in order to reduce lazy * conversion overhead. Evolution may be performed concurrently with * normal access to the store. * *

Conversion is performed one entity class at a time. An entity class * is converted only if it has {@link Mutations} associated with it via * {@link StoreConfig#setMutations StoreConfig.setMutations}.

* *

Conversion of an entity class is performed by reading each entity, * converting it if necessary, and updating it if conversion was performed. * When all instances of an entity class are converted, references to the * appropriate {@link Mutations} are deleted. Therefore, if this method is * called twice successfully without changing class definitions, the second * call will do nothing.

* * @param config the EvolveConfig. * * @return the EvolveStats. * * * @throws OperationFailureException if one of the Write * Operation Failures occurs. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. * * @see com.sleepycat.persist.evolve Class Evolution */ public EvolveStats evolve(EvolveConfig config) throws DatabaseException { return store.evolve(config); } /** * Deletes all instances of this entity class and its (non-entity) * subclasses. * *

The primary database for the given entity class will be truncated and * all secondary databases will be removed. The primary and secondary * databases associated with the entity class must not be open except by * this store, since database truncation/removal is only possible when the * database is not open.

* *

The primary and secondary databases for the entity class will be * closed by this operation and the existing {@link PrimaryIndex} and * {@link SecondaryIndex} objects will be invalidated. To access the * indexes, the user must call {@link #getPrimaryIndex} and {@link * #getSecondaryIndex} after this operation is complete.

* *

Auto-commit is used implicitly if the store is transactional.

* * @param entityClass the entity class whose instances are to be deleted. * * * @throws OperationFailureException if one of the Write * Operation Failures occurs. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. */ public void truncateClass(Class entityClass) throws DatabaseException { store.truncateClass(null, entityClass); } /** * Deletes all instances of this entity class and its (non-entity) * subclasses. * *

The primary database for the given entity class will be truncated and * all secondary databases will be removed. The primary and secondary * databases associated with the entity class must not be open except by * this store, since database truncation/removal is only possible when the * database is not open.

* *

The primary and secondary databases for the entity class will be * closed by this operation and the existing {@link PrimaryIndex} and * {@link SecondaryIndex} objects will be invalidated. To access the * indexes, the user must call {@link #getPrimaryIndex} and {@link * #getSecondaryIndex} after this operation is complete.

* * @param txn the transaction used to protect this operation, null to use * auto-commit, or null if the store is non-transactional. * * @param entityClass the entity class whose instances are to be deleted. * * * @throws OperationFailureException if one of the Write * Operation Failures occurs. * * @throws EnvironmentFailureException if an unexpected, internal or * environment-wide failure occurs. * * * @throws DatabaseException the base class for all BDB exceptions. */ public void truncateClass(Transaction txn, Class entityClass) throws DatabaseException { store.truncateClass(txn, entityClass); } /* */ /** * Flushes each modified index to disk that was opened in deferred-write * mode. * *

All indexes are opened in deferred-write mode if true was passed to * {@link StoreConfig#setDeferredWrite} for the store.

* *

Alternatively, individual databases may be configured for deferred * write using {@link DatabaseConfig#setDeferredWrite} along with {@link * #getPrimaryConfig} and {@link #setPrimaryConfig}. Caution should be * used when configuring only some databases for deferred-write, since * durability will be different for these databases than for other * databases in the same store.

* *

This method is equivalent to calling {@link Database#sync} for each * deferred-write index Database that is open for this store. * *

Instead of calling this method, {@link Environment#sync} may be used. * The difference is that this method will only flush the databases for * this store, while {@link Environment#sync} will sync all deferred-write * databases currently open for the environment and will also perform a * full checkpoint. This method is therefore less expensive than a full * sync of the environment.

* * @throws DatabaseException the base class for all BDB exceptions. */ public void sync() throws DatabaseException { store.sync(); } /* */ /** * Closes the primary and secondary databases for the given entity class * that were opened via this store. The caller must ensure that the * primary and secondary indices for the entity class are no longer in * use. * *

The primary and secondary databases for the entity class will be * closed by this operation and the existing {@link PrimaryIndex} and * {@link SecondaryIndex} objects will be invalidated. To access the * indexes, the user must call {@link #getPrimaryIndex} and {@link * #getSecondaryIndex} after this operation is complete.

* * @param entityClass the entity class whose databases are to be closed. * * @throws DatabaseException the base class for all BDB exceptions. */ public void closeClass(Class entityClass) throws DatabaseException { store.closeClass(entityClass); } /** * Closes all databases and sequences that were opened via this store. The * caller must ensure that no databases opened via this store are in use. * * *

WARNING: To prevent memory leaks, the application must call this * method even when the Environment has become invalid. While this is not * necessary for Database objects, it is necessary for EntityStore objects * to prevent the accumulation of memory in the global DPL metadata cache. * * *

WARNING: To guard against memory leaks, the application should * discard all references to the closed handle. While BDB makes an effort * to discard references from closed objects to the allocated memory for an * environment, this behavior is not guaranteed. The safe course of action * for an application is to discard all references to closed BDB * objects.

* * @throws DatabaseException the base class for all BDB exceptions. */ public void close() throws DatabaseException { store.close(); } /** * Returns a named sequence for using Berkeley DB engine API directly, * opening it if necessary. * * @param name the sequence name, which is normally defined using the * {@link PrimaryKey#sequence} annotation property. * * @return the open sequence for the given sequence name. * * @throws DatabaseException the base class for all BDB exceptions. */ public Sequence getSequence(String name) throws DatabaseException { return store.getSequence(name); } /** * Returns the default Berkeley DB engine API configuration for a named key * sequence. * *

The returned configuration is as follows. All other properties have * default values.

*
    *
  • The {@link SequenceConfig#setInitialValue InitialValue} is one.
  • *
  • The {@link SequenceConfig#setRange Range} minimum is one.
  • *
  • The {@link SequenceConfig#setCacheSize CacheSize} is 100.
  • *
  • {@link SequenceConfig#setAutoCommitNoSync AutoCommitNoSync} is * true.
  • *
  • {@link SequenceConfig#setAllowCreate AllowCreate} is set to the * inverse of the store {@link StoreConfig#setReadOnly ReadOnly}. * setting.
  • *
* * @param name the sequence name, which is normally defined using the * {@link PrimaryKey#sequence} annotation property. * * @return the default configuration for the given sequence name. */ public SequenceConfig getSequenceConfig(String name) { return store.getSequenceConfig(name); } /** * Configures a named key sequence using the Berkeley DB engine API. * *

To be compatible with the entity model and the Direct Persistence * Layer, the configuration should be retrieved using {@link * #getSequenceConfig getSequenceConfig}, modified, and then passed to this * method. The following configuration properties may not be changed:

*
    *
  • {@link SequenceConfig#setExclusiveCreate ExclusiveCreate}
  • *
*

In addition, {@link SequenceConfig#setAllowCreate AllowCreate} must be * the inverse of {@code ReadOnly}

* *

If the range is changed to include the value zero, see {@link * PrimaryKey} for restrictions.

* * @param name the sequence name, which is normally defined using the * {@link PrimaryKey#sequence} annotation property. * * @param config the configuration to use for the given sequence name. * * @throws IllegalArgumentException if the configuration is incompatible * with the entity model or the Direct Persistence Layer. * * @throws IllegalStateException if the sequence has already been opened. */ public void setSequenceConfig(String name, SequenceConfig config) { store.setSequenceConfig(name, config); } /** * Returns the default primary database Berkeley DB engine API * configuration for an entity class. * *

The returned configuration is as follows. All other properties have * default values.

*
    *
  • {@link DatabaseConfig#setTransactional Transactional} is set to * match {@link StoreConfig#setTransactional StoreConfig}.
  • *
  • {@link DatabaseConfig#setAllowCreate AllowCreate} is set to the * inverse of the store {@link StoreConfig#setReadOnly ReadOnly}. * setting.
  • *
  • {@link DatabaseConfig#setReadOnly ReadOnly} is set to match * {@link StoreConfig#setReadOnly StoreConfig}.
  • * *
  • {@link DatabaseConfig#setDeferredWrite DeferredWrite} is set to * match {@link StoreConfig#setDeferredWrite StoreConfig}.
  • *
  • {@link DatabaseConfig#setTemporary Temporary} is set to * match {@link StoreConfig#setTemporary StoreConfig}.
  • * *
  • {@link DatabaseConfig#setBtreeComparator BtreeComparator} is set to * an internal class if a key comparator is used.
  • *
* * @param entityClass the entity class identifying the primary database. * * @return the default configuration for the given entity class. */ public DatabaseConfig getPrimaryConfig(Class entityClass) { return store.getPrimaryConfig(entityClass); } /** * Configures the primary database for an entity class using the Berkeley * DB engine API. * *

To be compatible with the entity model and the Direct Persistence * Layer, the configuration should be retrieved using {@link * #getPrimaryConfig getPrimaryConfig}, modified, and then passed to this * method. The following configuration properties may not be changed:

*
    *
  • {@link DatabaseConfig#setExclusiveCreate ExclusiveCreate}
  • *
  • {@link DatabaseConfig#setSortedDuplicates SortedDuplicates}
  • * *
  • {@link DatabaseConfig#setTemporary Temporary}
  • * *
  • {@link DatabaseConfig#setBtreeComparator BtreeComparator}
  • *
*

In addition, {@link DatabaseConfig#setAllowCreate AllowCreate} must be * the inverse of {@code ReadOnly}

* * @param entityClass the entity class identifying the primary database. * * @param config the configuration to use for the given entity class. * * @throws IllegalArgumentException if the configuration is incompatible * with the entity model or the Direct Persistence Layer. * * @throws IllegalStateException if the database has already been opened. */ public void setPrimaryConfig(Class entityClass, DatabaseConfig config) { store.setPrimaryConfig(entityClass, config); } /** * Returns the default secondary database Berkeley DB engine API * configuration for an entity class and key name. * *

The returned configuration is as follows. All other properties have * default values.

*
    *
  • {@link DatabaseConfig#setTransactional Transactional} is set to * match the primary database.
  • *
  • {@link DatabaseConfig#setAllowCreate AllowCreate} is set to the * inverse of the primary database {@link DatabaseConfig#setReadOnly * ReadOnly} setting.
  • *
  • {@link DatabaseConfig#setReadOnly ReadOnly} is set to match * the primary database.
  • * *
  • {@link DatabaseConfig#setDeferredWrite DeferredWrite} is set to * match the primary database.
  • *
  • {@link DatabaseConfig#setTemporary Temporary} is set to * match {@link StoreConfig#setTemporary StoreConfig}.
  • * *
  • {@link DatabaseConfig#setBtreeComparator BtreeComparator} is set to * an internal class if a key comparator is used.
  • *
  • {@link DatabaseConfig#setSortedDuplicates SortedDuplicates} is set * according to {@link SecondaryKey#relate}.
  • *
  • {@link SecondaryConfig#setAllowPopulate AllowPopulate} is set to * true when a secondary key is added to an existing primary index.
  • *
  • {@link SecondaryConfig#setKeyCreator KeyCreator} or {@link * SecondaryConfig#setMultiKeyCreator MultiKeyCreator} is set to an * internal instance.
  • *
  • {@link SecondaryConfig#setForeignMultiKeyNullifier * ForeignMultiKeyNullifier} is set to an internal instance if {@link * SecondaryKey#onRelatedEntityDelete} is {@link DeleteAction#NULLIFY}.
  • *
* * @param entityClass the entity class containing the given secondary key * name. * * @param keyName the name of the secondary key field, or the {@link * SecondaryKey#name} if this name annotation property was specified. * * @return the default configuration for the given secondary key. */ public SecondaryConfig getSecondaryConfig(Class entityClass, String keyName) { return store.getSecondaryConfig(entityClass, keyName); } /** * Configures a secondary database for an entity class and key name using * the Berkeley DB engine API. * *

To be compatible with the entity model and the Direct Persistence * Layer, the configuration should be retrieved using {@link * #getSecondaryConfig getSecondaryConfig}, modified, and then passed to * this method. The following configuration properties may not be * changed:

*
    *
  • {@link DatabaseConfig#setExclusiveCreate ExclusiveCreate}
  • *
  • {@link DatabaseConfig#setSortedDuplicates SortedDuplicates}
  • *
  • {@link DatabaseConfig#setBtreeComparator BtreeComparator}
  • *
  • {@link DatabaseConfig#setDuplicateComparator * DuplicateComparator}
  • * *
  • {@link DatabaseConfig#setTemporary Temporary}
  • * *
  • {@link SecondaryConfig#setAllowPopulate AllowPopulate}
  • *
  • {@link SecondaryConfig#setKeyCreator KeyCreator}
  • *
  • {@link SecondaryConfig#setMultiKeyCreator MultiKeyCreator}
  • *
  • {@link SecondaryConfig#setForeignKeyNullifier * ForeignKeyNullifier}
  • *
  • {@link SecondaryConfig#setForeignMultiKeyNullifier * ForeignMultiKeyNullifier}
  • *
  • {@link SecondaryConfig#setForeignKeyDeleteAction * ForeignKeyDeleteAction}
  • *
  • {@link SecondaryConfig#setForeignKeyDatabase * ForeignKeyDatabase}
  • *
*

In addition, {@link DatabaseConfig#setAllowCreate AllowCreate} must be * the inverse of {@code ReadOnly}

* * @param entityClass the entity class containing the given secondary key * name. * * @param keyName the name of the secondary key field, or the {@link * SecondaryKey#name} if this name annotation property was specified. * * @param config the configuration to use for the given secondary key. * * @throws IllegalArgumentException if the configuration is incompatible * with the entity model or the Direct Persistence Layer. * * @throws IllegalStateException if the database has already been opened. */ public void setSecondaryConfig(Class entityClass, String keyName, SecondaryConfig config) { store.setSecondaryConfig(entityClass, keyName, config); } }




© 2015 - 2025 Weber Informatics LLC | Privacy Policy