使用级联删除子类对域类进行Grails高效的批量删除

Question

What techniques are people using to efficiently do cascading delete on a large collection of classes?

Suppose I have the following domain classes:

class Submission {
   static hasMany = [members: Member]
}

class Member {
   static belongsTo = [submission: Submission]
   static hasMany = [events: Event, hashCodes: HashCode]
}

class Event {
   static belongsTo = [member: Member]
}

class HashCode {
   static belongsTo = [member: Member]
}

Now the number of Members for a given Submission could be very large, say 100,000+, but this is no way limited. The Events and HashCodes would be say 15 per Member.

I need to delete some or all of the Members for a given Submission (let's assume all of them for now), but leave the Submission record intact. So I currently do this as follows:

Set<Member> membersToDelete = Member.findAllBySubmissionId( submission.id )
withSessionCleaner(membersToDelete){ member ->
   submission.payroll.removeFromMembers( member )
   member.delete( failOnError: true )
}

where some generic base service provide the session cleaner as:

SessionFactory sessionFactory
def propertyInstanceMap = org.codehaus.groovy.grails.plugins.DomainClassGrailsPlugin.PROPERTY_INSTANCE_MAP
private static final int DEFAULT_SESSION_CLEANER_CHECKPOINT = 100
def withSessionCleaner(def items, Closure c)
{
    items.eachWithIndex { obj, index ->
       c(obj)
       if (++index % DEFAULT_SESSION_CLEANER_CHECKPOINT == 0) {
           def session = sessionFactory.currentSession
           session.flush()
           session.clear()
           propertyInstanceMap.get().clear()
        }
    }
}

The session cleaner method is required as otherwise Grails retains all objects in the session cache and eventually I get out of memory issues and/or the processing begins to takes a long time towards the end of the collection.

My main concerns with this approach are:

1. What is Grails reading or loading from the db into memory for the Member/Event/HashCode classes? I've heard of lazy loading but not sure how to check or configure this on these 3 classes.
2. Processing each Member seperately seems necessary for the cascade delete to work, but seems potentially expensive for what I'm trying to achieve.

Could I run some SQL queries to achieve what I what:

1. delete from Event where member_id in (select id from Member where submission_id = ?)
2. delete from HashCode where member_id in (select id from Member where submission_id = ?)
3. delete from Member where submission_id = ?

But now I'm in raw SQL and not really using the Grails classes or relationships. Are there Grails/GORM commands that would equate to these SQL statements?

Any suggestions?

Answer 1

The fastest way is to create FOREIGN KEYS with ON DELETE CASCADE on child objects (hope your DB allows you to do it). After that you can safely delete Members by ID, the database will do the rest.