ReactiveActionQueue (hibernate-reactive-core 1.0.0.Alpha8 API)

java.lang.Object
- org.hibernate.reactive.engine.ReactiveActionQueue

```
public class ReactiveActionQueue
extends java.lang.Object
```
A reactive counterpart to ActionQueue, where DML operations are queued before execution during a flush.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ReactiveActionQueue.TransactionCompletionProcesses` Wrapper class allowing to bind the same transaction completion process queues in different sessions.

Constructor Summary

Constructors
Constructor and Description

ReactiveActionQueue(org.hibernate.engine.spi.SessionImplementor session)
Constructs an action queue bound to the given session.

Constructors
Constructor and Description
`ReactiveActionQueue(org.hibernate.engine.spi.SessionImplementor session)` Constructs an action queue bound to the given session.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAction(org.hibernate.action.internal.BulkOperationCleanupAction action)` Adds an action defining a cleanup relating to a bulk operation (HQL/JPQL or Criteria based update/delete)
`void`	`addAction(org.hibernate.action.internal.CollectionRecreateAction action)` Adds a collection (re)create action
`void`	`addAction(org.hibernate.action.internal.CollectionRemoveAction action)` Adds a collection remove action
`void`	`addAction(org.hibernate.action.internal.CollectionUpdateAction action)` Adds a collection update action
`void`	`addAction(org.hibernate.action.internal.OrphanRemovalAction action)` Adds an orphan removal action
`void`	`addAction(org.hibernate.action.internal.QueuedOperationCollectionAction action)` Adds an action relating to a collection queued operation (extra lazy).
`void`	`addAction(ReactiveEntityDeleteAction action)` Adds an entity delete action
`java.util.concurrent.CompletionStage<java.lang.Void>`	`addAction(ReactiveEntityIdentityInsertAction action)` Adds an entity (IDENTITY) insert action
`java.util.concurrent.CompletionStage<java.lang.Void>`	`addAction(ReactiveEntityRegularInsertAction action)`
`void`	`addAction(ReactiveEntityUpdateAction action)` Adds an entity update action
`void`	`afterTransactionCompletion(boolean success)` Performs cleanup of any held cache softlocks.
`boolean`	`areInsertionsOrDeletionsQueued()` Check whether any insertion or deletion actions are currently queued.
`boolean`	`areTablesToBeUpdated(java.util.Set tables)` Check whether the given tables/query-spaces are to be executed against given the currently queued actions.
`void`	`beforeTransactionCompletion()` Execute any registered `BeforeTransactionCompletionProcess`
`void`	`checkNoUnresolvedActionsAfterOperation()` Throws `PropertyValueException` if there are any unresolved entity insert actions that depend on non-nullable associations with a transient entity.
`void`	`clear()`
`void`	`clearFromFlushNeededCheck(int previousCollectionRemovalSize)`
`static ReactiveActionQueue`	`deserialize(java.io.ObjectInputStream ois, org.hibernate.engine.spi.SessionImplementor session)` Used by the owning session to explicitly control deserialization of the action queue.
`<E extends ReactiveExecutable> java.util.concurrent.CompletionStage<java.lang.Void>`	`execute(E executable)`
`java.util.concurrent.CompletionStage<java.lang.Void>`	`executeActions()` Perform all currently queued actions.
`java.util.concurrent.CompletionStage<java.lang.Void>`	`executeInserts()` Perform all currently queued entity-insertion actions.
`ReactiveActionQueue.TransactionCompletionProcesses`	`getTransactionCompletionProcesses()`
`boolean`	`hasAfterTransactionActions()`
`boolean`	`hasAnyQueuedActions()`
`boolean`	`hasBeforeTransactionActions()`
`boolean`	`hasUnresolvedEntityInsertActions()` Are there unresolved entity insert actions that depend on non-nullable associations with a transient entity?
`int`	`numberOfCollectionCreations()`
`int`	`numberOfCollectionRemovals()`
`int`	`numberOfCollectionUpdates()`
`int`	`numberOfDeletions()`
`int`	`numberOfInsertions()`
`int`	`numberOfUpdates()`
`void`	`prepareActions()` Prepares the internal action queues for execution.
`void`	`registerProcess(org.hibernate.action.spi.AfterTransactionCompletionProcess process)`
`void`	`registerProcess(org.hibernate.action.spi.BeforeTransactionCompletionProcess process)`
`void`	`serialize(java.io.ObjectOutputStream oos)` Used by the owning session to explicitly control serialization of the action queue
`void`	`setTransactionCompletionProcesses(ReactiveActionQueue.TransactionCompletionProcesses processes, boolean isTransactionCoordinatorShared)` Bind transaction completion processes to make them shared between primary and secondary session.
`void`	`sortActions()`
`void`	`sortCollectionActions()`
`java.lang.String`	`toString()` Returns a string representation of the object.
`void`	`unScheduleDeletion(org.hibernate.engine.spi.EntityEntry entry, java.lang.Object rescuedEntity)`

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

