All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.avaje.ebeaninternal.server.persist.DefaultPersister Maven / Gradle / Ivy

    /**
 * Copyright (C) 2006  Robin Bygrave
 * 
 * This file is part of Ebean.
 * 
 * Ebean is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *  
 * Ebean is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with Ebean; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
 */
package com.avaje.ebeaninternal.server.persist;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.persistence.PersistenceException;

import com.avaje.ebean.CallableSql;
import com.avaje.ebean.Query;
import com.avaje.ebean.SqlUpdate;
import com.avaje.ebean.Transaction;
import com.avaje.ebean.Update;
import com.avaje.ebean.bean.BeanCollection;
import com.avaje.ebean.bean.EntityBean;
import com.avaje.ebean.bean.EntityBeanIntercept;
import com.avaje.ebean.bean.BeanCollection.ModifyListenMode;
import com.avaje.ebean.config.ldap.LdapContextFactory;
import com.avaje.ebeaninternal.api.SpiEbeanServer;
import com.avaje.ebeaninternal.api.SpiTransaction;
import com.avaje.ebeaninternal.api.SpiUpdate;
import com.avaje.ebeaninternal.server.core.ConcurrencyMode;
import com.avaje.ebeaninternal.server.core.Message;
import com.avaje.ebeaninternal.server.core.PersistRequest;
import com.avaje.ebeaninternal.server.core.PersistRequestBean;
import com.avaje.ebeaninternal.server.core.PersistRequestCallableSql;
import com.avaje.ebeaninternal.server.core.PersistRequestOrmUpdate;
import com.avaje.ebeaninternal.server.core.PersistRequestUpdateSql;
import com.avaje.ebeaninternal.server.core.Persister;
import com.avaje.ebeaninternal.server.core.PstmtBatch;
import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
import com.avaje.ebeaninternal.server.deploy.BeanDescriptorManager;
import com.avaje.ebeaninternal.server.deploy.BeanManager;
import com.avaje.ebeaninternal.server.deploy.BeanProperty;
import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
import com.avaje.ebeaninternal.server.deploy.IntersectionRow;
import com.avaje.ebeaninternal.server.deploy.ManyType;
import com.avaje.ebeaninternal.server.ldap.DefaultLdapPersister;
import com.avaje.ebeaninternal.server.ldap.LdapPersistBeanRequest;

/**
 * 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
      • 
 * 
      
 * 
 * @see com.avaje.ebeaninternal.server.persist.DefaultPersistExecute
 */
public final class DefaultPersister implements Persister {

	private static final Logger logger = Logger.getLogger(DefaultPersister.class.getName());

	/**
	 * Actually does the persisting work.
	 */
	private final PersistExecute persistExecute;

	private final DefaultLdapPersister ldapPersister;

	private final SpiEbeanServer server;

	private final BeanDescriptorManager beanDescriptorManager;
	
	public DefaultPersister(SpiEbeanServer server, boolean validate,  
			Binder binder, BeanDescriptorManager descMgr, PstmtBatch pstmtBatch, LdapContextFactory contextFactory) {

		this.server = server;
		this.beanDescriptorManager = descMgr;
		
		this.persistExecute = new DefaultPersistExecute(validate, binder, pstmtBatch);
		this.ldapPersister = new DefaultLdapPersister(contextFactory);
	}

	/**
	 * Execute the CallableSql.
	 */
	public int executeCallable(CallableSql callSql, Transaction t) {

		PersistRequestCallableSql request = new PersistRequestCallableSql(server, callSql,
				(SpiTransaction) t, persistExecute);
		try {
		    request.initTransIfRequired();
			int rc = request.executeOrQueue();
			request.commitTransIfRequired();
			return rc;
			
		} catch (RuntimeException e) {
			request.rollbackTransIfRequired();
			throw e;
		}
	}

	/**
	 * Execute the orm update.
	 */
	public int executeOrmUpdate(Update update, Transaction t) {

		SpiUpdate ormUpdate = (SpiUpdate) update;
		
		BeanManager mgr = beanDescriptorManager.getBeanManager(ormUpdate.getBeanType());
		
		if (mgr == null){
			String msg = "No BeanManager found for type ["+ormUpdate.getBeanType()+"]. Is it an entity?";
			throw new PersistenceException(msg);
		}

		PersistRequestOrmUpdate request = new PersistRequestOrmUpdate(server, mgr, ormUpdate, (SpiTransaction) t, persistExecute);
		try {
            request.initTransIfRequired();
            int rc = request.executeOrQueue();
            request.commitTransIfRequired();
            return rc;

		} catch (RuntimeException e) {
			request.rollbackTransIfRequired();
			throw e;
		}
	}

	/**
	 * Execute the updateSql.
	 */
	public int executeSqlUpdate(SqlUpdate updSql, Transaction t) {

		PersistRequestUpdateSql request = new PersistRequestUpdateSql(server, updSql,
				(SpiTransaction) t, persistExecute);
		try {
            request.initTransIfRequired();
            int rc = request.executeOrQueue();
            request.commitTransIfRequired();
            return rc;

		} catch (RuntimeException e) {
			request.rollbackTransIfRequired();
			throw e;
		}
	}

