Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / ndp / fx / src / DataEntity / System / Data / Map / Update / Internal / ViewLoader.cs / 2 / ViewLoader.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Data.Common.CommandTrees;
using System.Data.Metadata.Edm;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common.CommandTrees.Internal;
using System.Data.Common.Utils;
using System.Diagnostics;
using System.Data.Common;
using System.Data.Objects;
using System.Linq;
using System.Threading;
namespace System.Data.Mapping.Update.Internal
{
///
/// Retrieves update mapping views and dependency information for update mapping views. Acts as a wrapper around
/// the metadata workspace (and allows direct definition of update mapping views for test purposes).
///
internal class ViewLoader
{
#region Constructors
///
/// Constructor specifying a metadata workspace to use for mapping views.
///
/// mapping item collection used for retrieving updating mapping views.
internal ViewLoader(StorageMappingItemCollection mappingItemCollection)
{
Debug.Assert(mappingItemCollection != null);
m_mappingItemCollection = mappingItemCollection;
}
#endregion
#region Fields
private readonly Dictionary m_associationSetMetadata = new Dictionary();
private readonly Dictionary> m_affectedTables = new Dictionary>();
private readonly Set m_serverGenProperties = new Set();
private readonly Set m_isNullConditionProperties = new Set();
private readonly StorageMappingItemCollection m_mappingItemCollection;
private readonly Dictionary m_functionMappingTranslators = new Dictionary(
EqualityComparer.Default);
private readonly ReaderWriterLockSlim m_readerWriterLock = new ReaderWriterLockSlim();
#endregion
#region Methods
///
/// For a given extent, returns the function mapping translator.
///
/// Association set or entity set for which to retrieve a translator
/// Function translator or null if none exists for this extent
internal FunctionMappingTranslator GetFunctionMappingTranslator(EntitySetBase extent)
{
return SyncGetValue(m_functionMappingTranslators, extent);
}
///
/// Returns store tables affected by modifications to a particular C-layer extent. Although this
/// information can be inferred from the update view, we want to avoid compiling or loading
/// views when not required. This information can be directly determined from mapping metadata.
///
/// C-layer extent.
/// Affected store tables.
internal Set GetAffectedTables(EntitySetBase extent)
{
return SyncGetValue(m_affectedTables, extent);
}
///
/// Gets information relevant to the processing of an AssociationSet in the update pipeline.
/// Caches information on first retrieval.
///
internal AssociationSetMetadata GetAssociationSetMetadata(AssociationSet associationSet)
{
return SyncGetValue(m_associationSetMetadata, associationSet);
}
///
/// Determines whether the given member maps to a server-generated column in the store.
/// Requires: InitializeExtentInformation has been called for the extent being persisted.
///
/// Member to lookup
/// Whether the member is server generated in some context
internal bool IsServerGen(EdmMember member)
{
return SyncContains(m_serverGenProperties, member);
}
///
/// Determines whether the given member maps to a column participating in an isnull
/// condition. Useful to determine if a nullability constraint violation is going to
/// cause roundtripping problems (e.g. if type is based on nullability of a 'non-nullable'
/// property of a derived entity type)
///
internal bool IsNullConditionMember(EdmMember member)
{
return SyncContains(m_isNullConditionProperties, member);
}
///
/// Utility method reading value from dictionary within read lock.
///
private T_Value SyncGetValue(Dictionary dictionary, T_Key key)
{
m_readerWriterLock.EnterReadLock();
try
{
return dictionary[key];
}
finally
{
m_readerWriterLock.ExitReadLock();
}
}
///
/// Utility method checking for membership of element in set within read lock.
///
private bool SyncContains(Set set, T_Element element)
{
m_readerWriterLock.EnterReadLock();
try
{
return set.Contains(element);
}
finally
{
m_readerWriterLock.ExitReadLock();
}
}
///
/// Initializes all information relevant to the entity set.
///
/// Association set or entity set to load.
/// metadata workspace
internal void SyncInitializeEntitySet(EntitySetBase entitySetBase, MetadataWorkspace workspace)
{
m_readerWriterLock.EnterReadLock();
try
{
// check if we've already done the work for this entity set
if (m_affectedTables.ContainsKey(entitySetBase))
{
return;
}
}
finally
{
m_readerWriterLock.ExitReadLock();
}
// acquire a write lock
m_readerWriterLock.EnterWriteLock();
try
{
// see if we've since done the work for this entity set
if (m_affectedTables.ContainsKey(entitySetBase))
{
return;
}
InitializeEntitySet(entitySetBase, workspace);
}
finally
{
m_readerWriterLock.ExitWriteLock();
}
}
private void InitializeEntitySet(EntitySetBase entitySetBase, MetadataWorkspace workspace)
{
// make sure views have been generated for this sub-graph (trigger generation of the sub-graph
// by retrieving a view for one of its components; not actually using the view here)
m_mappingItemCollection.GetGeneratedView(entitySetBase, workspace);
Set affectedTables = new Set();
StorageEntityContainerMapping mapping = (StorageEntityContainerMapping)m_mappingItemCollection.GetMap(entitySetBase.EntityContainer);
if (null != mapping)
{
Set isNullConditionColumns = new Set();
// find extent in the container mapping
StorageSetMapping setMapping;
if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.EntitySet)
{
setMapping = mapping.GetEntitySetMapping(entitySetBase.Name);
// Check for members that have result bindings in a function mapping. If a
// function returns the member values, it indicates they are server-generated
m_serverGenProperties.Unite(GetMembersWithResultBinding((StorageEntitySetMapping)setMapping));
}
else if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.AssociationSet)
{
setMapping = mapping.GetRelationshipSetMapping(entitySetBase.Name);
}
else
{
Debug.Fail("unexpected extent type " + entitySetBase.BuiltInTypeKind);
throw EntityUtil.NotSupported();
}
// gather interesting tables, columns and properties from mapping fragments
foreach (StorageMappingFragment mappingFragment in GetMappingFragments(setMapping))
{
affectedTables.Add(mappingFragment.TableSet);
// get all property mappings to figure out if anything is server generated
m_serverGenProperties.AddRange(FindServerGenMembers(mappingFragment));
// get all columns participating in is null conditions
isNullConditionColumns.AddRange(FindIsNullConditionColumns(mappingFragment));
}
if (0 < isNullConditionColumns.Count)
{
// gather is null condition properties based on is null condition columns
foreach (StorageMappingFragment mappingFragment in GetMappingFragments(setMapping))
{
m_isNullConditionProperties.AddRange(FindPropertiesMappedToColumns(isNullConditionColumns, mappingFragment));
}
}
}
m_affectedTables.Add(entitySetBase, affectedTables.MakeReadOnly());
InitializeFunctionMappingTranslators(entitySetBase, mapping);
// for association sets, initialize AssociationSetMetadata if no function has claimed ownership
// of the association yet
if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.AssociationSet)
{
AssociationSet associationSet = (AssociationSet)entitySetBase;
if (!m_associationSetMetadata.ContainsKey(associationSet))
{
m_associationSetMetadata.Add(associationSet, new AssociationSetMetadata(
m_affectedTables[associationSet], associationSet, workspace));
}
}
}
///
/// Yields all members appearing in function mapping result bindings.
///
/// Set mapping to examine
/// All result bindings
private IEnumerable GetMembersWithResultBinding(StorageEntitySetMapping entitySetMapping)
{
foreach (StorageEntityTypeFunctionMapping typeFunctionMapping in entitySetMapping.FunctionMappings)
{
// look at all result bindings for insert and update commands
if (null != typeFunctionMapping.InsertFunctionMapping.ResultBindings)
{
foreach (StorageFunctionResultBinding binding in typeFunctionMapping.InsertFunctionMapping.ResultBindings)
{
yield return binding.Property;
}
}
if (null != typeFunctionMapping.UpdateFunctionMapping.ResultBindings)
{
foreach (StorageFunctionResultBinding binding in typeFunctionMapping.UpdateFunctionMapping.ResultBindings)
{
yield return binding.Property;
}
}
}
}
// Loads and registers any function mapping translators for the given extent (and related container)
private void InitializeFunctionMappingTranslators(EntitySetBase entitySetBase, StorageEntityContainerMapping mapping)
{
KeyToListMap requiredEnds = new KeyToListMap(
EqualityComparer.Default);
// see if function mapping metadata needs to be processed
if (!m_functionMappingTranslators.ContainsKey(entitySetBase))
{
// load all function mapping data from the current entity container
foreach (StorageEntitySetMapping entitySetMapping in mapping.EntitySetMaps)
{
if (0 < entitySetMapping.FunctionMappings.Count)
{
// register the function mapping
m_functionMappingTranslators.Add(entitySetMapping.Set, FunctionMappingTranslator.CreateEntitySetFunctionMappingTranslator(entitySetMapping));
// register "null" function translators for all implicitly mapped association sets
foreach (AssociationSetEnd end in entitySetMapping.ImplicitlyMappedAssociationSetEnds)
{
AssociationSet associationSet = end.ParentAssociationSet;
if (!m_functionMappingTranslators.ContainsKey(associationSet))
{
m_functionMappingTranslators.Add(associationSet, FunctionMappingTranslator.CreateAssociationSetFunctionMappingTranslator(null));
}
// Remember that the current entity set is required for all updates to the collocated
// relationship set. This entity set's end is opposite the target end for the mapping.
AssociationSetEnd oppositeEnd = MetadataHelper.GetOppositeEnd(end);
requiredEnds.Add(associationSet, oppositeEnd.CorrespondingAssociationEndMember);
}
}
else
{
// register null translator (so that we never attempt to process this extent again)
m_functionMappingTranslators.Add(entitySetMapping.Set, null);
}
}
foreach (StorageAssociationSetMapping associationSetMapping in mapping.RelationshipSetMaps)
{
if (null != associationSetMapping.FunctionMapping)
{
AssociationSet set = (AssociationSet)associationSetMapping.Set;
// use indexer rather than Add since the association set may already have an implicit function
// mapping -- this explicit function mapping takes precedence in such cases
m_functionMappingTranslators.Add(set,
FunctionMappingTranslator.CreateAssociationSetFunctionMappingTranslator(associationSetMapping));
// remember that we've seen a function mapping for this association set, which overrides
// any other behaviors for determining required/optional ends
requiredEnds.AddRange(set, Enumerable.Empty());
}
else
{
if (!m_functionMappingTranslators.ContainsKey(associationSetMapping.Set))
{
// register null translator (so that we never attempt to process this extent again)
m_functionMappingTranslators.Add(associationSetMapping.Set, null);
}
}
}
}
// register association metadata for all association sets encountered
foreach (AssociationSet associationSet in requiredEnds.Keys)
{
m_associationSetMetadata.Add(associationSet, new AssociationSetMetadata(
requiredEnds.EnumerateValues(associationSet)));
}
}
///
/// Gets all model properties mapped to server generated columns.
///
private static IEnumerable FindServerGenMembers(StorageMappingFragment mappingFragment)
{
foreach (var scalarPropertyMapping in FlattenPropertyMappings(mappingFragment.AllProperties)
.OfType())
{
if (StoreGeneratedPattern.None != MetadataHelper.GetStoreGeneratedPattern(scalarPropertyMapping.ColumnProperty))
{
yield return scalarPropertyMapping.EdmProperty;
}
}
}
///
/// Gets all store columns participating in is null conditions.
///
private static IEnumerable FindIsNullConditionColumns(StorageMappingFragment mappingFragment)
{
foreach (var conditionPropertyMapping in FlattenPropertyMappings(mappingFragment.AllProperties)
.OfType())
{
if (conditionPropertyMapping.ColumnProperty != null &&
conditionPropertyMapping.IsNull.HasValue)
{
yield return conditionPropertyMapping.ColumnProperty;
}
}
}
///
/// Gets all model properties mapped to given columns.
///
private static IEnumerable FindPropertiesMappedToColumns(Set columns, StorageMappingFragment mappingFragment)
{
foreach (var scalarPropertyMapping in FlattenPropertyMappings(mappingFragment.AllProperties)
.OfType())
{
if (columns.Contains(scalarPropertyMapping.ColumnProperty))
{
yield return scalarPropertyMapping.EdmProperty;
}
}
}
///
/// Enumerates all mapping fragments in given set mapping.
///
private static IEnumerable GetMappingFragments(StorageSetMapping setMapping)
{
// get all type mappings for the extent
foreach (StorageTypeMapping typeMapping in setMapping.TypeMappings)
{
// get all table mapping fragments for the type
foreach (StorageMappingFragment mappingFragment in typeMapping.MappingFragments)
{
yield return mappingFragment;
}
}
}
///
/// Returns all bottom-level mappings (e.g. conditions and scalar property mappings but not complex property mappings
/// whose components are returned)
///
private static IEnumerable FlattenPropertyMappings(System.Collections.ObjectModel.ReadOnlyCollection propertyMappings)
{
foreach (StoragePropertyMapping propertyMapping in propertyMappings)
{
StorageComplexPropertyMapping complexPropertyMapping = propertyMapping as StorageComplexPropertyMapping;
if (null != complexPropertyMapping)
{
foreach (StorageComplexTypeMapping complexTypeMapping in complexPropertyMapping.TypeMappings)
{
// recursively call self with nested type
foreach (StoragePropertyMapping nestedPropertyMapping in FlattenPropertyMappings(complexTypeMapping.AllProperties))
{
yield return nestedPropertyMapping;
}
}
}
else
{
yield return propertyMapping;
}
}
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Data.Common.CommandTrees;
using System.Data.Metadata.Edm;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common.CommandTrees.Internal;
using System.Data.Common.Utils;
using System.Diagnostics;
using System.Data.Common;
using System.Data.Objects;
using System.Linq;
using System.Threading;
namespace System.Data.Mapping.Update.Internal
{
///
/// Retrieves update mapping views and dependency information for update mapping views. Acts as a wrapper around
/// the metadata workspace (and allows direct definition of update mapping views for test purposes).
///
internal class ViewLoader
{
#region Constructors
///
/// Constructor specifying a metadata workspace to use for mapping views.
///
/// mapping item collection used for retrieving updating mapping views.
internal ViewLoader(StorageMappingItemCollection mappingItemCollection)
{
Debug.Assert(mappingItemCollection != null);
m_mappingItemCollection = mappingItemCollection;
}
#endregion
#region Fields
private readonly Dictionary m_associationSetMetadata = new Dictionary();
private readonly Dictionary> m_affectedTables = new Dictionary>();
private readonly Set m_serverGenProperties = new Set();
private readonly Set m_isNullConditionProperties = new Set();
private readonly StorageMappingItemCollection m_mappingItemCollection;
private readonly Dictionary m_functionMappingTranslators = new Dictionary(
EqualityComparer.Default);
private readonly ReaderWriterLockSlim m_readerWriterLock = new ReaderWriterLockSlim();
#endregion
#region Methods
///
/// For a given extent, returns the function mapping translator.
///
/// Association set or entity set for which to retrieve a translator
/// Function translator or null if none exists for this extent
internal FunctionMappingTranslator GetFunctionMappingTranslator(EntitySetBase extent)
{
return SyncGetValue(m_functionMappingTranslators, extent);
}
///
/// Returns store tables affected by modifications to a particular C-layer extent. Although this
/// information can be inferred from the update view, we want to avoid compiling or loading
/// views when not required. This information can be directly determined from mapping metadata.
///
/// C-layer extent.
/// Affected store tables.
internal Set GetAffectedTables(EntitySetBase extent)
{
return SyncGetValue(m_affectedTables, extent);
}
///
/// Gets information relevant to the processing of an AssociationSet in the update pipeline.
/// Caches information on first retrieval.
///
internal AssociationSetMetadata GetAssociationSetMetadata(AssociationSet associationSet)
{
return SyncGetValue(m_associationSetMetadata, associationSet);
}
///
/// Determines whether the given member maps to a server-generated column in the store.
/// Requires: InitializeExtentInformation has been called for the extent being persisted.
///
/// Member to lookup
/// Whether the member is server generated in some context
internal bool IsServerGen(EdmMember member)
{
return SyncContains(m_serverGenProperties, member);
}
///
/// Determines whether the given member maps to a column participating in an isnull
/// condition. Useful to determine if a nullability constraint violation is going to
/// cause roundtripping problems (e.g. if type is based on nullability of a 'non-nullable'
/// property of a derived entity type)
///
internal bool IsNullConditionMember(EdmMember member)
{
return SyncContains(m_isNullConditionProperties, member);
}
///
/// Utility method reading value from dictionary within read lock.
///
private T_Value SyncGetValue(Dictionary dictionary, T_Key key)
{
m_readerWriterLock.EnterReadLock();
try
{
return dictionary[key];
}
finally
{
m_readerWriterLock.ExitReadLock();
}
}
///
/// Utility method checking for membership of element in set within read lock.
///
private bool SyncContains(Set set, T_Element element)
{
m_readerWriterLock.EnterReadLock();
try
{
return set.Contains(element);
}
finally
{
m_readerWriterLock.ExitReadLock();
}
}
///
/// Initializes all information relevant to the entity set.
///
/// Association set or entity set to load.
/// metadata workspace
internal void SyncInitializeEntitySet(EntitySetBase entitySetBase, MetadataWorkspace workspace)
{
m_readerWriterLock.EnterReadLock();
try
{
// check if we've already done the work for this entity set
if (m_affectedTables.ContainsKey(entitySetBase))
{
return;
}
}
finally
{
m_readerWriterLock.ExitReadLock();
}
// acquire a write lock
m_readerWriterLock.EnterWriteLock();
try
{
// see if we've since done the work for this entity set
if (m_affectedTables.ContainsKey(entitySetBase))
{
return;
}
InitializeEntitySet(entitySetBase, workspace);
}
finally
{
m_readerWriterLock.ExitWriteLock();
}
}
private void InitializeEntitySet(EntitySetBase entitySetBase, MetadataWorkspace workspace)
{
// make sure views have been generated for this sub-graph (trigger generation of the sub-graph
// by retrieving a view for one of its components; not actually using the view here)
m_mappingItemCollection.GetGeneratedView(entitySetBase, workspace);
Set affectedTables = new Set();
StorageEntityContainerMapping mapping = (StorageEntityContainerMapping)m_mappingItemCollection.GetMap(entitySetBase.EntityContainer);
if (null != mapping)
{
Set isNullConditionColumns = new Set();
// find extent in the container mapping
StorageSetMapping setMapping;
if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.EntitySet)
{
setMapping = mapping.GetEntitySetMapping(entitySetBase.Name);
// Check for members that have result bindings in a function mapping. If a
// function returns the member values, it indicates they are server-generated
m_serverGenProperties.Unite(GetMembersWithResultBinding((StorageEntitySetMapping)setMapping));
}
else if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.AssociationSet)
{
setMapping = mapping.GetRelationshipSetMapping(entitySetBase.Name);
}
else
{
Debug.Fail("unexpected extent type " + entitySetBase.BuiltInTypeKind);
throw EntityUtil.NotSupported();
}
// gather interesting tables, columns and properties from mapping fragments
foreach (StorageMappingFragment mappingFragment in GetMappingFragments(setMapping))
{
affectedTables.Add(mappingFragment.TableSet);
// get all property mappings to figure out if anything is server generated
m_serverGenProperties.AddRange(FindServerGenMembers(mappingFragment));
// get all columns participating in is null conditions
isNullConditionColumns.AddRange(FindIsNullConditionColumns(mappingFragment));
}
if (0 < isNullConditionColumns.Count)
{
// gather is null condition properties based on is null condition columns
foreach (StorageMappingFragment mappingFragment in GetMappingFragments(setMapping))
{
m_isNullConditionProperties.AddRange(FindPropertiesMappedToColumns(isNullConditionColumns, mappingFragment));
}
}
}
m_affectedTables.Add(entitySetBase, affectedTables.MakeReadOnly());
InitializeFunctionMappingTranslators(entitySetBase, mapping);
// for association sets, initialize AssociationSetMetadata if no function has claimed ownership
// of the association yet
if (entitySetBase.BuiltInTypeKind == BuiltInTypeKind.AssociationSet)
{
AssociationSet associationSet = (AssociationSet)entitySetBase;
if (!m_associationSetMetadata.ContainsKey(associationSet))
{
m_associationSetMetadata.Add(associationSet, new AssociationSetMetadata(
m_affectedTables[associationSet], associationSet, workspace));
}
}
}
///
/// Yields all members appearing in function mapping result bindings.
///
/// Set mapping to examine
/// All result bindings
private IEnumerable GetMembersWithResultBinding(StorageEntitySetMapping entitySetMapping)
{
foreach (StorageEntityTypeFunctionMapping typeFunctionMapping in entitySetMapping.FunctionMappings)
{
// look at all result bindings for insert and update commands
if (null != typeFunctionMapping.InsertFunctionMapping.ResultBindings)
{
foreach (StorageFunctionResultBinding binding in typeFunctionMapping.InsertFunctionMapping.ResultBindings)
{
yield return binding.Property;
}
}
if (null != typeFunctionMapping.UpdateFunctionMapping.ResultBindings)
{
foreach (StorageFunctionResultBinding binding in typeFunctionMapping.UpdateFunctionMapping.ResultBindings)
{
yield return binding.Property;
}
}
}
}
// Loads and registers any function mapping translators for the given extent (and related container)
private void InitializeFunctionMappingTranslators(EntitySetBase entitySetBase, StorageEntityContainerMapping mapping)
{
KeyToListMap requiredEnds = new KeyToListMap(
EqualityComparer.Default);
// see if function mapping metadata needs to be processed
if (!m_functionMappingTranslators.ContainsKey(entitySetBase))
{
// load all function mapping data from the current entity container
foreach (StorageEntitySetMapping entitySetMapping in mapping.EntitySetMaps)
{
if (0 < entitySetMapping.FunctionMappings.Count)
{
// register the function mapping
m_functionMappingTranslators.Add(entitySetMapping.Set, FunctionMappingTranslator.CreateEntitySetFunctionMappingTranslator(entitySetMapping));
// register "null" function translators for all implicitly mapped association sets
foreach (AssociationSetEnd end in entitySetMapping.ImplicitlyMappedAssociationSetEnds)
{
AssociationSet associationSet = end.ParentAssociationSet;
if (!m_functionMappingTranslators.ContainsKey(associationSet))
{
m_functionMappingTranslators.Add(associationSet, FunctionMappingTranslator.CreateAssociationSetFunctionMappingTranslator(null));
}
// Remember that the current entity set is required for all updates to the collocated
// relationship set. This entity set's end is opposite the target end for the mapping.
AssociationSetEnd oppositeEnd = MetadataHelper.GetOppositeEnd(end);
requiredEnds.Add(associationSet, oppositeEnd.CorrespondingAssociationEndMember);
}
}
else
{
// register null translator (so that we never attempt to process this extent again)
m_functionMappingTranslators.Add(entitySetMapping.Set, null);
}
}
foreach (StorageAssociationSetMapping associationSetMapping in mapping.RelationshipSetMaps)
{
if (null != associationSetMapping.FunctionMapping)
{
AssociationSet set = (AssociationSet)associationSetMapping.Set;
// use indexer rather than Add since the association set may already have an implicit function
// mapping -- this explicit function mapping takes precedence in such cases
m_functionMappingTranslators.Add(set,
FunctionMappingTranslator.CreateAssociationSetFunctionMappingTranslator(associationSetMapping));
// remember that we've seen a function mapping for this association set, which overrides
// any other behaviors for determining required/optional ends
requiredEnds.AddRange(set, Enumerable.Empty());
}
else
{
if (!m_functionMappingTranslators.ContainsKey(associationSetMapping.Set))
{
// register null translator (so that we never attempt to process this extent again)
m_functionMappingTranslators.Add(associationSetMapping.Set, null);
}
}
}
}
// register association metadata for all association sets encountered
foreach (AssociationSet associationSet in requiredEnds.Keys)
{
m_associationSetMetadata.Add(associationSet, new AssociationSetMetadata(
requiredEnds.EnumerateValues(associationSet)));
}
}
///
/// Gets all model properties mapped to server generated columns.
///
private static IEnumerable FindServerGenMembers(StorageMappingFragment mappingFragment)
{
foreach (var scalarPropertyMapping in FlattenPropertyMappings(mappingFragment.AllProperties)
.OfType())
{
if (StoreGeneratedPattern.None != MetadataHelper.GetStoreGeneratedPattern(scalarPropertyMapping.ColumnProperty))
{
yield return scalarPropertyMapping.EdmProperty;
}
}
}
///
/// Gets all store columns participating in is null conditions.
///
private static IEnumerable FindIsNullConditionColumns(StorageMappingFragment mappingFragment)
{
foreach (var conditionPropertyMapping in FlattenPropertyMappings(mappingFragment.AllProperties)
.OfType())
{
if (conditionPropertyMapping.ColumnProperty != null &&
conditionPropertyMapping.IsNull.HasValue)
{
yield return conditionPropertyMapping.ColumnProperty;
}
}
}
///
/// Gets all model properties mapped to given columns.
///
private static IEnumerable FindPropertiesMappedToColumns(Set columns, StorageMappingFragment mappingFragment)
{
foreach (var scalarPropertyMapping in FlattenPropertyMappings(mappingFragment.AllProperties)
.OfType())
{
if (columns.Contains(scalarPropertyMapping.ColumnProperty))
{
yield return scalarPropertyMapping.EdmProperty;
}
}
}
///
/// Enumerates all mapping fragments in given set mapping.
///
private static IEnumerable GetMappingFragments(StorageSetMapping setMapping)
{
// get all type mappings for the extent
foreach (StorageTypeMapping typeMapping in setMapping.TypeMappings)
{
// get all table mapping fragments for the type
foreach (StorageMappingFragment mappingFragment in typeMapping.MappingFragments)
{
yield return mappingFragment;
}
}
}
///
/// Returns all bottom-level mappings (e.g. conditions and scalar property mappings but not complex property mappings
/// whose components are returned)
///
private static IEnumerable FlattenPropertyMappings(System.Collections.ObjectModel.ReadOnlyCollection propertyMappings)
{
foreach (StoragePropertyMapping propertyMapping in propertyMappings)
{
StorageComplexPropertyMapping complexPropertyMapping = propertyMapping as StorageComplexPropertyMapping;
if (null != complexPropertyMapping)
{
foreach (StorageComplexTypeMapping complexTypeMapping in complexPropertyMapping.TypeMappings)
{
// recursively call self with nested type
foreach (StoragePropertyMapping nestedPropertyMapping in FlattenPropertyMappings(complexTypeMapping.AllProperties))
{
yield return nestedPropertyMapping;
}
}
}
else
{
yield return propertyMapping;
}
}
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AspNetRouteServiceHttpHandler.cs
- CodeAttributeArgument.cs
- DelayedRegex.cs
- CharStorage.cs
- WebRequest.cs
- CapabilitiesAssignment.cs
- Activity.cs
- SafeFileHandle.cs
- DataGridViewRowHeaderCell.cs
- TextMetrics.cs
- UpdateProgress.cs
- LineSegment.cs
- TabItem.cs
- RulePatternOps.cs
- SponsorHelper.cs
- Encoder.cs
- DataGridTablesFactory.cs
- PageContent.cs
- WorkflowRuntimeServiceElement.cs
- SqlGatherConsumedAliases.cs
- PriorityQueue.cs
- TemplateBuilder.cs
- Array.cs
- DBCommandBuilder.cs
- JsonStringDataContract.cs
- _SafeNetHandles.cs
- CardSpacePolicyElement.cs
- Color.cs
- OdbcParameter.cs
- SecurityTokenProvider.cs
- IBuiltInEvidence.cs
- TraceSection.cs
- IconConverter.cs
- PropertyToken.cs
- ReadWriteObjectLock.cs
- InternalBase.cs
- QualifierSet.cs
- IndicShape.cs
- ListViewCommandEventArgs.cs
- AsyncOperationManager.cs
- DrawingVisualDrawingContext.cs
- AttachmentService.cs
- SortQueryOperator.cs
- GetParentChain.cs
- XmlNamespaceDeclarationsAttribute.cs
- BamlResourceDeserializer.cs
- WindowHideOrCloseTracker.cs
- XmlSchemas.cs
- XmlArrayItemAttributes.cs
- Image.cs
- ActivitySurrogateSelector.cs
- ToolStripContainer.cs
- CuspData.cs
- Metadata.cs
- WebEvents.cs
- PathGeometry.cs
- EventTask.cs
- WebResourceAttribute.cs
- XmlNodeComparer.cs
- FileEnumerator.cs
- XmlSchemaValidator.cs
- SqlDataSourceCommandEventArgs.cs
- ExtendedProperty.cs
- SQLInt16Storage.cs
- XmlWriterSettings.cs
- SimpleApplicationHost.cs
- XmlValueConverter.cs
- TextServicesCompartmentContext.cs
- TransformationRules.cs
- XhtmlConformanceSection.cs
- AggregateNode.cs
- SuppressedPackageProperties.cs
- SystemSounds.cs
- NativeStructs.cs
- GrammarBuilder.cs
- MergeFailedEvent.cs
- XmlSchemaComplexContentRestriction.cs
- BitmapEncoder.cs
- DetailsView.cs
- UserControlCodeDomTreeGenerator.cs
- LocalFileSettingsProvider.cs
- DisposableCollectionWrapper.cs
- WizardStepBase.cs
- GeometryModel3D.cs
- httpstaticobjectscollection.cs
- OracleParameterCollection.cs
- QuaternionRotation3D.cs
- EntityKeyElement.cs
- NameNode.cs
- AttributedMetaModel.cs
- RSAPKCS1SignatureFormatter.cs
- ConfigurationLocation.cs
- cache.cs
- PropertyChangeTracker.cs
- CellRelation.cs
- DesignerActionItemCollection.cs
- embossbitmapeffect.cs
- TextTabProperties.cs
- BoundConstants.cs
- InputScope.cs