- Constructor Detail
  - ReactiveActionQueue
```
public ReactiveActionQueue(org.hibernate.engine.spi.SessionImplementor session)
```
    Constructs an action queue bound to the given session.
    
    Parameters:
    
    session - The session "owning" this queue.
- Method Detail
  - deserialize
```
public static ReactiveActionQueue deserialize(java.io.ObjectInputStream ois,
                                              org.hibernate.engine.spi.SessionImplementor session)
                                       throws java.io.IOException,
                                              java.lang.ClassNotFoundException
```
    Used by the owning session to explicitly control deserialization of the action queue.
    
    Parameters:
    
    ois - The stream from which to read the action queue
    
    session - The session to which the action queue belongs
    
    Returns:
    
    The deserialized action queue
    
    Throws:
    
    java.io.IOException - indicates a problem reading from the stream
    
    java.lang.ClassNotFoundException - Generally means we were unable to locate user classes.
  - clear
```
public void clear()
```
  - addAction
```
public java.util.concurrent.CompletionStage<java.lang.Void> addAction(ReactiveEntityRegularInsertAction action)
```
  - addAction
```
public java.util.concurrent.CompletionStage<java.lang.Void> addAction(ReactiveEntityIdentityInsertAction action)
```
    Adds an entity (IDENTITY) insert action
    
    Parameters:
    
    action - The action representing the entity insertion
  - addAction
```
public void addAction(ReactiveEntityDeleteAction action)
```
    Adds an entity delete action
    
    Parameters:
    
    action - The action representing the entity deletion
  - addAction
```
public void addAction(org.hibernate.action.internal.OrphanRemovalAction action)
```
    Adds an orphan removal action
    
    Parameters:
    
    action - The action representing the orphan removal
  - addAction
```
public void addAction(ReactiveEntityUpdateAction action)
```
    Adds an entity update action
    
    Parameters:
    
    action - The action representing the entity update
  - addAction
```
public void addAction(org.hibernate.action.internal.CollectionRecreateAction action)
```
    Adds a collection (re)create action
    
    Parameters:
    
    action - The action representing the (re)creation of a collection
  - addAction
```
public void addAction(org.hibernate.action.internal.CollectionRemoveAction action)
```
    Adds a collection remove action
    
    Parameters:
    
    action - The action representing the removal of a collection
  - addAction
```
public void addAction(org.hibernate.action.internal.CollectionUpdateAction action)
```
    Adds a collection update action
    
    Parameters:
    
    action - The action representing the update of a collection
  - addAction
```
public void addAction(org.hibernate.action.internal.QueuedOperationCollectionAction action)
```
    Adds an action relating to a collection queued operation (extra lazy).
    
    Parameters:
    
    action - The action representing the queued operation
  - addAction
```
public void addAction(org.hibernate.action.internal.BulkOperationCleanupAction action)
```
    Adds an action defining a cleanup relating to a bulk operation (HQL/JPQL or Criteria based update/delete)
    
    Parameters:
    
    action - The action representing the queued operation
  - hasUnresolvedEntityInsertActions
```
public boolean hasUnresolvedEntityInsertActions()
```
    Are there unresolved entity insert actions that depend on non-nullable associations with a transient entity?
    
    Returns:
    
    true, if there are unresolved entity insert actions that depend on non-nullable associations with a transient entity; false, otherwise
  - checkNoUnresolvedActionsAfterOperation
```
public void checkNoUnresolvedActionsAfterOperation()
                                            throws org.hibernate.PropertyValueException
```
    Throws PropertyValueException if there are any unresolved entity insert actions that depend on non-nullable associations with a transient entity. This method should be called on completion of an operation (after all cascades are completed) that saves an entity.
    
    Throws:
    
    org.hibernate.PropertyValueException - if there are any unresolved entity insert actions; PropertyValueException.getEntityName() and PropertyValueException.getPropertyName() will return the entity name and property value for the first unresolved entity insert action.
  - registerProcess
```
public void registerProcess(org.hibernate.action.spi.AfterTransactionCompletionProcess process)
```
  - registerProcess
```
public void registerProcess(org.hibernate.action.spi.BeforeTransactionCompletionProcess process)
```
  - executeInserts
```
public java.util.concurrent.CompletionStage<java.lang.Void> executeInserts()
```
    Perform all currently queued entity-insertion actions.
    
    Throws:
    
    org.hibernate.HibernateException - error executing queued insertion actions.
  - executeActions
