private PropagatorResult CreateSimpleResult(
IEntityStateEntry stateEntry, IExtendedDataRecord record, MemberInformation memberInformation,
int identifier, bool isModified, int recordOrdinal, object value)
{
var updatableRecord = record as CurrentValueRecord;
// construct flags for the value, which is needed for complex type and simple members
var flags = memberInformation.Flags;
if (!isModified)
{
flags |= PropagatorFlags.Preserve;
}
if (PropagatorResult.NullIdentifier != identifier)
{
// construct a key member
PropagatorResult result;
if ((memberInformation.IsServerGenerated || memberInformation.IsForeignKeyMember) &&
null != updatableRecord)
{
result = PropagatorResult.CreateServerGenKeyValue(flags, value, stateEntry, identifier, recordOrdinal);
}
else
{
result = PropagatorResult.CreateKeyValue(flags, value, stateEntry, identifier);
}
// we register the entity as the "owner" of an identity so that back-propagation can succeed
// (keys can only be back-propagated to entities, not association ends). It also allows us
// to walk to the entity state entry in case of exceptions, since the state entry propagated
// through the stack may be eliminated in a project above a join.
m_translator.KeyManager.RegisterIdentifierOwner(result);
return(result);
}
else
{
if ((memberInformation.IsServerGenerated || memberInformation.IsForeignKeyMember) &&
null != updatableRecord)
{
// note: we only produce a server gen result when
return(PropagatorResult.CreateServerGenSimpleValue(flags, value, updatableRecord, recordOrdinal));
}
else
{
return(PropagatorResult.CreateSimpleValue(flags, value));
}
}
}
// Note that this is called only for association ends. Entities have key values inline.
private PropagatorResult CreateEntityKeyResult(IEntityStateEntry stateEntry, EntityKey entityKey)
{
// get metadata for key
var entityType = entityKey.GetEntitySet(m_translator.MetadataWorkspace).ElementType;
var keyRowType = entityType.GetKeyRowType();
var keyMetadata = m_translator.GetExtractorMetadata(stateEntry.EntitySet, keyRowType);
var keyMemberCount = keyRowType.Properties.Count;
var keyValues = new PropagatorResult[keyMemberCount];
for (var ordinal = 0; ordinal < keyRowType.Properties.Count; ordinal++)
{
EdmMember keyMember = keyRowType.Properties[ordinal];
// retrieve information about this key value
var keyMemberInformation = keyMetadata.m_memberMap[ordinal];
var keyIdentifier = m_translator.KeyManager.GetKeyIdentifierForMemberOffset(entityKey, ordinal, keyRowType.Properties.Count);
object keyValue = null;
if (entityKey.IsTemporary)
{
// If the EntityKey is temporary, we need to retrieve the appropriate
// key value from the entity itself (or in this case, the IEntityStateEntry).
var entityEntry = stateEntry.StateManager.GetEntityStateEntry(entityKey);
Debug.Assert(
entityEntry.State == EntityState.Added,
"The corresponding entry for a temp EntityKey should be in the Added State.");
keyValue = entityEntry.CurrentValues[keyMember.Name];
}
else
{
// Otherwise, we extract the value from within the EntityKey.
keyValue = entityKey.FindValueByName(keyMember.Name);
}
Debug.Assert(keyValue != null, "keyValue should've been retrieved.");
// construct propagator result
keyValues[ordinal] = PropagatorResult.CreateKeyValue(
keyMemberInformation.Flags,
keyValue,
stateEntry,
keyIdentifier);
// see UpdateTranslator.Identifiers for information on key identifiers and ordinals
}
return(PropagatorResult.CreateStructuralValue(keyValues, keyMetadata.m_type, false));
}
private PropagatorResult CreateEntityKeyResult(
IEntityStateEntry stateEntry,
EntityKey entityKey)
{
RowType keyRowType = entityKey.GetEntitySet(this.m_translator.MetadataWorkspace).ElementType.GetKeyRowType();
ExtractorMetadata extractorMetadata = this.m_translator.GetExtractorMetadata(stateEntry.EntitySet, (StructuralType)keyRowType);
PropagatorResult[] values = new PropagatorResult[keyRowType.Properties.Count];
for (int memberOffset = 0; memberOffset < keyRowType.Properties.Count; ++memberOffset)
{
EdmMember property = (EdmMember)keyRowType.Properties[memberOffset];
ExtractorMetadata.MemberInformation member = extractorMetadata.m_memberMap[memberOffset];
int identifierForMemberOffset = this.m_translator.KeyManager.GetKeyIdentifierForMemberOffset(entityKey, memberOffset, keyRowType.Properties.Count);
object obj = !entityKey.IsTemporary ? entityKey.FindValueByName(property.Name) : stateEntry.StateManager.GetEntityStateEntry(entityKey).CurrentValues[property.Name];
values[memberOffset] = PropagatorResult.CreateKeyValue(member.Flags, obj, stateEntry, identifierForMemberOffset);
}
return(PropagatorResult.CreateStructuralValue(values, extractorMetadata.m_type, false));
}
private PropagatorResult CreateSimpleResult(
IEntityStateEntry stateEntry,
IExtendedDataRecord record,
ExtractorMetadata.MemberInformation memberInformation,
int identifier,
bool isModified,
int recordOrdinal,
object value)
{
CurrentValueRecord record1 = record as CurrentValueRecord;
PropagatorFlags flags = memberInformation.Flags;
if (!isModified)
{
flags |= PropagatorFlags.Preserve;
}
if (-1 != identifier)
{
PropagatorResult owner = !memberInformation.IsServerGenerated && !memberInformation.IsForeignKeyMember || record1 == null?PropagatorResult.CreateKeyValue(flags, value, stateEntry, identifier) : PropagatorResult.CreateServerGenKeyValue(flags, value, stateEntry, identifier, recordOrdinal);
this.m_translator.KeyManager.RegisterIdentifierOwner(owner);
return(owner);
}
if ((memberInformation.IsServerGenerated || memberInformation.IsForeignKeyMember) && record1 != null)
{
return(PropagatorResult.CreateServerGenSimpleValue(flags, value, record1, recordOrdinal));
}
return(PropagatorResult.CreateSimpleValue(flags, value));
}