	/**
	 * Recursively delete the bean. This calls back to the EbeanServer.
	 */
	private void deleteRecurse(Object detailBean, Transaction t) {
		// NB: a new PersistRequest is made
		server.delete(detailBean, t);
	}

	/**
	 * Force an Update using the given bean.
	 */
    public void forceUpdate(Object bean, Set updateProps, Transaction t) {
        
        if (bean == null) {
            throw new NullPointerException(Message.msg("bean.isnull"));
        }

        if (bean instanceof EntityBean){
            EntityBeanIntercept ebi = ((EntityBean)bean)._ebean_getIntercept();
            if (ebi.isDirty()) {
                // normal update of an enhanced bean
                PersistRequestBean req = createRequest(bean, t, null);
                try {
                    req.initTransIfRequired();
                    update(req);
                    req.commitTransIfRequired();
                    return;

                } catch (RuntimeException ex) {
                    req.rollbackTransIfRequired();
                    throw ex;
                }
            } else if (ebi.isLoaded()) {
                // fetched/loaded but not dirty so skip update
                return;
            }
            if (updateProps == null){
                updateProps = ebi.getLoadedProps();
            }
        }
        
        BeanManager mgr = getBeanManager(bean);
        if (mgr == null){
            throw new PersistenceException(errNotRegistered(bean.getClass()));
        }
        
        forceUpdate(bean, t, null, mgr, updateProps);
    }
    
    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void forceUpdate(Object bean, Transaction t, Object parentBean, BeanManager mgr, Set updateProps) {
        
        BeanDescriptor descriptor = mgr.getBeanDescriptor();
        
        // determine concurrency mode based on version property not null
        ConcurrencyMode mode = descriptor.determineConcurrencyMode(bean);
        
        if (updateProps == null){
            // determine based on anything that is non-null
            updateProps = descriptor.determineLoadedProperties(bean);
            
        } else if (updateProps.isEmpty()){
            // in this case means we want to include all properties in the update 
            updateProps = null;
        
        } else if (ConcurrencyMode.VERSION.equals(mode)){
            // check that the version property is included
            String verName = descriptor.firstVersionProperty().getName();
            if (!updateProps.contains(verName)){
                // defensively copy the updateProps and add the version property name
                updateProps = new HashSet(updateProps);
                updateProps.add(verName);
            }
        }
        
        PersistRequestBean req;
        if (descriptor.isLdapEntityType()){
            req = new LdapPersistBeanRequest(server, bean, parentBean, mgr, ldapPersister, updateProps, mode);

        } else {
            // special constructor for forceUpdate mode ...
            req = new PersistRequestBean(server, bean, parentBean, mgr, (SpiTransaction)t, persistExecute, updateProps, mode);
        }

        try {
            req.initTransIfRequired();
            update(req);
            req.commitTransIfRequired();

        } catch (RuntimeException ex) {
            req.rollbackTransIfRequired();
            throw ex;
        }
    }

	public void save(Object bean, Transaction t) {
		saveRecurse(bean, t, null);
	}

	/**
	 * Explicitly specify to insert this bean.
	 */
	public void forceInsert(Object bean, Transaction t) {
	    
        PersistRequestBean req = createRequest(bean, t, null);
        try {
            req.initTransIfRequired();
            insert(req);
            req.commitTransIfRequired();

        } catch (RuntimeException ex) {
            req.rollbackTransIfRequired();
            throw ex;
        }
	}
	
	private void saveRecurse(Object bean, Transaction t, Object parentBean) {
		if (bean == null) {
			throw new NullPointerException(Message.msg("bean.isnull"));
		}
	
		if (bean instanceof EntityBean == false){
		    saveVanillaRecurse(bean, t, parentBean);
		    return;
		}
		
		PersistRequestBean req = createRequest(bean, t, parentBean);
		try {
			req.initTransIfRequired();
			saveEnhanced(req);
			req.commitTransIfRequired();

		} catch (RuntimeException ex) {
			req.rollbackTransIfRequired();
			throw ex;
		}
	}

	/**
	 * Insert or update the bean depending on PersistControl and the bean state.
	 */
	private void saveEnhanced(PersistRequestBean request) {

		EntityBeanIntercept intercept = request.getEntityBeanIntercept();
		
		if (intercept.isReference()) {
			// its a reference...
			if (request.isPersistCascade()) {
				// save any associated List held beans
				intercept.setLoaded();
				saveAssocMany(false, request);
				intercept.setReference();
			}

		} else {
			if (intercept.isLoaded()) {
				// Need to call setLoaded(false) to simulate insert
				update(request);
			} else {
				insert(request);
			}
		}
	}

