RAMAccessManager (Apache Derby V10.10 Internals)

java.lang.Object
- org.apache.derby.impl.store.access.RAMAccessManager

All Implemented Interfaces:: CacheableFactory, ModuleControl, PropertySetCallback, AccessFactory

Direct Known Subclasses:: RllRAMAccessManager

public abstract class RAMAccessManager
extends java.lang.Object
implements AccessFactory, CacheableFactory, ModuleControl, PropertySetCallback

Field Summary

Fields
Modifier and Type	Field and Description
`private CacheManager`	`conglom_cache` Cache of Conglomerate objects, keyed by conglom id.
`protected ConglomerateFactory[]`	`conglom_map` A map of the implementation specific id to conglomerate object.
`private long`	`conglom_nextid` Routines to map to/from conglomid/containerid:
`private java.util.Hashtable`	`formathash` Hash table on primary format.
`private java.util.Hashtable`	`implhash` Hash table on primary implementation type.
`private PropertyFactory`	`pf`
`private RawStoreFactory`	`rawstore` The raw store that this access manager uses.
`protected LockingPolicy[]`	`record_level_policy`
`private java.util.Properties`	`serviceProperties` Service properties.
`(package private) LockingPolicy`	`system_default_locking_policy` Default locking policy for the entire system.
`protected LockingPolicy[]`	`table_level_policy`
`private PropertyConglomerate`	`xactProperties` The object providing the properties like behaviour that is transactional.

Fields inherited from interface org.apache.derby.iapi.store.access.AccessFactory
MODULE

Constructor Summary

Constructors
Constructor and Description

RAMAccessManager()
Constructors for This class:

Constructors
Constructor and Description
`RAMAccessManager()` Constructors for This class:

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addPropertySetNotification(PropertySetCallback who, TransactionController tc)`
`Serviceable`	`apply(java.lang.String key, java.io.Serializable value, java.util.Dictionary p)` Apply a property change.
`void`	`backup(java.lang.String backupDir, boolean wait)` Backup the database to backupDir.
`void`	`backupAndEnableLogArchiveMode(java.lang.String backupDir, boolean deleteOnlineArchivedLogFiles, boolean wait)` Backup the database to a backup directory and enable the log archive mode that will keep the archived log files required for roll-forward from this version backup.
`private void`	`boot_load_conglom_map()`
`void`	`boot(boolean create, java.util.Properties startParams)` Public Methods implementing ModuleControl Interface:
`protected abstract void`	`bootLookupSystemLockLevel(TransactionController tc)` Query property system to get the System lock level.
`void`	`checkpoint()` Checkpoints the database, that is, flushes all dirty data to disk.
`(package private) void`	`conglomCacheAddEntry(long conglomid, Conglomerate conglom)` Add a newly created conglomerate to the cache.
`(package private) Conglomerate`	`conglomCacheFind(TransactionManager xact_mgr, long conglomid)` Find a conglomerate by conglomid in the cache.
`private void`	`conglomCacheInit()` Initialize the conglomerate cache.
`protected void`	`conglomCacheInvalidate()` Invalide the current Conglomerate Cache.
`(package private) void`	`conglomCacheRemoveEntry(long conglomid)` Remove an entry from the cache.
`void`	`createFinished()` Database creation finished.
`void`	`createReadMeFiles()` DERBY-5996(Create readme files (cautioning users against modifying database files) at database hard upgrade time) This gets called during hard upgrade.
`void`	`disableLogArchiveMode(boolean deleteOnlineArchivedLogFiles)` disables the log archival process, i.e No old log files will be kept around for a roll-forward recovery.
`void`	`failover(java.lang.String dbname)` Start the failover for this database.
`MethodFactory`	`findMethodFactoryByFormat(UUID format)` Find an access method that implements a format type.
`MethodFactory`	`findMethodFactoryByImpl(java.lang.String impltype)` Find an access method that implements an implementation type.
`void`	`freeze()` Freeze the database temporarily so a backup can be taken.
`TransactionController`	`getAndNameTransaction(ContextManager cm, java.lang.String transName)` Get a transaction.
`(package private) RAMTransactionContext`	`getCurrentTransactionContext()` Get the current transaction context.
`protected LockingPolicy`	`getDefaultLockingPolicy()` Return the default locking policy for this access manager.
`(package private) ConglomerateFactory`	`getFactoryFromConglomId(long conglom_id)` Given a conglomid, return the factory which "owns" it.
`LockFactory`	`getLockFactory()` Get the LockFactory to use with this store.
`protected long`	`getNextConglomId(int factory_type)` Return next conglomid to try to add the container with.
`(package private) RawStoreFactory`	`getRawStore()`
`protected abstract int`	`getSystemLockLevel()` Return the locking level of the system.
`TransactionController`	`getTransaction(ContextManager cm)` Get a transaction controller with which to manipulate data within the access manager.
`(package private) PropertyConglomerate`	`getTransactionalProperties()`
`TransactionInfo[]`	`getTransactionInfo()` Return a snap shot of all transactions in the db.
`java.lang.Object`	`getXAResourceManager()` Return the XAResourceManager associated with this AccessFactory.
`void`	`init(boolean dbOnly, java.util.Dictionary p)` Initialize the properties for this callback.
`boolean`	`isReadOnly()` Is the store read-only.
`java.io.Serializable`	`map(java.lang.String key, java.io.Serializable value, java.util.Dictionary p)` Map a proposed new value for a property to an official value.
`Cacheable`	`newCacheable(CacheManager cm)`
`void`	`registerAccessMethod(MethodFactory factory)` Register an access method that this access manager can use.
`void`	`startReplicationMaster(java.lang.String dbmaster, java.lang.String host, int port, java.lang.String replicationMode)` Start the replication master role for this database.
`java.lang.Object`	`startXATransaction(ContextManager cm, int format_id, byte[] global_id, byte[] branch_id)` Start a global transaction.
`void`	`stop()` Stop the module.
`void`	`stopReplicationMaster()` Stop the replication master role for this database.
`void`	`unfreeze()` Unfreeze the database after a backup has been taken.
`boolean`	`validate(java.lang.String key, java.io.Serializable value, java.util.Dictionary p)` Validate a property change.
`void`	`waitForPostCommitToFinishWork()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - rawstore
```
private RawStoreFactory rawstore
```
    The raw store that this access manager uses.
  - implhash
