/// <summary> /// Updates a data object record using the "table" and a list of column/value pairs. /// </summary> /// <param name="transaction">The transaction to do this as part of.</param> /// <param name="mapping">The mapping of the table or other data container we're dealing with.</param> /// <param name="crit">All records matching this criteria will be updated per the dictionary of /// values.</param> /// <param name="propValues">A dictionary of column/value pairs for all non-ID columns to be updated.</param> /// <returns>The number of records affected.</returns> public override int Update(ITransaction transaction, ClassMapping mapping, DaoCriteria crit, IDictionary<string, object> propValues) { // Since the update might change one of the id fields, we can't just overwrite the // table with new values (since that might be an add). Instead create a temp table, // put in everything that doesn't match, then put in everything that does after // modifying it. DaoCriteria inverseCrit = new DaoCriteria(); foreach (IExpression expr in crit.Expressions) { inverseCrit.Expressions.Add(expr.Invert()); } IDictionary<string, MemoryObject> table = GetTable(mapping); int retVal = 0; lock (table) { IDictionary<string, MemoryObject> tempTable = new Dictionary<string, MemoryObject>(); // First the unchanged records. MemoryDataReader reader = new MemoryDataReader(this, mapping, inverseCrit, table.Values.GetEnumerator()); while (reader.Read()) { MemoryObject unchanged = reader.GetCurrentObject(); tempTable[unchanged.GetKey()] = unchanged; } // Now the changed ones. reader = new MemoryDataReader(this, mapping, crit, table.Values.GetEnumerator()); while (reader.Read()) { MemoryObject changed = reader.GetCurrentObject(); // Set the changed values. foreach (KeyValuePair<string, object> kvp in propValues) { changed.ColValues[kvp.Key] = kvp.Value; } tempTable[changed.GetKey()] = changed; retVal++; } // Now replace the real table contents with the temp ones. table.Clear(); foreach (KeyValuePair<string, MemoryObject> kvp in tempTable) { table.Add(kvp); } } return retVal; }
/// <summary> /// Deletes a data object record using the mapping and criteria for what's deleted. /// </summary> /// <param name="transaction">The transaction to do this as part of.</param> /// <param name="mapping">The mapping of the table from which to delete.</param> /// <param name="crit">Criteria for deletion. NOTE: Only the expressions are observed, /// other things (like "order" or start / limit) are ignored. /// WARNING: A null or empty (no expression) criteria will /// delete ALL records!</param> /// <returns>The number of records affected.</returns> public override int Delete(ITransaction transaction, ClassMapping mapping, DaoCriteria crit) { // Find all the records that don't match, and just keep those. DaoCriteria inverseCrit = new DaoCriteria(); foreach (IExpression expr in crit.Expressions) { inverseCrit.Expressions.Add(expr.Invert()); } IDictionary<string, MemoryObject> table = GetTable(mapping); int retVal; lock (table) { int oldCount = table.Count; MemoryDataReader reader = new MemoryDataReader(this, mapping, inverseCrit, table.Values.GetEnumerator()); IDictionary<string, MemoryObject> tempTable = new Dictionary<string, MemoryObject>(); while (reader.Read()) { MemoryObject keeper = reader.GetCurrentObject(); tempTable[keeper.GetKey()] = keeper; } table.Clear(); foreach (KeyValuePair<string, MemoryObject> kvp in tempTable) { table.Add(kvp); } retVal = oldCount - table.Count; } return retVal; }