	/**
	 * Determine if this is an Insert or update for the 'vanilla' bean.
	 */
	private void saveVanillaRecurse(Object bean, Transaction t, Object parentBean) {

	    BeanManager mgr = getBeanManager(bean);
	    if (mgr == null){
	        throw new RuntimeException("No Mgr found for "+bean+" "+bean.getClass());
	    }
		// use the version property to determine insert or update
		if (mgr.getBeanDescriptor().isVanillaInsert(bean)) {
		    saveVanillaInsert(bean, t, parentBean, mgr);
		    
		} else {
		    // update non-null properties (no partial object knowledge with vanilla bean)
		    forceUpdate(bean, t, parentBean, mgr, null);
		}
	}
	
	/**
	 * Perform insert on non-enhanced bean (effectively same as enhanced bean).
	 */
	private void saveVanillaInsert(Object bean, Transaction t, Object parentBean, BeanManager mgr) {
        
	    PersistRequestBean req = createRequest(bean, t, parentBean, mgr);
        try {
            req.initTransIfRequired();
            insert(req);
            req.commitTransIfRequired();

        } catch (RuntimeException ex) {
            req.rollbackTransIfRequired();
            throw ex;
        }
	}
	
	/**
	 * Insert the bean.
	 */
	private void insert(PersistRequestBean request) {

		request.setType(PersistRequest.Type.INSERT);

		if (request.isPersistCascade()) {
			// save associated One beans recursively first
			saveAssocOne(request);
		}

		// set the IDGenerated value if required
		setIdGenValue(request);
		
		request.executeOrQueue();

		if (request.isPersistCascade()) {
			// save any associated List held beans
			saveAssocMany(true, request);
		}
	}

	/**
	 * Update the bean. Return NOT_SAVED if the bean values have not changed.
	 */
	private void update(PersistRequestBean request) {

		// we have determined that it is an update
		request.setType(PersistRequest.Type.UPDATE);

		if (request.isPersistCascade()) {
			// save associated One beans recursively first
			saveAssocOne(request);
		}

		if (request.isDirty()) {
			request.executeOrQueue();

		} else {
			// skip validation on unchanged bean
			if (logger.isLoggable(Level.FINE)) {
				logger.fine(Message.msg("persist.update.skipped", request.getBean()));
			}
		}

		if (request.isPersistCascade()) {
			// save all the beans in assocMany's after
			saveAssocMany(false, request);
		}
	}
	   
	/**
	 * Delete the bean with the explicit transaction.
	 */
	public void delete(Object bean, Transaction t) {
		
		PersistRequestBean req = createRequest(bean, t, null);
		if (req.isRegistered()){
			// skip deleting bean. Used where cascade is on
			// both sides of a relationship
			if (logger.isLoggable(Level.FINE)){
				logger.fine("skipping delete on alreadyRegistered "+bean);
			}
			return;
		}
		
		req.setType(PersistRequest.Type.DELETE);
		try {
			req.initTransIfRequired();
			delete(req);
			req.commitTransIfRequired();

		} catch (RuntimeException ex) {
			req.rollbackTransIfRequired();
			throw ex;
		}
	}

    private void deleteList(List beanList, Transaction t) {
        for (int i = 0; i < beanList.size(); i++) {
            Object bean = beanList.get(i);
            delete(bean, t);
        }
    }

	/**
	 * Delete by a List of Id's.
	 */
    public void deleteMany(Class beanType, Collection ids, Transaction transaction) {

        if (ids == null || ids.size() == 0){
            return;
        }

        BeanDescriptor descriptor = beanDescriptorManager.getBeanDescriptor(beanType);

        ArrayList idList = new ArrayList(ids.size());
        for (Object id : ids) {
            // convert to appropriate type if required
            idList.add(descriptor.convertId(id));
        }
        
        delete(descriptor, null, idList, transaction);
    }
    