```
private java.util.Hashtable implhash
```
    Hash table on primary implementation type.
  - formathash
```
private java.util.Hashtable formathash
```
    Hash table on primary format.
  - serviceProperties
```
private java.util.Properties serviceProperties
```
    Service properties. These are supplied from ModuleControl.boot(), and ultimately come from the service.properties file. By convention, these properties are passed down to all modules booted by this one. If this module needs to pass specific instructions to its sub-modules, it should create a new Properties object with serviceProperties as its default (so that the rest of the modules that are looking at it don't see the properties that this module needs to add).
  - system_default_locking_policy
```
LockingPolicy system_default_locking_policy
```
    Default locking policy for the entire system.
  - xactProperties
```
private PropertyConglomerate xactProperties
```
    The object providing the properties like behaviour that is transactional.
  - pf
```
private PropertyFactory pf
```
  - table_level_policy
```
protected LockingPolicy[] table_level_policy
```
  - record_level_policy
```
protected LockingPolicy[] record_level_policy
```
  - conglom_map
```
protected ConglomerateFactory[] conglom_map
```
    A map of the implementation specific id to conglomerate object.
    A map of the implementation specific id to conglomerate object. The id is encoded into the conglomerate number, and then used to pick the right implementation of the conglomerate. It is then up to the conglomerate implementation to retrieve it's stored representation from disk. An internal mapping of the encoding of conglomerate identity in the conglomerate number to the actual conglomerate implementation. Encoding this means that we can't dynamically add conglomerate implementations into the system, so when we want to do that this mapping will have to be more dynamic - but for now store knows exactly what implementations there are.
  - conglom_cache
```
private CacheManager conglom_cache
```
    Cache of Conglomerate objects, keyed by conglom id. Used to speed up subsquent open of conglomerates, first open will need to call the conglomerate to read and return it's description.
  - conglom_nextid
```
private long conglom_nextid
```
    Routines to map to/from conglomid/containerid:
- Constructor Detail
  - RAMAccessManager
```
public RAMAccessManager()
```
    Constructors for This class:
- Method Detail
  - getDefaultLockingPolicy
```
protected LockingPolicy getDefaultLockingPolicy()
```
    Return the default locking policy for this access manager.
    
    Returns:
    
    the default locking policy for this accessmanager.
  - getRawStore
```
RawStoreFactory getRawStore()
```
  - getTransactionalProperties
```
PropertyConglomerate getTransactionalProperties()
```
  - boot_load_conglom_map
```
private void boot_load_conglom_map()
                            throws StandardException
```
    Throws:
    
    StandardException
  - getSystemLockLevel
```
protected abstract int getSystemLockLevel()
```
    Return the locking level of the system.
    This routine controls the lowest level of locking enabled for all locks for all tables accessed through this accessmanager. The concrete implementation may set this value always to table level locking for a client configuration, or it may set it to row level locking for a server configuration.
    If TransactionController.MODE_RECORD is returned table may either be locked at table or row locking depending on the type of access expected (ie. level 3 will require table locking for heap scans.)
    
    Returns:
    
    TransactionController.MODE_TABLE if only table locking allowed, else returns TransactionController.MODE_RECORD.
  - bootLookupSystemLockLevel
```
protected abstract void bootLookupSystemLockLevel(TransactionController tc)
                                           throws StandardException
```
    Query property system to get the System lock level.
    This routine will be called during boot after access has booted far enough, to allow access to the property conglomerate. This routine will call the property system and set the value to be returned by getSystemLockLevel().
    
    Throws:
    
    StandardException - Standard exception policy.
  - getNextConglomId
```
protected long getNextConglomId(int factory_type)
                         throws StandardException
```
    Return next conglomid to try to add the container with.
    The conglomerate number has 2 parts. The low 4 bits are used to encode the factory which "owns" the conglomerate. The high 60 bits are used as a normal unique id mechanism.
    So for example if the next id to assign is 0x54 the following will be the conglomid: if a HEAP (factory 0) - 0x540 if a BTREE (factory 1) - 0x541 And the next id assigned will be: if a HEAP (factory 0) - 0x550 if a BTREE (factory 1) - 0x551
    
    Parameters:
    
    factory_type - factory id as gotten from getConglomerateFactoryId()
    
    Returns:
    
    The identifier to be used to open the conglomerate later.
    
    Throws:
    
    StandardException - Standard exception policy.
  - getFactoryFromConglomId
```
ConglomerateFactory getFactoryFromConglomId(long conglom_id)
                                     throws StandardException
```
    Given a conglomid, return the factory which "owns" it.
    A simple lookup on the boot time built table which maps the low order 4 bits into which factory owns the conglomerate.
    
    Parameters:
    
    conglom_id - The conglomerate id of the conglomerate to look up.
    
    Returns:
    
    The ConglomerateFactory which "owns" this conglomerate.
    
    Throws:
    
    StandardException - Standard exception policy.
  - conglomCacheInit
```
private void conglomCacheInit()
                       throws StandardException
```
    Initialize the conglomerate cache.
    Simply calls the cache manager to create the cache with some hard coded defaults for size.
    
    Throws:
    
    StandardException - Standard exception policy.
  - conglomCacheFind
```
Conglomerate conglomCacheFind(TransactionManager xact_mgr,
                              long conglomid)
                       throws StandardException
```
    Find a conglomerate by conglomid in the cache.
    Look for a conglomerate given a conglomid. If in cache return it, otherwise fault in an entry by asking the owning factory to produce an entry.
    
    Parameters:
    
    conglomid - The conglomerate id of the conglomerate to look up.
    
    Returns:
    
    The conglomerate object identified by "conglomid".
    
    Throws:
    
    StandardException - Standard exception policy.
  - conglomCacheInvalidate
```
protected void conglomCacheInvalidate()
                               throws StandardException
```
    Invalide the current Conglomerate Cache.
    Abort of certain operations will invalidate the contents of the cache. Longer term we could just invalidate those entries, but for now just invalidate the whole cache.
    
    Throws:
    
    StandardException - Standard exception policy.
  - conglomCacheAddEntry
```
void conglomCacheAddEntry(long conglomid,
                          Conglomerate conglom)
                   throws StandardException
```
    Add a newly created conglomerate to the cache.
    
    Parameters:
    
    conglomid - The conglomid of conglomerate to replace.
    
    conglom - The Conglom to add.
    
    Throws:
    
    StandardException - Standard exception policy.
  - conglomCacheRemoveEntry
```
void conglomCacheRemoveEntry(long conglomid)
                      throws StandardException
```
    Remove an entry from the cache.
    
    Parameters:
    
    conglomid - The conglomid of conglomerate to replace.
    
    Throws:
    
    StandardException - Standard exception policy.
  - getCurrentTransactionContext
```
RAMTransactionContext getCurrentTransactionContext()
```
    Get the current transaction context.
    
    If there is an internal transaction on the context stack, return the internal transaction. Otherwise, if there is a nested user transaction on the context stack, return the nested transaction. Otherwise, return the current user transaction.
    
    Returns:
    
    a context object referencing the current transaction
  - createFinished
```
public void createFinished()
                    throws StandardException
```
    Database creation finished. Tell RawStore.
    
    Specified by:
    
    createFinished in interface AccessFactory
    
    Throws:
    
    StandardException - standard Derby error policy
  - findMethodFactoryByFormat
```
public MethodFactory findMethodFactoryByFormat(UUID format)
```
    Find an access method that implements a format type.
    
    Specified by:
    
    findMethodFactoryByFormat in interface AccessFactory
    
    See Also:
    
    AccessFactory.findMethodFactoryByFormat(org.apache.derby.catalog.UUID)
  - findMethodFactoryByImpl
```
public MethodFactory findMethodFactoryByImpl(java.lang.String impltype)
                                      throws StandardException
```
    Find an access method that implements an implementation type.
    
    Specified by:
    
    findMethodFactoryByImpl in interface AccessFactory
    
    Throws:
    
    StandardException - Standard exception policy.
    
    See Also:
    
    AccessFactory.findMethodFactoryByImpl(java.lang.String)
  - getLockFactory
```
public LockFactory getLockFactory()
```
    Description copied from interface: AccessFactory
    
    Get the LockFactory to use with this store.
    
    Specified by:
    
    getLockFactory in interface AccessFactory
    
    Returns:
    
    The lock factory to use with this store.
  - getTransaction
```
public TransactionController getTransaction(ContextManager cm)
                                     throws StandardException
```
    Description copied from interface: AccessFactory
    
    Get a transaction controller with which to manipulate data within the access manager. Implicitly creates an access context if one does not already exist.
    
    Specified by:
    
    getTransaction in interface AccessFactory
    
    Parameters:
    
    cm - The context manager for the current context.
    
    Throws:
    
    StandardException - Standard exception policy.
    
    See Also:
    
    TransactionController
  - getAndNameTransaction
```
public TransactionController getAndNameTransaction(ContextManager cm,
                                                   java.lang.String transName)
                                            throws StandardException
```
    Description copied from interface: AccessFactory
    
    Get a transaction. If a new transaction is implicitly created, give it name transName.
    
    Specified by:
    
    getAndNameTransaction in interface AccessFactory
    
    Parameters:
    
    cm - The context manager for the current context.
    
    transName - If a new transaction is started, it will be given this name. The name is displayed in the transactiontable VTI.
    
    Throws:
    
    StandardException - Standard exception policy.
    
    See Also:
    
    TransactionController, AccessFactory.getTransaction(org.apache.derby.iapi.services.context.ContextManager)
  - startXATransaction
```
public java.lang.Object startXATransaction(ContextManager cm,
                                           int format_id,
                                           byte[] global_id,
                                           byte[] branch_id)
                                    throws StandardException
```
    Start a global transaction.
    Get a transaction controller with which to manipulate data within the access manager. Implicitly creates an access context.
    Must only be called if no other transaction context exists in the current context manager. If another transaction exists in the context an exception will be thrown.
    The (format_id, global_id, branch_id) triplet is meant to come exactly from a javax.transaction.xa.Xid. We don't use Xid so that the system can be delivered on a non-1.2 vm system and not require the javax classes in the path.
    
    Specified by:
    
    startXATransaction in interface AccessFactory
    
    Parameters:
    
    cm - The context manager for the current context.
    
    format_id - the format id part of the Xid - ie. Xid.getFormatId().
    
    global_id - the global transaction identifier part of XID - ie. Xid.getGlobalTransactionId().
    
    branch_id - The branch qualifier of the Xid - ie. Xid.getBranchQaulifier()
    
    Throws:
    
    StandardException - Standard exception policy.
    
    See Also:
    
    TransactionController
  - getXAResourceManager
```
public java.lang.Object getXAResourceManager()
                                      throws StandardException
```
    Return the XAResourceManager associated with this AccessFactory.
    Returns an object which can be used to implement the "offline" 2 phase commit interaction between the accessfactory and outstanding transaction managers taking care of in-doubt transactions.
    
    Specified by:
    
    getXAResourceManager in interface AccessFactory
    
    Returns:
    
    The XAResourceManager associated with this accessfactory.
    
    Throws:
    
    StandardException - Standard exception policy.
  - registerAccessMethod
```
public void registerAccessMethod(MethodFactory factory)
```
    Description copied from interface: AccessFactory
    
    Register an access method that this access manager can use.
    
    Specified by:
    
    registerAccessMethod in interface AccessFactory
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: AccessFactory
    
    Is the store read-only.
    
    Specified by:
    
    isReadOnly in interface AccessFactory
  - createReadMeFiles
```
public void createReadMeFiles()
                       throws StandardException
```
    DERBY-5996(Create readme files (cautioning users against modifying database files) at database hard upgrade time) This gets called during hard upgrade. It will create 3 readme files one in database directory, one in "seg0" directory and one in log directory. These readme files warn users against touching any of files associated with derby database
    
    Specified by:
    
    createReadMeFiles in interface AccessFactory
    
    Throws:
    
    StandardException
  - addPropertySetNotification
```
private void addPropertySetNotification(PropertySetCallback who,
                                        TransactionController tc)
```
  - getTransactionInfo
```
public TransactionInfo[] getTransactionInfo()
```
    Description copied from interface: AccessFactory
    
    Return a snap shot of all transactions in the db.
    Take a snap shot of all transactions currently in the database and make a record of their information.
    
    Specified by:
    
    getTransactionInfo in interface AccessFactory
    
    Returns:
    
    an array of TransactionInfo, or null if there is no transaction in the database.
  - startReplicationMaster
```
public void startReplicationMaster(java.lang.String dbmaster,
                                   java.lang.String host,
                                   int port,
                                   java.lang.String replicationMode)
                            throws StandardException
```
    Start the replication master role for this database.
    
    Specified by:
    
    startReplicationMaster in interface AccessFactory
    
    Parameters:
    
    dbmaster - The master database that is being replicated.
    
    host - The hostname for the slave
    
    port - The port the slave is listening on
    
    replicationMode - The type of replication contract. Currently only asynchronous replication is supported, but 1-safe/2-safe/very-safe modes may be added later.
    
    Throws:
    
    StandardException - Standard Derby exception policy, thrown on error.
  - failover
```
public void failover(java.lang.String dbname)
              throws StandardException
```
    Description copied from interface: AccessFactory
    
    Start the failover for this database.
    
    Specified by:
    
    failover in interface AccessFactory
    
    Parameters:
    
    dbname - the replication database that is being failed over.
    
    Throws:
    
    StandardException - Standard Derby exception policy, 1) If the failover succeeds, an exception is thrown to indicate that the master database was shutdown after a successful failover 2) If a failure occurs during network communication with slave.
    
    See Also:
    
    AccessFactory.failover(String dbname).
  - stopReplicationMaster
