/// <summary>
/// Given default values for children members, produces a new default expression for the requested (parent) member.
/// </summary>
/// <param name="node">Parent member</param>
/// <returns>Default value for parent member</returns>
internal PropagatorResult Visit(EdmMember node)
{
PropagatorResult result;
TypeUsage nodeType = Helper.GetModelTypeUsage(node);
if (Helper.IsScalarType(nodeType.EdmType))
{
GetPropagatorResultForPrimitiveType(Helper.AsPrimitive(nodeType.EdmType), out result);
}
else
{
// Construct a new 'complex type' (really any structural type) member.
StructuralType structuralType = (StructuralType)nodeType.EdmType;
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(structuralType);
PropagatorResult[] args = new PropagatorResult[members.Count];
for (int ordinal = 0; ordinal < members.Count; ordinal++)
// foreach (EdmMember member in members)
{
args[ordinal] = Visit(members[ordinal]);
}
result = PropagatorResult.CreateStructuralValue(args, structuralType, false);
}
return(result);
}
private static List <TypeUsage> GetStructuralMemberTypes(TypeUsage instanceType)
{
StructuralType edmType = instanceType.EdmType as StructuralType;
if (edmType == null)
{
throw new ArgumentException(Strings.Cqt_NewInstance_StructuralTypeRequired, nameof(instanceType));
}
if (edmType.Abstract)
{
throw new ArgumentException(Strings.Cqt_NewInstance_CannotInstantiateAbstractType((object)instanceType.ToString()), nameof(instanceType));
}
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers((EdmType)edmType);
if (structuralMembers == null || structuralMembers.Count < 1)
{
throw new ArgumentException(Strings.Cqt_NewInstance_CannotInstantiateMemberlessType((object)instanceType.ToString()), nameof(instanceType));
}
List <TypeUsage> typeUsageList = new List <TypeUsage>(structuralMembers.Count);
for (int index = 0; index < structuralMembers.Count; ++index)
{
typeUsageList.Add(Helper.GetModelTypeUsage(structuralMembers[index]));
}
return(typeUsageList);
}
/// <summary>
/// Initializes a new <see cref="T:System.Data.Common.DbDataRecord" /> object for a specific type with an enumerable collection of data fields.
/// </summary>
/// <param name="metadata">
/// The metadata for the type represented by this object, supplied by
/// <see cref="T:System.Data.Entity.Core.Metadata.Edm.TypeUsage" />
/// .
/// </param>
/// <param name="memberInfo">
/// An enumerable collection of <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmMember" /> objects that represent column information.
/// </param>
public DataRecordInfo(TypeUsage metadata, IEnumerable <EdmMember> memberInfo)
{
Check.NotNull <TypeUsage>(metadata, nameof(metadata));
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers(metadata.EdmType);
List <System.Data.Entity.Core.Common.FieldMetadata> fieldMetadataList = new List <System.Data.Entity.Core.Common.FieldMetadata>(structuralMembers.Count);
if (memberInfo != null)
{
foreach (EdmMember fieldType in memberInfo)
{
if (fieldType == null || 0 > structuralMembers.IndexOf(fieldType) || BuiltInTypeKind.EdmProperty != fieldType.BuiltInTypeKind && fieldType.BuiltInTypeKind != BuiltInTypeKind.AssociationEndMember)
{
throw Error.InvalidEdmMemberInstance();
}
if (fieldType.DeclaringType != metadata.EdmType && !fieldType.DeclaringType.IsBaseTypeOf(metadata.EdmType))
{
throw new ArgumentException(Strings.EdmMembersDefiningTypeDoNotAgreeWithMetadataType);
}
fieldMetadataList.Add(new System.Data.Entity.Core.Common.FieldMetadata(fieldMetadataList.Count, fieldType));
}
}
if (Helper.IsStructuralType(metadata.EdmType) != 0 < fieldMetadataList.Count)
{
throw Error.InvalidEdmMemberInstance();
}
this._fieldMetadata = new ReadOnlyCollection <System.Data.Entity.Core.Common.FieldMetadata>((IList <System.Data.Entity.Core.Common.FieldMetadata>)fieldMetadataList);
this._metadata = metadata;
}
internal ExtractorMetadata(
EntitySetBase entitySetBase,
StructuralType type,
UpdateTranslator translator)
{
this.m_type = type;
this.m_translator = translator;
EntityType entityType = (EntityType)null;
Set <EdmMember> set1;
Set <EdmMember> set2;
switch (type.BuiltInTypeKind)
{
case BuiltInTypeKind.EntityType:
entityType = (EntityType)type;
set1 = new Set <EdmMember>((IEnumerable <EdmMember>)entityType.KeyMembers).MakeReadOnly();
set2 = new Set <EdmMember>((IEnumerable <EdmMember>)((EntitySet)entitySetBase).ForeignKeyDependents.SelectMany <Tuple <AssociationSet, ReferentialConstraint>, EdmProperty>((Func <Tuple <AssociationSet, ReferentialConstraint>, IEnumerable <EdmProperty> >)(fk => (IEnumerable <EdmProperty>)fk.Item2.ToProperties))).MakeReadOnly();
break;
case BuiltInTypeKind.RowType:
set1 = new Set <EdmMember>((IEnumerable <EdmMember>)((RowType)type).Properties).MakeReadOnly();
set2 = Set <EdmMember> .Empty;
break;
default:
set1 = Set <EdmMember> .Empty;
set2 = Set <EdmMember> .Empty;
break;
}
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers((EdmType)type);
this.m_memberMap = new ExtractorMetadata.MemberInformation[structuralMembers.Count];
for (int ordinal = 0; ordinal < structuralMembers.Count; ++ordinal)
{
EdmMember edmMember = structuralMembers[ordinal];
PropagatorFlags flags = PropagatorFlags.NoFlags;
int? entityKeyOrdinal = new int?();
if (set1.Contains(edmMember))
{
flags |= PropagatorFlags.Key;
if (entityType != null)
{
entityKeyOrdinal = new int?(entityType.KeyMembers.IndexOf(edmMember));
}
}
if (set2.Contains(edmMember))
{
flags |= PropagatorFlags.ForeignKey;
}
if (MetadataHelper.GetConcurrencyMode(edmMember) == ConcurrencyMode.Fixed)
{
flags |= PropagatorFlags.ConcurrencyValue;
}
bool isServerGenerated = this.m_translator.ViewLoader.IsServerGen(entitySetBase, this.m_translator.MetadataWorkspace, edmMember);
bool isNullConditionMember = this.m_translator.ViewLoader.IsNullConditionMember(entitySetBase, this.m_translator.MetadataWorkspace, edmMember);
this.m_memberMap[ordinal] = new ExtractorMetadata.MemberInformation(ordinal, entityKeyOrdinal, flags, edmMember, isServerGenerated, isNullConditionMember);
}
}
internal override long Execute(
Dictionary <int, object> identifierValues,
List <KeyValuePair <PropagatorResult, object> > generatedValues)
{
EntityConnection connection = this.Translator.Connection;
this._dbCommand.Transaction = connection.CurrentTransaction == null ? (DbTransaction)null : connection.CurrentTransaction.StoreTransaction;
this._dbCommand.Connection = connection.StoreConnection;
if (this.Translator.CommandTimeout.HasValue)
{
this._dbCommand.CommandTimeout = this.Translator.CommandTimeout.Value;
}
this.SetInputIdentifiers(identifierValues);
long rowsAffected;
if (this.ResultColumns != null)
{
rowsAffected = 0L;
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers((EdmType)this.CurrentValues.StructuralType);
using (DbDataReader reader = this._dbCommand.ExecuteReader(CommandBehavior.SequentialAccess))
{
if (reader.Read())
{
++rowsAffected;
foreach (KeyValuePair <int, PropagatorResult> keyValuePair in (IEnumerable <KeyValuePair <int, PropagatorResult> >) this.ResultColumns.Select <KeyValuePair <string, PropagatorResult>, KeyValuePair <int, PropagatorResult> >((Func <KeyValuePair <string, PropagatorResult>, KeyValuePair <int, PropagatorResult> >)(r => new KeyValuePair <int, PropagatorResult>(this.GetColumnOrdinal(this.Translator, reader, r.Key), r.Value))).OrderBy <KeyValuePair <int, PropagatorResult>, int>((Func <KeyValuePair <int, PropagatorResult>, int>)(r => r.Key)))
{
int key1 = keyValuePair.Key;
if (key1 != -1)
{
TypeUsage typeUsage = structuralMembers[keyValuePair.Value.RecordOrdinal].TypeUsage;
object obj = !Helper.IsSpatialType(typeUsage) || reader.IsDBNull(key1) ? reader.GetValue(key1) : SpatialHelpers.GetSpatialValue(this.Translator.MetadataWorkspace, reader, typeUsage, key1);
PropagatorResult key2 = keyValuePair.Value;
generatedValues.Add(new KeyValuePair <PropagatorResult, object>(key2, obj));
int identifier = key2.Identifier;
if (-1 != identifier)
{
identifierValues.Add(identifier, obj);
}
}
else
{
break;
}
}
}
CommandHelper.ConsumeReader(reader);
}
}
else
{
rowsAffected = (long)this._dbCommand.ExecuteNonQuery();
}
return(this.GetRowsAffected(rowsAffected, this.Translator));
}
// requires: enumerations must have the same number of members
// effects: returns paired enumeration values
internal static IEnumerable <KeyValuePair <T, S> > PairEnumerations <T, S>(IBaseList <T> left, IEnumerable <S> right)
{
IEnumerator leftEnumerator = left.GetEnumerator();
IEnumerator <S> rightEnumerator = right.GetEnumerator();
while (leftEnumerator.MoveNext() && rightEnumerator.MoveNext())
{
yield return(new KeyValuePair <T, S>((T)leftEnumerator.Current, rightEnumerator.Current));
}
yield break;
}
internal DataRecordInfo(TypeUsage metadata)
{
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers(metadata);
System.Data.Entity.Core.Common.FieldMetadata[] fieldMetadataArray = new System.Data.Entity.Core.Common.FieldMetadata[structuralMembers.Count];
for (int ordinal = 0; ordinal < fieldMetadataArray.Length; ++ordinal)
{
EdmMember fieldType = structuralMembers[ordinal];
fieldMetadataArray[ordinal] = new System.Data.Entity.Core.Common.FieldMetadata(ordinal, fieldType);
}
this._fieldMetadata = new ReadOnlyCollection <System.Data.Entity.Core.Common.FieldMetadata>((IList <System.Data.Entity.Core.Common.FieldMetadata>)fieldMetadataArray);
this._metadata = metadata;
}
private static int[] InitializeKeyOrdinals(EntitySet table)
{
EntityType elementType = table.ElementType;
IList <EdmMember> keyMembers = (IList <EdmMember>)elementType.KeyMembers;
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers((EdmType)elementType);
int[] numArray = new int[keyMembers.Count];
for (int index = 0; index < keyMembers.Count; ++index)
{
EdmMember edmMember = keyMembers[index];
numArray[index] = structuralMembers.IndexOf(edmMember);
}
return(numArray);
}
internal override long Execute(
Dictionary <int, object> identifierValues,
List <KeyValuePair <PropagatorResult, object> > generatedValues)
{
using (DbCommand command = this.CreateCommand(identifierValues))
{
EntityConnection connection = this.Translator.Connection;
command.Transaction = connection.CurrentTransaction == null ? (DbTransaction)null : connection.CurrentTransaction.StoreTransaction;
command.Connection = connection.StoreConnection;
if (this.Translator.CommandTimeout.HasValue)
{
command.CommandTimeout = this.Translator.CommandTimeout.Value;
}
int num;
if (this._modificationCommandTree.HasReader)
{
num = 0;
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SequentialAccess))
{
if (reader.Read())
{
++num;
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers((EdmType)this.CurrentValues.StructuralType);
for (int index = 0; index < reader.FieldCount; ++index)
{
string name = reader.GetName(index);
EdmMember edmMember = structuralMembers[name];
object obj = !Helper.IsSpatialType(edmMember.TypeUsage) || reader.IsDBNull(index) ? reader.GetValue(index) : SpatialHelpers.GetSpatialValue(this.Translator.MetadataWorkspace, reader, edmMember.TypeUsage, index);
PropagatorResult memberValue = this.CurrentValues.GetMemberValue(structuralMembers.IndexOf(edmMember));
generatedValues.Add(new KeyValuePair <PropagatorResult, object>(memberValue, obj));
int identifier = memberValue.Identifier;
if (-1 != identifier)
{
identifierValues.Add(identifier, obj);
}
}
}
CommandHelper.ConsumeReader(reader);
}
}
else
{
num = command.ExecuteNonQuery();
}
return((long)num);
}
}
/// <summary>
/// Construct FieldMetadata for structuralType.Members from TypeUsage
/// </summary>
internal DataRecordInfo(TypeUsage metadata)
{
Debug.Assert(null != metadata, "invalid attempt to instantiate DataRecordInfo with null metadata information");
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers(metadata);
FieldMetadata[] fieldList = new FieldMetadata[structuralMembers.Count];
for (int i = 0; i < fieldList.Length; ++i)
{
EdmMember member = structuralMembers[i];
Debug.Assert((BuiltInTypeKind.EdmProperty == member.BuiltInTypeKind) ||
(BuiltInTypeKind.AssociationEndMember == member.BuiltInTypeKind),
"unexpected BuiltInTypeKind for member");
fieldList[i] = new FieldMetadata(i, member);
}
_fieldMetadata = new System.Collections.ObjectModel.ReadOnlyCollection <FieldMetadata>(fieldList);
_metadata = metadata;
}
/// <summary>
/// Construct DataRecordInfo with list of EdmMembers.
/// Each memberInfo must be a member of metadata.
/// </summary>
/// <param name="metadata"></param>
/// <param name="memberInfo"></param>
public DataRecordInfo(TypeUsage metadata, IEnumerable <EdmMember> memberInfo)
{
EntityUtil.CheckArgumentNull(metadata, "metadata");
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(metadata.EdmType);
List <FieldMetadata> fieldList = new List <FieldMetadata>(members.Count);
if (null != memberInfo)
{
foreach (EdmMember member in memberInfo)
{
if ((null != member) &&
(0 <= members.IndexOf(member)) &&
((BuiltInTypeKind.EdmProperty == member.BuiltInTypeKind) || // for ComplexType, EntityType; BuiltTypeKind.NaviationProperty not allowed
(BuiltInTypeKind.AssociationEndMember == member.BuiltInTypeKind))) // for AssociationType
{ // each memberInfo must be non-null and be part of Properties or AssociationEndMembers
//validate that EdmMembers are from the same type or base type of the passed in metadata.
if ((member.DeclaringType != metadata.EdmType) &&
!member.DeclaringType.IsBaseTypeOf(metadata.EdmType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.EdmMembersDefiningTypeDoNotAgreeWithMetadataType);
}
fieldList.Add(new FieldMetadata(fieldList.Count, member));
}
else
{ // expecting empty memberInfo for non-structural && non-null member part of members if structural
throw EntityUtil.Argument("memberInfo");
}
}
}
// expecting structural types to have something at least 1 property
// (((null == structural) && (0 == fieldList.Count)) || ((null != structural) && (0 < fieldList.Count)))
if (Helper.IsStructuralType(metadata.EdmType) == (0 < fieldList.Count))
{
_fieldMetadata = new System.Collections.ObjectModel.ReadOnlyCollection <FieldMetadata>(fieldList);
_metadata = metadata;
}
else
{
throw EntityUtil.Argument("memberInfo");
}
}
// Determines which column ordinals in the table are part of the key.
private static int[] InitializeKeyOrdinals(EntitySet table)
{
EntityType tableType = table.ElementType;
IList <EdmMember> keyMembers = tableType.KeyMembers;
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(tableType);
int[] keyOrdinals = new int[keyMembers.Count];
for (int keyMemberIndex = 0; keyMemberIndex < keyMembers.Count; keyMemberIndex++)
{
EdmMember keyMember = keyMembers[keyMemberIndex];
keyOrdinals[keyMemberIndex] = members.IndexOf(keyMember);
Debug.Assert(keyOrdinals[keyMemberIndex] >= 0 && keyOrdinals[keyMemberIndex] < members.Count,
"an EntityType key member must also be a member of the entity type");
}
return(keyOrdinals);
}
private static ColumnMap[] GetColumnMapsForType(
DbDataReader storeDataReader,
EdmType edmType,
Dictionary <string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping> renameList)
{
IBaseList <EdmMember> structuralMembers = TypeHelpers.GetAllStructuralMembers(edmType);
ColumnMap[] columnMapArray = new ColumnMap[structuralMembers.Count];
int index = 0;
foreach (EdmMember member in (IEnumerable)structuralMembers)
{
if (!Helper.IsScalarType(member.TypeUsage.EdmType))
{
throw new InvalidOperationException(Strings.ADP_InvalidDataReaderUnableToMaterializeNonScalarType((object)member.Name, (object)member.TypeUsage.EdmType.FullName));
}
int ordinalFromReader = ColumnMapFactory.GetMemberOrdinalFromReader(storeDataReader, member, edmType, renameList);
columnMapArray[index] = (ColumnMap) new ScalarColumnMap(member.TypeUsage, member.Name, 0, ordinalFromReader);
++index;
}
return(columnMapArray);
}
/// <summary>
/// For a given edmType, build an array of scalarColumnMaps that map to the columns
/// in the store datareader provided. Note that we're hooking things up by name, not
/// by ordinal position.
/// </summary>
/// <param name="storeDataReader"></param>
/// <param name="edmType"></param>
/// <returns></returns>
private static ColumnMap[] GetColumnMapsForType(DbDataReader storeDataReader, EdmType edmType, Dictionary <string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping> renameList)
{
// First get the list of properties; NOTE: we need to hook up the column by name,
// not by position.
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(edmType);
ColumnMap[] propertyColumnMaps = new ColumnMap[members.Count];
int index = 0;
foreach (EdmMember member in members)
{
if (!Helper.IsScalarType(member.TypeUsage.EdmType))
{
throw EntityUtil.InvalidOperation(Strings.ADP_InvalidDataReaderUnableToMaterializeNonScalarType(member.Name, member.TypeUsage.EdmType.FullName));
}
int ordinal = GetMemberOrdinalFromReader(storeDataReader, member, edmType, renameList);
propertyColumnMaps[index] = new ScalarColumnMap(member.TypeUsage, member.Name, 0, ordinal);
index++;
}
return(propertyColumnMaps);
}
internal override async Task <long> ExecuteAsync(
Dictionary <int, object> identifierValues,
List <KeyValuePair <PropagatorResult, object> > generatedValues,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
EntityConnection connection = this.Translator.Connection;
this._dbCommand.Transaction = connection.CurrentTransaction == null ? (DbTransaction)null : connection.CurrentTransaction.StoreTransaction;
this._dbCommand.Connection = connection.StoreConnection;
if (this.Translator.CommandTimeout.HasValue)
{
this._dbCommand.CommandTimeout = this.Translator.CommandTimeout.Value;
}
this.SetInputIdentifiers(identifierValues);
long rowsAffected;
if (this.ResultColumns != null)
{
rowsAffected = 0L;
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers((EdmType)this.CurrentValues.StructuralType);
using (DbDataReader reader = await this._dbCommand.ExecuteReaderAsync(CommandBehavior.SequentialAccess, cancellationToken).WithCurrentCulture <DbDataReader>())
{
if (await reader.ReadAsync(cancellationToken).WithCurrentCulture <bool>())
{
++rowsAffected;
foreach (KeyValuePair <int, PropagatorResult> keyValuePair in (IEnumerable <KeyValuePair <int, PropagatorResult> >) this.ResultColumns.Select <KeyValuePair <string, PropagatorResult>, KeyValuePair <int, PropagatorResult> >((Func <KeyValuePair <string, PropagatorResult>, KeyValuePair <int, PropagatorResult> >)(r => new KeyValuePair <int, PropagatorResult>(this.GetColumnOrdinal(this.Translator, reader, r.Key), r.Value))).OrderBy <KeyValuePair <int, PropagatorResult>, int>((Func <KeyValuePair <int, PropagatorResult>, int>)(r => r.Key)))
{
int columnOrdinal = keyValuePair.Key;
TypeUsage columnType = members[keyValuePair.Value.RecordOrdinal].TypeUsage;
object value;
if (Helper.IsSpatialType(columnType))
{
if (!await reader.IsDBNullAsync(columnOrdinal, cancellationToken).WithCurrentCulture <bool>())
{
value = await SpatialHelpers.GetSpatialValueAsync(this.Translator.MetadataWorkspace, reader, columnType, columnOrdinal, cancellationToken).WithCurrentCulture <object>();
goto label_14;
}
}
value = await reader.GetFieldValueAsync <object>(columnOrdinal, cancellationToken).WithCurrentCulture <object>();
label_14:
PropagatorResult result = keyValuePair.Value;
generatedValues.Add(new KeyValuePair <PropagatorResult, object>(result, value));
int identifier = result.Identifier;
if (-1 != identifier)
{
identifierValues.Add(identifier, value);
}
}
}
await CommandHelper.ConsumeReaderAsync(reader, cancellationToken).WithCurrentCulture();
}
}
else
{
rowsAffected = (long)await this._dbCommand.ExecuteNonQueryAsync(cancellationToken).WithCurrentCulture <int>();
}
return(this.GetRowsAffected(rowsAffected, this.Translator));
}
internal override long Execute(UpdateTranslator translator, EntityConnection connection, Dictionary <int, object> identifierValues, List <KeyValuePair <PropagatorResult, object> > generatedValues)
{
// Compile command
using (DbCommand command = this.CreateCommand(translator, identifierValues))
{
// configure command to use the connection and transaction for this session
command.Transaction = ((null != connection.CurrentTransaction) ? connection.CurrentTransaction.StoreTransaction : null);
command.Connection = connection.StoreConnection;
if (translator.CommandTimeout.HasValue)
{
command.CommandTimeout = translator.CommandTimeout.Value;
}
// Execute the query
int rowsAffected;
if (m_modificationCommandTree.HasReader)
{
// retrieve server gen results
rowsAffected = 0;
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SequentialAccess))
{
if (reader.Read())
{
rowsAffected++;
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(this.CurrentValues.StructuralType);
for (int ordinal = 0; ordinal < reader.FieldCount; ordinal++)
{
// column name of result corresponds to column name of table
string columnName = reader.GetName(ordinal);
EdmMember member = members[columnName];
object value;
if (Helper.IsSpatialType(member.TypeUsage) && !reader.IsDBNull(ordinal))
{
value = SpatialHelpers.GetSpatialValue(translator.MetadataWorkspace, reader, member.TypeUsage, ordinal);
}
else
{
value = reader.GetValue(ordinal);
}
// retrieve result which includes the context for back-propagation
int columnOrdinal = members.IndexOf(member);
PropagatorResult result = this.CurrentValues.GetMemberValue(columnOrdinal);
// register for back-propagation
generatedValues.Add(new KeyValuePair <PropagatorResult, object>(result, value));
// register identifier if it exists
int identifier = result.Identifier;
if (PropagatorResult.NullIdentifier != identifier)
{
identifierValues.Add(identifier, value);
}
}
}
// Consume the current reader (and subsequent result sets) so that any errors
// executing the command can be intercepted
CommandHelper.ConsumeReader(reader);
}
}
else
{
rowsAffected = command.ExecuteNonQuery();
}
return(rowsAffected);
}
}
internal ExtractorMetadata(EntitySetBase entitySetBase, StructuralType type, UpdateTranslator translator)
{
EntityUtil.CheckArgumentNull(entitySetBase, "entitySetBase");
m_type = EntityUtil.CheckArgumentNull(type, "type");
m_translator = EntityUtil.CheckArgumentNull(translator, "translator");
EntityType entityType = null;
Set <EdmMember> keyMembers;
Set <EdmMember> foreignKeyMembers;
switch (type.BuiltInTypeKind)
{
case BuiltInTypeKind.RowType:
// for row types (which are actually association end key records in disguise), all members
// are keys
keyMembers = new Set <EdmMember>(((RowType)type).Properties).MakeReadOnly();
foreignKeyMembers = Set <EdmMember> .Empty;
break;
case BuiltInTypeKind.EntityType:
entityType = (EntityType)type;
keyMembers = new Set <EdmMember>(entityType.KeyMembers).MakeReadOnly();
foreignKeyMembers = new Set <EdmMember>(((EntitySet)entitySetBase).ForeignKeyDependents
.SelectMany(fk => fk.Item2.ToProperties)).MakeReadOnly();
break;
default:
keyMembers = Set <EdmMember> .Empty;
foreignKeyMembers = Set <EdmMember> .Empty;
break;
}
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(type);
m_memberMap = new MemberInformation[members.Count];
// for each member, cache expensive to compute metadata information
for (int ordinal = 0; ordinal < members.Count; ordinal++)
{
EdmMember member = members[ordinal];
// figure out flags for this member
PropagatorFlags flags = PropagatorFlags.NoFlags;
int? entityKeyOrdinal = default(int?);
if (keyMembers.Contains(member))
{
flags |= PropagatorFlags.Key;
if (null != entityType)
{
entityKeyOrdinal = entityType.KeyMembers.IndexOf(member);
}
}
if (foreignKeyMembers.Contains(member))
{
flags |= PropagatorFlags.ForeignKey;
}
if (MetadataHelper.GetConcurrencyMode(member) == ConcurrencyMode.Fixed)
{
flags |= PropagatorFlags.ConcurrencyValue;
}
// figure out whether this member is mapped to any server generated
// columns in the store
bool isServerGenerated = m_translator.ViewLoader.IsServerGen(entitySetBase, m_translator.MetadataWorkspace, member);
// figure out whether member nullability is used as a condition in mapping
bool isNullConditionMember = m_translator.ViewLoader.IsNullConditionMember(entitySetBase, m_translator.MetadataWorkspace, member);
// add information about this member
m_memberMap[ordinal] = new MemberInformation(ordinal, entityKeyOrdinal, flags, member, isServerGenerated, isNullConditionMember);
}
}
public NumberedList(IBaseList baseList)
: base(baseList)
{
}
// efects: Executes the current function command in the given transaction and connection context.
// All server-generated values are added to the generatedValues list. If those values are identifiers, they are
// also added to the identifierValues dictionary, which associates proxy identifiers for keys in the session
// with their actual values, permitting fix-up of identifiers across relationships.
internal override long Execute(UpdateTranslator translator, EntityConnection connection, Dictionary <int, object> identifierValues,
List <KeyValuePair <PropagatorResult, object> > generatedValues)
{
// configure command to use the connection and transaction for this session
m_dbCommand.Transaction = ((null != connection.CurrentTransaction) ? connection.CurrentTransaction.StoreTransaction : null);
m_dbCommand.Connection = connection.StoreConnection;
if (translator.CommandTimeout.HasValue)
{
m_dbCommand.CommandTimeout = translator.CommandTimeout.Value;
}
// set all identifier inputs (to support propagation of identifier values across relationship
// boundaries)
if (null != m_inputIdentifiers)
{
foreach (KeyValuePair <int, DbParameter> inputIdentifier in m_inputIdentifiers)
{
object value;
if (identifierValues.TryGetValue(inputIdentifier.Key, out value))
{
// set the actual value for the identifier if it has been produced by some
// other command
inputIdentifier.Value.Value = value;
}
}
}
// Execute the query
long rowsAffected;
if (null != m_resultColumns)
{
// If there are result columns, read the server gen results
rowsAffected = 0;
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(this.CurrentValues.StructuralType);
using (DbDataReader reader = m_dbCommand.ExecuteReader(CommandBehavior.SequentialAccess))
{
// Retrieve only the first row from the first result set
if (reader.Read())
{
rowsAffected++;
foreach (var resultColumn in m_resultColumns
.Select(r => new KeyValuePair <int, PropagatorResult>(GetColumnOrdinal(translator, reader, r.Key), r.Value))
.OrderBy(r => r.Key)) // order by column ordinal to avoid breaking SequentialAccess readers
{
int columnOrdinal = resultColumn.Key;
TypeUsage columnType = members[resultColumn.Value.RecordOrdinal].TypeUsage;
object value;
if (Helper.IsSpatialType(columnType) && !reader.IsDBNull(columnOrdinal))
{
value = SpatialHelpers.GetSpatialValue(translator.MetadataWorkspace, reader, columnType, columnOrdinal);
}
else
{
value = reader.GetValue(columnOrdinal);
}
// register for back-propagation
PropagatorResult result = resultColumn.Value;
generatedValues.Add(new KeyValuePair <PropagatorResult, object>(result, value));
// register identifier if it exists
int identifier = result.Identifier;
if (PropagatorResult.NullIdentifier != identifier)
{
identifierValues.Add(identifier, value);
}
}
}
// Consume the current reader (and subsequent result sets) so that any errors
// executing the function can be intercepted
CommandHelper.ConsumeReader(reader);
}
}
else
{
rowsAffected = m_dbCommand.ExecuteNonQuery();
}
// if an explicit rows affected parameter exists, use this value instead
if (null != m_rowsAffectedParameter)
{
// by design, negative row counts indicate failure iff. an explicit rows
// affected parameter is used
if (DBNull.Value.Equals(m_rowsAffectedParameter.Value))
{
rowsAffected = 0;
}
else
{
try
{
rowsAffected = Convert.ToInt64(m_rowsAffectedParameter.Value, CultureInfo.InvariantCulture);
}
catch (Exception e)
{
if (UpdateTranslator.RequiresContext(e))
{
// wrap the exception
throw EntityUtil.Update(System.Data.Entity.Strings.Update_UnableToConvertRowsAffectedParameterToInt32(
m_rowsAffectedParameter.ParameterName, typeof(int).FullName), e, this.GetStateEntries(translator));
}
throw;
}
}
}
return(rowsAffected);
}
protected BaseList(IBaseList baseList)
{
BaseListImplementor = baseList;
}
internal override async Task <long> ExecuteAsync(
Dictionary <int, object> identifierValues,
List <KeyValuePair <PropagatorResult, object> > generatedValues,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
long num;
using (DbCommand command = this.CreateCommand(identifierValues))
{
EntityConnection connection = this.Translator.Connection;
command.Transaction = connection.CurrentTransaction == null ? (DbTransaction)null : connection.CurrentTransaction.StoreTransaction;
command.Connection = connection.StoreConnection;
if (this.Translator.CommandTimeout.HasValue)
{
command.CommandTimeout = this.Translator.CommandTimeout.Value;
}
int rowsAffected;
if (this._modificationCommandTree.HasReader)
{
rowsAffected = 0;
using (DbDataReader reader = await command.ExecuteReaderAsync(CommandBehavior.SequentialAccess, cancellationToken).WithCurrentCulture <DbDataReader>())
{
if (await reader.ReadAsync(cancellationToken).WithCurrentCulture <bool>())
{
++rowsAffected;
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers((EdmType)this.CurrentValues.StructuralType);
for (int ordinal = 0; ordinal < reader.FieldCount; ++ordinal)
{
string columnName = reader.GetName(ordinal);
EdmMember member = members[columnName];
object value;
if (Helper.IsSpatialType(member.TypeUsage))
{
if (!await reader.IsDBNullAsync(ordinal, cancellationToken).WithCurrentCulture <bool>())
{
value = await SpatialHelpers.GetSpatialValueAsync(this.Translator.MetadataWorkspace, reader, member.TypeUsage, ordinal, cancellationToken).WithCurrentCulture <object>();
goto label_14;
}
}
value = await reader.GetFieldValueAsync <object>(ordinal, cancellationToken).WithCurrentCulture <object>();
label_14:
int columnOrdinal = members.IndexOf(member);
PropagatorResult result = this.CurrentValues.GetMemberValue(columnOrdinal);
generatedValues.Add(new KeyValuePair <PropagatorResult, object>(result, value));
int identifier = result.Identifier;
if (-1 != identifier)
{
identifierValues.Add(identifier, value);
}
}
}
await CommandHelper.ConsumeReaderAsync(reader, cancellationToken).WithCurrentCulture();
}
}
else
{
rowsAffected = await command.ExecuteNonQueryAsync(cancellationToken).WithCurrentCulture <int>();
}
num = (long)rowsAffected;
}
return(num);
}
public OrnamentedList(IBaseList baseList)
: base(baseList)
{
}
