Here's the persister I whipped up to manage the deletion of constraints. It'd be a huge help for me if somebody on the Hibernate team takes a look and lets me know if it looks kosher. Thanks.
/**
* Like a regular EntityPersister except that it will nullify foreign keys
* columns pointing to the table for this type before executing a deletion.
*
* Created on Mar 3, 2004
* @author DSmith
*/
public class ConstraintDeletingPersister extends EntityPersister {
private static final Log log = LogFactory.getLog(EntityPersister.class);
// arg. I must duplicate this field from EntityPersister because
// it's not visible and not exposed by any accessor.
private final SessionFactoryImplementor factory;
private String[] sqlClearConstraints = null;
/**
* Get the array of sql statements needed to clear foreign key constraints
* that reference this object.
* @return Returns the sqlClearConstraints.
*/
public String[] getSqlClearConstraints() {
return sqlClearConstraints;
}
/**
* @param model Describes the relational map for this type.
* @param factory The factory that produces sessions that use this
* persister.
* @throws net.sf.hibernate.HibernateException if the configurtion mapping
* is invalid.
*/
public ConstraintDeletingPersister(PersistentClass model,
SessionFactoryImplementor factory) throws HibernateException
{
super(model, factory);
// arg. I must duplicate this field from EntityPersister because
// it's not visible and not exposed by any accessor.
this.factory = factory;
}
/* (non-Javadoc)
* @see net.sf.hibernate.persister.EntityPersister#postInstantiate()
*/
public void postInstantiate() throws MappingException {
super.postInstantiate();
List sqlClearFkList = new ArrayList();
// For each one-to-one property, get the unique fk that references
// this table and generate a sql string to nullify the fk.
String[] propertyNames = getPropertyNames();
Type[] propertyTypes = getPropertyTypes();
for ( int i=0; i<propertyNames.length; i++ ) {
Type propType = propertyTypes[i];
// xxxdsmith are one-to-one types always unique constrained?
if ( propType.isEntityType() &&
((EntityType) propType).isOneToOne()
// && ((OneToOneType) uniqueKeyType).getForeignKeyDirection()
// == ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT)
)
{
OneToOneType oneToOne = (OneToOneType) propType;
String[] fkColumns = oneToOne.getReferencedColumns(factory);
if (fkColumns.length > 0) {
Class clazz = ( (EntityType) propType ).getAssociatedClass();
// xxxdsmith what if the referenced object uses table-per-subclass?
// is there a better way to get the table name for the prop?
EntityPersister fkPersister =
(EntityPersister) factory.getPersister(clazz);
String tableName = fkPersister.getTableName();
// xxxdsmith not sure how to handle where clauses here because
// I don't know what to use as the alias argument to
// getSQLWhereString(String alias)
sqlClearFkList.add(
generateClearConstraintString(fkPersister.getTableName(),
fkColumns,
null));
}
}
}
this.sqlClearConstraints =
(String[]) sqlClearFkList.toArray(new String[sqlClearFkList.size()]);
}
/**
* Update objects pointing to this entity to remove their foreign keys,
* then do a normal delete.
* @see net.sf.hibernate.persister.EntityPersister#delete(java.io.Serializable, java.lang.Object, java.lang.Object, net.sf.hibernate.engine.SessionImplementor)
*/
public void delete(Serializable id, Object version, Object object,
SessionImplementor session)
throws HibernateException {
clearConstraints(id, version, object, session);
super.delete(id, version, object, session);
}
/**
* @param id
* @param version
* @param object
* @param session
*/
private void clearConstraints(Serializable id,
Object version,
Object object,
SessionImplementor session)
throws HibernateException {
if ( log.isTraceEnabled() ) {
log.trace( "Clearing constraints for entity: " + MessageHelper.infoString(this, id) );
if ( isVersioned() ) log.trace( "Version: " + version );
}
try {
String[] sqlClearStrings = getSqlClearConstraints();
for (int i = 0; i < sqlClearStrings.length; i++) {
//Render the SQL query
final PreparedStatement statement;// = session.getPreparedStatement( sqlDelete() );
statement = session.getBatcher().prepareBatchStatement( sqlClearStrings[i] );
try {
// Do the key. The key is immutable so we can use the _current_ object state - not necessarily
// the state at the time the delete was issued
getIdentifierType().nullSafeSet( statement, id, 1, session );
session.getBatcher().addToBatch(-1);
}
catch (SQLException sqle) {
session.getBatcher().abortBatch(sqle);
throw sqle;
}
}
}
catch (SQLException sqle) {
throw new JDBCException( "could not clear constraint for: " + MessageHelper.infoString(this, id), sqle );
}
}
/**
* Generate the SQL UPDATE that updates all the foreign keys to null
*/
protected String generateClearConstraintString(String tableName,
String[] fkColumnNames,
String sqlWhereString)
{
Update update = new Update()
.setTableName(tableName)
.addColumns(fkColumnNames, "null")
.setPrimaryKeyColumnNames(fkColumnNames);
if (sqlWhereString != null) update.setWhere(sqlWhereString);
return update.toStatementString();
}
}
Login
FAQ
Search
