• Home
• io.ebean
• ebean-core
• 15.7.0
• source code
• DefaultPersister.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.ebeaninternal.server.persist.DefaultPersister Maven / Gradle / Ivy

package io.ebeaninternal.server.persist;

import io.avaje.applog.AppLog;
import io.ebean.*;
import io.ebean.bean.BeanCollection;
import io.ebean.bean.BeanCollection.ModifyListenMode;
import io.ebean.bean.EntityBean;
import io.ebean.bean.PersistenceContext;
import io.ebean.event.BeanPersistController;
import io.ebean.meta.MetricVisitor;
import io.ebeaninternal.api.*;
import io.ebeaninternal.server.core.*;
import io.ebeaninternal.server.core.PersistRequest.Type;
import io.ebeaninternal.server.deploy.*;

import java.sql.SQLException;
import java.util.*;

import static java.lang.System.Logger.Level.DEBUG;
import static java.lang.System.Logger.Level.TRACE;

/**
 * Persister implementation using DML.
 * 

 * This object uses DmlPersistExecute to perform the actual persist execution.
 * 
 * 

 * This object:
 * 

 * 
Determines insert or update for saved beans
 * 
Determines the concurrency mode
 * 
Handles cascading of save and delete
 * 
Handles the batching and queueing
 * 

 */
public final class DefaultPersister implements Persister {

  private static final System.Logger PUB = AppLog.getLogger("io.ebean.PUB");
  private static final System.Logger log = CoreLog.internal;

  /**
   * Actually does the persisting work.
   */
  private final PersistExecute persistExecute;
  private final SpiEbeanServer server;
  private final BeanDescriptorManager beanDescriptorManager;
  private final int maxDeleteBatch;

  public DefaultPersister(SpiEbeanServer server, Binder binder, BeanDescriptorManager descMgr) {
    this.server = server;
    this.beanDescriptorManager = descMgr;
    this.persistExecute = new DefaultPersistExecute(binder, server.config().getPersistBatchSize());
    this.maxDeleteBatch = initMaxDeleteBatch(server.databasePlatform().maxInBinding());
  }

  /**
   * When delete batching is required limit the size.
   * e.g. SqlServer has a 2100 parameter limit, so delete max 2000 for it.
   */
  private int initMaxDeleteBatch(int maxInBinding) {
    return maxInBinding == 0 ? 1000 : Math.min(1000, maxInBinding);
  }

  @Override
  public void visitMetrics(MetricVisitor visitor) {
    persistExecute.visitMetrics(visitor);
  }

  /**
   * Execute the CallableSql.
   */
  @Override
  public int executeCallable(CallableSql callSql, Transaction t) {
    return executeOrQueue(new PersistRequestCallableSql(server, callSql, (SpiTransaction) t, persistExecute));
  }

  /**
   * Execute the orm update.
   */
  @Override
  public int executeOrmUpdate(Update update, Transaction t) {
    SpiUpdate ormUpdate = (SpiUpdate) update;
    BeanManager mgr = beanManager(ormUpdate.beanType());
    return executeOrQueue(new PersistRequestOrmUpdate(server, mgr, ormUpdate, (SpiTransaction) t, persistExecute));
  }

  private int executeOrQueue(PersistRequest request) {
    try {
      request.initTransIfRequired();
      int rc = request.executeOrQueue();
      request.commitTransIfRequired();
      return rc;
    } catch (Throwable e) {
      request.rollbackTransIfRequired();
      throw e;
    } finally {
      request.clearTransIfRequired();
    }
  }

  @Override
  public void addBatch(SpiSqlUpdate sqlUpdate, SpiTransaction transaction) {
    new PersistRequestUpdateSql(server, sqlUpdate, transaction, persistExecute).addBatch();
  }

  @Override
  public int[] executeBatch(SpiSqlUpdate sqlUpdate, SpiTransaction transaction) {
    BatchControl batchControl = transaction.batchControl();
    try {
      return batchControl.execute(sqlUpdate.getGeneratedSql(), sqlUpdate.isGetGeneratedKeys());
    } catch (SQLException e) {
      throw transaction.translate(e.getMessage(), e);
    }
  }

  @Override
  public void executeOrQueue(SpiSqlUpdate update, SpiTransaction t, boolean queue, int queuePosition) {
    if (queue) {
      addToFlushQueue(update, t, queuePosition);
    } else {
      executeSqlUpdate(update, t);
    }
  }