    /**
     * Delete by Id.
     */
    public int delete(Class beanType, Object id, Transaction transaction) {

        BeanDescriptor descriptor = beanDescriptorManager.getBeanDescriptor(beanType);

        // convert to appropriate type if required
        id = descriptor.convertId(id);
        return delete(descriptor, id, null, transaction);
    }
    
    
    /**
     * Delete by Id or a List of Id's.
     */
    private int delete(BeanDescriptor descriptor, Object id, List idList, Transaction transaction) {

        SpiTransaction t = (SpiTransaction)transaction;        
        if (t.isPersistCascade()){
            BeanPropertyAssocOne[] propImportDelete = descriptor.propertiesOneImportedDelete();
            if (propImportDelete.length > 0){
                // We actually need to execute a query to get the foreign key values
                // as they are required for the delete cascade. Query back just the 
                // Id and the appropriate foreign key values
                Query q = deleteRequiresQuery(descriptor, propImportDelete);
                if (idList != null){
                    q.where().idIn(idList);
                    t.log("-- DeleteById of "+descriptor.getName()+" ids["+idList+"] requires fetch of foreign key values");
                    List beanList = server.findList(q, t);
                    deleteList(beanList, t);
                    return beanList.size();
                    
                } else {
                    q.where().idEq(id);
                    t.log("-- DeleteById of "+descriptor.getName()+" id["+id+"] requires fetch of foreign key values");
                    Object bean = server.findUnique(q, t);
                    if (bean == null){
                        return 0;
                    } else {
                        delete(bean, t);
                        return 1;
                    }
                }
            }
        }
        
        if (t.isPersistCascade()){
            // OneToOne exported side with delete cascade
            BeanPropertyAssocOne[] expOnes = descriptor.propertiesOneExportedDelete();
            for (int i = 0; i < expOnes.length; i++) {
                BeanDescriptor targetDesc = expOnes[i].getTargetDescriptor();
                if (targetDesc.isDeleteRecurseSkippable() && !targetDesc.isUsingL2Cache()) {
                    SqlUpdate sqlDelete = expOnes[i].deleteByParentId(id, idList);
                    executeSqlUpdate(sqlDelete, t);
                } else {
                    List childIds = expOnes[i].findIdsByParentId(id, idList, t);
                    delete(targetDesc, null, childIds, t);
                }
            }
            
            // OneToMany's with delete cascade
            BeanPropertyAssocMany[] manys = descriptor.propertiesManyDelete();
            for (int i = 0; i < manys.length; i++) {
                BeanDescriptor targetDesc = manys[i].getTargetDescriptor();
                if (targetDesc.isDeleteRecurseSkippable() && !targetDesc.isUsingL2Cache()) {
                    // we can just delete children with a single statement
                    SqlUpdate sqlDelete = manys[i].deleteByParentId(id, idList);
                    executeSqlUpdate(sqlDelete, t);
                } else {
                    // we need to fetch the Id's to delete (recurse or notify L2 cache/lucene)
                    List childIds = manys[i].findIdsByParentId(id, idList, t);
                    delete(targetDesc, null, childIds, t);
                }
            }
        }
        
        // ManyToMany's ... delete from intersection table
        BeanPropertyAssocMany[] manys = descriptor.propertiesManyToMany();
        for (int i = 0; i < manys.length; i++) {
            SqlUpdate sqlDelete = manys[i].deleteByParentId(id, idList);
            t.log("-- Deleting intersection table entries: "+manys[i].getFullBeanName());
            executeSqlUpdate(sqlDelete, t);
        }
        
        // delete the bean(s) 
        SqlUpdate deleteById = descriptor.deleteById(id, idList);
        t.log("-- Deleting "+descriptor.getName()+" Ids"+idList);
        
        // use Id's to update L2 cache rather than Bulk table event
        deleteById.setAutoTableMod(false);
        if (idList != null){
            t.getEvent().addDeleteByIdList(descriptor, idList);
        } else {
            t.getEvent().addDeleteById(descriptor, id);
        }
        return executeSqlUpdate(deleteById, t);
    }

    /**
     * We need to create and execute a query to get the foreign key values as
     * the delete cascades to them (foreign keys).
     */
    private Query deleteRequiresQuery(BeanDescriptor desc, BeanPropertyAssocOne[] propImportDelete) {
        
        Query q  = server.createQuery(desc.getBeanType());
        StringBuilder sb = new StringBuilder(30);
        for (int i = 0; i < propImportDelete.length; i++) {
            sb.append(propImportDelete[i].getName()).append(",");
        }
        q.setAutofetch(false);
        q.select(sb.toString());
        return q;
    }
    
	/**
	 * Delete the bean.
	 * 
      
	 * Note that preDelete fires before the deletion of children.
	 * 
      
	 */
	private void delete(PersistRequestBean request) {

	    DeleteUnloadedForeignKeys unloadedForeignKeys = null;
	    
	    boolean pauseIndexInvalidate = request.getBeanDescriptor().isLuceneIndexed();
	    if (pauseIndexInvalidate){
	        // Stop any deletions of child beans to Invalidate the Index as we 
	        // will use the delete of this top level object to maintain the index
	        request.pauseIndexInvalidate();
	    }
	    
		if (request.isPersistCascade()) {
			// delete children first ... register the
			// bean to handle bi-directional cascading
			request.registerBean();
			deleteAssocMany(request);
			request.unregisterBean();

			unloadedForeignKeys = getDeleteUnloadedForeignKeys(request);
    		if (unloadedForeignKeys != null){
    		    // there are foreign keys that we don't have on this partially
    		    // populated bean so we actually need to query them (to cascade delete)
    		    unloadedForeignKeys.queryForeignKeys();
    		}
    	}
		
		request.executeOrQueue();

		if (request.isPersistCascade()) {
			deleteAssocOne(request);
			
			if (unloadedForeignKeys != null){
			    unloadedForeignKeys.deleteCascade();
			}
		}
        if (pauseIndexInvalidate){
            request.resumeIndexInvalidate();
        }
	}

