[SalesForce] Attachment Cloning: System.LimitException: Query of LOB fields caused heap usage to exceed limit

The children records will be contained within standard List collections under the parent object record.

Enhancing your much-too-genericized code sample:

Map<Id, Account> AcctOppCustomObjectMap = new Map<Id, Account>([SELECT Id
                                                                    ,(SELECT xxx 
                                                                        FROM xxx__r)
                                                                    ,(SELECT yyy 
                                                                        FROM yyy__r) 
                                                                FROM Account
                                                                WHERE Id IN :idSet]);

List<yyy__c> yThingsToUpdate = new List<yyy__c>();

for (Id accountId : AcctOppCustomObjectMap.keyset()) {
    Account acct = AcctOppCustomObjectMap.get(accountId);

    // the acct reference will have child lists for your subqueries
    // they will not be null, but they could be empty lists
    List<xxx__c> xxxList = acct.xxx__r;
    List<yyy__c> yyyList = acct.yyy__r;

    // iteration of the child records possible now using these two lists
    for (xxx__c xThing : xxxList) {
        for (yyy__c yThing : yyyList) {
            if (xThing.value == yThing.value) {
                // create your relationship and 
                // add to a list for bulk update / insert
                yThingsToUpdate.add(new yyy__c(Id = yThing.Id
                                                   , xxx__c = xThing.Id));

                break; // exit the for loop on the first match if desired
            }
        }
    }
}


if (!yThingsToUpdate.isEmpty()) {
    update yThingsToUpdate;
}

I would probably iterate each child list just once each to create maps of the contents by a desired key so that I could perform a Map.get() instead of repeatedly iterating lists to find the other child record to compare against. Your code sample needs more specific information in it.

Repeated iteration of the yyy list within the xxx list will limit your ability to process records since these will use script statements to iterate and match the records.

Here is the solution that I was discussing in the comments. It's very similar in concept to your's except it tries to reduce the number of DML and SOQL statements by grouping the Attachments into batches of 5MB (this will need adjusting, I just chose it to prove the concept).

The code could do with cleaning up a bit, and you'll want to change how the ParentIds are selected/assigned, but hopefully the concept is clear:

List<List<Id>> batches = new List<List<Id>>();
List<Integer> batchSizes = new List<Integer>();

for(Attachment attachment : [SELECT Id, BodyLength from Attachment WHERE ParentId = '5002000000ahX5f'])
{ 
    Boolean batched = false;

    for(Integer i = 0; i < batches.size(); i++)
    {
        Integer batchSize = batchSizes[i];

        if(batchSize + attachment.BodyLength < 10000000)
        {
            batches[i].add(attachment.Id);
            batchSizes[i] += attachment.BodyLength;
            batched = true;
            break;
        }
    }

    if(!batched)
    {
        batches.add(new List<Id>{attachment.Id});
        batchSizes.add(attachment.BodyLength);
    }

    System.debug('>>>first loop heap=' + Limits.getHeapSize());
}

for(List<Id> batchIds : batches)
{
    List<Attachment> attachmentsToInsert = new List<Attachment>();

    for(Attachment attachment : [SELECT Name, Body FROM Attachment WHERE Id IN :batchIds])
    {
        attachmentsToInsert.add(new Attachment(Name = attachment.Name, Body = attachment.Body, ParentId = '5002000000ahX5v'));
    }

    System.debug('>>> second loop heap=' + Limits.getHeapSize());
    insert attachmentsToInsert;
}

The output for an object with 5 Attachments (4.28MB, 1.23MB, 1.24MB, 3.59MB, 4.29MB) is as follows:

>>>first loop heap=1871
>>>first loop heap=1917
>>>first loop heap=1955
>>>first loop heap=1993
>>>first loop heap=2015

>>> second loop heap=4503453
>>> second loop heap=2589001
>>> second loop heap=4489577
>>> second loop heap=3759972

Number of SOQL queries: 5 out of 100
Number of DML statements: 4 out of 150

In this case it has only saved 1 DML, but with a lot of small Attachments or increasing the limit this will save a lot more.

For example, using a limit of 10MB gives you the following:

>>>first loop heap=1871
>>>first loop heap=1901
>>>first loop heap=1939
>>>first loop heap=1961
>>>first loop heap=1983

>>> second loop heap=9549616
>>> second loop heap=5788869

Number of SOQL queries: 3 out of 100
Number of DML statements: 2 out of 150