```
public java.util.concurrent.CompletionStage<java.lang.Void> executeActions()
```
    Perform all currently queued actions.
    
    Throws:
    
    org.hibernate.HibernateException - error executing queued actions.
  - prepareActions
```
public void prepareActions()
                    throws org.hibernate.HibernateException
```
    Prepares the internal action queues for execution.
    
    Throws:
    
    org.hibernate.HibernateException - error preparing actions.
  - afterTransactionCompletion
```
public void afterTransactionCompletion(boolean success)
```
    Performs cleanup of any held cache softlocks.
    
    Parameters:
    
    success - Was the transaction successful.
  - beforeTransactionCompletion
```
public void beforeTransactionCompletion()
```
    Execute any registered BeforeTransactionCompletionProcess
  - areInsertionsOrDeletionsQueued
```
public boolean areInsertionsOrDeletionsQueued()
```
    Check whether any insertion or deletion actions are currently queued.
    
    Returns:
    
    true if insertions or deletions are currently queued; false otherwise.
  - areTablesToBeUpdated
```
public boolean areTablesToBeUpdated(java.util.Set tables)
```
    Check whether the given tables/query-spaces are to be executed against given the currently queued actions.
    
    Parameters:
    
    tables - The table/query-spaces to check.
    
    Returns:
    
    true if we contain pending actions against any of the given tables; false otherwise.
  - execute
```
public <E extends ReactiveExecutable> java.util.concurrent.CompletionStage<java.lang.Void> execute(E executable)
```
    Parameters:
    
    executable - The action to execute
  - toString
```
public java.lang.String toString()
```
    Returns a string representation of the object.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    a string representation of the object.
  - numberOfCollectionRemovals
```
public int numberOfCollectionRemovals()
```
  - numberOfCollectionUpdates
```
public int numberOfCollectionUpdates()
```
  - numberOfCollectionCreations
```
public int numberOfCollectionCreations()
```
  - numberOfDeletions
```
public int numberOfDeletions()
```
  - numberOfUpdates
```
public int numberOfUpdates()
```
  - numberOfInsertions
```
public int numberOfInsertions()
```
  - getTransactionCompletionProcesses
```
public ReactiveActionQueue.TransactionCompletionProcesses getTransactionCompletionProcesses()
```
  - setTransactionCompletionProcesses
```
public void setTransactionCompletionProcesses(ReactiveActionQueue.TransactionCompletionProcesses processes,
                                              boolean isTransactionCoordinatorShared)
```
    Bind transaction completion processes to make them shared between primary and secondary session. Transaction completion processes are always executed by transaction owner (primary session), but can be registered using secondary session too.
    
    Parameters:
    
    processes - Transaction completion processes.
    
    isTransactionCoordinatorShared - Flag indicating shared transaction context.
  - sortCollectionActions
```
public void sortCollectionActions()
```
  - sortActions
```
public void sortActions()
```
  - clearFromFlushNeededCheck
```
public void clearFromFlushNeededCheck(int previousCollectionRemovalSize)
```
  - hasAfterTransactionActions
```
public boolean hasAfterTransactionActions()
```
  - hasBeforeTransactionActions
```
public boolean hasBeforeTransactionActions()
```
  - hasAnyQueuedActions
```
public boolean hasAnyQueuedActions()
```
  - unScheduleDeletion
```
public void unScheduleDeletion(org.hibernate.engine.spi.EntityEntry entry,
                               java.lang.Object rescuedEntity)
```
  - serialize
```
public void serialize(java.io.ObjectOutputStream oos)
               throws java.io.IOException
```
    Used by the owning session to explicitly control serialization of the action queue
    
    Parameters:
    
    oos - The stream to which the action queue should get written
    
    Throws:
    
    java.io.IOException - Indicates an error writing to the stream

Class ReactiveActionQueue

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ReactiveActionQueue

Method Detail

deserialize

clear

addAction

addAction

addAction

addAction

addAction

addAction

addAction

addAction

addAction

addAction

hasUnresolvedEntityInsertActions

checkNoUnresolvedActionsAfterOperation

registerProcess

registerProcess

executeInserts

executeActions

prepareActions

afterTransactionCompletion

beforeTransactionCompletion

areInsertionsOrDeletionsQueued

areTablesToBeUpdated

execute

toString

numberOfCollectionRemovals

numberOfCollectionUpdates

numberOfCollectionCreations

numberOfDeletions

numberOfUpdates

numberOfInsertions

getTransactionCompletionProcesses

setTransactionCompletionProcesses

sortCollectionActions

sortActions

clearFromFlushNeededCheck

hasAfterTransactionActions

hasBeforeTransactionActions

hasAnyQueuedActions

unScheduleDeletion

serialize