	/**
	 * Save the associated child beans contained in a List.
	 * 
      
	 * This will automatically copy over any join properties from the parent
	 * bean to the child beans.
	 * 
      
	 */
	private void saveAssocMany(boolean insertedParent, PersistRequestBean request) {

		Object parentBean = request.getBean();
		BeanDescriptor desc = request.getBeanDescriptor();
		SpiTransaction t  = request.getTransaction();

		// exported ones with cascade save
		BeanPropertyAssocOne[] expOnes = desc.propertiesOneExportedSave();
		for (int i = 0; i < expOnes.length; i++) {
			BeanPropertyAssocOne prop = expOnes[i];

			// check for partial beans
			if (request.isLoadedProperty(prop)) {
				Object detailBean = prop.getValue(parentBean);
				if (detailBean != null) {
					if (prop.isSaveRecurseSkippable(detailBean)) {
						// skip saving this bean
					} else {
						t.depth(+1);
						saveRecurse(detailBean, t, parentBean);
						t.depth(-1);
					}
				}
			}
		}

		// many's with cascade save
		BeanPropertyAssocMany[] manys = desc.propertiesManySave();
		for (int i = 0; i < manys.length; i++) {
		    saveMany(insertedParent, manys[i], parentBean, t, manys[i].getCascadeInfo().isSave());
		}
	}

    private void saveMany(boolean insertedParent, BeanPropertyAssocMany many, Object parentBean, SpiTransaction t, boolean cascade) {

        if (many.isManyToMany()) {
            // save the beans that are in the manyToMany
            if (cascade) {
                // Need explicit Cascade to save the beans on other side
                saveAssocManyDetails(insertedParent, many, parentBean, t);
                // for ManyToMany save the 'relationship' via inserts/deletes
                // into/from the intersection table
                saveAssocManyIntersection(insertedParent, many, parentBean, t);
            }

        } else {
            if (cascade) {
                saveAssocManyDetails(insertedParent, many, parentBean, t);
            }
            if (ModifyListenMode.REMOVALS.equals(many.getModifyListenMode())) {
                removeAssocManyPrivateOwned(many, parentBean, t);
            }
        }
    }
	
	private void removeAssocManyPrivateOwned(BeanPropertyAssocMany prop, Object parentBean, SpiTransaction t) {

		Object details = prop.getValueUnderlying(parentBean);

		// check that the list is not null and if it is a BeanCollection
		// check that is has been populated (don't trigger lazy loading)
		if (details instanceof BeanCollection) {
			BeanCollection c = (BeanCollection)details;
			Set modifyRemovals = c.getModifyRemovals();
			if (modifyRemovals != null && !modifyRemovals.isEmpty()) {
				// increase depth for batching order
				t.depth(+1);
				
				Iterator it = modifyRemovals.iterator();
				while (it.hasNext()) {
					Object removedBean = it.next();
					deleteRecurse(removedBean, t);
				}
				
				t.depth(-1);
			}
		}
	}
	
	/**
	 * Save the details from a OneToMany collection.
	 */
	private void saveAssocManyDetails(boolean insertedParent, 
			BeanPropertyAssocMany prop, Object parentBean, SpiTransaction t) {

		Object details = prop.getValueUnderlying(parentBean);

		// check that the list is not null and if it is a BeanCollection
		// check that is has been populated (don't trigger lazy loading)
		Collection collection = getDetailsIterator(details);

		if (collection != null) {

			if (insertedParent){
				// performance optimisation for large collections
				prop.getTargetDescriptor().preAllocateIds(collection.size());
			}
			
			// increase depth for batching order
			t.depth(+1);

			// if a map, then we get the key value and
			// set it to the appropriate property on the
			// detail bean before we save it
			boolean isMap = ManyType.JAVA_MAP.equals(prop.getManyType());
			Object mapKeyValue = null;
			boolean saveSkippable = prop.isSaveRecurseSkippable();
			boolean skipSavingThisBean = false;

			Iterator detailIt = collection.iterator();
			while (detailIt.hasNext()) {
				Object detailBean = detailIt.next();
				if (isMap) {
					// its a map so need the key and value
					Map.Entry entry = (Map.Entry) detailBean;
					mapKeyValue = entry.getKey();
					detailBean = entry.getValue();
				}
				if (!prop.isManyToMany()) {
					// set the 'parent/master' bean to the detailBean as long
					// as we don't make it 'dirty' in doing so
					if (detailBean instanceof EntityBean) {
						if (((EntityBean) detailBean)._ebean_getIntercept().isNewOrDirty()) {
							// set the parent bean to detailBean
							prop.setJoinValuesToChild(parentBean, detailBean, mapKeyValue);
						} else {
							// unmodified so potentially can skip
							// depending on prop.isSaveRecurseSkippable();
							skipSavingThisBean = saveSkippable;
						}
					} else {
						// set the parent bean to detailBean
						prop.setJoinValuesToChild(parentBean, detailBean, mapKeyValue);
					}
				}

				if (skipSavingThisBean) {
					// 1. unmodified bean that does not recurse its save
					// so we can skip the save for this bean.
					// 2. Reset skipSavingThisBean for the next detailBean
					skipSavingThisBean = false;
				} else {
					saveRecurse(detailBean, t, parentBean);
				}
			}
			t.depth(-1);
		}
	}