```
public void stopReplicationMaster()
                           throws StandardException
```
    Stop the replication master role for this database.
    
    Specified by:
    
    stopReplicationMaster in interface AccessFactory
    
    Throws:
    
    StandardException - Standard Derby exception policy, thrown on error.
  - freeze
```
public void freeze()
            throws StandardException
```
    Description copied from interface: AccessFactory
    
    Freeze the database temporarily so a backup can be taken.
    Please see Derby on line documentation on backup and restore.
    
    Specified by:
    
    freeze in interface AccessFactory
    
    Throws:
    
    StandardException - Thrown on error
  - unfreeze
```
public void unfreeze()
              throws StandardException
```
    Description copied from interface: AccessFactory
    
    Unfreeze the database after a backup has been taken.
    Please see Derby on line documentation on backup and restore.
    
    Specified by:
    
    unfreeze in interface AccessFactory
    
    Throws:
    
    StandardException - Thrown on error
  - backup
```
public void backup(java.lang.String backupDir,
                   boolean wait)
            throws StandardException
```
    Description copied from interface: AccessFactory
    
    Backup the database to backupDir.
    Please see Derby on line documentation on backup and restore.
    
    Specified by:
    
    backup in interface AccessFactory
    
    Parameters:
    
    backupDir - the name of the directory where the backup should be stored.
    
    wait - if true, waits for all the backup blocking operations in progress to finish.
    
    Throws:
    
    StandardException - Thrown on error
  - backupAndEnableLogArchiveMode
