Oh my god. It's full of code!

Deep Clone (Round 2)

So a day or two ago I posted my first draft of a deep clone, which would allow easy cloning of an entire data hierarchy. It was a semi proof of concept thing with some limitations (it could only handle somewhat smaller data sets, and didn’t let you configure all or nothing inserts, or specify if you wanted to copy standard objects as well as custom or not). I was doing some thinking and I remembered hearing about the queueable interface, which allows for asynchronous processing and bigger governor limits. I started thinking about chaining queueable jobs together to allow for copying much larger data sets. Each invocation would get it’s own governor limits and could theoretically go on as long as it took since you can chain jobs infinitely. I had attempted to use queueable to solve this before but i made the mistake of trying to kick off multiple jobs per invocation (one for each related object type). This obviously didn’t work due to limits imposed on queueable. Once I thought of a way to only need one invocation per call (basically just rolling all the records that need to get cloned into one object and iterate over it) I figured I might have a shot at making this work. I took what I had written before, added a few options, and I think I’ve done it. An asynchronous deep clone that operates in distinct batches with all or nothing handling, and cleanup in case of error. This is some hot off the presses code, so there is likely some lingering bugs, but I was too excited not to share this. Feast your eyes!

public class deepClone implements Queueable {

    //global describe to hold object describe data for query building and relationship iteration
    public map<String, Schema.SObjectType> globalDescribeMap = Schema.getGlobalDescribe();
    //holds the data to be cloned. Keyed by object type. Contains cloneData which contains the object to clone, and some data needed for queries
    public map<string,cloneData> thisInvocationCloneMap = new map<string,cloneData>();
    //should the clone process be all or nothing?
    public boolean allOrNothing = false;
    //each iteration adds the records it creates to this property so in the event of an error we can roll it all back
    public list<id> allCreatedObjects = new list<id>();
    //only clone custom objects. Helps to avoid trying to clone system objects like chatter posts and such.
    public boolean onlyCloneCustomObjects = true;
    public static id clone(id sObjectId, boolean onlyCustomObjects, boolean allOrNothing)
        deepClone startClone= new deepClone();
        startClone.onlyCloneCustomObjects  = onlyCustomObjects;
        startClone.allOrNothing = allOrNothing;
        sObject thisObject = sObjectId.getSobjectType().newSobject(sObjectId);
        cloneData thisClone = new cloneData(new list<sObject>{thisObject}, new map<id,id>());
        map<string,cloneData> cloneStartMap = new map<string,cloneData>();
        startClone.thisInvocationCloneMap = cloneStartMap;
        return System.enqueueJob(startClone);      
    public void execute(QueueableContext context) {
    * @description Clones an object and the entire related data hierarchy. Currently only clones custom objects, but enabling standard objects is easy. It is disabled because it increases risk of hitting governor limits
    * @param sObject objectToClone the root object be be cloned. All descended custom objects will be cloned as well
    * @return list<sobject> all of the objects that were created during the clone.
    public list<id> deepCloneBatched()
        map<string,cloneData> nextInvocationCloneMap = new map<string,cloneData>();
        //iterate over every object type in the public map
        for(string relatedObjectType : thisInvocationCloneMap.keySet())
            list<sobject> objectsToClone = thisInvocationCloneMap.get(relatedObjectType).objectsToClone;
            map<id,id> previousSourceToCloneMap = thisInvocationCloneMap.get(relatedObjectType).previousSourceToCloneMap;
            system.debug('\n\n\n--------------------  Cloning record ' + objectsToClone.size() + ' records');
            list<id> objectIds = new list<id>();
            list<sobject> clones = new list<sobject>();
            list<sObject> newClones = new list<sObject>();
            map<id,id> sourceToCloneMap = new map<id,id>();
            list<database.saveresult> cloneInsertResult;
            //if this function has been called recursively, then the previous batch of cloned records
            //have not been inserted yet, so now they must be before we can continue. Also, in that case
            //because these are already clones, we do not need to clone them again, so we can skip that part
            if(objectsToClone[0].Id == null)
                //if they don't have an id that means these records are already clones. So just insert them with no need to clone beforehand.
                cloneInsertResult = database.insert(objectsToClone,allOrNothing);

                for(sObject thisClone : clones)
                objectIds.addAll(new list<id>(previousSourceToCloneMap.keySet()));
                //get the ids of all these objects.                    
                //get the ids of all these objects.
                for(sObject thisObj :objectsToClone)
                //create a select all query to get all the data for these objects since if we only got passed a basic sObject without data 
                //then the clone will be empty
                string objectDataQuery = buildSelectAllStatment(relatedObjectType);
                //add a where condition
                objectDataQuery += ' where id in :objectIds';
                //get the details of this object
                list<sObject> objectToCloneWithData = database.query(objectDataQuery);
                for(sObject thisObj : objectToCloneWithData)
                    sObject clonedObject = thisObj.clone(false,true,false,false);
                //insert the clones
                cloneInsertResult = database.insert(clones,allOrNothing);
                for(sObject thisClone : clones)
            for(database.saveResult saveResult :  cloneInsertResult)
                else if(allOrNothing)
                    return allCreatedObjects;
            //Describes this object type so we can deduce it's child relationships
            Schema.DescribeSObjectResult objectDescribe = globalDescribeMap.get(relatedObjectType).getDescribe();
            //get this objects child relationship types
            List<Schema.ChildRelationship> childRelationships = objectDescribe.getChildRelationships();
            system.debug('\n\n\n-------------------- ' + objectDescribe.getName() + ' has ' + childRelationships.size() + ' child relationships');
            //then have to iterate over every child relationship type, and every record of that type and clone them as well. 
            for(Schema.ChildRelationship thisRelationship : childRelationships)
                Schema.DescribeSObjectResult childObjectDescribe = thisRelationship.getChildSObject().getDescribe();
                string relationshipField = thisRelationship.getField().getDescribe().getName();
                    system.debug('\n\n\n-------------------- Looking at ' + childObjectDescribe.getName() + ' which is a child object of ' + objectDescribe.getName());
                    if(!childObjectDescribe.isCreateable() || !childObjectDescribe.isQueryable())
                        system.debug('-------------------- Object is not one of the following: queryable, creatable. Skipping attempting to clone this object');
                    if(onlyCloneCustomObjects && !childObjectDescribe.isCustom())
                        system.debug('-------------------- Object is not custom and custom object only clone is on. Skipping this object.');
                    if(Limits.getQueries() >= Limits.getLimitQueries())
                        system.debug('\n\n\n-------------------- Governor limits hit. Must abort.');
                        //if we hit an error, and this is an all or nothing job, we have to delete what we created and abort
                        return allCreatedObjects;
                    //create a select all query from the child object type
                    string childDataQuery = buildSelectAllStatment(childObjectDescribe.getName());
                    //add a where condition that will only find records that are related to this record. The field which the relationship is defined is stored in the maps value
                    childDataQuery+= ' where '+relationshipField+ ' in :objectIds';
                    //get the details of this object
                    list<sObject> childObjectsWithData = database.query(childDataQuery);
                    system.debug('\n\n\n-------------------- Object queried. Found ' + childObjectsWithData.size() + ' records to clone');
                        map<id,id> childRecordSourceToClone = new map<id,id>();
                        for(sObject thisChildObject : childObjectsWithData)
                            //clone the object
                            sObject newClone = thisChildObject.clone();
                            //since the record we cloned still has the original parent id, we now need to update the clone with the id of it's cloned parent.
                            //to do that we reference the map we created above and use it to get the new cloned parent.                        
                            system.debug('\n\n\n----------- Attempting to change parent of clone....');
                            id newParentId = sourceToCloneMap.get((id) thisChildObject.get(relationshipField));
                            system.debug('Old Parent: ' + thisChildObject.get(relationshipField) + ' new parent ' + newParentId);
                            //write the new parent value into the record
                            newClone.put(thisRelationship.getField().getDescribe().getName(),newParentId );
                            //add this new clone to the list. It will be inserted once the deepClone function is called again. I know it's a little odd to not just insert them now
                            //but it save on redudent logic in the long run.
                        cloneData thisCloneData = new cloneData(newClones,childRecordSourceToClone);
                catch(exception e)
                    system.debug('\n\n\n---------------------- Error attempting to clone child records of type: ' + childObjectDescribe.getName());
        system.debug('\n\n\n-------------------- Done iterating cloneable objects.');
        system.debug('\n\n\n-------------------- Clone Map below');
        system.debug('\n\n\n-------------------- All created object ids thus far across this invocation');
        //if our map is not empty that means we have more records to clone. So queue up the next job.
            system.debug('\n\n\n-------------------- Clone map is not empty. Sending objects to be cloned to another job');
            deepClone nextIteration = new deepClone();
            nextIteration.thisInvocationCloneMap = nextInvocationCloneMap;
            nextIteration.allCreatedObjects = allCreatedObjects;
            nextIteration.onlyCloneCustomObjects  = onlyCloneCustomObjects;
            nextIteration.allOrNothing = allOrNothing;
            id  jobId = System.enqueueJob(nextIteration);       
            system.debug('\n\n\n-------------------- Next queable job scheduled. Id is: ' + jobId);  
        system.debug('\n\n\n-------------------- Cloneing Done!');
        return allCreatedObjects;
    * @description create a string which is a select statement for the given object type that will select all fields. Equivalent to Select * from objectName ins SQL
    * @param objectName the API name of the object which to build a query string for
    * @return string a string containing the SELECT keyword, all the fields on the specified object and the FROM clause to specify that object type. You may add your own where statements after.
    public string buildSelectAllStatment(string objectName){ return buildSelectAllStatment(objectName, new list<string>());}
    public string buildSelectAllStatment(string objectName, list<string> extraFields)
        // Initialize setup variables
        String query = 'SELECT ';
        String objectFields = String.Join(new list<string>(globalDescribeMap.get(objectName).getDescribe().fields.getMap().keySet()),',');
        if(extraFields != null)
            objectFields += ','+String.Join(extraFields,',');
        objectFields = objectFields.removeEnd(',');
        query += objectFields;
        // Add FROM statement
        query += ' FROM ' + objectName;
        return query;   
    public void cleanUpError()
    public class cloneData
        public list<sObject> objectsToClone = new list<sObject>();        
        public map<id,id> previousSourceToCloneMap = new map<id,id>();  
        public cloneData(list<sObject> objects, map<id,id> previousDataMap)
            this.objectsToClone = objects;
            this.previousSourceToCloneMap = previousDataMap;

It’ll clone your record, your records children, your records children’s children’s, and yes even your records children’s children’s children (you get the point)! Simply invoke the deepClone.clone() method with the id of the object to start the clone process at, whether you want to only copy custom objects, and if you want to use all or nothing processing. Deep Clone takes care of the rest automatically handling figuring out relationships, cloning, re-parenting, and generally being awesome. As always I’m happy to get feedback or suggestions! Enjoy!


7 responses

  1. Pingback: Dynamic Apex Invocation/Callbacks | I Write Crappy Code

  2. Nelson Rodriguez

    Do you have a the test class for this code? I am using it and it seems to work fine but I am having trouble creating the unit test
    getting Error: System.AsyncException: Maximum stack depth has been reached

    Here is my test code

    public class deepClone_Test {
    static void test_method(){
    system.debug(‘Starting clone of draft a1N55000000B0CgEAL’);
    System.assertEquals(1, 1);

    May 9, 2017 at 2:22 pm

  3. Nelson Rodriguez

    Just added new comment

    May 9, 2017 at 2:22 pm

  4. Jon M

    Im getting an “unreachable statement” error on line 34 “return null;”

    October 1, 2020 at 9:10 pm

    • Oh weird, I’m not sure where that came from as yeah that would definitely cause a problem. Just delete the extra ‘return null’ and give that a shot. Must have been an extra during me cleaning it up for posting or something. Been a couple years since I looked at this.

      October 1, 2020 at 9:14 pm

  5. Jon M

    Thanks That worked

    October 1, 2020 at 9:21 pm

  6. Jon M

    @Kenji776- I have utilized your code to bring in all the related records needed except attachments. Do you have any direction that could help with that?

    October 2, 2020 at 4:03 pm

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s