    public int deleteManyToManyAssociations(Object ownerBean, String propertyName, Transaction t) {

        BeanDescriptor descriptor = beanDescriptorManager.getBeanDescriptor(ownerBean.getClass());
        BeanPropertyAssocMany prop = (BeanPropertyAssocMany)descriptor.getBeanProperty(propertyName);
        return deleteAssocManyIntersection(ownerBean, prop, t);
    }
    
    public void saveManyToManyAssociations(Object ownerBean, String propertyName, Transaction t) {

        BeanDescriptor descriptor = beanDescriptorManager.getBeanDescriptor(ownerBean.getClass());
        BeanPropertyAssocMany prop = (BeanPropertyAssocMany)descriptor.getBeanProperty(propertyName);
        
        saveAssocManyIntersection(false, prop, ownerBean, (SpiTransaction)t);
    }

    public void saveAssociation(Object parentBean, String propertyName, Transaction t) {
        
        BeanDescriptor descriptor = beanDescriptorManager.getBeanDescriptor(parentBean.getClass());
        SpiTransaction trans = (SpiTransaction)t;
        
        BeanProperty prop = descriptor.getBeanProperty(propertyName);
        if (prop == null){
            String msg = "Could not find property ["+propertyName+"] on bean "+parentBean.getClass();
            throw new PersistenceException(msg);
        }
        
        if (prop instanceof BeanPropertyAssocMany){
            BeanPropertyAssocMany manyProp = (BeanPropertyAssocMany)prop;
            saveMany(false, manyProp, parentBean, (SpiTransaction)t, true);
            
        } else if (prop instanceof BeanPropertyAssocOne){
            BeanPropertyAssocOne oneProp = (BeanPropertyAssocOne)prop;
            Object assocBean = oneProp.getValue(parentBean);
            
            int depth = oneProp.isOneToOneExported() ? 1 : -1;
            int revertDepth = -1 * depth;
            
            trans.depth(depth);
            saveRecurse(assocBean, t, parentBean);
            trans.depth(revertDepth);
        
        } else {
            String msg = "Expecting ["+prop.getFullBeanName()
                +"] to be a OneToMany, OneToOne, ManyToOne or ManyToMany property?";
            throw new PersistenceException(msg);
        }
        
    }

	/**
	 * Save the additions and removals from a ManyToMany collection as inserts
	 * and deletes from the intersection table.
	 * 
      
	 * This is done via MapBeans.
	 * 
      
	 */
	private void saveAssocManyIntersection(boolean insertedParent, BeanPropertyAssocMany prop, Object parentBean, SpiTransaction t) {

		Object value = prop.getValueUnderlying(parentBean);
		if (value == null) {
			return;
		}
		
		Collection additions = null;
		Collection deletions = null;
		
		boolean vanillaCollection = (value instanceof BeanCollection == false);

		if (vanillaCollection || insertedParent){
			// treat everything in the list/set/map as an intersection addition  
			if (value instanceof Map){
				additions = ((Map)value).values();
			} else if (value instanceof Collection) {
				additions = (Collection)value;
			} else {
				String msg = "Unhandled ManyToMany type "+value.getClass().getName()+" for "+prop.getFullBeanName();
				throw new PersistenceException(msg);
			}
			if (!vanillaCollection){
			    ((BeanCollection) value).modifyReset();
			}
		} else {
			// BeanCollection so get the additions/deletions
			BeanCollection manyValue = (BeanCollection) value;
			additions = manyValue.getModifyAdditions();
			deletions = manyValue.getModifyRemovals();
			// reset so the changes are only processed once
			manyValue.modifyReset();
		}

		t.depth(+1);

		if (additions != null && !additions.isEmpty()) {
			Iterator it = additions.iterator();
			while (it.hasNext()) {
				// the object from the 'other' side of the ManyToMany
				Object otherBean = it.next();
				if (deletions != null && deletions.remove(otherBean)) {
					String m = "Inserting and Deleting same object? " + otherBean;
					t.log(m);
					logger.log(Level.WARNING, m);

				} else {
				    if (!prop.hasImportedId(otherBean)){
				        String msg = "ManyToMany bean "+otherBean+" does not have an Id value.";
                        throw new PersistenceException(msg);
                        
				    } else {
    					// build a intersection row for 'insert'
    					IntersectionRow intRow = prop.buildManyToManyMapBean(parentBean, otherBean);
    					SqlUpdate sqlInsert = intRow.createInsert(server);
    					executeSqlUpdate(sqlInsert, t);
				    }
				}
			}
		}
		if (deletions != null && !deletions.isEmpty()) {
			Iterator it = deletions.iterator();
			while (it.hasNext()) {
				// the object from the 'other' side of the ManyToMany
				Object otherDelete = it.next();

				// build a intersection row for 'delete'
				IntersectionRow intRow = prop.buildManyToManyMapBean(parentBean, otherDelete);
				SqlUpdate sqlDelete = intRow.createDelete(server);
				executeSqlUpdate(sqlDelete, t);
			}
		}

		// decrease the depth back to what it was
		t.depth(-1);
	}