```
public void backupAndEnableLogArchiveMode(java.lang.String backupDir,
                                          boolean deleteOnlineArchivedLogFiles,
                                          boolean wait)
                                   throws StandardException
```
    Description copied from interface: AccessFactory
    
    Backup the database to a backup directory and enable the log archive mode that will keep the archived log files required for roll-forward from this version backup.
    
    Specified by:
    
    backupAndEnableLogArchiveMode in interface AccessFactory
    
    Parameters:
    
    backupDir - the directory name where the database backup should go. This directory will be created if not it does not exist.
    
    deleteOnlineArchivedLogFiles - If true deletes online archived log files that exist before this backup, delete will occur only after backup is complete.
    
    wait - if true, waits for all the backup blocking operations in progress to finish.
    
    Throws:
    
    StandardException - Thrown on error
  - disableLogArchiveMode
```
public void disableLogArchiveMode(boolean deleteOnlineArchivedLogFiles)
                           throws StandardException
```
    Description copied from interface: AccessFactory
    
    disables the log archival process, i.e No old log files will be kept around for a roll-forward recovery.
    
    Specified by:
    
    disableLogArchiveMode in interface AccessFactory
    
    Parameters:
    
    deleteOnlineArchivedLogFiles - If true deletes all online archived log files that exist before this call immediately; Only restore that can be performed after disabling log archive mode is version recovery.
    
    Throws:
    
    StandardException - Thrown on error
  - checkpoint