  /**
   * Add to the flush queue in position 0, 1 or 2.
   */
  @Override
  public void addToFlushQueue(SpiSqlUpdate update, SpiTransaction t, int pos) {
    new PersistRequestUpdateSql(server, update, t, persistExecute).addToFlushQueue(pos);
  }

  /**
   * Execute the updateSql.
   */
  @Override
  public int executeSqlUpdate(SqlUpdate updSql, Transaction t) {
    return executeOrQueue(new PersistRequestUpdateSql(server, (SpiSqlUpdate) updSql, (SpiTransaction) t, persistExecute));
  }

  @Override
  public int executeSqlUpdateNow(SpiSqlUpdate updSql, Transaction t) {
    return executeOrQueue(new PersistRequestUpdateSql(server, updSql, (SpiTransaction) t, persistExecute, true));
  }

  /**
   * Recursively delete the bean. This calls back to the EbeanServer.
   */
  private int deleteRecurse(EntityBean detailBean, Transaction t, DeleteMode deleteMode) {
    return deleteRequest(createDeleteCascade(detailBean, t, deleteMode.persistType()));
  }

  /**
   * Delete without being a cascade.
   */
  private int delete(EntityBean detailBean, Transaction t, DeleteMode deleteMode) {
    return deleteRequest(createDeleteRequest(detailBean, t, deleteMode.persistType()));
  }

  @Override
  public int merge(BeanDescriptor desc, EntityBean bean, MergeOptions options, SpiTransaction transaction) {
    MergeHandler merge = new MergeHandler(server, desc, bean, options, transaction);
    List deleteBeans = merge.merge();
    if (!deleteBeans.isEmpty()) {
      // all detected deletes for the merge paths
      for (EntityBean deleteBean : deleteBeans) {
        delete(deleteBean, transaction, options.isDeletePermanent());
      }
    }
    // cascade save as normal with forceUpdate flags set
    PersistRequestBean request = createRequestRecurse(bean, transaction, null, Flags.MERGE);
    request.checkBatchEscalationOnCascade();
    saveRecurse(request);
    request.flushBatchOnCascade();
    // lambda expects a return
    return 0;
  }

  /**
   * Update the bean.
   */
  @Override
  public void update(EntityBean entityBean, Transaction t) {
    PersistRequestBean req = createRequest(entityBean, t, PersistRequest.Type.UPDATE);
    try {
      req.initTransIfRequiredWithBatchCascade();
      if (req.isReference()) {
        // its a reference so see if there are manys to save...
        if (req.isPersistCascade()) {
          saveAssocMany(req);
        }
        req.completeUpdate();
      } else {
        update(req);
      }
      req.resetDepth();
      req.commitTransIfRequired();
      req.flushBatchOnCascade();
    } catch (Throwable ex) {
      req.rollbackTransIfRequired();
      throw ex;
    } finally {
      req.clearTransIfRequired();
    }
  }

  /**
   * Insert or update the bean.
   */
  @Override
  public void save(EntityBean bean, Transaction t) {
    if (bean._ebean_getIntercept().isUpdate()) {
      update(bean, t);
    } else {
      insert(bean, null, t);
    }
  }

  /**
   * Insert this bean.
   */
  @Override
  public void insert(EntityBean bean, InsertOptions insertOptions, Transaction t) {
    PersistRequestBean req = createRequest(bean, t, PersistRequest.Type.INSERT);
    if (req.isSkipReference()) {
      // skip insert on reference bean
      return;
    }
    if (insertOptions != null) {
      req.setInsertOptions(insertOptions);
    }
    try {
      req.initTransIfRequiredWithBatchCascade();
      insert(req);
      req.resetDepth();
      req.commitTransIfRequired();
      req.flushBatchOnCascade();
    } catch (Throwable ex) {
      req.rollbackTransIfRequired();
      throw ex;
    } finally {
      req.clearTransIfRequired();
    }
  }

  void saveRecurse(EntityBean bean, Transaction t, Object parentBean, int flags) {
    // determine insert or update taking into account stateless updates
    saveRecurse(createRequestRecurse(bean, t, parentBean, flags));
  }

