Package org.apache.openjpa.kernel

Interface Broker

    • Method Detail

      • setImplicitBehavior

        void setImplicitBehavior​(OpCallbacks call,
                         RuntimeExceptionTranslator ex)
        Set the broker's behavior for implicit actions such as flushing, automatic detachment, and exceptions thrown by managed instances outside a broker operation. A broker's implicit behavior can only be set once; after the first invocation with non-null arguments, subsequent invocations of this method are ignored.

      • getBrokerFactory

        BrokerFactory getBrokerFactory()
        Return the factory that produced this broker.

      • getConnectionRetainMode

        int getConnectionRetainMode()
        Return the connection retain mode for this broker.

      • getManagedRuntime

        ManagedRuntime getManagedRuntime()
        Return the managed runtime in use.

      • getInverseManager

        InverseManager getInverseManager()
        Return the inverse manager in use.
        Since:
        0.3.2

      • getMultithreaded

        boolean getMultithreaded()
        Whether the broker or its managed instances are used in a multithreaded environment.

      • setMultithreaded

        void setMultithreaded​(boolean multi)
        Whether the broker or its managed instances are used in a multithreaded environment.

      • getIgnoreChanges

        boolean getIgnoreChanges()
        Whether to take into account changes in the transaction when executing a query or iterating an extent.

      • setIgnoreChanges

        void setIgnoreChanges​(boolean ignore)
        Whether to take into account changes in the transaction when executing a query or iterating an extent.

      • getNontransactionalRead

        boolean getNontransactionalRead()
        Whether to allow nontransactional access to persistent state.

      • setNontransactionalRead

        void setNontransactionalRead​(boolean read)
        Whether to allow nontransactional access to persistent state.

      • getNontransactionalWrite

        boolean getNontransactionalWrite()
        Whether to allow nontransactional changes to persistent state.

      • setNontransactionalWrite

        void setNontransactionalWrite​(boolean write)
        Whether to allow nontransactional changes to persistent state.

      • getRestoreState

        int getRestoreState()
        Whether to restore an object's original state on rollback.

      • setRestoreState

        void setRestoreState​(int restore)
        Whether to restore an object's original state on rollback.

      • getOptimistic

        boolean getOptimistic()
        Whether to use optimistic transactional semantics.

      • setOptimistic

        void setOptimistic​(boolean opt)
        Whether to use optimistic transactional semantics.

      • getRetainState

        boolean getRetainState()
        Whether objects retain their persistent state on transaction commit.

      • setRetainState

        void setRetainState​(boolean retain)
        Whether objects retain their persistent state on transaction commit.

      • getAutoClear

        int getAutoClear()
        Whether objects clear when entering transactions.

      • setAutoClear

        void setAutoClear​(int clear)
        Whether objects clear when entering transactions.

      • getSyncWithManagedTransactions

        boolean getSyncWithManagedTransactions()
        Whether to check for a global transaction upon every managed, non-transactional operation. Defaults to false.

      • setSyncWithManagedTransactions

        void setSyncWithManagedTransactions​(boolean resync)
        Whether to check for a global transaction upon every managed, non-transactional operation. Defaults to false.

      • getAutoDetach

        int getAutoDetach()
        Bit flags marked in AutoDetach which indicate when persistent managed objects should be automatically detached in-place.

      • setAutoDetach

        void setAutoDetach​(int flags)
        Bit flags marked in AutoDetach which indicate when persistent managed objects should be automatically detached in-place.

      • setAutoDetach

        void setAutoDetach​(int flag,
                   boolean on)
        Bit flags marked in AutoDetach which indicate when persistent managed objects should be automatically detached in-place.

      • getProperties

        Map<String,​Object> getProperties()
        Retrieve the current properties for this broker Some of these properties may have been changed from the original configuration.
        Returns:
        the changed properties
        Since:
        2.0.0

      • getSupportedProperties

        Set<String> getSupportedProperties()
        Return the supported properties for this broker as property keys. If a property has multiple keys, all keys will be returned.
        Since:
        2.0.0

      • isDetachedNew

        boolean isDetachedNew()
        Whether to treat relations to detached instances during persist operations as new or as pseudo-hollow instances.

      • setDetachedNew

        void setDetachedNew​(boolean isNew)
        Whether to treat relations to detached instances as new.

      • getEvictFromDataCache

        boolean getEvictFromDataCache()
        Whether to also evict an object from the store cache when it is evicted through this broker.

      • setEvictFromDataCache

        void setEvictFromDataCache​(boolean evict)
        Whether to also evict an object from the store cache when it is evicted through this broker.

      • putUserObject

        Object putUserObject​(Object key,
                     Object val)
        Put the specified key-value pair into the map of user objects. Use a value of null to remove the key.
        Since:
        0.3.2

      • getUserObject

        Object getUserObject​(Object key)
        Get the value for the specified key from the map of user objects.
        Since:
        0.3.2

      • addTransactionListener

        void addTransactionListener​(Object listener)
        Register a listener for transaction-related events.
        Since:
        0.2.5

      • removeTransactionListener

        void removeTransactionListener​(Object listener)
        Remove a listener for transaction-related events.
        Since:
        0.2.5

      • getTransactionListeners

        Collection<Object> getTransactionListeners()
        Gets an umodifiable collection of currently registered lsteners.
        Since:
        2.0.0

      • getTransactionListenerCallbackMode

        int getTransactionListenerCallbackMode()
        The callback mode for handling exceptions from transaction event listeners.

      • setTransactionListenerCallbackMode

        void setTransactionListenerCallbackMode​(int mode)
        The callback mode for handling exceptions from transaction event listeners.

      • addLifecycleListener

        void addLifecycleListener​(Object listener,
                          Class[] classes)
        Register a listener for lifecycle-related events on the specified classes. If the classes are null, all events will be propagated to the listener.
        Since:
        0.3.3

      • removeLifecycleListener

        void removeLifecycleListener​(Object listener)
        Remove a listener for lifecycle-related events.
        Since:
        0.3.3

      • getLifecycleEventManager

        LifecycleEventManager getLifecycleEventManager()
        Return the lifecycle event manager associated with the broker.

      • getLifecycleListenerCallbackMode

        int getLifecycleListenerCallbackMode()
        The callback mode for handling exceptions from lifecycle event listeners.

      • setLifecycleListenerCallbackMode

        void setLifecycleListenerCallbackMode​(int mode)
        The callback mode for handling exceptions from lifecycle event listeners.

      • getCachePreparedQuery

        boolean getCachePreparedQuery()
        Affirms if this receiver is caching prepared queries.
        Since:
        2.0.0

      • setCachePreparedQuery

        void setCachePreparedQuery​(boolean flag)
        Sets whether this receiver will cache prepared queries during its lifetime. The cache configured at BrokerFactory level is not affected by setting it inactive for this receiver.
        Since:
        2.0.0

      • begin

        void begin()
        Begin a transaction.

      • commit

        void commit()
        Commit the current transaction.

      • rollback

        void rollback()
        Rollback the current transaction.

      • syncWithManagedTransaction

        boolean syncWithManagedTransaction()
        Attempt to synchronize with a current managed transaction, returning true if successful, false if no managed transaction is active.

      • commitAndResume

        void commitAndResume()
        Issue a commit and then start a new transaction. This is identical to: 
         broker.commit (); broker.begin ();
        except that the broker's internal atomic lock is utilized, so this method can be safely executed from multiple threads.
        Since:
        0.2.4
        See Also:
        commit(), begin()

      • rollbackAndResume

        void rollbackAndResume()
        Issue a rollback and then start a new transaction. This is identical to: 
         broker.rollback (); broker.begin ();
        except that the broker's internal atomic lock is utilized, so this method can be safely executed from multiple threads.
        Since:
        0.2.4
        See Also:
        rollback(), begin()

      • getRollbackOnly

        boolean getRollbackOnly()
        Return whether the current transaction has been marked for rollback.

      • setRollbackOnly

        void setRollbackOnly()
        Mark the current transaction for rollback.

      • setRollbackOnly

        void setRollbackOnly​(Throwable cause)
        Mark the current transaction for rollback with the specified cause of the rollback.
        Since:
        0.9.7

      • getRollbackCause

        Throwable getRollbackCause()
        Returns the Throwable that caused the transaction to be marked for rollback.
        Returns:
        the Throwable, or null if none was given
        Since:
        0.9.7

      • setSavepoint

        void setSavepoint​(String name)
        Set a transactional savepoint where operations after this savepoint will be rolled back.

      • rollbackToSavepoint

        void rollbackToSavepoint()
        Rollback the current transaction to the last savepoint. Savepoints set after this one will become invalid.

      • rollbackToSavepoint

        void rollbackToSavepoint​(String name)
        Rollback the current transaction to the given savepoint name. Savepoints set after this one will become invalid.

      • releaseSavepoint

        void releaseSavepoint()
        Release the last set savepoint and any resources associated with it. The given savepoint and any set after it will become invalid.

      • releaseSavepoint

        void releaseSavepoint​(String name)
        Release the savepoint and any resources associated with it. The given savepoint and any set after it will become invalid.

      • flush

        void flush()
        Flush all transactional instances to the data store. This method may set the rollback only flag on the current transaction if it encounters an error.
        Since:
        0.2.5

      • preFlush

        void preFlush()
        Run pre-flush actions on transactional objects, including persistence-by-reachability, inverse relationship management, deletion of dependent instances, and instance callbacks. Transaction listeners are not invoked.
        Since:
        0.3.3

      • validateChanges

        void validateChanges()
        Validate the changes made in this transaction, reporting any optimistic violations, constraint violations, etc. In a datastore transaction or a flushed optimistic transaction, this method will act just like flush(). In an optimistic transaction that has not yet begun a datastore-level transaction, however, it will only report exceptions that would occur on flush, without retaining any datastore resources.

      • persist

        OpenJPAStateManager persist​(Object pc,
                            Object id,
                            OpCallbacks call)
        Make the given instance persistent. Unlike other persist operations, this method does not immediately cascade to fields marked ValueMetaData.CASCADE_IMMEDIATE.
        Parameters:
        pc - the instance to persist
        id - the id to give the state manager; may be null for default
        Returns:
        the state manager for the newly persistent instance

      • release

        void release​(Object pc,
             OpCallbacks call)
        Release the given object from management. This operation is not recursive.

      • releaseAll

        void releaseAll​(Collection objs,
                OpCallbacks call)
        Release the given objects from management. This operation is not recursive.

      • refresh

        void refresh​(Object pc,
             OpCallbacks call)
        Refresh the state of the given object.

      • refreshAll

        void refreshAll​(Collection objs,
                OpCallbacks call)
        Refresh the state of the given objects.

      • evictAll

        void evictAll​(OpCallbacks call)
        Evict all clean objects.

      • evictAll

        void evictAll​(Extent extent,
              OpCallbacks call)
        Evict all persistent-clean and persistent-nontransactional instances in the given Extent.

      • detachAll

        void detachAll​(OpCallbacks call)
        Detach all objects in place. A flush will be performed before detaching the entities.

      • detachAll

        void detachAll​(OpCallbacks call,
               boolean flush)
        Detach all objects in place, with the option of performing a flush before doing the detachment.
        Parameters:
        call - Persistence operation callbacks
        flush - boolean value to indicate whether to perform a flush before detaching the entities (true, do the flush; false, don't do the flush)

      • detach

        Object detach​(Object pc,
              OpCallbacks call)
        Detach the specified object from the broker.
        Parameters:
        pc - the instance to detach
        Returns:
        the detached instance

      • detachAll

        Object[] detachAll​(Collection objs,
                   OpCallbacks call)
        Detach the specified objects from the broker. The objects returned can be manipulated and re-attached with attachAll(java.util.Collection, boolean, org.apache.openjpa.kernel.OpCallbacks). The detached instances will be unmanaged copies of the specified parameters, and are suitable for serialization and manipulation outside of a OpenJPA environment. When detaching instances, only fields in the current FetchConfiguration will be traversed. Thus, to detach a graph of objects, relations to other persistent instances must either be in the default-fetch-group, or in the current custom FetchConfiguration.
        Parameters:
        objs - the instances to detach
        Returns:
        the detached instances

      • attach

        Object attach​(Object pc,
              boolean copyNew,
              OpCallbacks call)
        Import the specified detached object into the broker.
        Parameters:
        pc - instance to import
        copyNew - whether to copy new instances
        Returns:
        the re-attached instance

      • attachAll

        Object[] attachAll​(Collection objs,
                   boolean copyNew,
                   OpCallbacks call)
        Import the specified objects into the broker. Instances that were previously detached from this or another broker will have their changed merged into the persistent instances. Instances that are new will be persisted as new instances.
        Parameters:
        objs - array of instances to import
        copyNew - whether to copy new instances
        Returns:
        the re-attached instances

      • newInstance

        Object newInstance​(Class cls)
        Create a new instance of type cls. If cls is an interface or an abstract class whose abstract methods follow the JavaBeans convention, this method will create a concrete implementation according to the metadata that defines the class. Otherwise, if cls is a managed type, this will return an instance of the specified class.
        Throws:
        IllegalArgumentException - if cls is not a managed type or interface.

      • newExtent

        Extent newExtent​(Class cls,
                 boolean subs)
        Return an extent of the given class, optionally including subclasses.

      • newQuery

        Query newQuery​(String language,
               Class cls,
               Object query)
        Create a new query from the given data, with the given candidate class and language.

      • newQuery

        Query newQuery​(String language,
               Object query)
        Create a new query in the given language.

      • getIdentitySequence

        Seq getIdentitySequence​(ClassMetaData meta)
        Returns a Seq for the datastore identity values of the specified persistent class, or null if the class' identity cannot be represented as a sequence.

      • getValueSequence

        Seq getValueSequence​(FieldMetaData fmd)
        Returns a Seq for the generated values of the specified field, or null if the field is not generated.

      • lock

        void lock​(Object pc,
          int level,
          int timeout,
          OpCallbacks call)
        Ensure that the given instance is locked at the given lock level.
        Parameters:
        pc - the object to lock
        level - the lock level to use
        timeout - the number of milliseconds to wait for the lock before giving up, or -1 for no limit
        Since:
        0.3.1

      • lock

        void lock​(Object pc,
          OpCallbacks call)
        Ensure that the given instance is locked at the current lock level, as set in the FetchConfiguration for the broker.
        Since:
        0.3.1

      • lockAll

        void lockAll​(Collection objs,
             int level,
             int timeout,
             OpCallbacks call)
        Ensure that the given instances are locked at the given lock level.
        Parameters:
        objs - the objects to lock
        level - the lock level to use
        timeout - the number of milliseconds to wait for the lock before giving up, or -1 for no limit
        Since:
        0.3.1

      • lockAll

        void lockAll​(Collection objs,
             OpCallbacks call)
        Ensure that the given instances are locked at the current lock level, as set in the FetchConfiguration for the broker.
        Since:
        0.3.1

      • cancelAll

        boolean cancelAll()
        Cancel all pending data store statements. If statements are cancelled while a flush is in progress, the transaction rollback only flag will be set.
        Returns:
        true if any statements were cancelled, false otherwise
        Since:
        0.3.1

      • dirtyType

        void dirtyType​(Class cls)
        Mark the given class as dirty within the current transaction.
        Since:
        0.3.0

      • beginOperation

        boolean beginOperation​(boolean syncTrans)
        Begin a logical operation. This indicates to the broker the granularity of an operation which may require pre/post operation side-effects, such as non-tx detach. Will lock the broker until the endOperation() is called.
        Parameters:
        syncTrans - whether instances may be loaded/modified during this operation requiring a re-check of global tx
        Returns:
        whether this is the outermost operation on the stack

      • endOperation

        boolean endOperation()
        End a logical operation. This indicates to the broker the granularity of an operation which may require pre/post operation side-effects, such as non-tx detach. Unlocks the given broker.
        Returns:
        whether this is the outermost operation on the stack

      • isClosed

        boolean isClosed()
        Whether the broker is closed.

      • isCloseInvoked

        boolean isCloseInvoked()
        Whether close() has been invoked, though the broker might remain open until the current managed transaction completes.

      • close

        void close()
        Close the broker.
        Specified by:
        close in interface Closeable

      • assertOpen

        void assertOpen()
        Throw an exception if this broker has been closed.

      • assertActiveTransaction

        void assertActiveTransaction()
        Throw an exception if there is no active transaction.

      • assertNontransactionalRead

        void assertNontransactionalRead()
        Throw an exception if there is no transaction active and nontransactional reading is not enabled.

      • assertWriteOperation

        void assertWriteOperation()
        Throw an exception if a write operation is not permitted (there is no active transaction and nontransactional writing is not enabled).