```
public void checkpoint()
                throws StandardException
```
    Description copied from interface: AccessFactory
    
    Checkpoints the database, that is, flushes all dirty data to disk. Records a checkpoint in the transaction log, if there is a log.
    
    Specified by:
    
    checkpoint in interface AccessFactory
    
    Throws:
    
    StandardException - Thrown on error
  - waitForPostCommitToFinishWork
```
public void waitForPostCommitToFinishWork()
```
    Specified by:
    
    waitForPostCommitToFinishWork in interface AccessFactory
  - boot
```
public void boot(boolean create,
                 java.util.Properties startParams)
          throws StandardException
```
    Public Methods implementing ModuleControl Interface:
    
    Specified by:
    
    boot in interface ModuleControl
    
    Throws:
    
    StandardException - Module cannot be started.
    
    See Also:
    
    Monitor, ModuleFactory
  - stop
```
public void stop()
```
    Description copied from interface: ModuleControl
    
    Stop the module. The module may be found via a findModule() method until some time after this method returns. Therefore the factory must be prepared to reject requests to it once it has been stopped. In addition other modules may cache a reference to the module and make requests of it after it has been stopped, these requests should be rejected as well.
    
    Specified by:
    
    stop in interface ModuleControl
    
    See Also:
    
    Monitor, ModuleFactory
  - init
