protected virtual void Update(object id, object[] fields, object[] oldFields, bool[] includeProperty, object oldVersion, object obj, SqlString sqlUpdateString, ISessionImplementor session) { if (log.IsDebugEnabled) { log.Debug("Updating entity: " + MessageHelper.InfoString(this, id)); if (IsVersioned) { log.Debug("Existing version: " + oldVersion + " -> New Version: " + fields[VersionProperty]); } } if (!hasUpdateableColumns) { return; } try { IDbCommand statement = IsBatchable ? session.Batcher.PrepareBatchCommand(sqlUpdateString) : session.Batcher.PrepareCommand(sqlUpdateString); try { // now write the values of fields onto the command int index = Dehydrate(id, fields, includeProperty, statement, session); // Write any appropriate versioning conditional parameters if (IsVersioned && OptimisticLockMode == OptimisticLockMode.Version) { VersionType.NullSafeSet(statement, oldVersion, index, session); } else if (OptimisticLockMode.Version < OptimisticLockMode && null != oldFields) { bool[] includeOldField = OptimisticLockMode == OptimisticLockMode.All ? PropertyUpdateability : includeProperty; for (int j = 0; j < HydrateSpan; j++) { if (includeOldField[j] && oldFields[j] != null) { PropertyTypes[j].NullSafeSet(statement, oldFields[j], index, session); index += propertyColumnSpans[j]; } } } if (IsBatchable) { session.Batcher.AddToBatch(1); } else { Check(session.Batcher.ExecuteNonQuery(statement), id); } } catch (Exception e) { if (IsBatchable) { session.Batcher.AbortBatch(e); } throw; } finally { if (!IsBatchable) { session.Batcher.CloseCommand(statement, null); } } } catch (HibernateException) { // Do not call Convert on HibernateExceptions throw; } catch (Exception sqle) { throw Convert(sqle, "could not update: " + MessageHelper.InfoString(this, id)); } }
/// <summary> /// Delete an object /// </summary> /// <param name="id">The id of the object to delete.</param> /// <param name="version">The version of the object to delete.</param> /// <param name="obj">The object to delete.</param> /// <param name="session">The session to perform the deletion in.</param> public override void Delete(object id, object version, object obj, ISessionImplementor session) { if (log.IsDebugEnabled) { log.Debug("Deleting entity: " + MessageHelper.InfoString(this, id)); if (IsVersioned) { log.Debug("Version: " + version); } } try { IDbCommand deleteCmd; if (IsVersioned) { deleteCmd = session.Batcher.PrepareCommand(SqlDeleteString); } else { deleteCmd = session.Batcher.PrepareBatchCommand(SqlDeleteString); } 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. IdentifierType.NullSafeSet(deleteCmd, id, 0, session); // we should use the _current_ object state (ie. after any updates that occurred during flush) if (IsVersioned) { VersionType.NullSafeSet(deleteCmd, version, IdentifierColumnNames.Length, session); Check(session.Batcher.ExecuteNonQuery(deleteCmd), id); } else { session.Batcher.AddToBatch(1); } } catch (Exception e) { if (!IsVersioned) { session.Batcher.AbortBatch(e); } throw; } finally { if (IsVersioned) { session.Batcher.CloseCommand(deleteCmd, null); } } } catch (HibernateException) { // Do not call Convert on HibernateExceptions throw; } catch (Exception sqle) { throw Convert(sqle, "could not delete: " + MessageHelper.InfoString(this, id)); } }