io.ebeaninternal.server.persist.BatchedBeanHolder 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.10.0
package io.ebeaninternal.server.persist;

import io.ebeaninternal.server.core.PersistRequest;
import io.ebeaninternal.server.core.PersistRequestBean;
import io.ebeaninternal.server.deploy.BeanDescriptor;

import java.util.ArrayList;
import java.util.IdentityHashMap;

/**
 * Holds lists of persist requests for beans of a given type.
 * 
 * This is used to delay the actual binding of the bean to PreparedStatements.
 * The reason is that we don't have all the bind values yet in the case of inserts
 * with getGeneratedKeys.
 * 
 * 
 * Has a depth which is used to determine the order in which it should be
 * executed. The lowest depth is executed first.
 * 
 */
public class BatchedBeanHolder {

  private static final Object DUMMY = new Object();

  /**
   * The owning queue.
   */
  private final BatchControl control;

  private final String shortDesc;

  /**
   * The 'depth' which is used to determine the execution order.
   */
  private final int order;

  /**
   * The list of bean insert requests.
   */
  private ArrayList inserts;

  /**
   * The list of bean update requests.
   */
  private ArrayList updates;

  /**
   * The list of bean delete requests.
   */
  private ArrayList deletes;

  /**
   * Set of beans in this batch. This is used to ensure that a single bean instance is not included
   * in the batch twice (two separate insert requests etc).
   */
  private final IdentityHashMap persistedBeans = new IdentityHashMap<>();

  /**
   * Create a new entry with a given type and depth.
   */
  public BatchedBeanHolder(BatchControl control, BeanDescriptor beanDescriptor, int order) {
    this.control = control;
    this.shortDesc = beanDescriptor.getName() + ":" + order;
    this.order = order;
  }

  /**
   * Return the depth.
   */
  public int getOrder() {
    return order;
  }

  /**
   * Execute all the persist requests in this entry.
   * 
   * This will Batch all the similar requests into one or more BatchStatements
   * and then execute them.
   * 
   */
  void executeNow() throws BatchedSqlException {
    // process the requests. Creates one or more PreparedStatements
    // with binding addBatch() for each request.
    // Note updates and deletes can result in many PreparedStatements
    // if their where clauses differ via use of IS NOT NULL.
    if (deletes != null && !deletes.isEmpty()) {
      ArrayList bufferedDeletes = deletes;
      deletes = new ArrayList<>();
      control.executeNow(bufferedDeletes);
    }
    if (inserts != null && !inserts.isEmpty()) {
      ArrayList bufferedInserts = inserts;
      inserts = new ArrayList<>();
      control.executeNow(bufferedInserts);
    }
    if (updates != null && !updates.isEmpty()) {
      ArrayList bufferedUpdates = updates;
      updates = new ArrayList<>();
      control.executeNow(bufferedUpdates);
    }
    persistedBeans.clear();
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder(shortDesc.length() + 18);
    sb.append(shortDesc);
    if (inserts != null) {
      sb.append(" i:").append(inserts.size());
    }
    if (updates != null) {
      sb.append(" u:").append(updates.size());
    }
    if (deletes != null) {
      sb.append(" d:").append(deletes.size());
    }
    return sb.toString();
  }

  /**
   * Add the request to the appropriate persist list.
   */
  public int append(PersistRequestBean request) {

    Object alreadyInBatch = persistedBeans.put(request.getEntityBean(), DUMMY);
    if (alreadyInBatch != null) {
      // special case where the same bean instance has already been
      // added to the batch (doesn't really occur with non-batching
      // as the bean gets changed from dirty to loaded earlier)
      return 0;
    }

    request.setBatched();

    switch (request.getType()) {
      case INSERT:
        if (inserts == null) {
          inserts = new ArrayList<>();
        }
        inserts.add(request);
        return inserts.size();

      case UPDATE:
      case DELETE_SOFT:
        if (updates == null) {
          updates = new ArrayList<>();
        }
        updates.add(request);
        return updates.size();

      case DELETE:
        if (deletes == null) {
          deletes = new ArrayList<>();
        }
        deletes.add(request);
        return deletes.size();

      default:
        throw new RuntimeException("Invalid type code " + request.getType());
    }
  }

  /**
   * Return true if this is empty containing no batched beans.
   */
  public boolean isEmpty() {
    return persistedBeans.isEmpty();
  }
}