```
public void init(boolean dbOnly,
                 java.util.Dictionary p)
```
    Description copied from interface: PropertySetCallback
    
    Initialize the properties for this callback. Called when addPropertySetNotification() is called with a non-null transaction controller. This allows code to set read its initial property values at boot time.
    Code within an init() method should use the 3 argument PropertyUtil method getPropertyFromSet() to obtain a property's value.
    
    Specified by:
    
    init in interface PropertySetCallback
    
    Parameters:
    
    dbOnly - true if only per-database properties are to be looked at
    
    p - the complete set of per-database properties.
  - validate
```
public boolean validate(java.lang.String key,
                        java.io.Serializable value,
                        java.util.Dictionary p)
                 throws StandardException
```
    Description copied from interface: PropertySetCallback
    
    Validate a property change.
    
    Specified by:
    
    validate in interface PropertySetCallback
    
    Parameters:
    
    key - Property key for the property being set
    
    value - proposed new value for the property being set or null if the property is being dropped.
    
    p - Property set before the change. SettingProperty may read but must never change p.
    
    Returns:
    
    true if this object was interested in this property, false otherwise.
    
    Throws:
    
    StandardException - Oh well.
  - apply
```
public Serviceable apply(java.lang.String key,
                         java.io.Serializable value,
                         java.util.Dictionary p)
                  throws StandardException
```
    Description copied from interface: PropertySetCallback
    
    Apply a property change. Will only be called after validate has been called and only if validate returned true. If this method is called then the new value is the value to be used, ie. the property is not set in the overriding JVM system set.
    
    Specified by:
    
    apply in interface PropertySetCallback
    
    Parameters:
    
    key - Property key for the property being set
    
    value - proposed new value for the property being set or null if the property is being dropped.
    
    p - Property set before the change. SettingProperty may read but must never change p.
    
    Returns:
    
    post commit work for the property change.
    
    Throws:
    
    StandardException - Oh well.
  - map