    private int deleteAssocManyIntersection(Object bean, BeanPropertyAssocMany many, Transaction t) {

        // delete all intersection rows for this bean
        IntersectionRow intRow = many.buildManyToManyDeleteChildren(bean);
        SqlUpdate sqlDelete = intRow.createDeleteChildren(server);

        return executeSqlUpdate(sqlDelete, t);
    }
   
	/**
	 * Delete beans in any associated many.
	 * 
      
	 * This is called prior to deleting the parent bean.
	 * 
      
	 */
	private void deleteAssocMany(PersistRequestBean request) {

		SpiTransaction t = request.getTransaction();
		t.depth(-1);
		
		BeanDescriptor desc = request.getBeanDescriptor();
		Object parentBean = request.getBean();

		BeanPropertyAssocOne[] expOnes = desc.propertiesOneExportedDelete();
		if (expOnes.length > 0){
		    
		    DeleteUnloadedForeignKeys unloaded = null;
    		for (int i = 0; i < expOnes.length; i++) {
    			BeanPropertyAssocOne prop = expOnes[i];
    			if (request.isLoadedProperty(prop)) {
                    Object detailBean = prop.getValue(parentBean);
                    if (detailBean != null) {
                        deleteRecurse(detailBean, t);
                    }
    			} else {
                    if (unloaded == null){
                        unloaded = new DeleteUnloadedForeignKeys(server, request);
                    }
                    unloaded.add(prop);
    			}
    		}
    		if (unloaded != null){
    		    unloaded.queryForeignKeys();
    		    unloaded.deleteCascade();
    		}
		}

		// Many's with delete cascade
		BeanPropertyAssocMany[] manys = desc.propertiesManyDelete();
		for (int i = 0; i < manys.length; i++) {
			if (manys[i].isManyToMany()) {
			    // delete associated rows from intersection table
			    deleteAssocManyIntersection(parentBean, manys[i], t);
                
			} else {
				
				if (ModifyListenMode.REMOVALS.equals(manys[i].getModifyListenMode())) {
					// PrivateOwned ...
	                Object details = manys[i].getValueUnderlying(parentBean);
					if (details instanceof BeanCollection){
						Set modifyRemovals = ((BeanCollection)details).getModifyRemovals();
						if (modifyRemovals != null && !modifyRemovals.isEmpty()){
						    
							// delete the orphans that have been removed from the collection
							Iterator it = modifyRemovals.iterator();
							while (it.hasNext()) {
								Object detailBean = it.next();
								if (manys[i].hasId(detailBean)) {
									deleteRecurse(detailBean, t);
								}
							}
						}
					}
				}
				
				if (manys[i].getCascadeInfo().isDelete()) {
    				// cascade delete the beans in the collection
				    BeanDescriptor targetDesc = manys[i].getTargetDescriptor();
				    if (targetDesc.isDeleteRecurseSkippable() && !targetDesc.isUsingL2Cache()) {
				        // Just delete all the children with one statement
                        IntersectionRow intRow = manys[i].buildManyDeleteChildren(parentBean);
                        SqlUpdate sqlDelete = intRow.createDelete(server);
                        executeSqlUpdate(sqlDelete, t);
				        
				    } else {
				        // Delete recurse using the Id values of the children
                        Object parentId = desc.getId(parentBean);
                        List idsByParentId = manys[i].findIdsByParentId(parentId, null, t);
                        if (!idsByParentId.isEmpty()){                            
                            delete(targetDesc, null, idsByParentId, t);
                        }
				    }
				}
			}
		}
		
		// restore the depth
        t.depth(+1);
	}

	/**
	 * Save any associated one beans.
	 */
	private void saveAssocOne(PersistRequestBean request) {

		BeanDescriptor desc = request.getBeanDescriptor();

		// imported ones with save cascade
		BeanPropertyAssocOne[] ones = desc.propertiesOneImportedSave();

		for (int i = 0; i < ones.length; i++) {
			BeanPropertyAssocOne prop = ones[i];

			// check for partial objects
			if (request.isLoadedProperty(prop)) {
				Object detailBean = prop.getValue(request.getBean());
				if (detailBean != null) {
				    if (isReference(detailBean)){
				        // skip saving a reference
				    } else if (request.isParent(detailBean)) {
						// skip saving the parent as already saved
					} else if (prop.isSaveRecurseSkippable(detailBean)) {
						// we can skip saving this bean
					
					} else {
						SpiTransaction t = request.getTransaction();
						t.depth(-1);
						saveRecurse(detailBean, t, null);
						t.depth(+1);
					}
				}
			}
		}
	}
	
	/**
	 * Return true if the bean is a reference.
	 */
	private boolean isReference(Object bean){
	    return (bean instanceof EntityBean) && ((EntityBean)bean)._ebean_getIntercept().isReference();
	}