  private void saveRecurse(PersistRequestBean request) {
    request.setSaveRecurse();
    if (request.isReference()) {
      // its a reference...
      if (request.isPersistCascade()) {
        // save any associated List held beans
        request.flagUpdate();
        saveAssocMany(request);
      }
      request.completeUpdate();
    } else {
      if (request.isInsert()) {
        insert(request);
      } else {
        update(request);
      }
    }
  }

  /**
   * Insert the bean.
   */
  private void insert(PersistRequestBean request) {
    if (request.isRegisteredBean()) {
      // skip as already inserted/updated in this request (recursive cascading)
      return;
    }
    request.flagInsert();
    try {
      if (request.isPersistCascade()) {
        // save associated One beans recursively first
        saveAssocOne(request);
      }
      request.executeOrQueue();
      if (request.isPersistCascade()) {
        // save any associated List held beans
        saveAssocMany(request);
      }
      request.complete();

    } finally {
      request.unRegisterBean();
    }
  }

  /**
   * Update the bean.
   */
  private void update(PersistRequestBean request) {
    if (request.isRegisteredBean()) {
      // skip as already inserted/updated in this request (recursive cascading)
      return;
    }
    request.flagUpdate();
    try {
      if (request.isPersistCascade()) {
        // save associated One beans recursively first
        saveAssocOne(request);
      }
      if (request.isDirty()) {
        request.executeOrQueue();
      } else if (log.isLoggable(DEBUG)) {
        log.log(DEBUG, "Update skipped as bean is unchanged: {0}", request.bean());
      }
      if (request.isPersistCascade()) {
        // save all the beans in assocMany's after
        saveAssocMany(request);
      }
      request.completeUpdate();
    } finally {
      request.unRegisterBean();
    }
  }

  /**
   * Delete the bean with the explicit transaction.
   * Return false if the delete is executed without OCC and 0 rows were deleted.
   */
  @Override
  public int delete(EntityBean bean, Transaction t, boolean permanent) {
    Type deleteType = permanent ? Type.DELETE_PERMANENT : Type.DELETE;
    PersistRequestBean originalRequest = createDeleteRequest(bean, t, deleteType);
    // normal delete or soft delete
    return deleteRequest(originalRequest);
  }

  /**
   * Execute the delete request returning true if a delete occurred.
   */
  int deleteRequest(PersistRequestBean req) {
    return deleteRequest(req, null);
  }

  /**
   * Execute the delete request support a second delete request for live and draft permanent delete.
   * A common transaction is used across both requests.
   */
  private int deleteRequest(PersistRequestBean req, PersistRequestBean draftReq) {
    if (req.isRegisteredForDeleteBean()) {
      // skip deleting bean. Used where cascade is on
      // both sides of a relationship
      if (log.isLoggable(DEBUG)) {
        log.log(DEBUG, "skipping delete on alreadyRegistered {0}", req.bean());
      }
      return 0;
    }
    try {
      req.initTransIfRequiredWithBatchCascade();
      int rows = delete(req);
      if (draftReq != null) {
        // delete the 'draft' bean ('live' bean deleted first)
        draftReq.setTrans(req.transaction());
        rows = delete(draftReq);
      }
      req.commitTransIfRequired();
      req.flushBatchOnCascade();
      return rows;

    } catch (Throwable ex) {
      req.rollbackTransIfRequired();
      throw ex;
    } finally {
      req.clearTransIfRequired();
    }
  }

  private void deleteCascade(List beanList, SpiTransaction t, DeleteMode deleteMode, boolean children) {
    if (children) {
      t.depth(-1);
      t.checkBatchEscalationOnCollection();
    }
    for (Object bean : beanList) {
      deleteRecurse((EntityBean) bean, t, deleteMode);
    }
    if (children) {
      t.flushBatchOnCollection();
      t.depth(+1);
    }
  }

  /**
   * Delete by a List of Id's.
   */
  @Override
  public int deleteMany(Class beanType, Collection ids, Transaction transaction, boolean permanent) {
    if (ids == null || ids.isEmpty()) {
      return 0;
    }
    BeanDescriptor descriptor = beanDescriptorManager.descriptor(beanType);
    DeleteMode deleteMode = (permanent || !descriptor.isSoftDelete()) ? DeleteMode.HARD : DeleteMode.SOFT;
    if (descriptor.isMultiTenant()) {
      return deleteAsBeans(ids, transaction, deleteMode, descriptor);
    }
    ArrayList