/// <summary>
/// Permanently remove an object.
/// </summary>
/// <param name="obj">The object to persist</param>
/// <param name="dbTransaction">The database transaction for when participating in transactions</param>
public void Remove(object obj, IDbTransaction dbTransaction)
{
SqlResult sr = Execute(obj, StatementType.Delete, null, dbTransaction);
if (sr.ErrorCode == 0)
{
// clear the identity column if any
ObjectMap map = ObjectFactory.GetMap(this, obj);
if (map.IdentityMap != null)
{
map.SetIdentity(obj, 0);
}
// make sure the object does not think it is persisted
if (obj is IEntity)
{
(obj as IEntity).IsPersisted = false;
}
}
}
/// <summary>
/// Internal helper method used for standard CRUD operations on known types.
/// </summary>
/// <param name="obj">The object instance being operated on</param>
/// <param name="st">The statement type</param>
/// <param name="conn">An existing database connection to reuse. This is useful
/// when you need to execute statements in the same session as a previous statement.</param>
/// <param name="tr">The database transaction for when participating in transactions.</param>
/// <returns>The result of the operation</returns>
internal SqlResult Execute(object obj, StatementType st, IDbConnection conn, IDbTransaction tr)
{
ObjectMap map = ObjectFactory.GetMap(this, obj);
// perform validations first
if (StatementType.Insert == st || StatementType.Update == st)
{
ValidationBroker.Validate(obj);
}
if (map.IsSoftDelete && st == StatementType.Delete)
{
st = StatementType.SoftDelete;
}
SqlStatement stmt = GetStatement(obj, st);
stmt.SetParameters(obj, true);
// connections are supplied from outside when in a transaction or executing batch queries
conn = tr != null ? tr.Connection : conn ?? stmt.SessionBroker.Provider.GetConnection();
SqlResult sr = stmt.Execute(conn, tr);
// throw an error if execution failed
Check.Verify(sr.ErrorCode == 0, Error.StatementError, sr.Error, stmt.Sql);
// check that statement affected a row
if (st == StatementType.Insert || st == StatementType.Update ||
st == StatementType.Delete || st == StatementType.SoftDelete)
{
Check.Verify(sr.RowsAffected >= 1, Error.UnexpectedRowCount, sr.RowsAffected, "1+");
}
// update identity values for inserts
if (st == StatementType.Insert)
{
if (sr.LastRowId != 0 && map.IdentityMap != null)
{
map.SetIdentity(obj, sr.LastRowId);
}
if (obj is IEntity)
{
(obj as IEntity).IsPersisted = true;
}
// this is not really necessary but nice for error checking (also used in test cases)
if (map.InheritanceMap != null)
{
map.InheritanceMap.SetValue(obj, obj.GetType().AssemblyQualifiedName);
}
}
// update/invalidate the cache
if (GentleSettings.CacheObjects && map.CacheStrategy != CacheStrategy.Never)
{
if (st == StatementType.Insert)
{
// insert new object into cache
CacheManager.Insert(map.GetInstanceHashKey(obj), obj, map.CacheStrategy);
// invalidate query results for select statements for this type, reducing the
// effectiveness of the cache (but ensuring correct results)
if (GentleSettings.CacheStatements)
{
CacheManager.ClearQueryResultsByType(map.Type);
}
}
else if (st == StatementType.Delete || st == StatementType.SoftDelete)
{
// remove invalidated object from the cache
CacheManager.Remove(obj);
// invalidate query results for select statements for this type, reducing the
// effectiveness of the cache (but ensuring correct results)
if (GentleSettings.CacheStatements)
{
CacheManager.ClearQueryResultsByType(map.Type);
}
}
}
// update the in-memory version/revision counter for objects under concurrency control
if (st == StatementType.Update && GentleSettings.ConcurrencyControl)
{
if (map.ConcurrencyMap != null)
{
FieldMap fm = map.ConcurrencyMap;
long version = Convert.ToInt64(fm.GetValue(obj));
// handle wrap-around of the version counter
if ((fm.Type.Equals(typeof(int)) && version == int.MaxValue) ||
(fm.Type.Equals(typeof(long)) && version == long.MaxValue))
{
version = 1;
}
else
{
version += 1;
}
map.ConcurrencyMap.SetValue(obj, version);
}
}
// update object with database-created values if UpdateAfterWrite is set to true
if (map.IsUpdateAfterWrite && (st == StatementType.Insert || st == StatementType.Update))
{
if (tr != null)
{
Refresh(obj, tr);
}
else
{
Refresh(obj);
}
}
return(sr);
}