public void Process(DeleteReferenceCommand c) { XmlElement reference = FindReference(GetKey(c.ParentType, c.ParentId), GetKey(c.ChildType, c.ChildId)); if(reference == null) throw new Exception("Unknow Reference"); reference.ParentNode.RemoveChild(reference); }
internal Command CreateCommand(Entity e) { switch (e.Type) { case SyncUtils.CREATE_ENTITY: CreateEntityCommand ce = new CreateEntityCommand( e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.TYPE) ); return ce; case SyncUtils.DELETE_ENTITY: DeleteEntityCommand de = new DeleteEntityCommand( e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.TYPE) ); return de; case SyncUtils.CREATE_ATTRIBUTE: CreateAttributeCommand ca = new CreateAttributeCommand( e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.PARENTTYPE), e.GetString(SyncUtils.NAME), MetaData.TypeResolver.GetType(e.GetString(SyncUtils.TYPE)), Factory.Serializer.Unserialize(e.GetString(SyncUtils.VALUE)) ); return ca; case SyncUtils.DELETE_ATTRIBUTE: DeleteAttributeCommand da = new DeleteAttributeCommand( e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.PARENTTYPE), e.GetString(SyncUtils.NAME), MetaData.TypeResolver.GetType(e.GetString(SyncUtils.TYPE)), null ); return da; case SyncUtils.UPDATE_ATTRIBUTE: UpdateAttributeCommand ua = new UpdateAttributeCommand( e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.PARENTTYPE), e.GetString(SyncUtils.NAME), MetaData.TypeResolver.GetType(e.GetString(SyncUtils.TYPE)), Factory.Serializer.Unserialize(e.GetString(SyncUtils.VALUE)) ); return ua; case SyncUtils.CREATE_REFERENCE: CreateReferenceCommand cr = new CreateReferenceCommand( e.GetString(SyncUtils.ROLE), e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.PARENTTYPE), e.GetString(SyncUtils.CHILDID), e.GetString(SyncUtils.CHILDTYPE) ); return cr; case SyncUtils.DELETE_REFERENCE: DeleteReferenceCommand dr = new DeleteReferenceCommand( e.GetString(SyncUtils.ROLE), e.GetString(SyncUtils.PARENTID), e.GetString(SyncUtils.PARENTTYPE), e.GetString(SyncUtils.CHILDID), e.GetString(SyncUtils.CHILDTYPE) ); return dr; default: throw new UniversalStorageException("Unexpected command type"); } }
public override DeleteReferenceCommand Visit(DeleteReferenceCommand c) { _RWL.AcquireWriterLock(); try { Entity entity = GetEntity(c.ParentType, c.ParentId); for (int i = entity.EntityEntries.Count - 1; i >= 0; i--) { Entry ee = (Entry)entity.EntityEntries[i]; if (ee.IsEntity && ((Entity)ee.Value).Id == c.ChildId) entity.EntityEntries.Remove(ee); } } finally { _RWL.ReleaseWriterLock(); } return c; }
public override DeleteReferenceCommand Visit(DeleteReferenceCommand c) { Entity e = new Entity(SyncUtils.DELETE_REFERENCE); PopulateDefaults(e, c); e.SetValue(SyncUtils.PARENTID, c.ParentId); e.SetValue(SyncUtils.PARENTTYPE, c.ParentType); e.SetValue(SyncUtils.ROLE, c.Role); e.SetValue(SyncUtils.CHILDID, c.ChildId); e.SetValue(SyncUtils.CHILDTYPE, c.ChildType); transaction.Serialize(e); return c; }
public void Process(DeleteReferenceCommand c) { ReferenceMapping referenceMapping = null; if (!string.IsNullOrEmpty(c.ChildType)) referenceMapping = _Mapping.Entities[c.ParentType, true].References[c.Role, c.ChildType]; else referenceMapping = _Mapping.Entities[c.ParentType, true].References[c.Role]; if (referenceMapping == null) { Evaluant.Uss.Models.Entity current = _Engine.Model.GetEntity(c.ParentType); while (referenceMapping == null && current != null) { Evaluant.Uss.Models.Entity currentChild = _Engine.Model.GetEntity(c.ChildType); while (referenceMapping == null && currentChild != null) { referenceMapping = _Mapping.Entities[current.Type, true].References[c.Role, current.Type, currentChild.Type]; currentChild = _Engine.Model.GetParent(currentChild); } if (referenceMapping == null) current = _Engine.Model.GetParent(current); } } if (referenceMapping == null) throw new Exception(String.Format("The reference '{0}' of the entity '{1}' is not defined in your mapping file", c.Role, c.ParentType)); EntityMapping parentMapping = referenceMapping.EntityParent; EntityMapping childMapping = _Mapping.Entities[referenceMapping.EntityChild, true]; RuleMappingCollection rules = referenceMapping.Rules; bool isParentRefered = true; // Delete all records to index tables for (int index = 0; index < rules.Count; index++) { ISQLExpression query = null; //if first rule : ParentField is a foreign key ==> update parent table if ((index == 0) && (rules[index].ParentField != parentMapping.IdFields)) { // UPDATE parenttable SET FK_column = NULL WHERE PK_Column = PK_Value query = new UpdateCommand(rules[index], rules[index].ParentTable); for (int i = 0; i < rules[index].ParentFields.Length; i++) { if (parentMapping.Ids[rules[index].ParentFields[i]] == null) { Constant constant = new Constant(DBNull.Value, _Dialect.GetDbTypeToPrimaryKey(childMapping.Ids[i].Generator)); if (rules[index].ParentDefaultValues.Length > i && !string.IsNullOrEmpty(rules[index].ParentDefaultValues[i])) constant = new Constant(rules[index].ParentDefaultValues[i], _Dialect.GetDbTypeToPrimaryKey(childMapping.Ids[i].Generator)); ((UpdateCommand)query).ColumnValueCollection.Add(rules[index].ParentFields[i], constant); } } for (int i = 0; i < parentMapping.Ids.Count; i++) { string PK_Column = parentMapping.IdFields.Split(SqlMapperProvider.IDSEP)[i]; string PK_Value = ConvertId(parentMapping, PK_Column, c.ParentId); ((UpdateCommand)query).WhereClause.SearchCondition.Add(new BinaryLogicExpression( new Column(parentMapping.Ids[i], PK_Column), BinaryLogicOperator.Equals, new Constant(PK_Value, _Dialect.GetDbTypeToPrimaryKey(parentMapping.Ids[i].Generator)))); } ExecuteCommand(query); } //if last rule : ChildField is a foreign key ==> update child table if ((index == rules.Count - 1) && (rules[index].ChildField != childMapping.IdFields)) { // UPDATE childtable SET FK_column = NULL WHERE PK_Column = PK_Value query = new UpdateCommand(rules[index], rules[index].ChildTable); for (int i = 0; i < rules[index].ChildFields.Length; i++) { if (childMapping.Ids[rules[index].ChildFields[i]] == null) { Constant constant = new Constant(DBNull.Value, _Dialect.GetDbTypeToPrimaryKey(parentMapping.Ids[i].Generator)); if (rules[index].ChildDefaultValues.Length > i && !string.IsNullOrEmpty(rules[index].ChildDefaultValues[i])) constant = new Constant(rules[index].ChildDefaultValues[i], _Dialect.GetDbTypeToPrimaryKey(parentMapping.Ids[i].Generator)); ((UpdateCommand)query).ColumnValueCollection.Add(rules[index].ChildFields[i], constant); } } for (int i = 0; i < childMapping.Ids.Count; i++) ((UpdateCommand)query).WhereClause.SearchCondition.Add(new BinaryLogicExpression( new Column(childMapping.Ids[i], childMapping.IdFields.Split(SqlMapperProvider.IDSEP)[i]), BinaryLogicOperator.Equals, new Constant(ConvertId(childMapping, childMapping.IdFields.Split(SqlMapperProvider.IDSEP)[i], c.ChildId), _Dialect.GetDbTypeToPrimaryKey(childMapping.Ids[i].Generator)))); //PrimaryKeyMapping PK_mapping = index == 0 ? parentMapping.Ids[0] : childMapping.Ids[0]; //string PK_column = childMapping.IdFields; //string PK_value = c.ChildId; ExecuteCommand(query); } // Execute a delete command to index table if (index != rules.Count - 1) { // Delete records to index table with one foreign key : rule(n).ChildField == rule(n+1).ParentField if (rules[index].ChildField == rules[index + 1].ParentField) { // the refered table is parent table ==> WHERE rule(n).ChildField == ParentId if (isParentRefered) { query = new DeleteCommand(rules[index], rules[index].ChildTable); ((DeleteCommand)query).Condition.SearchCondition.Add(new BinaryLogicExpression( new Column(rules[index], rules[index].ChildField), BinaryLogicOperator.Equals, new Constant(c.ParentId, _Dialect.GetDbTypeToPrimaryKey(parentMapping.Ids[0].Generator)))); } // the refered table is child table ==> WHERE rule(n).ChildField == ChildId else { query = new DeleteCommand(rules[index], rules[index].ChildTable); ((DeleteCommand)query).Condition.SearchCondition.Add(new BinaryLogicExpression( new Column(rules[index], rules[index].ChildField), BinaryLogicOperator.Equals, new Constant(c.ChildId, _Dialect.GetDbTypeToPrimaryKey(childMapping.Ids[0].Generator)))); } } // Delete records to index table with two foreign key : rule(n).ChildField != rule(n+1).ParentField else { query = new DeleteCommand(rules[index], rules[index].ChildTable); ((DeleteCommand)query).Condition.SearchCondition.Add(new BinaryLogicExpression( new Column(rules[index], rules[index].ChildField), BinaryLogicOperator.Equals, new Constant(c.ParentId, _Dialect.GetDbTypeToPrimaryKey(parentMapping.Ids[0].Generator)))); ((DeleteCommand)query).Condition.SearchCondition.Add(new BinaryLogicExpression( new Column(rules[index + 1], rules[index + 1].ParentField), BinaryLogicOperator.Equals, new Constant(c.ChildId, _Dialect.GetDbTypeToPrimaryKey(childMapping.Ids[0].Generator)))); isParentRefered = false; } ExecuteCommand(query); } } }
public abstract DeleteReferenceCommand Visit(DeleteReferenceCommand item);
/// <summary> /// Generated a set of commands to be processed to take into account any modification applied to an entity graph /// </summary> /// <param name="entity">The Entity to compute</param> /// <param name="processing">A collection of all currently processed entities</param> /// <param name="commands">A collection of all currently created commands</param> public void ComputeChanges(Entity entity, ICollection<Entity> processing, ICollection<Command> commands) { // Nothing to do if the entity is currently processed if (processing.Contains(entity)) return; processing.Add(entity); // To know if we can optimize the command with a compound bool canCreateCompound = true; // Will contain the commands created for the attributes of the current entity List<AttributeCommand> attributeCommands = new List<AttributeCommand>(entity.Count); // First process all attributes not to increase the stack size because of deep hierarchies in the object graph and the recursive algorithm if (entity.State == State.Modified || entity.State == State.New) foreach (Entry e in entity) { if (!e.IsEntity) { // The current entry is an Attribute switch (e.State) { case State.Deleted: attributeCommands.Add(new DeleteAttributeCommand(e)); break; case State.Modified: attributeCommands.Add(new UpdateAttributeCommand(e)); break; case State.New: attributeCommands.Add(new CreateAttributeCommand(e)); break; default: break; } } } // Selects the optimized command /// TODO: Add a property to PE so that the user could specify whether he wants all attributes to be sent with a compound command switch (entity.State) { case State.New: if (canCreateCompound) commands.Add(new CompoundCreateCommand(entity, attributeCommands)); else { commands.Add(new CreateEntityCommand(entity)); foreach (Command attributeCommand in attributeCommands) commands.Add(attributeCommand); } break; case State.Deleted: commands.Add(new DeleteEntityCommand(entity.Id, entity.Type)); break; case State.Modified: if (attributeCommands.Count > 1) { CompoundUpdateCommand cuc = new CompoundUpdateCommand(entity, attributeCommands); commands.Add(cuc); } else foreach (Command attributeCommand in attributeCommands) commands.Add(attributeCommand); break; default: foreach (Command attributeCommand in attributeCommands) commands.Add(attributeCommand); break; } foreach (Entry e in entity) { if (e.IsEntity) { Model.Reference referenceModel = Model.GetReference(entity.Type, e.Name); if (e.IsMultiple) { foreach (Entity child in ((IEnumerable<Entity>)e)) { ComputeChanges(child, processing, commands); switch (e.State) { case State.New: CreateReferenceCommand crc1 = new CreateReferenceCommand(referenceModel, entity, child); commands.Add(crc1); break; case State.Deleted: DeleteReferenceCommand drc = new DeleteReferenceCommand(referenceModel, entity, child); commands.Add(drc); break; } } } else { // The current entry is an Entity Entity child = (Entity)e.Value; ComputeChanges(child, processing, commands); switch (e.State) { case State.New: CreateReferenceCommand crc1 = new CreateReferenceCommand(referenceModel, entity, child); commands.Add(crc1); break; case State.Deleted: DeleteReferenceCommand drc = new DeleteReferenceCommand(referenceModel, entity, child); commands.Add(drc); break; } } } } }
public override DeleteReferenceCommand Visit(DeleteReferenceCommand c) { _RWL.AcquireWriterLock(Timeout.Infinite); try { Entity entity = _Entities[CacheEngine.GetCacheKey(c.ParentType, c.ParentId)]; if (entity == null) return c; for (int i = entity.EntityEntries.Count - 1; i >= 0; i--) { Entry ee = (Entry)entity.EntityEntries[i]; if (ee.IsEntity && ((Entity)ee.Value).Id == c.ChildId) entity.EntityEntries.Remove(ee); } } finally { _RWL.ReleaseWriterLock(); } return c; }