    /**
     * Support for loading any Imported Associated One properties that are not loaded
     * but required for Delete cascade.
     */
	private DeleteUnloadedForeignKeys getDeleteUnloadedForeignKeys(PersistRequestBean request) {
	    
	    DeleteUnloadedForeignKeys fkeys = null;
        
        BeanPropertyAssocOne[] ones = request.getBeanDescriptor().propertiesOneImportedDelete();
        for (int i = 0; i < ones.length; i++) {
            if (!request.isLoadedProperty(ones[i])) { 
                // we have cascade Delete on a partially populated bean and
                // this property was not loaded (so we are going to have to fetch it)
                if (fkeys == null){
                    fkeys = new DeleteUnloadedForeignKeys(server, request);
                }
                fkeys.add(ones[i]);
            }
        }
        
        return fkeys;
	}
	
	/**
	 * Delete any associated one beans.
	 */
	private void deleteAssocOne(PersistRequestBean request) {

		BeanDescriptor desc = request.getBeanDescriptor();		
		BeanPropertyAssocOne[] ones = desc.propertiesOneImportedDelete();
		
		for (int i = 0; i < ones.length; i++) {
			BeanPropertyAssocOne prop = ones[i];
			if (!request.isLoadedProperty(prop)) {
			    // handled by DeleteUnloadedForeignKeys that was built
			    // via getDeleteUnloadedForeignKeys();
			} else {
				Object detailBean = prop.getValue(request.getBean());
				if (detailBean != null && prop.hasId(detailBean)) {
					deleteRecurse(detailBean, request.getTransaction());
				}
			}
		}
	}

	/**
	 * Set Id Generated value for insert.
	 */
	private void setIdGenValue(PersistRequestBean request) {

		BeanDescriptor desc = request.getBeanDescriptor();
		if (!desc.isUseIdGenerator()) {
			return;
		}

		BeanProperty idProp = desc.getSingleIdProperty();
		if (idProp == null || idProp.isEmbedded()) {
			// not supporting IdGeneration for concatenated or Embedded
			return;
		}

		Object bean = request.getBean();
		Object uid = idProp.getValue(bean);

		if (DmlUtil.isNullOrZero(uid)) {
			
			// generate the nextId and set it to the property
			Object nextId = desc.nextId(request.getTransaction());

			// cast the data type if required and set it
			desc.convertSetId(nextId, bean);
		}
	}

	/**
	 * Return the details of the collection or map taking care to avoid
	 * unnecessary fetching of the data.
	 */
	private Collection getDetailsIterator(Object o) {
		if (o == null) {
			return null;
		}
		if (o instanceof BeanCollection) {
			BeanCollection bc = (BeanCollection) o;
			if (!bc.isPopulated()) {
				return null;
			}
			return bc.getActualDetails();
		}

		if (o instanceof Map) {
			// yes, we want the entrySet (to set the keys)
			return ((Map) o).entrySet();

		} else if (o instanceof Collection) {
			return ((Collection) o);
		}
		String m = "expecting a Map or Collection but got [" + o.getClass().getName() + "]";
		throw new PersistenceException(m);
	}

    /**
     * Create the Persist Request Object that wraps all the objects used to
     * perform an insert, update or delete.
     */
    @SuppressWarnings("unchecked")
    private  PersistRequestBean createRequest(T bean, Transaction t, Object parentBean) {
        BeanManager mgr = getBeanManager(bean);
        if (mgr == null) {
            throw new PersistenceException(errNotRegistered(bean.getClass()));
        }
        return (PersistRequestBean)createRequest(bean, t, parentBean, mgr);
    }

    private String errNotRegistered(Class beanClass) {
        String msg = "The type [" + beanClass + "] is not a registered entity?";
        msg += " If you don't explicitly list the entity classes to use Ebean will search for them in the classpath.";
        msg += " If the entity is in a Jar check the ebean.search.jars property in ebean.properties file or check ServerConfig.addJar().";
        return msg;
    }
    
    /**
     * Create the Persist Request Object that wraps all the objects used to
     * perform an insert, update or delete.
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private PersistRequestBean createRequest(Object bean, Transaction t, Object parentBean, BeanManager mgr) {

        if (mgr.isLdapEntityType()){
            return new LdapPersistBeanRequest(server, bean, parentBean, mgr, ldapPersister);
        }
        return new PersistRequestBean(server, bean, parentBean, mgr, (SpiTransaction) t, persistExecute);
    }
    
	/**
	 * Return the BeanDescriptor for a bean that is being persisted.
	 * 
      
	 * Note that this checks to see if the bean is a MapBean with a tableName.
	 * If so it will return the table based BeanDescriptor.
	 * 
      
	 */
	@SuppressWarnings("unchecked")
	private  BeanManager getBeanManager(T bean) {
		
		return (BeanManager) beanDescriptorManager.getBeanManager(bean.getClass());
	}
}
    
      
    
      

      




      
    
      © 2015 - 2025 Weber Informatics LLC | Privacy Policy