io.ebeaninternal.server.transaction.TChangeLogHolder Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of ebean Show documentation

composite of common runtime dependencies for all platforms

There is a newer version: 15.8.1

package io.ebeaninternal.server.transaction;

import io.ebean.event.changelog.BeanChange;
import io.ebean.event.changelog.ChangeSet;
import io.ebean.event.changelog.TxnState;
import io.ebeaninternal.api.SpiTransaction;

import java.util.UUID;

/**
 * Holder of the changes handling the case when we send the changes
 * prior to commit or rollback as we hit the allowed 'batch size'.
 */
public class TChangeLogHolder {

  /**
   * The owning transaction.
   */
  private final SpiTransaction owner;

  /**
   * A transaction id that can be used to join many changeSets when
   * we send multiple for a large transaction.
   */
  private final String transactionId;

  /**
   * When we hit batch size then send the changeSet even when the tranaction
   * has not yet completed.
   */
  private final int batchSize;

  /**
   * The changes we collect to send to the listener.
   */
  private ChangeSet changes;

  private long batchId;

  /**
   * Counter to check when we hit the batch size.
   */
  private int count;

  /**
   * Construct with the owning transaction and batch size to use.
   */
  public TChangeLogHolder(SpiTransaction owner, int batchSize) {
    this.owner = owner;
    this.transactionId = UUID.randomUUID().toString();
    this.batchSize = batchSize;
    this.changes = new ChangeSet(transactionId, 0);
  }

  /**
   * Add a bean change to the change set.
   */
  public void addBeanChange(BeanChange change) {

    changes.addBeanChange(change);
    if (++count >= batchSize) {
      // we hit the batch size so send what we have knowing
      // that the transaction has not completed yet and
      // reset the changes and count
      owner.sendChangeLog(changes);
      changes = new ChangeSet(transactionId, ++batchId);
      count = 0;
    }
  }

  /**
   * On post commit send the changes we have collected.
   */
  public void postCommit() {
    changes.setTxnState(TxnState.COMMITTED);
    owner.sendChangeLog(changes);
  }

  /**
   * On post rollback send the changes we have collected and
   * leave it up to the listener to decide what to do.
   */
  public void postRollback() {
    changes.setTxnState(TxnState.ROLLBACK);
    owner.sendChangeLog(changes);
  }

}