```
public java.io.Serializable map(java.lang.String key,
                                java.io.Serializable value,
                                java.util.Dictionary p)
                         throws StandardException
```
    Description copied from interface: PropertySetCallback
    
    Map a proposed new value for a property to an official value. Will only be called after apply() has been called.
    
    Specified by:
    
    map in interface PropertySetCallback
    
    Parameters:
    
    key - Property key for the property being set
    
    value - proposed new value for the property being set or null if the property is being dropped.
    
    p - Property set before the change. SettingProperty may read but must never change p.
    
    Returns:
    
    new value for the change
    
    Throws:
    
    StandardException - Oh well.
  - newCacheable
```
public Cacheable newCacheable(CacheManager cm)
```
    Specified by:
    
    newCacheable in interface CacheableFactory

Class RAMAccessManager

Field Summary

Fields inherited from interface org.apache.derby.iapi.store.access.AccessFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

rawstore

implhash

formathash

serviceProperties

system_default_locking_policy

xactProperties

pf

table_level_policy

record_level_policy

conglom_map

conglom_cache

conglom_nextid

Constructor Detail

RAMAccessManager

Method Detail

getDefaultLockingPolicy

getRawStore

getTransactionalProperties

boot_load_conglom_map

getSystemLockLevel

bootLookupSystemLockLevel

getNextConglomId

getFactoryFromConglomId

conglomCacheInit

conglomCacheFind

conglomCacheInvalidate

conglomCacheAddEntry

conglomCacheRemoveEntry

getCurrentTransactionContext

createFinished

findMethodFactoryByFormat

findMethodFactoryByImpl

getLockFactory

getTransaction

getAndNameTransaction

startXATransaction

getXAResourceManager

registerAccessMethod

isReadOnly

createReadMeFiles

addPropertySetNotification

getTransactionInfo

startReplicationMaster

failover

stopReplicationMaster

freeze

unfreeze

backup

backupAndEnableLogArchiveMode

disableLogArchiveMode

checkpoint

waitForPostCommitToFinishWork

boot

stop

init

validate

apply

map

newCacheable