File: StorageMappingItemLoader.cs

package info (click to toggle)
mono 6.14.1%2Bds2-1
links: PTS, VCS
area: main
in suites: forky, sid
size: 1,282,732 kB
sloc: cs: 11,182,461; xml: 2,850,281; ansic: 699,123; cpp: 122,919; perl: 58,604; javascript: 30,841; asm: 21,845; makefile: 19,602; sh: 10,973; python: 4,772; pascal: 925; sql: 859; sed: 16; php: 1
file content (4453 lines) | stat: -rw-r--r-- 236,455 bytes
parent folder | download | duplicates (6)
//---------------------------------------------------------------------
// <copyright file="StorageMappingItemLoader.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Common.Utils;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.XPath;
using System.Data.Entity;

namespace System.Data.Mapping
{
    using Triple = Pair<EntitySetBase, Pair<EntityTypeBase, bool>>;

    /// <summary>
    /// The class loads an MSL file into memory and exposes CSMappingMetadata interfaces.
    /// The primary consumers of the interfaces are view genration and tools.
    /// </summary>
    /// <example>
    /// For Example if conceptually you could represent the CS MSL file as following
    /// --Mapping 
    ///   --EntityContainerMapping ( CNorthwind-->SNorthwind )
    ///     --EntitySetMapping
    ///       --EntityTypeMapping
    ///         --TableMappingFragment
    ///           --EntityKey
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///           --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///           --DiscriminatorProperyMap ( constant value-->SMemberMetadata )
    ///       --EntityTypeMapping
    ///         --TableMappingFragment
    ///           --EntityKey
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///           --ComplexPropertyMap
    ///             --ComplexTypeMap
    ///               --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///               --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata )
    ///           --DiscriminatorProperyMap ( constant value-->SMemberMetadata )
    ///     --AssociationSetMapping 
    ///       --AssociationTypeMapping
    ///         --TableMappingFragment
    ///           --EndPropertyMap
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///             --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata )
    ///           --EndPropertyMap
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///   --EntityContainerMapping ( CMyDatabase-->SMyDatabase )
    ///     --CompositionSetMapping
    ///       --CompositionTypeMapping
    ///         --TableMappingFragment
    ///           --ParentEntityKey
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///           --EntityKey
    ///             --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///             --ScalarPropertyMap ( CMemberMetadata-->Constant value )
    ///           --ComplexPropertyMap
    ///             --ComplexTypeMap
    ///               --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata )
    ///               --DiscriminatorProperyMap ( constant value-->SMemberMetadata )
    ///           --ScalarPropertyMap ( CMemberMetadata-->Constant value )
    /// The CCMappingSchemaLoader loads an Xml file that has a conceptual structure
    /// equivalent to the above example into in-memory data structure in a
    /// top-dwon approach.
    /// </example>
    /// <remarks>
    /// The loader uses XPathNavigator to parse the XML. The advantage of using XPathNavigator
    /// over DOM is that it exposes the line number of the current xml content.
    /// This is really helpful when throwing exceptions. Another advantage is
    /// </remarks>
    internal class StorageMappingItemLoader
    {
        #region Constructors
        /// <summary>
        /// Public constructor.
        /// For Beta2 we wont support delay loading Mapping information and we would also support
        /// only one mapping file for workspace.
        /// </summary>
        /// <param name="edmCollection"></param>
        /// <param name="storeItemCollection"></param>
        /// <param name="fileName"></param>
        /// <param name="scalarMemberMappings">Dictionary to keep the list of all scalar member mappings</param>
        internal StorageMappingItemLoader(XmlReader reader, StorageMappingItemCollection storageMappingItemCollection, string fileName, Dictionary<EdmMember, KeyValuePair<TypeUsage, TypeUsage>> scalarMemberMappings)
        {
            Debug.Assert(storageMappingItemCollection != null);
            Debug.Assert(scalarMemberMappings != null);

            this.m_storageMappingItemCollection = storageMappingItemCollection;
            this.m_alias = new Dictionary<string, string>(StringComparer.Ordinal);
            //The fileName field in this class will always have absolute path since
            //StorageMappingItemCollection would have already done it while
            //preparing the filePaths
            if (fileName != null)
            {
                this.m_sourceLocation = fileName;
            }
            else
            {
                this.m_sourceLocation = null;
            }
            m_parsingErrors = new List<EdmSchemaError>();
            this.m_scalarMemberMappings = scalarMemberMappings;
            m_containerMapping = LoadMappingItems(reader);
            if (m_currentNamespaceUri != null)
            {
                if (m_currentNamespaceUri == StorageMslConstructs.NamespaceUriV1)
                {
                    m_version = StorageMslConstructs.MappingVersionV1;
                }
                else if (m_currentNamespaceUri == StorageMslConstructs.NamespaceUriV2)
                {
                    m_version = StorageMslConstructs.MappingVersionV2;
                }
                else
                {
                    Debug.Assert(m_currentNamespaceUri == StorageMslConstructs.NamespaceUriV3, "Did you add a new Namespace?");
                    m_version = StorageMslConstructs.MappingVersionV3;
                }
            }
        }
        #endregion

        #region Fields
        private Dictionary<string, string> m_alias;  //To support the aliasing mechanism provided by MSL.
        private StorageMappingItemCollection m_storageMappingItemCollection; //StorageMappingItemCollection
        private string m_sourceLocation; //location identifier for the MSL file.
        private List<EdmSchemaError> m_parsingErrors;
        private Dictionary<EdmMember, KeyValuePair<TypeUsage, TypeUsage>> m_scalarMemberMappings; // dictionary of all the scalar member mappings - this is to validate that no property is mapped to different store types across mappings.
        private bool m_hasQueryViews;  //set to true if any of the SetMaps have a query view so that 
        private string m_currentNamespaceUri;
        private StorageEntityContainerMapping m_containerMapping;
        private double m_version;

        // cached xsd schema
        private static XmlSchemaSet s_mappingXmlSchema;
        #endregion

        #region Properties
        internal double MappingVersion
        {
            get { return m_version; }
        }

        internal IList<EdmSchemaError> ParsingErrors
        {
            get { return m_parsingErrors; }

        }

        internal bool HasQueryViews
        {
            get { return m_hasQueryViews; }
        }

        internal StorageEntityContainerMapping ContainerMapping
        {
            get { return m_containerMapping; }
        }

        private EdmItemCollection EdmItemCollection
        {
            get { return m_storageMappingItemCollection.EdmItemCollection; }
        }

        private StoreItemCollection StoreItemCollection
        {
            get { return m_storageMappingItemCollection.StoreItemCollection; }
        }
        #endregion

        #region Methods
        /// <summary>
        /// The LoadMappingSchema method loads the mapping file and initializes the
        /// MappingSchema that represents this mapping file.
        /// For Beta2 atleast, we will support only one EntityContainerMapping per mapping file.
        /// </summary>
        /// <returns></returns>
        private StorageEntityContainerMapping LoadMappingItems(XmlReader innerReader)
        {
            // Using XPathDocument to load the xml file into memory.
            XmlReader reader = GetSchemaValidatingReader(innerReader);

            try
            {
                XPathDocument doc = new XPathDocument(reader);
                // If there were any xsd validation errors, we would have caught these while creatring xpath document.
                if (m_parsingErrors.Count != 0)
                {
                    // If the errors were only warnings continue, otherwise return the errors without loading the mapping.
                    if (!MetadataHelper.CheckIfAllErrorsAreWarnings(m_parsingErrors))
                    {
                        return null;
                    }
                }

                // Create an XPathNavigator to navigate the document in a forward only manner.
                // The XPathNavigator can also be used to run quries through the document while still maintaining
                // the current position. This will be helpful in running validation rules that are not part of Schema.
                XPathNavigator nav = doc.CreateNavigator();
                return LoadMappingItems(nav.Clone());
            }
            catch (XmlException xmlException)
            {
                // There must have been a xml parsing exception. Add the exception information to the error list.
                EdmSchemaError error = new EdmSchemaError(Strings.Mapping_InvalidMappingSchema_Parsing(xmlException.Message)
                    , (int)StorageMappingErrorCode.XmlSchemaParsingError, EdmSchemaErrorSeverity.Error, m_sourceLocation, xmlException.LineNumber, xmlException.LinePosition);
                m_parsingErrors.Add(error);
            }

            // Do not close the wrapping reader here, as doing so will close the inner reader. See SQLBUDT 522950 for details.

            return null;
        }

        private StorageEntityContainerMapping LoadMappingItems(XPathNavigator nav)
        {
            // XSD validation is not validating missing Root element.
            if (!MoveToRootElement(nav) || (nav.NodeType != XPathNodeType.Element))
            {
                StorageMappingItemLoader.AddToSchemaErrors(
                    Strings.Mapping_Invalid_CSRootElementMissing(
                        StorageMslConstructs.NamespaceUriV1,
                        StorageMslConstructs.NamespaceUriV2,
                        StorageMslConstructs.NamespaceUriV3), 
                    StorageMappingErrorCode.RootMappingElementMissing, 
                    m_sourceLocation,
                    (IXmlLineInfo)nav, m_parsingErrors);
                // There is no point in going forward if the required root element is not found.
                return null;
            }
            StorageEntityContainerMapping entityContainerMap = LoadMappingChildNodes(nav.Clone());
            // If there were any parsing errors, invalidate the entity container map and return null.
            if (m_parsingErrors.Count != 0)
            {
                // If all the schema errors are warnings, don't return null.
                if (!MetadataHelper.CheckIfAllErrorsAreWarnings(m_parsingErrors))
                {
                    entityContainerMap = null;
                }
            }
            return entityContainerMap;
        }

        private bool MoveToRootElement(XPathNavigator nav)
        {
            if (nav.MoveToChild(StorageMslConstructs.MappingElement, StorageMslConstructs.NamespaceUriV3))
            {
                // found v3 schema
                m_currentNamespaceUri = StorageMslConstructs.NamespaceUriV3;
                return true;
            }
            else if (nav.MoveToChild(StorageMslConstructs.MappingElement, StorageMslConstructs.NamespaceUriV2))
            {
                // found v2 schema
                m_currentNamespaceUri = StorageMslConstructs.NamespaceUriV2;
                return true;
            }
            else if (nav.MoveToChild(StorageMslConstructs.MappingElement, StorageMslConstructs.NamespaceUriV1))
            {
                m_currentNamespaceUri = StorageMslConstructs.NamespaceUriV1;
                return true;
            }
            //the xml namespace corresponds to neither v1 namespace nor v2 namespace
            return false;
        }

        /// <summary>
        /// The method loads the child nodes for the root Mapping node
        /// into the internal datastructures.
        /// </summary>
        private StorageEntityContainerMapping LoadMappingChildNodes(XPathNavigator nav)
        {
            bool hasContainerMapping;
            // If there are any Alias elements in the document, they should be the first ones.
            // This method can only move to the Alias element since comments, PIS etc wont have any Namespace
            // though they could have same name as Alias element.
            if (nav.MoveToChild(StorageMslConstructs.AliasElement, m_currentNamespaceUri))
            {
                // Collect all the alias elements.
                do
                {
                    m_alias.Add(StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.AliasKeyAttribute), StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.AliasValueAttribute));
                } while (nav.MoveToNext(StorageMslConstructs.AliasElement, m_currentNamespaceUri));
                // Now move on to the Next element that will be "EntityContainer" element.
                hasContainerMapping = nav.MoveToNext(XPathNodeType.Element);
            }
            else
            {
                // Since there was no Alias element, move on to the Container element.
                hasContainerMapping = nav.MoveToChild(XPathNodeType.Element);
            }

            // Load entity container mapping if any.
            var containerMapping = hasContainerMapping ? LoadEntityContainerMapping(nav.Clone()) : null;
            return containerMapping;
        }

        /// <summary>
        /// The method loads and returns the EntityContainer Mapping node.
        /// </summary>
        private StorageEntityContainerMapping LoadEntityContainerMapping(XPathNavigator nav)
        {
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            // The element name can only be EntityContainerMapping element name since XSD validation should have guarneteed this.
            Debug.Assert(nav.LocalName == StorageMslConstructs.EntityContainerMappingElement);
            string entityContainerName = GetAttributeValue(nav.Clone(), StorageMslConstructs.CdmEntityContainerAttribute);
            string storageEntityContainerName = GetAttributeValue(nav.Clone(), StorageMslConstructs.StorageEntityContainerAttribute);

            bool generateUpdateViews = GetBoolAttributeValue(nav.Clone(), StorageMslConstructs.GenerateUpdateViews, true /* default is true */);

            StorageEntityContainerMapping entityContainerMapping;
            EntityContainer entityContainerType;
            EntityContainer storageEntityContainerType;

            // Now that we support partial mapping, we should first check if the entity container mapping is
            // already present. If its already present, we should add the new child nodes to the existing entity container mapping
            if (m_storageMappingItemCollection.TryGetItem<StorageEntityContainerMapping>(
                    entityContainerName, out entityContainerMapping))
            {
                entityContainerType = entityContainerMapping.EdmEntityContainer;
                storageEntityContainerType = entityContainerMapping.StorageEntityContainer;

                // The only thing we need to make sure is that the storage entity container mapping is the same.
                if (storageEntityContainerName != storageEntityContainerType.Name)
                {
                    AddToSchemaErrors(Strings.StorageEntityContainerNameMismatchWhileSpecifyingPartialMapping(
                            storageEntityContainerName, storageEntityContainerType.Name, entityContainerType.Name),
                        StorageMappingErrorCode.StorageEntityContainerNameMismatchWhileSpecifyingPartialMapping,
                        m_sourceLocation, navLineInfo, m_parsingErrors);

                    return null;
                }
            }
            else
            {
                // At this point we know that the EdmEntityContainer has not been mapped already.
                // If we do find that StorageEntityContainer has already been mapped, return null.
                if (m_storageMappingItemCollection.ContainsStorageEntityContainer(storageEntityContainerName))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_AlreadyMapped_StorageEntityContainer, storageEntityContainerName,
                        StorageMappingErrorCode.AlreadyMappedStorageEntityContainer, m_sourceLocation, navLineInfo, m_parsingErrors);
                    return null;
                }

                // Get the CDM EntityContainer by this name from the metadata workspace.
                this.EdmItemCollection.TryGetEntityContainer(entityContainerName, out entityContainerType);
                if (entityContainerType == null)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_EntityContainer,
                        entityContainerName, StorageMappingErrorCode.InvalidEntityContainer, m_sourceLocation,
                        navLineInfo, m_parsingErrors);
                }

                this.StoreItemCollection.TryGetEntityContainer(storageEntityContainerName, out storageEntityContainerType);
                if (storageEntityContainerType == null)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_StorageEntityContainer, storageEntityContainerName,
                        StorageMappingErrorCode.InvalidEntityContainer, m_sourceLocation, navLineInfo, m_parsingErrors);
                }

                // If the EntityContainerTypes are not found, there is no point in continuing with the parsing.
                if ((entityContainerType == null) || (storageEntityContainerType == null))
                {
                    return null;
                }

                // Create an EntityContainerMapping object to hold the mapping information for this EntityContainer.
                // Create a MappingKey and pass it in.
                entityContainerMapping = new StorageEntityContainerMapping(entityContainerType, storageEntityContainerType,
                    m_storageMappingItemCollection, generateUpdateViews /* make validate same as generateUpdateView*/, generateUpdateViews);
                entityContainerMapping.StartLineNumber = navLineInfo.LineNumber;
                entityContainerMapping.StartLinePosition = navLineInfo.LinePosition;
            }

            // Load the child nodes for the created EntityContainerMapping.
            LoadEntityContainerMappingChildNodes(nav.Clone(), entityContainerMapping, storageEntityContainerType);
            return entityContainerMapping;
        }
        
        /// <summary>
        /// The method loads the child nodes for the EntityContainer Mapping node
        /// into the internal datastructures.
        /// </summary>
        private void LoadEntityContainerMappingChildNodes(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping, EntityContainer storageEntityContainerType)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;
            bool anyEntitySetMapped = false;

            //If there is no child node for the EntityContainerMapping Element, return.
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                //The valid child nodes for EntityContainerMapping node are various SetMappings( EntitySet, AssociationSet etc ).
                //Loop through the child nodes and lod them as children of the EntityContainerMapping object.
                do
                {
                    switch (nav.LocalName)
                    {
                        case StorageMslConstructs.EntitySetMappingElement:
                            {
                                LoadEntitySetMapping(nav.Clone(), entityContainerMapping, storageEntityContainerType);
                                anyEntitySetMapped = true;
                                break;
                            }
                        case StorageMslConstructs.AssociationSetMappingElement:
                            {
                                LoadAssociationSetMapping(nav.Clone(), entityContainerMapping, storageEntityContainerType);
                                break;
                            }
                        case StorageMslConstructs.FunctionImportMappingElement:
                            {
                                LoadFunctionImportMapping(nav.Clone(), entityContainerMapping, storageEntityContainerType);
                                break;
                            }
                        default:
                            AddToSchemaErrors(Strings.Mapping_InvalidContent_Container_SubElement,
                                StorageMappingErrorCode.SetMappingExpected, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                            break;
                    }
                } while (nav.MoveToNext(XPathNodeType.Element));
            }

            //If the EntityContainer contains entity sets but they are not mapped then we should add an error
            if (entityContainerMapping.EdmEntityContainer.BaseEntitySets.Count != 0 && !anyEntitySetMapped)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.ViewGen_Missing_Sets_Mapping,
                    entityContainerMapping.EdmEntityContainer.Name, StorageMappingErrorCode.EmptyContainerMapping,
                    this.m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return;
            }

            ValidateFunctionAssociationFunctionMappingUnique(nav.Clone(), entityContainerMapping);
            ValidateModificationFunctionMappingConsistentForAssociations(nav.Clone(), entityContainerMapping);
            ValidateQueryViewsClosure(nav.Clone(), entityContainerMapping);
            ValidateEntitySetFunctionMappingClosure(nav.Clone(), entityContainerMapping);
            // The fileName field in this class will always have absolute path since StorageMappingItemCollection would have already done it while
            // preparing the filePaths.
            entityContainerMapping.SourceLocation = m_sourceLocation;
        }

        /// <summary>
        /// Validates that collocated association sets are consistently mapped for each entity set (all operations or none). In the case
        /// of relationships between sub-types of an entity set, ensures the relationship mapping is legal.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping"></param>
        private void ValidateModificationFunctionMappingConsistentForAssociations(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping)
        {
            foreach (StorageEntitySetMapping entitySetMapping in entityContainerMapping.EntitySetMaps)
            {
                if (entitySetMapping.ModificationFunctionMappings.Count > 0)
                {
                    // determine the set of association sets that should be mapped for every operation
                    Set<AssociationSetEnd> expectedEnds = new Set<AssociationSetEnd>(
                        entitySetMapping.ImplicitlyMappedAssociationSetEnds).MakeReadOnly();

                    // check that each operation covers each association set
                    foreach (StorageEntityTypeModificationFunctionMapping entityTypeMapping in entitySetMapping.ModificationFunctionMappings)
                    {
                        if (null != entityTypeMapping.DeleteFunctionMapping)
                        {
                            ValidateModificationFunctionMappingConsistentForAssociations(nav, entitySetMapping, entityTypeMapping,
                                entityTypeMapping.DeleteFunctionMapping,
                                expectedEnds, StorageMslConstructs.DeleteFunctionElement);
                        }
                        if (null != entityTypeMapping.InsertFunctionMapping)
                        {
                            ValidateModificationFunctionMappingConsistentForAssociations(nav, entitySetMapping, entityTypeMapping,
                                entityTypeMapping.InsertFunctionMapping,
                                expectedEnds, StorageMslConstructs.InsertFunctionElement);
                        }
                        if (null != entityTypeMapping.UpdateFunctionMapping)
                        {
                            ValidateModificationFunctionMappingConsistentForAssociations(nav, entitySetMapping, entityTypeMapping,
                                entityTypeMapping.UpdateFunctionMapping,
                                expectedEnds, StorageMslConstructs.UpdateFunctionElement);
                        }
                    }
                }
            }
        }
        private void ValidateModificationFunctionMappingConsistentForAssociations(
            XPathNavigator nav,
            StorageEntitySetMapping entitySetMapping,
            StorageEntityTypeModificationFunctionMapping entityTypeMapping,
            StorageModificationFunctionMapping functionMapping,
            Set<AssociationSetEnd> expectedEnds, string elementName)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            // check that all expected association sets are mapped for in this function mapping
            Set<AssociationSetEnd> actualEnds = new Set<AssociationSetEnd>(functionMapping.CollocatedAssociationSetEnds);
            actualEnds.MakeReadOnly();

            // check that all required ends are present
            foreach (AssociationSetEnd expectedEnd in expectedEnds)
            {
                // check that the association set is required based on the entity type
                if (MetadataHelper.IsAssociationValidForEntityType(expectedEnd, entityTypeMapping.EntityType))
                {
                    if (!actualEnds.Contains(expectedEnd))
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_ModificationFunction_AssociationSetNotMappedForOperation(
                            entitySetMapping.Set.Name,
                            expectedEnd.ParentAssociationSet.Name,
                            elementName,
                            entityTypeMapping.EntityType.FullName),
                            StorageMappingErrorCode.InvalidModificationFunctionMappingAssociationSetNotMappedForOperation,
                            m_sourceLocation,
                            xmlLineInfoNav,
                            m_parsingErrors);
                    }
                }
            }

            // check that no ends with invalid types are included
            foreach (AssociationSetEnd actualEnd in actualEnds)
            {
                if (!MetadataHelper.IsAssociationValidForEntityType(actualEnd, entityTypeMapping.EntityType))
                {
                    AddToSchemaErrorWithMessage(Strings.Mapping_ModificationFunction_AssociationEndMappingInvalidForEntityType(
                        entityTypeMapping.EntityType.FullName,
                        actualEnd.ParentAssociationSet.Name,
                        MetadataHelper.GetEntityTypeForEnd(MetadataHelper.GetOppositeEnd(actualEnd).CorrespondingAssociationEndMember).FullName),
                        StorageMappingErrorCode.InvalidModificationFunctionMappingAssociationEndMappingInvalidForEntityType,
                        m_sourceLocation,
                        xmlLineInfoNav,
                        m_parsingErrors);
                }
            }
        }

        /// <summary>
        /// Validates that association sets are only mapped once.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping">Container to validate</param>
        private void ValidateFunctionAssociationFunctionMappingUnique(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping)
        {
            Dictionary<EntitySetBase, int> mappingCounts = new Dictionary<EntitySetBase, int>();

            // Walk through all entity set mappings
            foreach (StorageEntitySetMapping entitySetMapping in entityContainerMapping.EntitySetMaps)
            {
                if (entitySetMapping.ModificationFunctionMappings.Count > 0)
                {
                    // Get set of association sets implicitly mapped associations to avoid double counting
                    Set<EntitySetBase> associationSets = new Set<EntitySetBase>();
                    foreach (AssociationSetEnd end in entitySetMapping.ImplicitlyMappedAssociationSetEnds)
                    {
                        associationSets.Add(end.ParentAssociationSet);
                    }

                    foreach (EntitySetBase associationSet in associationSets)
                    {
                        IncrementCount(mappingCounts, associationSet);
                    }
                }
            }

            // Walk through all association set mappings
            foreach (StorageAssociationSetMapping associationSetMapping in entityContainerMapping.RelationshipSetMaps)
            {
                if (null != associationSetMapping.ModificationFunctionMapping)
                {
                    IncrementCount(mappingCounts, associationSetMapping.Set);
                }
            }

            // Check for redundantly mapped association sets
            List<string> violationNames = new List<string>();
            foreach (KeyValuePair<EntitySetBase, int> mappingCount in mappingCounts)
            {
                if (mappingCount.Value > 1)
                {
                    violationNames.Add(mappingCount.Key.Name);
                }
            }

            if (0 < violationNames.Count)
            {
                // Warn the user that association sets are mapped multiple times                
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_AssociationSetAmbiguous,
                    StringUtil.ToCommaSeparatedString(violationNames), StorageMappingErrorCode.AmbiguousModificationFunctionMappingForAssociationSet,
                    m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);

            }
        }

        private static void IncrementCount<T>(Dictionary<T, int> counts, T key)
        {
            int count;
            if (counts.TryGetValue(key, out count))
            {
                count++;
            }
            else
            {
                count = 1;
            }
            counts[key] = count;
        }

        /// <summary>
        /// Validates that all or no related extents have function mappings. If an EntitySet or an AssociationSet has a function mapping,
        /// then all the sets that touched the same store tableSet must also have function mappings.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping">Container to validate.</param>
        private void ValidateEntitySetFunctionMappingClosure(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping)
        {
            // here we build a mapping between the tables and the sets,
            // setmapping => typemapping => mappingfragments, foreach mappingfragments we have one Tableset,
            // then add the tableset with setmapping to the dictionary

            KeyToListMap<EntitySet, StorageSetMapping> setMappingPerTable =
                new KeyToListMap<EntitySet, StorageSetMapping>(EqualityComparer<EntitySet>.Default);

            // Walk through all set mappings
            foreach (var setMapping in entityContainerMapping.AllSetMaps)
            {
                foreach (var typeMapping in setMapping.TypeMappings)
                {
                    foreach (var fragment in typeMapping.MappingFragments)
                    {
                        setMappingPerTable.Add(fragment.TableSet, setMapping);
                    }
                }
            }

            // Get set of association sets implicitly mapped associations to avoid double counting
            Set<EntitySetBase> implicitMappedAssociationSets = new Set<EntitySetBase>();

            // Walk through all entity set mappings
            foreach (StorageEntitySetMapping entitySetMapping in entityContainerMapping.EntitySetMaps)
            {
                if (entitySetMapping.ModificationFunctionMappings.Count > 0)
                {
                    foreach (AssociationSetEnd end in entitySetMapping.ImplicitlyMappedAssociationSetEnds)
                    {
                        implicitMappedAssociationSets.Add(end.ParentAssociationSet);
                    }
                }
            }

            foreach (var table in setMappingPerTable.Keys)
            {
                // if any of the sets who touches the same table has modification function, 
                // then all the sets that touches the same table should have modification function
                if (setMappingPerTable.ListForKey(table).Any(s => s.HasModificationFunctionMapping || implicitMappedAssociationSets.Any(aset=> aset == s.Set)) &&
                    setMappingPerTable.ListForKey(table).Any(s => !s.HasModificationFunctionMapping && !implicitMappedAssociationSets.Any(aset => aset == s.Set)))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_MissingSetClosure,
                        StringUtil.ToCommaSeparatedString(setMappingPerTable.ListForKey(table)
                            .Where(s => !s.HasModificationFunctionMapping).Select(s=>s.Set.Name)),
                        StorageMappingErrorCode.MissingSetClosureInModificationFunctionMapping, m_sourceLocation, (IXmlLineInfo)nav
                        , m_parsingErrors);
                }
            }
        }

        private static void ValidateClosureAmongSets(StorageEntityContainerMapping entityContainerMapping, Set<EntitySetBase> sets, Set<EntitySetBase> additionalSetsInClosure)
        {
            bool nodeFound;
            do
            {
                nodeFound = false;
                List<EntitySetBase> newNodes = new List<EntitySetBase>();

                // Register entity sets dependencies for association sets
                foreach (EntitySetBase entitySetBase in additionalSetsInClosure)
                {
                    AssociationSet associationSet = entitySetBase as AssociationSet;
                    //Foreign Key Associations do not add to the dependancies
                    if (associationSet != null
                        && !associationSet.ElementType.IsForeignKey)
                    {
                        // add the entity sets bound to the end roles to the required list
                        foreach (AssociationSetEnd end in associationSet.AssociationSetEnds)
                        {
                            if (!additionalSetsInClosure.Contains(end.EntitySet))
                            {
                                newNodes.Add(end.EntitySet);
                            }
                        }
                    }
                }

                // Register all association sets referencing known entity sets
                foreach (EntitySetBase entitySetBase in entityContainerMapping.EdmEntityContainer.BaseEntitySets)
                {
                    AssociationSet associationSet = entitySetBase as AssociationSet;
                    //Foreign Key Associations do not add to the dependancies
                    if (associationSet != null
                        && !associationSet.ElementType.IsForeignKey)
                    {
                        // check that this association set isn't already in the required set
                        if (!additionalSetsInClosure.Contains(associationSet))
                        {
                            foreach (AssociationSetEnd end in associationSet.AssociationSetEnds)
                            {
                                if (additionalSetsInClosure.Contains(end.EntitySet))
                                {
                                    // this association set must be added to the required list if
                                    // any of its ends are in that list
                                    newNodes.Add(associationSet);
                                    break; // no point adding the association set twice
                                }
                            }
                        }
                    }
                }

                if (0 < newNodes.Count)
                {
                    nodeFound = true;
                    additionalSetsInClosure.AddRange(newNodes);
                }
            }
            while (nodeFound);

            additionalSetsInClosure.Subtract(sets);
        }

        /// <summary>
        /// Validates that all or no related extents have query views defined. If an extent has a query view defined, then
        /// all related extents must also have query views.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping">Container to validate.</param>
        private void ValidateQueryViewsClosure(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping)
        {
            //If there is no query view defined, no need to validate
            if (!m_hasQueryViews)
            {
                return;
            }
            // Check that query views apply to complete subgraph by tracking which extents have query
            // mappings and which extents must include query views
            Set<EntitySetBase> setsWithQueryViews = new Set<EntitySetBase>();
            Set<EntitySetBase> setsRequiringQueryViews = new Set<EntitySetBase>();

            // Walk through all set mappings
            foreach (StorageSetMapping setMapping in entityContainerMapping.AllSetMaps)
            {
                if (setMapping.QueryView != null)
                {
                    // a function mapping exists for this entity set
                    setsWithQueryViews.Add(setMapping.Set);
                }
            }

            // Initialize sets requiring function mapping with the sets that are actually function mapped
            setsRequiringQueryViews.AddRange(setsWithQueryViews);

            ValidateClosureAmongSets(entityContainerMapping, setsWithQueryViews, setsRequiringQueryViews);

            // Check that no required entity or association sets are missing
            if (0 < setsRequiringQueryViews.Count)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_Invalid_Query_Views_MissingSetClosure,
                    StringUtil.ToCommaSeparatedString(setsRequiringQueryViews),
                    StorageMappingErrorCode.MissingSetClosureInQueryViews, m_sourceLocation, (IXmlLineInfo)nav
                    , m_parsingErrors);
            }
        }

        /// <summary>
        /// The method loads the child nodes for the EntitySet Mapping node
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping"></param>
        /// <param name="storageEntityContainerType"></param>
        private void LoadEntitySetMapping(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping, EntityContainer storageEntityContainerType)
        {
            //Get the EntitySet name 
            string entitySetName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingNameAttribute);
            //Get the EntityType name, need to parse it if the mapping information is being specified for multiple types 
            string entityTypeName = StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingTypeNameAttribute);
            //Get the table name. This might be emptystring since the user can have a TableMappingFragment instead of this.
            string tableName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingStoreEntitySetAttribute);
            
            bool distinctFlag = GetBoolAttributeValue(nav.Clone(), StorageMslConstructs.MappingFragmentMakeColumnsDistinctAttribute, false /*default value*/);
            
            EntitySet entitySet;

            // First check to see if the Entity Set Mapping is already specified. It can be specified, in the same schema file later on
            // on a totally different file. Since we support partial mapping, we should just add mapping fragments or entity type
            // mappings to the existing entity set mapping
            StorageEntitySetMapping setMapping = (StorageEntitySetMapping)entityContainerMapping.GetEntitySetMapping(entitySetName);

            // Update the info about the schema element
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            if (setMapping == null)
            {
                //Try to find the EntitySet with the given name in the EntityContainer.
                if (!entityContainerMapping.EdmEntityContainer.TryGetEntitySetByName(entitySetName, /*ignoreCase*/ false, out entitySet))
                {
                    //If no EntitySet with the given name exists, than add a schema error and return
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Entity_Set, entitySetName,
                        StorageMappingErrorCode.InvalidEntitySet, m_sourceLocation, navLineInfo, m_parsingErrors);
                    //There is no point in continuing the loding of this EntitySetMapping if the EntitySet is not found
                    return;
                }
                //Create the EntitySet Mapping which contains the mapping information for EntitySetMap.
                setMapping = new StorageEntitySetMapping(entitySet, entityContainerMapping);
            }
            else
            {
                entitySet = (EntitySet)setMapping.Set;
            }

            //Set the Start Line Information on Fragment
            setMapping.StartLineNumber = navLineInfo.LineNumber;
            setMapping.StartLinePosition = navLineInfo.LinePosition;
            entityContainerMapping.AddEntitySetMapping(setMapping);

            //If the TypeName was not specified as an attribute, than an EntityTypeMapping element should be present 
            if (String.IsNullOrEmpty(entityTypeName))
            {
                if (nav.MoveToChild(XPathNodeType.Element))
                {

                    do
                    {
                        switch (nav.LocalName)
                        {
                            case StorageMslConstructs.EntityTypeMappingElement:
                                {
                                    //TableName could also be specified on EntityTypeMapping element
                                    tableName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.EntityTypeMappingStoreEntitySetAttribute);
                                    //Load the EntityTypeMapping into memory.
                                    LoadEntityTypeMapping(nav.Clone(), setMapping, tableName, storageEntityContainerType, false /*No distinct flag so far*/, entityContainerMapping.GenerateUpdateViews);
                                    break;
                                }
                            case StorageMslConstructs.QueryViewElement:
                                {
                                    if (!(String.IsNullOrEmpty(tableName)))
                                    {
                                        AddToSchemaErrorsWithMemberInfo(Strings.Mapping_TableName_QueryView, entitySetName,
                                            StorageMappingErrorCode.TableNameAttributeWithQueryView, m_sourceLocation, navLineInfo, m_parsingErrors);
                                        return;
                                    }
                                    //Load the Query View into the set mapping,
                                    //if you get an error, return immediately since 
                                    //you go on, you could be giving lot of dubious errors
                                    if(!LoadQueryView(nav.Clone(), setMapping))
                                    {
                                        return;
                                    }
                                    break;
                                }
                            default:
                                AddToSchemaErrors(Strings.Mapping_InvalidContent_TypeMapping_QueryView,
                                    StorageMappingErrorCode.InvalidContent, m_sourceLocation, navLineInfo, m_parsingErrors);
                                break;
                        }
                    } while (nav.MoveToNext(XPathNodeType.Element));
                }
            }
            else
            {
                //Load the EntityTypeMapping into memory.
                LoadEntityTypeMapping(nav.Clone(), setMapping, tableName, storageEntityContainerType, distinctFlag, entityContainerMapping.GenerateUpdateViews);
            }
            ValidateAllEntityTypesHaveFunctionMapping(nav.Clone(), setMapping);
            //Add a schema error if the set mapping has no content
            if (setMapping.HasNoContent)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Emtpty_SetMap, entitySet.Name,
                    StorageMappingErrorCode.EmptySetMapping, m_sourceLocation, navLineInfo, m_parsingErrors);
            }
        }

        // Ensure if any type has a function mapping, all types have function mappings
        private void ValidateAllEntityTypesHaveFunctionMapping(XPathNavigator nav, StorageEntitySetMapping setMapping)
        {
            Set<EdmType> functionMappedTypes = new Set<EdmType>();
            foreach (StorageEntityTypeModificationFunctionMapping modificationFunctionMapping in setMapping.ModificationFunctionMappings)
            {
                functionMappedTypes.Add(modificationFunctionMapping.EntityType);
            }
            if (0 < functionMappedTypes.Count)
            {
                Set<EdmType> unmappedTypes = new Set<EdmType>(MetadataHelper.GetTypeAndSubtypesOf(setMapping.Set.ElementType, EdmItemCollection, false /*includeAbstractTypes*/));
                unmappedTypes.Subtract(functionMappedTypes);

                // Remove abstract types
                Set<EdmType> abstractTypes = new Set<EdmType>();
                foreach (EntityType unmappedType in unmappedTypes)
                {
                    if (unmappedType.Abstract)
                    {
                        abstractTypes.Add(unmappedType);
                    }
                }
                unmappedTypes.Subtract(abstractTypes);

                // See if there are any remaining entity types requiring function mapping
                if (0 < unmappedTypes.Count)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_MissingEntityType,
                        StringUtil.ToCommaSeparatedString(unmappedTypes),
                        StorageMappingErrorCode.MissingModificationFunctionMappingForEntityType, m_sourceLocation, (IXmlLineInfo)nav
                        , m_parsingErrors);
                }
            }
        }

        private bool TryParseEntityTypeAttribute(
            XPathNavigator nav,
            EntityType rootEntityType,
            Func<EntityType, string> typeNotAssignableMessage,
            out Set<EntityType> isOfTypeEntityTypes,
            out Set<EntityType> entityTypes)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;
            string entityTypeAttribute = GetAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingTypeNameAttribute);

            isOfTypeEntityTypes = new Set<EntityType>();
            entityTypes = new Set<EntityType>();

            // get components of type declaration
            var entityTypeNames = entityTypeAttribute.Split(StorageMslConstructs.TypeNameSperator).Select(s => s.Trim());

            // figure out each component
            foreach (var name in entityTypeNames)
            {
                bool isTypeOf = name.StartsWith(StorageMslConstructs.IsTypeOf, StringComparison.Ordinal);
                string entityTypeName;
                if (isTypeOf)
                {
                    // get entityTypeName of OfType(entityTypeName)
                    if (!name.EndsWith(StorageMslConstructs.IsTypeOfTerminal, StringComparison.Ordinal))
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_InvalidContent_IsTypeOfNotTerminated,
                            StorageMappingErrorCode.InvalidEntityType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                        // No point in continuing with an error in the entitytype name
                        return false;
                    }
                    entityTypeName = name.Substring(StorageMslConstructs.IsTypeOf.Length);
                    entityTypeName = entityTypeName.Substring(0, entityTypeName.Length - StorageMslConstructs.IsTypeOfTerminal.Length).Trim();
                }
                else
                {
                    entityTypeName = name;
                }

                // resolve aliases
                entityTypeName = GetAliasResolvedValue(entityTypeName);

                EntityType entityType;
                if (!this.EdmItemCollection.TryGetItem<EntityType>(entityTypeName, out entityType))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Entity_Type, entityTypeName,
                        StorageMappingErrorCode.InvalidEntityType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                    // No point in continuing with an error in the entitytype name
                    return false;
                }
                if (!(Helper.IsAssignableFrom(rootEntityType, entityType)))
                {
                    IXmlLineInfo lineInfo = xmlLineInfoNav;
                    AddToSchemaErrorWithMessage(
                        typeNotAssignableMessage(entityType),
                        StorageMappingErrorCode.InvalidEntityType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                    //no point in continuing with an error in the entitytype name
                    return false;
                }

                // Using TypeOf construct on an abstract type that does not have
                // any concrete descendants is not allowed
                if (entityType.Abstract)
                {
                    if (isTypeOf)
                    {
                        IEnumerable<EdmType> typeAndSubTypes = MetadataHelper.GetTypeAndSubtypesOf(entityType, EdmItemCollection, false /*includeAbstractTypes*/);
                        if (!typeAndSubTypes.GetEnumerator().MoveNext())
                        {
                            AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_AbstractEntity_IsOfType, entityType.FullName,
                                StorageMappingErrorCode.MappingOfAbstractType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                            return false;
                        }
                    }
                    else
                    {
                        AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_AbstractEntity_Type, entityType.FullName,
                            StorageMappingErrorCode.MappingOfAbstractType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                        return false;
                    }
                }

                // Add type to set
                if (isTypeOf)
                {
                    isOfTypeEntityTypes.Add(entityType);
                }
                else
                {
                    entityTypes.Add(entityType);
                }
            }

            // No failures
            return true;
        }

        /// <summary>
        /// The method loads the child nodes for the EntityType Mapping node
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entitySetMapping"></param>
        /// <param name="tableName"></param>
        /// <param name="storageEntityContainerType"></param>
        private void LoadEntityTypeMapping(XPathNavigator nav, StorageEntitySetMapping entitySetMapping, string tableName, EntityContainer storageEntityContainerType, bool distinctFlagAboveType, bool generateUpdateViews)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            //Create an EntityTypeMapping to hold the information for EntityType mapping.
            StorageEntityTypeMapping entityTypeMapping = new StorageEntityTypeMapping(entitySetMapping);

            //Get entity types
            Set<EntityType> entityTypes;
            Set<EntityType> isOfTypeEntityTypes;
            EntityType rootEntityType = (EntityType)entitySetMapping.Set.ElementType;
            if (!TryParseEntityTypeAttribute(nav.Clone(), rootEntityType,
                e => Strings.Mapping_InvalidContent_Entity_Type_For_Entity_Set(e.FullName, rootEntityType.FullName, entitySetMapping.Set.Name),
                out isOfTypeEntityTypes,
                out entityTypes))
            {
                // Return if we cannot parse entity types
                return;
            }

            // Register all mapped types
            foreach (EntityType entityType in entityTypes)
            {
                entityTypeMapping.AddType(entityType);
            }
            foreach (EntityType isOfTypeEntityType in isOfTypeEntityTypes)
            {
                entityTypeMapping.AddIsOfType(isOfTypeEntityType);
            }

            //If the table name was not specified on the EntitySetMapping element nor the EntityTypeMapping element
            //than a table mapping fragment element should be present
            //Loop through the TableMappingFragment elements and add them to EntityTypeMappings
            if (String.IsNullOrEmpty(tableName))
            {
                if (!nav.MoveToChild(XPathNodeType.Element))
                    return;
                do
                {
                    if (nav.LocalName == StorageMslConstructs.ModificationFunctionMappingElement)
                    {
                        entitySetMapping.HasModificationFunctionMapping = true;
                        LoadEntityTypeModificationFunctionMapping(nav.Clone(), entitySetMapping, entityTypeMapping);
                    }
                    else if (nav.LocalName != StorageMslConstructs.MappingFragmentElement)
                    {
                        AddToSchemaErrors(Strings.Mapping_InvalidContent_Table_Expected,
                            StorageMappingErrorCode.TableMappingFragmentExpected, m_sourceLocation, xmlLineInfoNav
                            , m_parsingErrors);
                    }
                    else
                    {
                        bool distinctFlag = GetBoolAttributeValue(nav.Clone(), StorageMslConstructs.MappingFragmentMakeColumnsDistinctAttribute, false /*default value*/);

                        if (generateUpdateViews && distinctFlag)
                        {
                            AddToSchemaErrors(Strings.Mapping_DistinctFlagInReadWriteContainer,
                                StorageMappingErrorCode.DistinctFragmentInReadWriteContainer, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                        }
                        
                        tableName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.MappingFragmentStoreEntitySetAttribute);
                        StorageMappingFragment fragment = LoadMappingFragment(nav.Clone(), entityTypeMapping, tableName, storageEntityContainerType, distinctFlag);
                        //The fragment can be null in the cases of validation errors.
                        if (fragment != null)
                        {
                            entityTypeMapping.AddFragment(fragment);
                        }
                    }
                } while (nav.MoveToNext(XPathNodeType.Element));
            }
            else
            {
                if (nav.LocalName == StorageMslConstructs.ModificationFunctionMappingElement)
                {
                    // function mappings cannot exist in the context of a table mapping
                    AddToSchemaErrors(Strings.Mapping_ModificationFunction_In_Table_Context,
                        StorageMappingErrorCode.InvalidTableNameAttributeWithModificationFunctionMapping,
                        m_sourceLocation, xmlLineInfoNav
                        , m_parsingErrors);
                }

                if (generateUpdateViews && distinctFlagAboveType)
                {
                    AddToSchemaErrors(Strings.Mapping_DistinctFlagInReadWriteContainer,
                        StorageMappingErrorCode.DistinctFragmentInReadWriteContainer, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                }

                StorageMappingFragment fragment = LoadMappingFragment(nav.Clone(), entityTypeMapping, tableName,
                    storageEntityContainerType, distinctFlagAboveType);
                //The fragment can be null in the cases of validation errors.
                if (fragment != null)
                {
                    entityTypeMapping.AddFragment(fragment);
                }
            }
            entitySetMapping.AddTypeMapping(entityTypeMapping);
        }


        /// <summary>
        /// Loads modification function mappings for entity type.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entitySetMapping"></param>
        /// <param name="entityTypeMapping"></param>
        private void LoadEntityTypeModificationFunctionMapping(
            XPathNavigator nav,
            StorageEntitySetMapping entitySetMapping,
            StorageEntityTypeMapping entityTypeMapping)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            // Function mappings can apply only to a single type.
            if (entityTypeMapping.IsOfTypes.Count != 0 || entityTypeMapping.Types.Count != 1)
            {
                AddToSchemaErrors(Strings.Mapping_ModificationFunction_Multiple_Types,
                    StorageMappingErrorCode.InvalidModificationFunctionMappingForMultipleTypes,
                    m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return;
            }
            EntityType entityType = (EntityType)entityTypeMapping.Types[0];
            //Function Mapping is not allowed to be defined for Abstract Types
            if (entityType.Abstract)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_AbstractEntity_FunctionMapping, entityType.FullName,
                    StorageMappingErrorCode.MappingOfAbstractType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return;
            }

            // check that no mapping exists for this entity type already
            foreach (StorageEntityTypeModificationFunctionMapping existingMapping in entitySetMapping.ModificationFunctionMappings)
            {
                if (existingMapping.EntityType.Equals(entityType))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_RedundantEntityTypeMapping,
                        entityType.Name, StorageMappingErrorCode.RedundantEntityTypeMappingInModificationFunctionMapping, m_sourceLocation, xmlLineInfoNav
                        , m_parsingErrors);
                    return;
                }
            }

            // create function loader
            ModificationFunctionMappingLoader functionLoader = new ModificationFunctionMappingLoader(this, entitySetMapping.Set);

            // Load all function definitions (for insert, delete and update)
            StorageModificationFunctionMapping deleteFunctionMapping = null;
            StorageModificationFunctionMapping insertFunctionMapping = null;
            StorageModificationFunctionMapping updateFunctionMapping = null;
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                do
                {
                    switch (nav.LocalName)
                    {
                        case StorageMslConstructs.DeleteFunctionElement:
                            deleteFunctionMapping = functionLoader.LoadEntityTypeModificationFunctionMapping(nav.Clone(), entitySetMapping.Set, false, true, entityType);
                            break;
                        case StorageMslConstructs.InsertFunctionElement:
                            insertFunctionMapping = functionLoader.LoadEntityTypeModificationFunctionMapping(nav.Clone(), entitySetMapping.Set, true, false, entityType);
                            break;
                        case StorageMslConstructs.UpdateFunctionElement:
                            updateFunctionMapping = functionLoader.LoadEntityTypeModificationFunctionMapping(nav.Clone(), entitySetMapping.Set, true, true, entityType);
                            break;
                    }
                } while (nav.MoveToNext(XPathNodeType.Element));
            }


            // Ensure that assocation set end mappings bind to the same end (e.g., in Person Manages Person
            // self-association, ensure that the manager end or the report end is mapped but not both)
            IEnumerable<StorageModificationFunctionParameterBinding> parameterList = new List<StorageModificationFunctionParameterBinding>();
            if (null != deleteFunctionMapping)
            {
                parameterList = Helper.Concat(parameterList, deleteFunctionMapping.ParameterBindings);
            }
            if (null != insertFunctionMapping)
            {
                parameterList = Helper.Concat(parameterList, insertFunctionMapping.ParameterBindings);
            }
            if (null != updateFunctionMapping)
            {
                parameterList = Helper.Concat(parameterList, updateFunctionMapping.ParameterBindings);
            }

            var associationEnds = new Dictionary<AssociationSet, AssociationEndMember>();
            foreach (StorageModificationFunctionParameterBinding parameterBinding in parameterList)
            {
                if (null != parameterBinding.MemberPath.AssociationSetEnd)
                {
                    AssociationSet associationSet = parameterBinding.MemberPath.AssociationSetEnd.ParentAssociationSet;
                    // the "end" corresponds to the second member in the path, e.g.
                    // ID<-Manager where Manager is the end
                    AssociationEndMember currentEnd = parameterBinding.MemberPath.AssociationSetEnd.CorrespondingAssociationEndMember;

                    AssociationEndMember existingEnd;
                    if (associationEnds.TryGetValue(associationSet, out existingEnd) &&
                        existingEnd != currentEnd)
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_ModificationFunction_MultipleEndsOfAssociationMapped(
                            currentEnd.Name, existingEnd.Name, associationSet.Name),
                            StorageMappingErrorCode.InvalidModificationFunctionMappingMultipleEndsOfAssociationMapped, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                        return;
                    }
                    else
                    {
                        associationEnds[associationSet] = currentEnd;
                    }
                }
            }

            // Register the function mapping on the entity set mapping
            StorageEntityTypeModificationFunctionMapping mapping = new StorageEntityTypeModificationFunctionMapping(
                entityType, deleteFunctionMapping, insertFunctionMapping, updateFunctionMapping);
            
            entitySetMapping.AddModificationFunctionMapping(mapping);
        }

        /// <summary>
        /// The method loads the query view for the Set Mapping node
        /// into the internal datastructures.
        /// </summary>
        private bool LoadQueryView(XPathNavigator nav, StorageSetMapping setMapping)
        {
            Debug.Assert(nav.LocalName == StorageMslConstructs.QueryViewElement);

            string queryView = nav.Value;
            bool includeSubtypes = false;

            string typeNameString = StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingTypeNameAttribute);
            if (typeNameString != null)
            {
                typeNameString = typeNameString.Trim();
            }

            if (setMapping.QueryView == null)
            {
                // QV must be the special-case first view.
                if (typeNameString != null)
                {
                    AddToSchemaErrorsWithMemberInfo(val => Strings.Mapping_TypeName_For_First_QueryView,
                        setMapping.Set.Name, StorageMappingErrorCode.TypeNameForFirstQueryView,
                        m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                    return false;
                }

                if (String.IsNullOrEmpty(queryView))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_Empty_QueryView,
                        setMapping.Set.Name, StorageMappingErrorCode.EmptyQueryView,
                        m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                    return false;
                }
                setMapping.QueryView = queryView;
                this.m_hasQueryViews = true;
                return true;
            }
            else
            {
                //QV must be typeof or typeofonly view
                if (typeNameString == null || typeNameString.Trim().Length == 0)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_QueryView_TypeName_Not_Defined,
                        setMapping.Set.Name, StorageMappingErrorCode.NoTypeNameForTypeSpecificQueryView,
                        m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                    return false;
                }

                //Get entity types
                Set<EntityType> entityTypes;
                Set<EntityType> isOfTypeEntityTypes;
                EntityType rootEntityType = (EntityType)setMapping.Set.ElementType;
                if (!TryParseEntityTypeAttribute(nav.Clone(), rootEntityType,
                    e => Strings.Mapping_InvalidContent_Entity_Type_For_Entity_Set(e.FullName, rootEntityType.FullName, setMapping.Set.Name),
                    out isOfTypeEntityTypes,
                    out entityTypes))
                {
                    // Return if we cannot parse entity types
                    return false;
                }
                Debug.Assert(isOfTypeEntityTypes.Count > 0 || entityTypes.Count > 0);
                Debug.Assert(!(isOfTypeEntityTypes.Count > 0 && entityTypes.Count > 0));

                EntityType entityType;
                if (isOfTypeEntityTypes.Count == 1)
                {   //OfType View
                    entityType = isOfTypeEntityTypes.First();
                    includeSubtypes = true;
                }
                else if (entityTypes.Count == 1)
                {   //OfTypeOnly View
                    entityType = entityTypes.First();
                    includeSubtypes = false;
                }
                else
                {
                    //More than one type
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_QueryViewMultipleTypeInTypeName, setMapping.Set.ToString(),
                        StorageMappingErrorCode.TypeNameContainsMultipleTypesForQueryView, m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                    return false;
                }

                //Check if IsTypeOf(A) and A is the base type
                if (includeSubtypes && setMapping.Set.ElementType.EdmEquals(entityType))
                {   //Don't allow TypeOFOnly(a) if a is a base type. 
                    AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_QueryView_For_Base_Type, entityType.ToString(), setMapping.Set.ToString(),
                        StorageMappingErrorCode.IsTypeOfQueryViewForBaseType, m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                    return false;                    
                }

                if (String.IsNullOrEmpty(queryView))
                {
                    if (includeSubtypes)
                    {
                        AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_Empty_QueryView_OfType,
                            entityType.Name, setMapping.Set.Name, StorageMappingErrorCode.EmptyQueryView,
                            m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                        return false;
                    }
                    else
                    {
                        AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_Empty_QueryView_OfTypeOnly,
                            setMapping.Set.Name, entityType.Name, StorageMappingErrorCode.EmptyQueryView,
                            m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                        return false;
                    }
                }


                //Add it to the QV cache
                Triple key = new Triple(setMapping.Set, new Pair<EntityTypeBase, bool>(entityType, includeSubtypes));


                if (setMapping.ContainsTypeSpecificQueryView(key))
                { //two QVs for the same type 

                    EdmSchemaError error = null;
                    if (includeSubtypes)
                    {
                        error =
                            new EdmSchemaError(
                                Strings.Mapping_QueryView_Duplicate_OfType(setMapping.Set, entityType),
                                (int)StorageMappingErrorCode.QueryViewExistsForEntitySetAndType, EdmSchemaErrorSeverity.Error, m_sourceLocation,
                                ((IXmlLineInfo)nav).LineNumber, ((IXmlLineInfo)nav).LinePosition);
                    }
                    else
                    {
                        error =
                            new EdmSchemaError(
                                Strings.Mapping_QueryView_Duplicate_OfTypeOnly(setMapping.Set, entityType),
                                (int)StorageMappingErrorCode.QueryViewExistsForEntitySetAndType, EdmSchemaErrorSeverity.Error, m_sourceLocation,
                                ((IXmlLineInfo)nav).LineNumber, ((IXmlLineInfo)nav).LinePosition);
                    }

                    m_parsingErrors.Add(error);
                    return false;
                }

                setMapping.AddTypeSpecificQueryView(key, queryView);
                return true;
            }
        }        

        /// <summary>
        /// The method loads the child nodes for the AssociationSet Mapping node
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping"></param>
        /// <param name="storageEntityContainerType"></param>
        private void LoadAssociationSetMapping(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping, EntityContainer storageEntityContainerType)
        {
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            //Get the AssociationSet name 
            string associationSetName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.AssociationSetMappingNameAttribute);
            //Get the AssociationType name, need to parse it if the mapping information is being specified for multiple types 
            string associationTypeName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.AssociationSetMappingTypeNameAttribute);
            //Get the table name. This might be emptystring since the user can have a TableMappingFragment instead of this.
            string tableName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingStoreEntitySetAttribute);
            //Try to find the AssociationSet with the given name in the EntityContainer.
            RelationshipSet relationshipSet;
            entityContainerMapping.EdmEntityContainer.TryGetRelationshipSetByName(associationSetName, false /*ignoreCase*/, out relationshipSet);
            AssociationSet associationSet = relationshipSet as AssociationSet;
            //If no AssociationSet with the given name exists, than Add a schema error and return
            if (associationSet == null)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Association_Set, associationSetName,
                    StorageMappingErrorCode.InvalidAssociationSet, m_sourceLocation, navLineInfo, m_parsingErrors);
                //There is no point in continuing the loading of association set map if the AssociationSetName has a problem
                return;
            }

            if (associationSet.ElementType.IsForeignKey)
            {
                ReferentialConstraint constraint = associationSet.ElementType.ReferentialConstraints.Single();
                IEnumerable<EdmMember> dependentKeys = MetadataHelper.GetEntityTypeForEnd((AssociationEndMember)constraint.ToRole).KeyMembers;
                if (associationSet.ElementType.ReferentialConstraints.Single().ToProperties.All(p => dependentKeys.Contains(p)))
                {
                    EdmSchemaError error = AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_ForeignKey_Association_Set_PKtoPK, associationSetName,
                        StorageMappingErrorCode.InvalidAssociationSet, m_sourceLocation, navLineInfo, m_parsingErrors);
                    //Downgrade to a warning if the foreign key constraint is between keys (for back-compat reasons)
                    error.Severity = EdmSchemaErrorSeverity.Warning;
                }
                else
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_ForeignKey_Association_Set, associationSetName,
                        StorageMappingErrorCode.InvalidAssociationSet, m_sourceLocation, navLineInfo, m_parsingErrors);
                }
                return;
            }

            if (entityContainerMapping.ContainsAssociationSetMapping(associationSet))
            {
                //Can not add this set mapping since our storage dictionary won't allow
                //duplicate maps
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_Duplicate_CdmAssociationSet_StorageMap, associationSetName,
                    StorageMappingErrorCode.DuplicateSetMapping, m_sourceLocation, navLineInfo, m_parsingErrors);
                return;

            }
            //Create the AssociationSet Mapping which contains the mapping information for association set.
            StorageAssociationSetMapping setMapping = new StorageAssociationSetMapping(associationSet, entityContainerMapping);

            //Set the Start Line Information on Fragment
            setMapping.StartLineNumber = navLineInfo.LineNumber;
            setMapping.StartLinePosition = navLineInfo.LinePosition;


            if (!nav.MoveToChild(XPathNodeType.Element))
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Emtpty_SetMap, associationSet.Name,
                    StorageMappingErrorCode.EmptySetMapping, m_sourceLocation, navLineInfo, m_parsingErrors);
                return;
            }

            entityContainerMapping.AddAssociationSetMapping(setMapping);

            //If there is a query view it has to be the first element
            if (nav.LocalName == StorageMslConstructs.QueryViewElement)
            {
                if (!(String.IsNullOrEmpty(tableName)))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_TableName_QueryView, associationSetName,
                        StorageMappingErrorCode.TableNameAttributeWithQueryView, m_sourceLocation, navLineInfo, m_parsingErrors);
                    return;
                }
                //Load the Query View into the set mapping,
                //if you get an error, return immediately since 
                //you go on, you could be giving lot of dubious errors
                if (!LoadQueryView(nav.Clone(), setMapping))
                {
                    return;
                }
                //If there are no more elements just return
                if (!nav.MoveToNext(XPathNodeType.Element))
                {
                    return;
                }
            }

            if ((nav.LocalName == StorageMslConstructs.EndPropertyMappingElement) ||
                     (nav.LocalName == StorageMslConstructs.ModificationFunctionMappingElement))
            {
                if ((String.IsNullOrEmpty(associationTypeName)))
                {
                    AddToSchemaErrors(Strings.Mapping_InvalidContent_Association_Type_Empty,
                        StorageMappingErrorCode.InvalidAssociationType, m_sourceLocation, navLineInfo, m_parsingErrors);
                    return;
                }
                //Load the AssociationTypeMapping into memory.
                LoadAssociationTypeMapping(nav.Clone(), setMapping, associationTypeName, tableName, storageEntityContainerType);
            }
            else if (nav.LocalName == StorageMslConstructs.ConditionElement)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_AssociationSet_Condition, associationSetName,
                    StorageMappingErrorCode.InvalidContent, m_sourceLocation, navLineInfo, m_parsingErrors);
                return;
            }
            else
            {

                Debug.Assert(false, "XSD validation should ensure this");
            }
        }

        #region LoadFunctionImportMapping implementation
        /// <summary>
        /// The method loads a function import mapping element
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="entityContainerMapping"></param>
        /// <param name="storageEntityContainerType"></param>
        private void LoadFunctionImportMapping(XPathNavigator nav, StorageEntityContainerMapping entityContainerMapping, EntityContainer storageEntityContainerType)
        {
            IXmlLineInfo lineInfo = (IXmlLineInfo)(nav.Clone());

            // Get target (store) function
            EdmFunction targetFunction;
            if (!TryGetFunctionImportStoreFunction(nav, out targetFunction))
            {
                return;
            }

            // Get source (model) function
            EdmFunction functionImport;
            if (!TryGetFunctionImportModelFunction(nav, entityContainerMapping, out functionImport))
            {
                return;
            }

            // Validate composability alignment of function import and target function.
            if (!functionImport.IsComposableAttribute && targetFunction.IsComposableAttribute)
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_TargetFunctionMustBeNonComposable(functionImport.FullName, targetFunction.FullName),
                    StorageMappingErrorCode.MappingFunctionImportTargetFunctionMustBeNonComposable,
                    m_sourceLocation, lineInfo, m_parsingErrors);
                return;
            }
            else if (functionImport.IsComposableAttribute && !targetFunction.IsComposableAttribute)
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_TargetFunctionMustBeComposable(functionImport.FullName, targetFunction.FullName),
                    StorageMappingErrorCode.MappingFunctionImportTargetFunctionMustBeComposable,
                    m_sourceLocation, lineInfo, m_parsingErrors);
                return;
            }

            // Validate parameters are compatible between the store and model functions
            ValidateFunctionImportMappingParameters(nav, targetFunction, functionImport);

            // Process type mapping information
            var typeMappingsList = new List<List<FunctionImportStructuralTypeMapping>>();
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                int resultSetIndex = 0;
                do 
                {
                    if (nav.LocalName == StorageMslConstructs.FunctionImportMappingResultMapping)
                    {
                        List<FunctionImportStructuralTypeMapping> typeMappings = GetFunctionImportMappingResultMapping(nav.Clone(), lineInfo, targetFunction, functionImport, resultSetIndex, typeMappingsList);
                        typeMappingsList.Add(typeMappings);

                    }
                    resultSetIndex++;
                } while (nav.MoveToNext(XPathNodeType.Element));
            }

            // Verify that there are the right number of result mappings
            if (typeMappingsList.Count > 0 && typeMappingsList.Count != functionImport.ReturnParameters.Count)
            {
                AddToSchemaErrors(Strings.Mapping_FunctionImport_ResultMappingCountDoesNotMatchResultCount(functionImport.Identity),
                    StorageMappingErrorCode.FunctionResultMappingCountMismatch, m_sourceLocation, lineInfo, m_parsingErrors);
                return;
            }

            if (functionImport.IsComposableAttribute)
            {
                //
                // Add composable function import mapping to the list.
                //

                // Function mapping is allowed only for TVFs on the s-space.
                var cTypeTargetFunction = this.StoreItemCollection.ConvertToCTypeFunction(targetFunction);
                var cTypeTvfElementType = System.Data.Common.TypeHelpers.GetTvfReturnType(cTypeTargetFunction);
                var sTypeTvfElementType = System.Data.Common.TypeHelpers.GetTvfReturnType(targetFunction);
                if (cTypeTvfElementType == null)
                {
                    Debug.Assert(sTypeTvfElementType == null, "sTypeTvfElementType == null");
                    AddToSchemaErrors(Strings.Mapping_FunctionImport_ResultMapping_InvalidSType(functionImport.Identity),
                        StorageMappingErrorCode.MappingFunctionImportTVFExpected, m_sourceLocation, lineInfo, m_parsingErrors);
                    return;
                }

                Debug.Assert(functionImport.ReturnParameters.Count == 1, "functionImport.ReturnParameters.Count == 1 for a composable function import.");
                var typeMappings = typeMappingsList.Count > 0 ? typeMappingsList[0] : new List<FunctionImportStructuralTypeMapping>();

                FunctionImportMappingComposable mapping = null;
                EdmType resultType;
                if (MetadataHelper.TryGetFunctionImportReturnType<EdmType>(functionImport, 0, out resultType))
                {
                    if (Helper.IsStructuralType(resultType))
                    {
                        if (!TryCreateFunctionImportMappingComposableWithStructuralResult(
                                functionImport,
                                cTypeTargetFunction,
                                typeMappings,
                                (StructuralType)resultType,
                                cTypeTvfElementType,
                                sTypeTvfElementType,
                                lineInfo,
                                out mapping))
                        {
                            return;
                        }
                    }
                    else
                    {
                        Debug.Assert(TypeSemantics.IsScalarType(resultType), "TypeSemantics.IsScalarType(resultType)");
                        Debug.Assert(typeMappings.Count == 0, "typeMappings.Count == 0");
                        if (!TryCreateFunctionImportMappingComposableWithScalarResult(
                                functionImport,
                                cTypeTargetFunction,
                                targetFunction,
                                resultType,
                                cTypeTvfElementType,
                                sTypeTvfElementType,
                                lineInfo,
                                out mapping))
                        {
                            return;
                        }
                    }
                }
                else
                {
                    Debug.Fail("Composable function import must have return type.");
                }
                Debug.Assert(mapping != null, "mapping != null");

                entityContainerMapping.AddFunctionImportMapping(functionImport, mapping);
            }
            else
            {
                //
                // Add non-composable function import mapping to the list.
                //

                var mapping = new FunctionImportMappingNonComposable(functionImport, targetFunction, typeMappingsList, this.EdmItemCollection);

                // Verify that all entity types can be produced.
                foreach (FunctionImportStructuralTypeMappingKB resultMapping in mapping.ResultMappings)
                {
                    resultMapping.ValidateTypeConditions(/*validateAmbiguity: */false, m_parsingErrors, m_sourceLocation);
                }

                // Verify that function imports returning abstract types include explicit mappings
                for (int i = 0; i < mapping.ResultMappings.Count; i++)
                {
                    EntityType returnEntityType;
                    if (MetadataHelper.TryGetFunctionImportReturnType<EntityType>(functionImport, i, out returnEntityType) &&
                        returnEntityType.Abstract &&
                        mapping.GetResultMapping(i).NormalizedEntityTypeMappings.Count == 0)
                    {
                        AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_FunctionImport_ImplicitMappingForAbstractReturnType, returnEntityType.FullName,
                            functionImport.Identity, StorageMappingErrorCode.MappingOfAbstractType, m_sourceLocation, lineInfo, m_parsingErrors);
                    }
                }

                entityContainerMapping.AddFunctionImportMapping(functionImport, mapping);
            }
        }

        private bool TryGetFunctionImportStoreFunction(XPathNavigator nav, out EdmFunction targetFunction)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;
            targetFunction = null;

            // Get the function name
            string functionName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.FunctionImportMappingFunctionNameAttribute);

            // Try to find the function definition
            ReadOnlyCollection<EdmFunction> functionOverloads = this.StoreItemCollection.GetFunctions(functionName);

            if (functionOverloads.Count == 0)
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_StoreFunctionDoesNotExist(functionName),
                    StorageMappingErrorCode.MappingFunctionImportStoreFunctionDoesNotExist,
                    m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return false;
            }
            else if (functionOverloads.Count > 1)
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_FunctionAmbiguous(functionName),
                    StorageMappingErrorCode.MappingFunctionImportStoreFunctionAmbiguous,
                    m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return false;
            }

            targetFunction = functionOverloads.Single();

            return true;
        }

        private bool TryGetFunctionImportModelFunction(
            XPathNavigator nav,
            StorageEntityContainerMapping entityContainerMapping,
            out EdmFunction functionImport)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            // Get the function import name
            string functionImportName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.FunctionImportMappingFunctionImportNameAttribute);

            // Try to find the function import
            EntityContainer modelContainer = entityContainerMapping.EdmEntityContainer;
            functionImport = null;
            foreach (EdmFunction functionImportCandidate in modelContainer.FunctionImports)
            {
                if (functionImportCandidate.Name == functionImportName)
                {
                    functionImport = functionImportCandidate;
                    break;
                }
            }
            if (null == functionImport)
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_FunctionImportDoesNotExist(functionImportName, entityContainerMapping.EdmEntityContainer.Name),
                    StorageMappingErrorCode.MappingFunctionImportFunctionImportDoesNotExist,
                    m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return false;
            }

            // check that no existing mapping exists for this function import
            FunctionImportMapping targetFunctionCollision;
            if (entityContainerMapping.TryGetFunctionImportMapping(functionImport, out targetFunctionCollision))
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_FunctionImportMappedMultipleTimes(functionImportName),
                    StorageMappingErrorCode.MappingFunctionImportFunctionImportMappedMultipleTimes,
                    m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return false;
            }
            return true;
        }

        private void ValidateFunctionImportMappingParameters(XPathNavigator nav, EdmFunction targetFunction, EdmFunction functionImport)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            foreach (FunctionParameter targetParameter in targetFunction.Parameters)
            {
                // find corresponding import parameter
                FunctionParameter importParameter;
                if (!functionImport.Parameters.TryGetValue(targetParameter.Name, false, out importParameter))
                {
                    AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_TargetParameterHasNoCorrespondingImportParameter(targetParameter.Name),
                        StorageMappingErrorCode.MappingFunctionImportTargetParameterHasNoCorrespondingImportParameter,
                        m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                }
                else
                {
                    // parameters must have the same direction (in|out)
                    if (targetParameter.Mode != importParameter.Mode)
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_IncompatibleParameterMode(targetParameter.Name, targetParameter.Mode, importParameter.Mode),
                            StorageMappingErrorCode.MappingFunctionImportIncompatibleParameterMode,
                            m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                    }

                    PrimitiveType importType = Helper.AsPrimitive(importParameter.TypeUsage.EdmType);
                    Debug.Assert(importType != null, "Function import parameters must be primitive.");

                    if (Helper.IsSpatialType(importType))
                    {
                        importType = Helper.GetSpatialNormalizedPrimitiveType(importType);
                    }


                    PrimitiveType cspaceTargetType = (PrimitiveType)StoreItemCollection.StoreProviderManifest.GetEdmType(targetParameter.TypeUsage).EdmType;
                    if (cspaceTargetType == null)
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_ProviderReturnsNullType(targetParameter.Name),
                            StorageMappingErrorCode.MappingStoreProviderReturnsNullEdmType,
                            m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                        return;
                    }

                    // there are no type facets declared for function parameter types;
                    // we simply verify the primitive type kind is equivalent. 
                    // for enums we just use the underlying enum type.
                    if (cspaceTargetType.PrimitiveTypeKind != importType.PrimitiveTypeKind)
                    {
                        var schemaErrorMessage = Helper.IsEnumType(importParameter.TypeUsage.EdmType) ? 
                            Strings.Mapping_FunctionImport_IncompatibleEnumParameterType(
                                targetParameter.Name, 
                                cspaceTargetType.Name, 
                                importParameter.TypeUsage.EdmType.FullName,
                                Helper.GetUnderlyingEdmTypeForEnumType(importParameter.TypeUsage.EdmType).Name) : 
                            Strings.Mapping_FunctionImport_IncompatibleParameterType(
                                targetParameter.Name, 
                                cspaceTargetType.Name, 
                                importType.Name);

                        AddToSchemaErrorWithMessage(
                            schemaErrorMessage,
                            StorageMappingErrorCode.MappingFunctionImportIncompatibleParameterType,
                            m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                    }
                }
            }

            foreach (FunctionParameter importParameter in functionImport.Parameters)
            {
                // find corresponding target parameter
                FunctionParameter targetParameter;
                if (!targetFunction.Parameters.TryGetValue(importParameter.Name, false, out targetParameter))
                {
                    AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_ImportParameterHasNoCorrespondingTargetParameter(importParameter.Name),
                        StorageMappingErrorCode.MappingFunctionImportImportParameterHasNoCorrespondingTargetParameter,
                        m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                }
            }
        }

        private List<FunctionImportStructuralTypeMapping> GetFunctionImportMappingResultMapping(
            XPathNavigator nav,
            IXmlLineInfo functionImportMappingLineInfo,
            EdmFunction targetFunction,
            EdmFunction functionImport, 
            int resultSetIndex,
            List<List<FunctionImportStructuralTypeMapping>> typeMappingsList)
        {
            List<FunctionImportStructuralTypeMapping> typeMappings = new List<FunctionImportStructuralTypeMapping>();
 
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                do
                {
                    EntitySet entitySet = functionImport.EntitySets.Count > resultSetIndex ?
                                          functionImport.EntitySets[resultSetIndex] : null;

                    if (nav.LocalName == StorageMslConstructs.EntityTypeMappingElement)
                    {
                        EntityType resultEntityType;
                        if (MetadataHelper.TryGetFunctionImportReturnType<EntityType>(functionImport, resultSetIndex, out resultEntityType))
                        {
                            // Cannot specify an entity type mapping for a function import that does not return members of an entity set.
                            if (entitySet == null)
                            {
                                AddToSchemaErrors(Strings.Mapping_FunctionImport_EntityTypeMappingForFunctionNotReturningEntitySet(
                                    StorageMslConstructs.EntityTypeMappingElement, functionImport.Identity),
                                    StorageMappingErrorCode.MappingFunctionImportEntityTypeMappingForFunctionNotReturningEntitySet,
                                    m_sourceLocation, functionImportMappingLineInfo, m_parsingErrors);
                            }
                                
                            FunctionImportEntityTypeMapping typeMapping;
                            if (TryLoadFunctionImportEntityTypeMapping(
                                    nav.Clone(),
                                    resultEntityType,
                                    (EntityType e) => Strings.Mapping_FunctionImport_InvalidContentEntityTypeForEntitySet(e.FullName,
                                                                                                                            resultEntityType.FullName,
                                                                                                                            entitySet.Name,
                                                                                                                            functionImport.Identity),
                                    out typeMapping))
                            {
                                typeMappings.Add(typeMapping);
                            }
                        }
                        else
                        {
                            AddToSchemaErrors(Strings.Mapping_FunctionImport_ResultMapping_InvalidCTypeETExpected(functionImport.Identity),
                                StorageMappingErrorCode.MappingFunctionImportUnexpectedEntityTypeMapping,
                                m_sourceLocation, functionImportMappingLineInfo, m_parsingErrors);
                        }
                    }
                    else if (nav.LocalName == StorageMslConstructs.ComplexTypeMappingElement)
                    {
                        ComplexType resultComplexType;
                        if (MetadataHelper.TryGetFunctionImportReturnType<ComplexType>(functionImport, resultSetIndex, out resultComplexType))
                        {
                            Debug.Assert(entitySet == null, "entitySet == null for complex type mapping in function imports.");

                            FunctionImportComplexTypeMapping typeMapping;
                            if (TryLoadFunctionImportComplexTypeMapping(nav.Clone(), resultComplexType, functionImport, out typeMapping))
                            {
                                typeMappings.Add(typeMapping);
                            }
                        }
                        else
                        {
                            AddToSchemaErrors(Strings.Mapping_FunctionImport_ResultMapping_InvalidCTypeCTExpected(functionImport.Identity),
                                StorageMappingErrorCode.MappingFunctionImportUnexpectedComplexTypeMapping,
                                m_sourceLocation, functionImportMappingLineInfo, m_parsingErrors);
                        }
                    }
                }
                while (nav.MoveToNext(XPathNodeType.Element));
            }

            return typeMappings;
        }

        private bool TryLoadFunctionImportComplexTypeMapping(
            XPathNavigator nav,
            ComplexType resultComplexType,
            EdmFunction functionImport,
            out FunctionImportComplexTypeMapping typeMapping)
        {
            typeMapping = null;
            var lineInfo = new LineInfo(nav);

            ComplexType complexType;
            if (!TryParseComplexTypeAttribute(nav, resultComplexType, functionImport, out complexType))
            {
                return false;
            }

            Collection<FunctionImportReturnTypePropertyMapping> columnRenameMappings = new Collection<FunctionImportReturnTypePropertyMapping>();

            if (!LoadFunctionImportStructuralType(nav.Clone(), new List<StructuralType>() { complexType }, columnRenameMappings, null))
            {
                return false;
            }
                
            typeMapping = new FunctionImportComplexTypeMapping(complexType, columnRenameMappings, lineInfo);
            return true;
        }

        private bool TryParseComplexTypeAttribute(XPathNavigator nav, ComplexType resultComplexType, EdmFunction functionImport, out ComplexType complexType)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;
            string complexTypeName = GetAttributeValue(nav.Clone(), StorageMslConstructs.ComplexTypeMappingTypeNameAttribute);
            complexTypeName = GetAliasResolvedValue(complexTypeName);

            if (!this.EdmItemCollection.TryGetItem<ComplexType>(complexTypeName, out complexType))
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Complex_Type, complexTypeName,
                    StorageMappingErrorCode.InvalidComplexType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return false;
            }

            if (!Helper.IsAssignableFrom(resultComplexType, complexType))
            {
                IXmlLineInfo lineInfo = xmlLineInfoNav;
                AddToSchemaErrorWithMessage(
                    Strings.Mapping_FunctionImport_ResultMapping_MappedTypeDoesNotMatchReturnType(functionImport.Identity, complexType.FullName),
                    StorageMappingErrorCode.InvalidComplexType, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                return false;
            }

            return true;
        }

        private bool TryLoadFunctionImportEntityTypeMapping(
            XPathNavigator nav,
            EntityType resultEntityType,
            Func<EntityType, string> registerEntityTypeMismatchError,
            out FunctionImportEntityTypeMapping typeMapping)
        {
            typeMapping = null;
            var lineInfo = new LineInfo(nav);

            // Process entity type.
            string entityTypeString = GetAttributeValue(nav.Clone(), StorageMslConstructs.EntitySetMappingTypeNameAttribute);
            Set<EntityType> isOfTypeEntityTypes;
            Set<EntityType> entityTypes;
            {
                // Verify the entity type is appropriate to the function import's result entity type.
                if (!TryParseEntityTypeAttribute(nav.Clone(), resultEntityType, registerEntityTypeMismatchError, out isOfTypeEntityTypes, out entityTypes))
                {
                    return false;
                }
            }

            IEnumerable<StructuralType> currentTypesInHierachy = isOfTypeEntityTypes.Concat(entityTypes).Distinct().OfType<StructuralType>();
            Collection<FunctionImportReturnTypePropertyMapping> columnRenameMappings = new Collection<FunctionImportReturnTypePropertyMapping>();

            // Process all conditions and column renames.
            List<FunctionImportEntityTypeMappingCondition> conditions = new List<FunctionImportEntityTypeMappingCondition>();

            if (!LoadFunctionImportStructuralType(nav.Clone(), currentTypesInHierachy, columnRenameMappings, conditions))
            {
                return false;
            }

            typeMapping = new FunctionImportEntityTypeMapping(isOfTypeEntityTypes, entityTypes, conditions, columnRenameMappings, lineInfo);
            return true;
        }

        private bool LoadFunctionImportStructuralType(
            XPathNavigator nav,
            IEnumerable<StructuralType> currentTypes,
            Collection<FunctionImportReturnTypePropertyMapping> columnRenameMappings, 
            List<FunctionImportEntityTypeMappingCondition> conditions)
        {
            Debug.Assert(null != columnRenameMappings, "columnRenameMappings cannot be null");
            Debug.Assert(null != nav, "nav cannot be null");
            Debug.Assert(null != currentTypes, "currentTypes cannot be null");

            IXmlLineInfo lineInfo = (IXmlLineInfo)(nav.Clone());

            if (nav.MoveToChild(XPathNodeType.Element))
            {
                do
                {
                    if (nav.LocalName == StorageMslConstructs.ScalarPropertyElement)
                    {
                        LoadFunctionImportStructuralTypeMappingScalarProperty(nav, columnRenameMappings, currentTypes);
                    }
                    if (nav.LocalName == StorageMslConstructs.ConditionElement)
                    {
                        LoadFunctionImportEntityTypeMappingCondition(nav, conditions);
                    }
                }
                while (nav.MoveToNext(XPathNodeType.Element));
            }

            bool errorFound = false;
            if (null != conditions)
            {
                // make sure a single condition is specified per column
                HashSet<string> columnsWithConditions = new HashSet<string>();
                foreach (var condition in conditions)
                {
                    if (!columnsWithConditions.Add(condition.ColumnName))
                    {
                        AddToSchemaErrorWithMessage(
                            Strings.Mapping_InvalidContent_Duplicate_Condition_Member(condition.ColumnName),
                            StorageMappingErrorCode.ConditionError,
                            m_sourceLocation, lineInfo, m_parsingErrors);
                        errorFound = true;
                    }
                }
            }
            return !errorFound;
        }

        private void LoadFunctionImportStructuralTypeMappingScalarProperty(
            XPathNavigator nav,
            Collection<FunctionImportReturnTypePropertyMapping> columnRenameMappings,
            IEnumerable<StructuralType> currentTypes)
        {
            var lineInfo = new LineInfo(nav);
            string memberName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ScalarPropertyNameAttribute);
            string columnName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ScalarPropertyColumnNameAttribute);

            // Negative case: the property name is invalid
            if (!currentTypes.All(t=>t.Members.Contains(memberName)))
            {
                AddToSchemaErrorWithMessage(
                    Strings.Mapping_InvalidContent_Cdm_Member(memberName),
                    StorageMappingErrorCode.InvalidEdmMember,
                    m_sourceLocation, lineInfo, m_parsingErrors);
            }

            if (columnRenameMappings.Any(m => m.CMember == memberName))
            {
                // Negative case: duplicate member name mapping in one type rename mapping
                AddToSchemaErrorWithMessage(
                    Strings.Mapping_InvalidContent_Duplicate_Cdm_Member(memberName),
                    StorageMappingErrorCode.DuplicateMemberMapping,
                    m_sourceLocation, lineInfo, m_parsingErrors);
            }
            else
            {
                columnRenameMappings.Add(new FunctionImportReturnTypeScalarPropertyMapping(memberName, columnName, lineInfo));
            }
        }

        private bool TryCreateFunctionImportMappingComposableWithStructuralResult(
            EdmFunction functionImport,
            EdmFunction cTypeTargetFunction,
            List<FunctionImportStructuralTypeMapping> typeMappings,
            StructuralType structuralResultType,
            RowType cTypeTvfElementType,
            RowType sTypeTvfElementType,
            IXmlLineInfo lineInfo,
            out FunctionImportMappingComposable mapping)
        {
            mapping = null;

            // If it is an implicit structural type mapping, add a type mapping fragment for the return type of the function import,
            // unless it is an abstract type.
            if (typeMappings.Count == 0)
            {
                StructuralType resultType;
                if (MetadataHelper.TryGetFunctionImportReturnType<StructuralType>(functionImport, 0, out resultType))
                {
                    if (resultType.Abstract)
                    {
                        AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_FunctionImport_ImplicitMappingForAbstractReturnType,
                            resultType.FullName, functionImport.Identity,
                            StorageMappingErrorCode.MappingOfAbstractType, m_sourceLocation, lineInfo, m_parsingErrors);
                        return false;
                    }
                    if (resultType.BuiltInTypeKind == BuiltInTypeKind.EntityType)
                    {
                        typeMappings.Add(new FunctionImportEntityTypeMapping(
                            Enumerable.Empty<EntityType>(),
                            new EntityType[] { (EntityType)resultType },
                            Enumerable.Empty<FunctionImportEntityTypeMappingCondition>(),
                            new Collection<FunctionImportReturnTypePropertyMapping>(),
                            new LineInfo(lineInfo)));
                    }
                    else
                    {
                        Debug.Assert(resultType.BuiltInTypeKind == BuiltInTypeKind.ComplexType, "resultType.BuiltInTypeKind == BuiltInTypeKind.ComplexType");
                        typeMappings.Add(new FunctionImportComplexTypeMapping(
                            (ComplexType)resultType,
                            new Collection<FunctionImportReturnTypePropertyMapping>(),
                            new LineInfo(lineInfo)));
                    }
                }
            }

            // Validate and convert FunctionImportEntityTypeMapping elements into structure suitable for composable function import mapping.
            var functionImportKB = new FunctionImportStructuralTypeMappingKB(typeMappings, this.EdmItemCollection);

            var structuralTypeMappings = new List<Tuple<StructuralType, List<StorageConditionPropertyMapping>, List<StoragePropertyMapping>>>();
            EdmProperty[] targetFunctionKeys = null;
            if (functionImportKB.MappedEntityTypes.Count > 0)
            {
                // Validate TPH ambiguity.
                if (!functionImportKB.ValidateTypeConditions(/*validateAmbiguity: */true, m_parsingErrors, m_sourceLocation))
                {
                    return false;
                }

                // For each mapped entity type, prepare list of conditions and list of property mappings.
                for (int i = 0; i < functionImportKB.MappedEntityTypes.Count; ++i)
                {
                    List<StorageConditionPropertyMapping> typeConditions;
                    List<StoragePropertyMapping> propertyMappings;
                    if (TryConvertToEntityTypeConditionsAndPropertyMappings(
                            functionImport,
                            functionImportKB,
                            i,
                            cTypeTvfElementType,
                            sTypeTvfElementType,
                            lineInfo, out typeConditions, out propertyMappings))
                    {
                        structuralTypeMappings.Add(Tuple.Create((StructuralType)functionImportKB.MappedEntityTypes[i], typeConditions, propertyMappings));
                    }
                }
                if (structuralTypeMappings.Count < functionImportKB.MappedEntityTypes.Count)
                {
                    // Some of the entity types produced errors during conversion, exit.
                    return false;
                }

                // Infer target function keys based on the c-space entity types.
                if (!TryInferTVFKeys(structuralTypeMappings, out targetFunctionKeys))
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_FunctionImport_CannotInferTargetFunctionKeys, functionImport.Identity,
                        StorageMappingErrorCode.MappingFunctionImportCannotInferTargetFunctionKeys, m_sourceLocation, lineInfo, m_parsingErrors);
                    return false;
                }
            }
            else
            {
                ComplexType resultComplexType;
                if (MetadataHelper.TryGetFunctionImportReturnType<ComplexType>(functionImport, 0, out resultComplexType))
                {
                    // Gather and validate complex type property mappings.
                    List<StoragePropertyMapping> propertyMappings;
                    if (!TryConvertToProperyMappings(resultComplexType, cTypeTvfElementType, sTypeTvfElementType, functionImport, functionImportKB, lineInfo, out propertyMappings))
                    {
                        return false;
                    }
                    structuralTypeMappings.Add(Tuple.Create((StructuralType)resultComplexType, new List<StorageConditionPropertyMapping>(), propertyMappings));
                }
                else
                {
                    Debug.Fail("Function import return type is expected to be a collection of complex type.");
                }
            }

            mapping = new FunctionImportMappingComposable(
                functionImport,
                cTypeTargetFunction,
                structuralTypeMappings,
                targetFunctionKeys,
                m_storageMappingItemCollection,
                m_sourceLocation,
                new LineInfo(lineInfo));
            return true;
        }

        /// <summary>
        /// Attempts to infer key columns of the target function based on the function import mapping.
        /// </summary>
        internal static bool TryInferTVFKeys(List<Tuple<StructuralType, List<StorageConditionPropertyMapping>, List<StoragePropertyMapping>>> structuralTypeMappings, out EdmProperty[] keys)
        {
            keys = null;
            Debug.Assert(structuralTypeMappings.Count > 0, "Function import returning entities must have non-empty structuralTypeMappings.");
            foreach (var typeMapping in structuralTypeMappings)
            {
                EdmProperty[] currentKeys;
                if (!TryInferTVFKeysForEntityType((EntityType)typeMapping.Item1, typeMapping.Item3, out currentKeys))
                {
                    keys = null;
                    return false;
                }
                if (keys == null)
                {
                    keys = currentKeys;
                }
                else
                {
                    // Make sure all keys are mapped to the same columns.
                    Debug.Assert(keys.Length == currentKeys.Length, "All subtypes must have the same number of keys.");
                    for (int i = 0; i < keys.Length; ++i)
                    {
                        if (!keys[i].EdmEquals(currentKeys[i]))
                        {
                            keys = null;
                            return false;
                        }
                    }
                }
            }
            // Make sure columns are non-nullable, otherwise it shouldn't be considered a key.
            for (int i = 0; i < keys.Length; ++i)
            {
                if (keys[i].Nullable)
                {
                    keys = null;
                    return false;
                }
            }
            return true;
        }

        private static bool TryInferTVFKeysForEntityType(EntityType entityType, List<StoragePropertyMapping> propertyMappings, out EdmProperty[] keys)
        {
            keys = new EdmProperty[entityType.KeyMembers.Count];
            for (int i = 0; i < keys.Length; ++i)
            {
                var mapping = propertyMappings[entityType.Properties.IndexOf((EdmProperty)entityType.KeyMembers[i])] as StorageScalarPropertyMapping;
                if (mapping == null)
                {
                    keys = null;
                    return false;
                }
                keys[i] = mapping.ColumnProperty;
            }
            return true;
        }

        private bool TryCreateFunctionImportMappingComposableWithScalarResult(
            EdmFunction functionImport,
            EdmFunction cTypeTargetFunction,
            EdmFunction sTypeTargetFunction,
            EdmType scalarResultType,
            RowType cTypeTvfElementType,
            RowType sTypeTvfElementType,
            IXmlLineInfo lineInfo,
            out FunctionImportMappingComposable mapping)
        {
            mapping = null;

            // Make sure that TVF returns exactly one column
            if (cTypeTvfElementType.Properties.Count > 1)
            {
                AddToSchemaErrors(Strings.Mapping_FunctionImport_ScalarMappingToMulticolumnTVF(functionImport.Identity, sTypeTargetFunction.Identity),
                    StorageMappingErrorCode.MappingFunctionImportScalarMappingToMulticolumnTVF, m_sourceLocation, lineInfo, m_parsingErrors);
                return false;
            }

            // Make sure that scalarResultType agrees with the column type.
            if (!ValidateFunctionImportMappingResultTypeCompatibility(TypeUsage.Create(scalarResultType), cTypeTvfElementType.Properties[0].TypeUsage))
            {

                AddToSchemaErrors(Strings.Mapping_FunctionImport_ScalarMappingTypeMismatch(
                    functionImport.ReturnParameter.TypeUsage.EdmType.FullName,
                    functionImport.Identity,
                    sTypeTargetFunction.ReturnParameter.TypeUsage.EdmType.FullName,
                    sTypeTargetFunction.Identity),
                    StorageMappingErrorCode.MappingFunctionImportScalarMappingTypeMismatch, m_sourceLocation, lineInfo, m_parsingErrors);
                return false;
            }

            mapping = new FunctionImportMappingComposable(
                functionImport,
                cTypeTargetFunction,
                null,
                null,
                m_storageMappingItemCollection,
                m_sourceLocation,
                new LineInfo(lineInfo));
            return true;
        }

        private bool ValidateFunctionImportMappingResultTypeCompatibility(TypeUsage cSpaceMemberType, TypeUsage sSpaceMemberType)
        {
            // Function result data flows from S-side to C-side.
            var fromType = sSpaceMemberType;
            var toType = ResolveTypeUsageForEnums(cSpaceMemberType);

            bool directlyPromotable = TypeSemantics.IsStructurallyEqualOrPromotableTo(fromType, toType);
            bool inverselyPromotable = TypeSemantics.IsStructurallyEqualOrPromotableTo(toType, fromType);

            // We are quite lax here. We only require that values belong to the same class (can flow in one or the other direction).
            // We could require precisely s-type to be promotable to c-type, but in this case it won't be possible to reuse the same 
            // c-types for mapped functions and entity sets, because entity sets (read-write) require c-types to be promotable to s-types.
            return directlyPromotable || inverselyPromotable;
        }

        private void LoadFunctionImportEntityTypeMappingCondition(XPathNavigator nav, List<FunctionImportEntityTypeMappingCondition> conditions)
        {
            var lineInfo = new LineInfo(nav);

            string columnName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ConditionColumnNameAttribute);
            string value = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ConditionValueAttribute);
            string isNull = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ConditionIsNullAttribute);

            //Either Value or NotNull need to be specifid on the condition mapping but not both
            if ((isNull != null) && (value != null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_Both_Values,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, lineInfo, m_parsingErrors);
            }
            else if ((isNull == null) && (value == null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_Either_Values,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, lineInfo, m_parsingErrors);
            }
            else
            {
                if (isNull != null)
                {
                    bool isNullValue = Convert.ToBoolean(isNull, CultureInfo.InvariantCulture);
                    conditions.Add(new FunctionImportEntityTypeMappingConditionIsNull(columnName, isNullValue, lineInfo));
                }
                else
                {
                    XPathNavigator columnValue = nav.Clone();
                    columnValue.MoveToAttribute(StorageMslConstructs.ConditionValueAttribute, string.Empty);
                    conditions.Add(new FunctionImportEntityTypeMappingConditionValue(columnName, columnValue, lineInfo));
                }
            }
        }

        private bool TryConvertToEntityTypeConditionsAndPropertyMappings(
            EdmFunction functionImport,
            FunctionImportStructuralTypeMappingKB functionImportKB,
            int typeID,
            RowType cTypeTvfElementType,
            RowType sTypeTvfElementType,
            IXmlLineInfo navLineInfo,
            out List<StorageConditionPropertyMapping> typeConditions,
            out List<StoragePropertyMapping> propertyMappings)
        {
            var entityType = functionImportKB.MappedEntityTypes[typeID];
            typeConditions = new List<StorageConditionPropertyMapping>();

            bool errorFound = false;

            // Gather and validate entity type conditions from the type-producing fragments.
            foreach (var entityTypeMapping in functionImportKB.NormalizedEntityTypeMappings.Where(f => f.ImpliedEntityTypes[typeID]))
            {
                foreach (var condition in entityTypeMapping.ColumnConditions.Where(c => c != null))
                {
                    EdmProperty column;
                    if (sTypeTvfElementType.Properties.TryGetValue(condition.ColumnName, false, out column))
                    {
                        object value;
                        bool? isNull;
                        if (condition.ConditionValue.IsSentinel)
                        {
                            value = null;
                            if (condition.ConditionValue == ValueCondition.IsNull)
                            {
                                isNull = true;
                            }
                            else
                            {
                                Debug.Assert(condition.ConditionValue == ValueCondition.IsNotNull, "Only IsNull or IsNotNull condition values are expected.");
                                isNull = false;
                            }
                        }
                        else
                        {
                            var cTypeColumn = cTypeTvfElementType.Properties[column.Name];
                            Debug.Assert(cTypeColumn != null, "cTypeColumn != null");
                            Debug.Assert(Helper.IsPrimitiveType(cTypeColumn.TypeUsage.EdmType), "S-space columns are expected to be of a primitive type.");
                            var cPrimitiveType = (PrimitiveType)cTypeColumn.TypeUsage.EdmType;
                            Debug.Assert(cPrimitiveType.ClrEquivalentType != null, "Scalar Types should have associated clr type");
                            Debug.Assert(condition is FunctionImportEntityTypeMappingConditionValue, "Non-sentinel condition is expected to be of type FunctionImportEntityTypeMappingConditionValue.");
                            value = ((FunctionImportEntityTypeMappingConditionValue)condition).GetConditionValue(
                                cPrimitiveType.ClrEquivalentType,
                                handleTypeNotComparable: () =>
                                {
                                    AddToSchemaErrorWithMemberAndStructure(
                                        Strings.Mapping_InvalidContent_ConditionMapping_InvalidPrimitiveTypeKind, column.Name, column.TypeUsage.EdmType.FullName,
                                        StorageMappingErrorCode.ConditionError,
                                        m_sourceLocation, condition.LineInfo, m_parsingErrors);
                                },
                                handleInvalidConditionValue: () =>
                                {
                                    AddToSchemaErrors(
                                        Strings.Mapping_ConditionValueTypeMismatch,
                                        StorageMappingErrorCode.ConditionError,
                                        m_sourceLocation, condition.LineInfo, m_parsingErrors);
                                });
                            if (value == null)
                            {
                                errorFound = true;
                                continue;
                            }
                            isNull = null;
                        }
                        typeConditions.Add(new StorageConditionPropertyMapping(null, column, value, isNull));
                    }
                    else
                    {
                        AddToSchemaErrorsWithMemberInfo(
                            Strings.Mapping_InvalidContent_Column, condition.ColumnName,
                            StorageMappingErrorCode.InvalidStorageMember,
                            m_sourceLocation, condition.LineInfo, m_parsingErrors);
                    }
                }
            }

            // Gather and validate entity type property mappings.
            errorFound |= !TryConvertToProperyMappings(entityType, cTypeTvfElementType, sTypeTvfElementType, functionImport, functionImportKB, navLineInfo, out propertyMappings);

            return !errorFound;
        }

        private bool TryConvertToProperyMappings(
            StructuralType structuralType,
            RowType cTypeTvfElementType,
            RowType sTypeTvfElementType,
            EdmFunction functionImport,
            FunctionImportStructuralTypeMappingKB functionImportKB,
            IXmlLineInfo navLineInfo,
            out List<StoragePropertyMapping> propertyMappings)
        {
            propertyMappings = new List<StoragePropertyMapping>();

            // Gather and validate structuralType property mappings.
            bool errorFound = false;
            foreach (EdmProperty property in Common.TypeHelpers.GetAllStructuralMembers(structuralType))
            {
                // Only scalar property mappings are supported at the moment.
                if (!Helper.IsScalarType(property.TypeUsage.EdmType))
                {
                    EdmSchemaError error = new EdmSchemaError(
                        Strings.Mapping_Invalid_CSide_ScalarProperty(property.Name),
                        (int)StorageMappingErrorCode.InvalidTypeInScalarProperty,
                        EdmSchemaErrorSeverity.Error,
                        m_sourceLocation, navLineInfo.LineNumber, navLineInfo.LinePosition);
                    m_parsingErrors.Add(error);
                    errorFound = true;
                    continue;
                }

                string columnName = null;
                IXmlLineInfo columnMappingLineInfo = null;
                FunctionImportReturnTypeStructuralTypeColumnRenameMapping columnRenameMapping;
                bool explicitPropertyMapping;
                if (functionImportKB.ReturnTypeColumnsRenameMapping.TryGetValue(property.Name, out columnRenameMapping))
                {
                    explicitPropertyMapping = true;
                    columnName = columnRenameMapping.GetRename(structuralType, out columnMappingLineInfo);
                }
                else
                {
                    explicitPropertyMapping = false;
                    columnName = property.Name;
                }
                columnMappingLineInfo = columnMappingLineInfo != null && columnMappingLineInfo.HasLineInfo() ? columnMappingLineInfo : navLineInfo;

                EdmProperty column;
                if (sTypeTvfElementType.Properties.TryGetValue(columnName, false, out column))
                {
                    Debug.Assert(cTypeTvfElementType.Properties.Contains(columnName), "cTypeTvfElementType.Properties.Contains(columnName)");
                    var cTypeColumn = cTypeTvfElementType.Properties[columnName];
                    if (ValidateFunctionImportMappingResultTypeCompatibility(property.TypeUsage, cTypeColumn.TypeUsage))
                    {
                        propertyMappings.Add(new StorageScalarPropertyMapping(property, column));
                    }
                    else
                    {
                        EdmSchemaError error = new EdmSchemaError(
                            GetInvalidMemberMappingErrorMessage(property, column),
                            (int)StorageMappingErrorCode.IncompatibleMemberMapping,
                            EdmSchemaErrorSeverity.Error,
                            m_sourceLocation, columnMappingLineInfo.LineNumber, columnMappingLineInfo.LinePosition);
                        m_parsingErrors.Add(error);
                    }
                }
                else
                {
                    if (explicitPropertyMapping)
                    {
                        AddToSchemaErrorsWithMemberInfo(
                            Strings.Mapping_InvalidContent_Column, columnName,
                            StorageMappingErrorCode.InvalidStorageMember,
                            m_sourceLocation, columnMappingLineInfo, m_parsingErrors);
                    }
                    else
                    {
                        var error = new EdmSchemaError(
                            Strings.Mapping_FunctionImport_PropertyNotMapped(property.Name, structuralType.FullName, functionImport.Identity),
                            (int)StorageMappingErrorCode.MappingFunctionImportReturnTypePropertyNotMapped,
                            EdmSchemaErrorSeverity.Error,
                            m_sourceLocation, columnMappingLineInfo.LineNumber, columnMappingLineInfo.LinePosition);
                        m_parsingErrors.Add(error);
                        errorFound = true;
                    }
                }
            }

            // Make sure that propertyMappings is in the order of properties of the structuredType.
            // The rest of the code depends on it.
            Debug.Assert(errorFound ||
                Common.TypeHelpers.GetAllStructuralMembers(structuralType).Count == propertyMappings.Count &&
                Common.TypeHelpers.GetAllStructuralMembers(structuralType).Cast<EdmMember>().Zip(propertyMappings)
                    .All(ppm => ppm.Key.EdmEquals(ppm.Value.EdmProperty)), "propertyMappings order does not correspond to the order of properties in the structuredType.");

            return !errorFound;
        }
        #endregion

        /// <summary>
        /// The method loads the child nodes for the AssociationType Mapping node
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="associationSetMapping"></param>
        /// <param name="associationTypeName"></param>
        /// <param name="tableName"></param>
        /// <param name="storageEntityContainerType"></param>
        private void LoadAssociationTypeMapping(XPathNavigator nav, StorageAssociationSetMapping associationSetMapping, string associationTypeName, string tableName, EntityContainer storageEntityContainerType)
        {
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            //Get the association type for association type name specified in MSL
            //If no AssociationType with the given name exists, add a schema error and return
            AssociationType associationType;
            this.EdmItemCollection.TryGetItem<AssociationType>(associationTypeName, out associationType);
            if (associationType == null)
            {
                //There is no point in continuing loading if the AssociationType is null
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Association_Type, associationTypeName,
                    StorageMappingErrorCode.InvalidAssociationType, m_sourceLocation, navLineInfo, m_parsingErrors);
                return;
            }
            //Verify that AssociationType specified should be the declared type of
            //AssociationSet or a derived Type of it.
            //Future Enhancement : Change the code to use EdmEquals
            if ((!(associationSetMapping.Set.ElementType.Equals(associationType))))
            {
                AddToSchemaErrorWithMessage(Strings.Mapping_Invalid_Association_Type_For_Association_Set(associationTypeName,
                    associationSetMapping.Set.ElementType.FullName, associationSetMapping.Set.Name),
                    StorageMappingErrorCode.DuplicateTypeMapping, m_sourceLocation, navLineInfo, m_parsingErrors);
                return;
            }

            //Create an AssociationTypeMapping to hold the information for AssociationType mapping.
            StorageAssociationTypeMapping associationTypeMapping = new StorageAssociationTypeMapping(associationType, associationSetMapping);
            associationSetMapping.AddTypeMapping(associationTypeMapping);
            //If the table name was not specified on the AssociationSetMapping element 
            //Then there should have been a query view. Otherwise throw.
            if (String.IsNullOrEmpty(tableName) && (associationSetMapping.QueryView == null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_Table_Expected, StorageMappingErrorCode.InvalidTable,
                    m_sourceLocation, navLineInfo, m_parsingErrors);
            }
            else
            {
                StorageMappingFragment fragment = LoadAssociationMappingFragment(nav.Clone(), associationSetMapping, associationTypeMapping, tableName, storageEntityContainerType);
                if (fragment != null)
                {
                    //Fragment can be null because of validation errors
                    associationTypeMapping.AddFragment(fragment);
                }
            }
        }

        /// <summary>
        /// Loads function mappings for the entity type.
        /// </summary>
        /// <param name="associationSetMapping"></param>
        /// <param name="associationTypeMapping"></param>
        /// <param name="nav"></param>
        private void LoadAssociationTypeModificationFunctionMapping(
            XPathNavigator nav,
            StorageAssociationSetMapping associationSetMapping,
            StorageAssociationTypeMapping associationTypeMapping)
        {
            // create function loader
            ModificationFunctionMappingLoader functionLoader = new ModificationFunctionMappingLoader(this, associationSetMapping.Set);

            // Load all function definitions (for insert, delete and update)
            StorageModificationFunctionMapping deleteFunctionMapping = null;
            StorageModificationFunctionMapping insertFunctionMapping = null;
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                do
                {
                    switch (nav.LocalName)
                    {
                        case StorageMslConstructs.DeleteFunctionElement:
                            deleteFunctionMapping = functionLoader.LoadAssociationSetModificationFunctionMapping(nav.Clone(), associationSetMapping.Set, false);
                            break;
                        case StorageMslConstructs.InsertFunctionElement:
                            insertFunctionMapping = functionLoader.LoadAssociationSetModificationFunctionMapping(nav.Clone(), associationSetMapping.Set, true);
                            break;
                    }
                } while (nav.MoveToNext(XPathNodeType.Element));
            }

            // register function mapping information
            associationSetMapping.ModificationFunctionMapping = new StorageAssociationSetModificationFunctionMapping(
                (AssociationSet)associationSetMapping.Set, deleteFunctionMapping, insertFunctionMapping);
        }

        /// <summary>
        /// The method loads the child nodes for the TableMappingFragment under the EntityType node
        /// into the internal datastructures.
        /// </summary>
        private StorageMappingFragment LoadMappingFragment(
            XPathNavigator nav,
            StorageEntityTypeMapping typeMapping,
            string tableName,
            EntityContainer storageEntityContainerType,
            bool distinctFlag)
        {
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            //First make sure that there was no QueryView specified for this Set
            if (typeMapping.SetMapping.QueryView != null)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_QueryView_PropertyMaps, typeMapping.SetMapping.Set.Name,
                    StorageMappingErrorCode.PropertyMapsWithQueryView, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }

            //Get the table type that represents this table
            EntitySet tableMember;
            storageEntityContainerType.TryGetEntitySetByName(tableName, false /*ignoreCase*/, out tableMember);
            if (tableMember == null)
            {
                //There is no point in continuing loading if the Table on S side can not be found
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Table, tableName,
                    StorageMappingErrorCode.InvalidTable, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }
            EntityType tableType = tableMember.ElementType;
            //Create a table mapping fragment to hold the mapping information for a TableMappingFragment node
            StorageMappingFragment fragment = new StorageMappingFragment(tableMember, typeMapping, distinctFlag);
            //Set the Start Line Information on Fragment
            fragment.StartLineNumber = navLineInfo.LineNumber;
            fragment.StartLinePosition = navLineInfo.LinePosition;

            //Go through the property mappings for this TableMappingFragment and load them in memory.
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                do
                {
                    //need to get the type that this member exists in
                    EdmType containerType = null;
                    string propertyName = StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.ComplexPropertyNameAttribute);
                    //PropertyName could be null for Condition Maps
                    if (propertyName != null)
                    {
                        containerType = typeMapping.GetContainerType(propertyName);
                    }
                    switch (nav.LocalName)
                    {
                        case StorageMslConstructs.ScalarPropertyElement:
                            StorageScalarPropertyMapping scalarMap = LoadScalarPropertyMapping(nav.Clone(), containerType, tableType.Properties);
                            if (scalarMap != null)
                            {
                                //scalarMap can be null in invalid cases
                                fragment.AddProperty(scalarMap);
                            }
                            break;
                        case StorageMslConstructs.ComplexPropertyElement:
                            StorageComplexPropertyMapping complexMap =
                                LoadComplexPropertyMapping(nav.Clone(), containerType, tableType.Properties);
                            //Complex Map can be null in case of invalid MSL files.
                            if (complexMap != null)
                            {
                                fragment.AddProperty(complexMap);
                            }
                            break;
                        case StorageMslConstructs.ConditionElement:
                            StorageConditionPropertyMapping conditionMap =
                                LoadConditionPropertyMapping(nav.Clone(), containerType, tableType.Properties);
                            //conditionMap can be null in cases of invalid Map
                            if (conditionMap != null)
                            {
                                fragment.AddConditionProperty(conditionMap, duplicateMemberConditionError: (member) =>
                                    {
                                        AddToSchemaErrorsWithMemberInfo(
                                                            Strings.Mapping_InvalidContent_Duplicate_Condition_Member, member.Name,
                                                            StorageMappingErrorCode.ConditionError,
                                                            m_sourceLocation, navLineInfo, m_parsingErrors);
                                    });
                            }
                            break;
                        default:
                            AddToSchemaErrors(Strings.Mapping_InvalidContent_General,
                                StorageMappingErrorCode.InvalidContent, m_sourceLocation, navLineInfo, m_parsingErrors);
                            break;
                    }
                } while (nav.MoveToNext(XPathNodeType.Element));
            }

            nav.MoveToChild(XPathNodeType.Element);
            return fragment;
        }

        /// <summary>
        /// The method loads the child nodes for the TableMappingFragment under the AssociationType node
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="typeMapping"></param>
        /// <param name="setMapping"></param>
        /// <param name="tableName"></param>
        /// <param name="storageEntityContainerType"></param>
        /// <returns></returns>
        private StorageMappingFragment LoadAssociationMappingFragment(XPathNavigator nav, StorageAssociationSetMapping setMapping, StorageAssociationTypeMapping typeMapping, string tableName, EntityContainer storageEntityContainerType)
        {
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;
            StorageMappingFragment fragment = null;
            EntityType tableType = null;

            //If there is a query view, Dont create a mapping fragment since there should n't be one
            if (setMapping.QueryView == null)
            {
                //Get the table type that represents this table
                EntitySet tableMember;
                storageEntityContainerType.TryGetEntitySetByName(tableName, false /*ignoreCase*/, out tableMember);
                if (tableMember == null)
                {
                    //There is no point in continuing loading if the Table is null
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Table, tableName,
                        StorageMappingErrorCode.InvalidTable, m_sourceLocation, navLineInfo, m_parsingErrors);
                    return null;
                }
                tableType = tableMember.ElementType;
                //Create a Mapping fragment and load all the End node under it
                fragment = new StorageMappingFragment(tableMember, typeMapping, false /*No distinct flag*/);
                //Set the Start Line Information on Fragment, For AssociationSet there are 
                //no fragments, so the start Line Info is same as that of Set
                fragment.StartLineNumber = setMapping.StartLineNumber;
                fragment.StartLinePosition = setMapping.StartLinePosition;
            }

            do
            {
                //need to get the type that this member exists in
                switch (nav.LocalName)
                {
                    case StorageMslConstructs.EndPropertyMappingElement:
                        //Make sure that there was no QueryView specified for this Set
                        if (setMapping.QueryView != null)
                        {
                            AddToSchemaErrorsWithMemberInfo(Strings.Mapping_QueryView_PropertyMaps, setMapping.Set.Name,
                                StorageMappingErrorCode.PropertyMapsWithQueryView, m_sourceLocation, navLineInfo, m_parsingErrors);
                            return null;
                        }
                        string endName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.EndPropertyMappingNameAttribute);
                        EdmMember endMember = null;
                        typeMapping.AssociationType.Members.TryGetValue(endName, false, out endMember);
                        AssociationEndMember end = endMember as AssociationEndMember;
                        if (end == null)
                        {
                            //Don't try to load the end property map if the end property itself is null
                            AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_End, endName,
                                StorageMappingErrorCode.InvalidEdmMember, m_sourceLocation, navLineInfo, m_parsingErrors);
                            continue;
                        }
                        fragment.AddProperty((LoadEndPropertyMapping(nav.Clone(), end, tableType)));
                        break;
                    case StorageMslConstructs.ConditionElement:
                        //Make sure that there was no QueryView specified for this Set
                        if (setMapping.QueryView != null)
                        {
                            AddToSchemaErrorsWithMemberInfo(Strings.Mapping_QueryView_PropertyMaps, setMapping.Set.Name,
                                StorageMappingErrorCode.PropertyMapsWithQueryView, m_sourceLocation, navLineInfo, m_parsingErrors);
                            return null;
                        }
                        //Need to add validation for conditions in Association mapping fragment.
                        StorageConditionPropertyMapping conditionMap = LoadConditionPropertyMapping(nav.Clone(), null /*containerType*/, tableType.Properties);
                        //conditionMap can be null in cases of invalid Map
                        if (conditionMap != null)
                        {
                            fragment.AddConditionProperty(conditionMap, duplicateMemberConditionError: (member) =>
                                {
                                    AddToSchemaErrorsWithMemberInfo(
                                        Strings.Mapping_InvalidContent_Duplicate_Condition_Member, member.Name,
                                        StorageMappingErrorCode.ConditionError,
                                        m_sourceLocation, navLineInfo, m_parsingErrors);
                                });
                        }
                        break;
                    case StorageMslConstructs.ModificationFunctionMappingElement:
                        setMapping.HasModificationFunctionMapping = true;
                        LoadAssociationTypeModificationFunctionMapping(nav.Clone(), setMapping, typeMapping);
                        break;
                    default:
                        AddToSchemaErrors(Strings.Mapping_InvalidContent_General,
                            StorageMappingErrorCode.InvalidContent, m_sourceLocation, navLineInfo, m_parsingErrors);
                        break;
                }
            } while (nav.MoveToNext(XPathNodeType.Element));

            return fragment;
        }

        /// <summary>
        /// The method loads the ScalarProperty mapping
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="containerType"></param>
        /// <param name="tableType"></param>
        /// <returns></returns>
        private StorageScalarPropertyMapping LoadScalarPropertyMapping(XPathNavigator nav, EdmType containerType, ReadOnlyMetadataCollection<EdmProperty> tableProperties)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            //Get the property name from MSL.
            string propertyName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ScalarPropertyNameAttribute);
            EdmProperty member = null;
            if (!String.IsNullOrEmpty(propertyName))
            {
                //If the container type is a collection type, there wouldn't be a member to represent this scalar property
                if (containerType == null || !(Helper.IsCollectionType(containerType)))
                {
                    //If container type is null that means we have not found the member in any of the IsOfTypes.
                    if (containerType != null)
                    {
                        if (Helper.IsRefType(containerType))
                        {
                            RefType refType = (RefType)containerType;
                            ((EntityType)refType.ElementType).Properties.TryGetValue(propertyName, false /*ignoreCase*/, out member);
                        }
                        else
                        {
                            EdmMember tempMember;
                            (containerType as StructuralType).Members.TryGetValue(propertyName, false, out tempMember);
                            member = tempMember as EdmProperty;
                        }
                    }
                    if (member == null)
                    {
                        AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Cdm_Member, propertyName,
                            StorageMappingErrorCode.InvalidEdmMember, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
                    }
                }
            }
            //Get the property from Storeside
            string columnName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ScalarPropertyColumnNameAttribute);
            Debug.Assert(columnName != null, "XSD validation should have caught this");
            EdmProperty columnMember;
            tableProperties.TryGetValue(columnName, false, out columnMember);
            if (columnMember == null)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Column, columnName,
                    StorageMappingErrorCode.InvalidStorageMember, m_sourceLocation, xmlLineInfoNav, m_parsingErrors);
            }
            //Don't create scalar property map if the property or column metadata is null
            if ((member == null) || (columnMember == null))
            {
                return null;
            }

            if (!Helper.IsScalarType(member.TypeUsage.EdmType))
            {
                EdmSchemaError error = new EdmSchemaError(
                    Strings.Mapping_Invalid_CSide_ScalarProperty(
                        member.Name),
                    (int)StorageMappingErrorCode.InvalidTypeInScalarProperty,
                    EdmSchemaErrorSeverity.Error,
                    m_sourceLocation,
                    xmlLineInfoNav.LineNumber,
                    xmlLineInfoNav.LinePosition);
                m_parsingErrors.Add(error);
                return null;
            }

            ValidateAndUpdateScalarMemberMapping(member, columnMember, xmlLineInfoNav);
            StorageScalarPropertyMapping scalarPropertyMapping = new StorageScalarPropertyMapping(member, columnMember);
            return scalarPropertyMapping;
        }

        /// <summary>
        /// The method loads the ComplexProperty mapping into the internal datastructures.
        /// </summary>
        private StorageComplexPropertyMapping LoadComplexPropertyMapping(XPathNavigator nav, EdmType containerType, ReadOnlyMetadataCollection<EdmProperty> tableProperties)
        {
            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            CollectionType collectionType = containerType as CollectionType;
            //Get the property name from MSL
            string propertyName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ComplexPropertyNameAttribute);
            //Get the member metadata from the contianer type passed in.
            //But if the continer type is collection type, there would n't be any member to represent the member.
            EdmProperty member = null;
            EdmType memberType = null;
            //If member specified the type name, it takes precedence
            string memberTypeName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ComplexTypeMappingTypeNameAttribute);
            StructuralType containerStructuralType = containerType as StructuralType;

            if (String.IsNullOrEmpty(memberTypeName))
            {
                if (collectionType == null)
                {
                    if (containerStructuralType != null)
                    {
                        EdmMember tempMember;
                        containerStructuralType.Members.TryGetValue(propertyName, false /*ignoreCase*/, out tempMember);
                        member = tempMember as EdmProperty;
                        if (member == null)
                        {
                            AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Cdm_Member, propertyName,
                                StorageMappingErrorCode.InvalidEdmMember, m_sourceLocation, navLineInfo, m_parsingErrors);
                        }
                        memberType = member.TypeUsage.EdmType;
                    }
                    else
                    {
                        AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Cdm_Member, propertyName,
                                                   StorageMappingErrorCode.InvalidEdmMember, m_sourceLocation, navLineInfo, m_parsingErrors);
                    }
                }
                else
                {
                    memberType = collectionType.TypeUsage.EdmType;
                }
            }
            else
            {
                //If container type is null that means we have not found the member in any of the IsOfTypes.
                if (containerType != null)
                {
                    EdmMember tempMember;
                    containerStructuralType.Members.TryGetValue(propertyName, false /*ignoreCase*/, out tempMember);
                    member = tempMember as EdmProperty;
                }
                if (member == null)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Cdm_Member, propertyName,
                        StorageMappingErrorCode.InvalidEdmMember, m_sourceLocation, navLineInfo, m_parsingErrors);
                }
                this.EdmItemCollection.TryGetItem<EdmType>(memberTypeName, out memberType);
                memberType = memberType as ComplexType;
                // If member type is null, that means the type wasn't found in the workspace
                if (memberType == null)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Complex_Type, memberTypeName,
                        StorageMappingErrorCode.InvalidComplexType, m_sourceLocation, navLineInfo, m_parsingErrors);
                }
            }

            StorageComplexPropertyMapping complexPropertyMapping = new StorageComplexPropertyMapping(member);

            XPathNavigator cloneNav = nav.Clone();
            bool hasComplexTypeMappingElements = false;
            if (cloneNav.MoveToChild(XPathNodeType.Element))
            {
                if (cloneNav.LocalName == StorageMslConstructs.ComplexTypeMappingElement)
                {
                    hasComplexTypeMappingElements = true;
                }
            }

            //There is no point in continuing if the complex member or complex member type is null
            if ((member == null) || (memberType == null))
            {
                return null;
            }

            if (hasComplexTypeMappingElements)
            {
                nav.MoveToChild(XPathNodeType.Element);
                do
                {
                    complexPropertyMapping.AddTypeMapping(LoadComplexTypeMapping(nav.Clone(), null, tableProperties));
                }
                while (nav.MoveToNext(XPathNodeType.Element));
            }
            else
            {
                complexPropertyMapping.AddTypeMapping(LoadComplexTypeMapping(nav.Clone(), memberType, tableProperties));
            }
            return complexPropertyMapping;
        }

        private StorageComplexTypeMapping LoadComplexTypeMapping(XPathNavigator nav, EdmType type, ReadOnlyMetadataCollection<EdmProperty> tableType)
        {
            //Get the IsPartial attribute from MSL
            bool isPartial = false;
            string partialAttribute = StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.ComplexPropertyIsPartialAttribute);
            if (!String.IsNullOrEmpty(partialAttribute))
            {
                //XSD validation should have guarenteed that the attribute value can only be true or false
                Debug.Assert(partialAttribute == "true" || partialAttribute == "false");
                isPartial = Convert.ToBoolean(partialAttribute, System.Globalization.CultureInfo.InvariantCulture);
            }
            //Create an ComplexTypeMapping to hold the information for Type mapping.
            StorageComplexTypeMapping typeMapping = new StorageComplexTypeMapping(isPartial);
            if (type != null)
            {
                typeMapping.AddType(type as ComplexType);
            }
            else
            {
                Debug.Assert(nav.LocalName == StorageMslConstructs.ComplexTypeMappingElement);
                string typeName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ComplexTypeMappingTypeNameAttribute);
                int index = typeName.IndexOf(StorageMslConstructs.TypeNameSperator);
                string currentTypeName = null;
                do
                {
                    if (index != -1)
                    {
                        currentTypeName = typeName.Substring(0, index);
                        typeName = typeName.Substring(index + 1, (typeName.Length - (index + 1)));
                    }
                    else
                    {
                        currentTypeName = typeName;
                        typeName = string.Empty;
                    }

                    int isTypeOfIndex = currentTypeName.IndexOf(StorageMslConstructs.IsTypeOf, StringComparison.Ordinal);
                    if (isTypeOfIndex == 0)
                    {
                        currentTypeName = currentTypeName.Substring(StorageMslConstructs.IsTypeOf.Length, (currentTypeName.Length - (StorageMslConstructs.IsTypeOf.Length + 1)));
                        currentTypeName = GetAliasResolvedValue(currentTypeName);
                    }
                    else
                    {
                        currentTypeName = GetAliasResolvedValue(currentTypeName);
                    }
                    ComplexType complexType;
                    this.EdmItemCollection.TryGetItem<ComplexType>(currentTypeName, out complexType);
                    if (complexType == null)
                    {
                        AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_Complex_Type, currentTypeName,
                            StorageMappingErrorCode.InvalidComplexType, m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                        index = typeName.IndexOf(StorageMslConstructs.TypeNameSperator);
                        continue;
                    }
                    if (isTypeOfIndex == 0)
                    {
                        typeMapping.AddIsOfType(complexType);
                    }
                    else
                    {
                        typeMapping.AddType(complexType);
                    }
                    index = typeName.IndexOf(StorageMslConstructs.TypeNameSperator);
                } while (typeName.Length != 0);
            }

            //Now load the children of ComplexTypeMapping
            if (nav.MoveToChild(XPathNodeType.Element))
            {
                do
                {
                    EdmType containerType = typeMapping.GetOwnerType(StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.ComplexPropertyNameAttribute));
                    switch (nav.LocalName)
                    {
                        case StorageMslConstructs.ScalarPropertyElement:
                            StorageScalarPropertyMapping scalarMap =
                                LoadScalarPropertyMapping(nav.Clone(), containerType, tableType);
                            //ScalarMap can be null in case of invalid MSL files
                            if (scalarMap != null)
                            {
                                typeMapping.AddProperty(scalarMap);
                            }
                            break;
                        case StorageMslConstructs.ComplexPropertyElement:
                            StorageComplexPropertyMapping complexMap =
                                LoadComplexPropertyMapping(nav.Clone(), containerType, tableType);
                            //complexMap can be null in case of invalid maps
                            if (complexMap != null)
                            {
                                typeMapping.AddProperty(complexMap);
                            }
                            break;
                        case StorageMslConstructs.ConditionElement:
                            StorageConditionPropertyMapping conditionMap =
                                LoadConditionPropertyMapping(nav.Clone(), containerType, tableType);
                            if (conditionMap != null)
                            {
                                typeMapping.AddConditionProperty(conditionMap, duplicateMemberConditionError: (member) =>
                                    {
                                        AddToSchemaErrorsWithMemberInfo(
                                            Strings.Mapping_InvalidContent_Duplicate_Condition_Member, member.Name,
                                            StorageMappingErrorCode.ConditionError,
                                            m_sourceLocation, (IXmlLineInfo)nav, m_parsingErrors);
                                    });
                            }
                            break;
                        default:
                            throw System.Data.Entity.Error.NotSupported();
                    }
                } while (nav.MoveToNext(XPathNodeType.Element));
            }
            return typeMapping;

        }

        /// <summary>
        /// The method loads the EndProperty mapping
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="end"></param>
        /// <param name="tableType"></param>
        /// <returns></returns>
        private StorageEndPropertyMapping LoadEndPropertyMapping(XPathNavigator nav, AssociationEndMember end, EntityType tableType)
        {
            //FutureEnhancement : Change End Property Mapping to not derive from
            //                    StoragePropertyMapping
            StorageEndPropertyMapping endMapping = new StorageEndPropertyMapping(null);
            endMapping.EndMember = end;

            nav.MoveToChild(XPathNodeType.Element);
            do
            {
                switch (nav.LocalName)
                {
                    case StorageMslConstructs.ScalarPropertyElement:
                        RefType endRef = end.TypeUsage.EdmType as RefType;
                        Debug.Assert(endRef != null);
                        EntityTypeBase containerType = endRef.ElementType;
                        StorageScalarPropertyMapping scalarMap = LoadScalarPropertyMapping(nav.Clone(), containerType, tableType.Properties);
                        //Scalar Property Mapping can be null
                        //in case of invalid MSL files.
                        if (scalarMap != null)
                        {

                            //Make sure that the properties mapped as part of EndProperty maps are the key properties.
                            //If any other property is mapped, we should raise an error.
                            if (!containerType.KeyMembers.Contains(scalarMap.EdmProperty))
                            {
                                IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;
                                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_EndProperty, scalarMap.EdmProperty.Name,
                                    StorageMappingErrorCode.InvalidEdmMember, m_sourceLocation, navLineInfo, m_parsingErrors);
                                return null;

                            }
                            endMapping.AddProperty(scalarMap);
                        }
                        break;
                    default:
                        Debug.Fail("XSD validation should have ensured that End EdmProperty Maps only have Schalar properties");
                        break;
                }
            } while (nav.MoveToNext(XPathNodeType.Element));
            return endMapping;
        }

        /// <summary>
        /// The method loads the ConditionProperty mapping
        /// into the internal datastructures.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="containerType"></param>
        /// <param name="tableType"></param>
        /// <returns></returns>
        private StorageConditionPropertyMapping LoadConditionPropertyMapping(XPathNavigator nav, EdmType containerType, ReadOnlyMetadataCollection<EdmProperty> tableProperties)
        {
            //Get the CDM side property name.
            string propertyName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ConditionNameAttribute);
            //Get the Store side property name from Storeside
            string columnName = GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ConditionColumnNameAttribute);

            IXmlLineInfo navLineInfo = (IXmlLineInfo)nav;

            //Either the property name or column name can be specified but both can not be.
            if ((propertyName != null) && (columnName != null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_Both_Members,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }
            if ((propertyName == null) && (columnName == null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_Either_Members,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }

            EdmProperty member = null;
            //Get the CDM EdmMember reprsented by the name specified.
            if (propertyName != null)
            {
                EdmMember tempMember;
                //If container type is null that means we have not found the member in any of the IsOfTypes.
                if (containerType != null)
                {
                    ((StructuralType)containerType).Members.TryGetValue(propertyName, false /*ignoreCase*/, out tempMember);
                    member = tempMember as EdmProperty;
                }
            }

            //Get the column EdmMember represented by the column name specified
            EdmProperty columnMember = null;
            if (columnName != null)
            {
                tableProperties.TryGetValue(columnName, false, out columnMember);
            }

            //Get the member for which the condition is being specified
            EdmProperty conditionMember = (columnMember != null) ? columnMember : member;
            if (conditionMember == null)
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_ConditionMapping_InvalidMember, ((columnName != null) ? columnName : propertyName),
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }

            Nullable<bool> isNullValue = null;
            object value = null;
            //Get the attribute value for IsNull attribute
            string isNullAttribute = StorageMappingItemLoader.GetAttributeValue(nav.Clone(), StorageMslConstructs.ConditionIsNullAttribute);

            //Get strongly Typed value if the condition was specified for a specific condition
            EdmType edmType = conditionMember.TypeUsage.EdmType;
            if (Helper.IsPrimitiveType(edmType))
            {
                //Decide if the member is of a type that we would allow a condition on.
                //First convert the type to C space, if this is a condition in s space( before checking this).
                TypeUsage cspaceTypeUsage;
                if (conditionMember.DeclaringType.DataSpace == DataSpace.SSpace)
                {
                    cspaceTypeUsage = StoreItemCollection.StoreProviderManifest.GetEdmType(conditionMember.TypeUsage);
                    if (cspaceTypeUsage == null)
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_ProviderReturnsNullType(conditionMember.Name),
                            StorageMappingErrorCode.MappingStoreProviderReturnsNullEdmType,
                            m_sourceLocation, navLineInfo, m_parsingErrors);
                        return null;
                    }
                }
                else
                {
                    cspaceTypeUsage = conditionMember.TypeUsage;
                }
                PrimitiveType memberType = ((PrimitiveType)cspaceTypeUsage.EdmType);
                Type clrMemberType = memberType.ClrEquivalentType;
                PrimitiveTypeKind primitiveTypeKind = memberType.PrimitiveTypeKind;
                //Only a subset of primitive types can be used in Conditions that are specified over values.
                //IsNull conditions can be specified on any primitive types
                if ((isNullAttribute == null) && !IsTypeSupportedForCondition(primitiveTypeKind))
                {
                    AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_InvalidContent_ConditionMapping_InvalidPrimitiveTypeKind,
                        conditionMember.Name, edmType.FullName, StorageMappingErrorCode.ConditionError,
                        m_sourceLocation, navLineInfo, m_parsingErrors);
                    return null;
                }
                Debug.Assert(clrMemberType != null, "Scalar Types should have associated clr type");
                //If the value is not compatible with the type, just add an error and return
                if(!StorageMappingItemLoader.TryGetTypedAttributeValue(nav.Clone(), StorageMslConstructs.ConditionValueAttribute, clrMemberType, m_sourceLocation, m_parsingErrors, out value))
                {
                    return null;
                }
            }
            else if (Helper.IsEnumType(edmType))
            {
                // Enumeration type - get the actual value
                value = StorageMappingItemLoader.GetEnumAttributeValue(nav.Clone(), StorageMslConstructs.ConditionValueAttribute, (EnumType)edmType, m_sourceLocation, m_parsingErrors);
            }
            else
            {
                // Since NullableComplexTypes are not being supported,
                // we don't allow conditions on complex types
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_NonScalar,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;

            }
            //Either Value or NotNull need to be specifid on the condition mapping but not both
            if ((isNullAttribute != null) && (value != null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_Both_Values,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }
            if ((isNullAttribute == null) && (value == null))
            {
                AddToSchemaErrors(Strings.Mapping_InvalidContent_ConditionMapping_Either_Values,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }

            if (isNullAttribute != null)
            {
                //XSD validation should have guarenteed that the attribute value can only be true or false
                Debug.Assert(isNullAttribute == "true" || isNullAttribute == "false");
                isNullValue = Convert.ToBoolean(isNullAttribute, System.Globalization.CultureInfo.InvariantCulture);
            }

            if (columnMember != null && (columnMember.IsStoreGeneratedComputed || columnMember.IsStoreGeneratedIdentity))
            {
                AddToSchemaErrorsWithMemberInfo(Strings.Mapping_InvalidContent_ConditionMapping_Computed, columnMember.Name,
                    StorageMappingErrorCode.ConditionError, m_sourceLocation, navLineInfo, m_parsingErrors);
                return null;
            }

            StorageConditionPropertyMapping conditionPropertyMapping = new StorageConditionPropertyMapping(member, columnMember, value, isNullValue);
            return conditionPropertyMapping;
        }

        internal static bool IsTypeSupportedForCondition(PrimitiveTypeKind primitiveTypeKind)
        {
            switch (primitiveTypeKind)
            {
                case PrimitiveTypeKind.Boolean:
                case PrimitiveTypeKind.Byte:
                case PrimitiveTypeKind.Int16:
                case PrimitiveTypeKind.Int32:
                case PrimitiveTypeKind.Int64:
                case PrimitiveTypeKind.String:
                case PrimitiveTypeKind.SByte:
                    return true;
                case PrimitiveTypeKind.Binary:
                case PrimitiveTypeKind.DateTime:
                case PrimitiveTypeKind.Time:
                case PrimitiveTypeKind.DateTimeOffset:
                case PrimitiveTypeKind.Double:
                case PrimitiveTypeKind.Guid:
                case PrimitiveTypeKind.Single:
                case PrimitiveTypeKind.Decimal:
                    return false;
                default:
                    Debug.Fail("New primitive type kind added?");
                    return false;
            }
        }

        private static XmlSchemaSet GetOrCreateSchemaSet()
        {
            if (s_mappingXmlSchema == null)
            {
                //Get the xsd stream for CS MSL Xsd.
                XmlSchemaSet set = new XmlSchemaSet();
                AddResourceXsdToSchemaSet(set, StorageMslConstructs.ResourceXsdNameV1);
                AddResourceXsdToSchemaSet(set, StorageMslConstructs.ResourceXsdNameV2);
                AddResourceXsdToSchemaSet(set, StorageMslConstructs.ResourceXsdNameV3);
                System.Threading.Interlocked.CompareExchange(ref s_mappingXmlSchema, set, null);
            }

            return s_mappingXmlSchema;
        }

        private static void AddResourceXsdToSchemaSet(XmlSchemaSet set, string resourceName)
        {
            using (XmlReader xsdReader = System.Data.Common.DbProviderServices.GetXmlResource(resourceName))
            {
                XmlSchema xmlSchema = XmlSchema.Read(xsdReader, null);
                set.Add(xmlSchema);
            }
        }

        /// <summary>
        /// Throws a new MappingException giving out the line number and 
        /// File Name where the error in Mapping specification is present.
        /// </summary>
        /// <param name="message"></param>
        /// <param name="errorCode"></param>
        /// <param name="uri"></param>
        /// <param name="lineInfo"></param>
        /// <param name="parsingErrors">Error Collection where the parsing errors are collected</param>
        private static void AddToSchemaErrors(string message, StorageMappingErrorCode errorCode, string location, IXmlLineInfo lineInfo, IList<EdmSchemaError> parsingErrors)
        {
            EdmSchemaError error = new EdmSchemaError(message, (int)errorCode, EdmSchemaErrorSeverity.Error, location, lineInfo.LineNumber, lineInfo.LinePosition);
            parsingErrors.Add(error);
        }

        private static EdmSchemaError AddToSchemaErrorsWithMemberInfo(Func<object, string> messageFormat, string errorMember, StorageMappingErrorCode errorCode, string location, IXmlLineInfo lineInfo, IList<EdmSchemaError> parsingErrors)
        {
            EdmSchemaError error = new EdmSchemaError(messageFormat(errorMember), (int)errorCode, EdmSchemaErrorSeverity.Error, location, lineInfo.LineNumber, lineInfo.LinePosition);
            parsingErrors.Add(error);
            return error;
        }

        private static void AddToSchemaErrorWithMemberAndStructure(Func<object, object, string> messageFormat, string errorMember,
            string errorStructure, StorageMappingErrorCode errorCode, string location, IXmlLineInfo lineInfo, IList<EdmSchemaError> parsingErrors)
        {
            EdmSchemaError error = new EdmSchemaError(
                messageFormat(errorMember, errorStructure)
                , (int)errorCode, EdmSchemaErrorSeverity.Error, location, lineInfo.LineNumber, lineInfo.LinePosition);
            parsingErrors.Add(error);
        }

        private static void AddToSchemaErrorWithMessage(string errorMessage, StorageMappingErrorCode errorCode, string location, IXmlLineInfo lineInfo, IList<EdmSchemaError> parsingErrors)
        {
            EdmSchemaError error = new EdmSchemaError(errorMessage, (int)errorCode, EdmSchemaErrorSeverity.Error, location, lineInfo.LineNumber, lineInfo.LinePosition);
            parsingErrors.Add(error);
        }

        /// <summary>
        /// Resolve the attribute value based on the aliases provided as part of MSL file.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        private string GetAliasResolvedAttributeValue(XPathNavigator nav, string attributeName)
        {
            return GetAliasResolvedValue(StorageMappingItemLoader.GetAttributeValue(nav, attributeName));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        private bool GetBoolAttributeValue(XPathNavigator nav, string attributeName, bool defaultValue)
        {
            bool boolValue = defaultValue;
            object boolObj = Helper.GetTypedAttributeValue(nav, attributeName, typeof(bool));

            if (boolObj != null)
            {
                boolValue = (bool)boolObj;
            }
            return boolValue;
        }


        /// <summary>
        /// The method simply calls the helper method on Helper class with the 
        /// namespaceURI that is default for CSMapping.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        private static string GetAttributeValue(XPathNavigator nav, string attributeName)
        {
            return Helper.GetAttributeValue(nav, attributeName);
        }

        /// <summary>
        /// The method simply calls the helper method on Helper class with the 
        /// namespaceURI that is default for CSMapping.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName"></param>
        /// <param name="clrType"></param>
        /// <param name="uri"></param>
        /// <param name="parsingErrors">Error Collection where the parsing errors are collected</param>
        /// <returns></returns>
        private static bool TryGetTypedAttributeValue(XPathNavigator nav, string attributeName, Type clrType, string sourceLocation, IList<EdmSchemaError> parsingErrors, out object value)
        {
            value = null;
            try
            {
                value = Helper.GetTypedAttributeValue(nav, attributeName, clrType);
            }
            catch (FormatException)
            {
                StorageMappingItemLoader.AddToSchemaErrors(Strings.Mapping_ConditionValueTypeMismatch,
                    StorageMappingErrorCode.ConditionError, sourceLocation, (IXmlLineInfo)nav, parsingErrors);
                return false;
            }
            return true;
        }

        /// <summary>
        /// Returns the enum EdmMember corresponding to attribute name in enumType.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName"></param>
        /// <param name="enumType"></param>
        /// <param name="uri"></param>
        /// <param name="parsingErrors">Error Collection where the parsing errors are collected</param>
        /// <returns></returns>
        private static EnumMember GetEnumAttributeValue(XPathNavigator nav, string attributeName, EnumType enumType, string sourceLocation, IList<EdmSchemaError> parsingErrors)
        {
            IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

            string value = GetAttributeValue(nav, attributeName);
            if (String.IsNullOrEmpty(value))
            {
                StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(Strings.Mapping_Enum_EmptyValue, enumType.FullName,
                    StorageMappingErrorCode.InvalidEnumValue, sourceLocation, xmlLineInfoNav, parsingErrors);
            }

            EnumMember result;
            bool found = enumType.Members.TryGetValue(value, false, out result);
            if (!found)
            {
                StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(Strings.Mapping_Enum_InvalidValue, value,
                    StorageMappingErrorCode.InvalidEnumValue, sourceLocation, xmlLineInfoNav, parsingErrors);
            }
            return result;
        }

        /// <summary>
        /// Resolve the string value based on the aliases provided as part of MSL file.
        /// </summary>
        /// <param name="aliasedString"></param>
        /// <returns></returns>
        private string GetAliasResolvedValue(string aliasedString)
        {
            if ((aliasedString == null) || (aliasedString.Length == 0))
                return aliasedString;
            //For now all attributes have no namespace
            int aliasIndex = aliasedString.LastIndexOf('.');
            //If no '.' in the string, than obviously the string is not aliased
            if (aliasIndex == -1)
                return aliasedString;
            string aliasKey = aliasedString.Substring(0, aliasIndex);
            string aliasValue;
            m_alias.TryGetValue(aliasKey, out aliasValue);
            if (aliasValue != null)
            {
                aliasedString = aliasValue + aliasedString.Substring(aliasIndex);
            }
            return aliasedString;
        }

        /// <summary>
        /// Creates Xml Reader with settings required for
        /// XSD validation.
        /// </summary>
        /// <param name="innerReader"></param>
        private XmlReader GetSchemaValidatingReader(XmlReader innerReader)
        {
            //Create the reader setting that will be used while
            //loading the MSL.
            XmlReaderSettings readerSettings = GetXmlReaderSettings();
            XmlReader reader = XmlReader.Create(innerReader, readerSettings);

            return reader;
        }


        private XmlReaderSettings GetXmlReaderSettings()
        {
            XmlReaderSettings readerSettings = System.Data.EntityModel.SchemaObjectModel.Schema.CreateEdmStandardXmlReaderSettings();

            readerSettings.ValidationFlags |= System.Xml.Schema.XmlSchemaValidationFlags.ReportValidationWarnings;
            readerSettings.ValidationEventHandler += this.XsdValidationCallBack;
            readerSettings.ValidationType = ValidationType.Schema;
            readerSettings.Schemas = GetOrCreateSchemaSet();
            return readerSettings;
        }


        /// <summary>
        /// The method is called by the XSD validation event handler when
        /// ever there are warnings or errors.
        /// We ignore the warnings but the errors will result in exception.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void XsdValidationCallBack(object sender, ValidationEventArgs args)
        {
            if (args.Severity != XmlSeverityType.Warning)
            {
                string sourceLocation = null;
                if (!string.IsNullOrEmpty(args.Exception.SourceUri))
                {
                    sourceLocation = Helper.GetFileNameFromUri(new Uri(args.Exception.SourceUri));
                }
                EdmSchemaErrorSeverity severity = EdmSchemaErrorSeverity.Error;
                if (args.Severity == XmlSeverityType.Warning)
                    severity = EdmSchemaErrorSeverity.Warning;
                EdmSchemaError error = new EdmSchemaError(Strings.Mapping_InvalidMappingSchema_validation(args.Exception.Message)
                    , (int)StorageMappingErrorCode.XmlSchemaValidationError, severity, sourceLocation, args.Exception.LineNumber, args.Exception.LinePosition);
                m_parsingErrors.Add(error);
            }
        }


        /// <summary>
        /// Validate the scalar property mapping - makes sure that the cspace type is promotable to the store side and updates
        /// the store type usage
        /// </summary>
        /// <param name="member"></param>
        /// <param name="columnMember"></param>
        /// <param name="lineInfo"></param>
        private void ValidateAndUpdateScalarMemberMapping(EdmProperty member, EdmProperty columnMember, IXmlLineInfo lineInfo)
        {
            Debug.Assert(
                Helper.IsScalarType(member.TypeUsage.EdmType), 
                "c-space member type must be of primitive or enumeration type");
            Debug.Assert(Helper.IsPrimitiveType(columnMember.TypeUsage.EdmType), "s-space column type must be primitive");

            KeyValuePair<TypeUsage, TypeUsage> memberMappingInfo;
            if (!m_scalarMemberMappings.TryGetValue(member, out memberMappingInfo))
            {
                int errorCount = m_parsingErrors.Count;

                // Validates that the CSpace member type is promotable to the SSpace member types and returns a typeUsage which contains
                // the store equivalent type for the CSpace member type.
                // For e.g. If a CSpace member of type Edm.Int32 maps to SqlServer.Int64, the return type usage will contain SqlServer.int
                //          which is store equivalent type for Edm.Int32
                TypeUsage storeEquivalentTypeUsage = Helper.ValidateAndConvertTypeUsage(member,
                    columnMember, lineInfo, m_sourceLocation, m_parsingErrors, StoreItemCollection);

                // If the cspace type is not compatible with the store type, add a schema error and return
                if (storeEquivalentTypeUsage == null)
                {
                    if (errorCount == m_parsingErrors.Count)
                    {
                        EdmSchemaError error = new EdmSchemaError(
                            GetInvalidMemberMappingErrorMessage(member, columnMember),
                            (int)StorageMappingErrorCode.IncompatibleMemberMapping, EdmSchemaErrorSeverity.Error,
                            m_sourceLocation, lineInfo.LineNumber,
                            lineInfo.LinePosition);
                        m_parsingErrors.Add(error);
                    }
                }
                else
                {
                    m_scalarMemberMappings.Add(member, new KeyValuePair<TypeUsage, TypeUsage>(storeEquivalentTypeUsage, columnMember.TypeUsage));
                }
            }
            else
            {
                // Get the store member type to which the cspace member was mapped to previously
                TypeUsage storeMappedTypeUsage = memberMappingInfo.Value;
                TypeUsage modelColumnMember = columnMember.TypeUsage.GetModelTypeUsage();
                if (!Object.ReferenceEquals(columnMember.TypeUsage.EdmType, storeMappedTypeUsage.EdmType))
                {
                    EdmSchemaError error = new EdmSchemaError(
                        Strings.Mapping_StoreTypeMismatch_ScalarPropertyMapping(
                                                             member.Name,
                                                             storeMappedTypeUsage.EdmType.Name),
                        (int)StorageMappingErrorCode.CSpaceMemberMappedToMultipleSSpaceMemberWithDifferentTypes,
                        EdmSchemaErrorSeverity.Error,
                        m_sourceLocation,
                        lineInfo.LineNumber,
                        lineInfo.LinePosition);
                    m_parsingErrors.Add(error);
                }
                // Check if the cspace facets are promotable to the new store type facets
                else if (!TypeSemantics.IsSubTypeOf(ResolveTypeUsageForEnums(member.TypeUsage), modelColumnMember))
                {
                    EdmSchemaError error = new EdmSchemaError(
                        GetInvalidMemberMappingErrorMessage(member, columnMember),
                        (int)StorageMappingErrorCode.IncompatibleMemberMapping, EdmSchemaErrorSeverity.Error,
                        m_sourceLocation, lineInfo.LineNumber,
                        lineInfo.LinePosition);
                    m_parsingErrors.Add(error);
                }
            }
        }

        private string GetInvalidMemberMappingErrorMessage(EdmMember cSpaceMember, EdmMember sSpaceMember)
        {
            return Strings.Mapping_Invalid_Member_Mapping(
                cSpaceMember.TypeUsage.EdmType + GetFacetsForDisplay(cSpaceMember.TypeUsage),
                cSpaceMember.Name,
                cSpaceMember.DeclaringType.FullName,
                sSpaceMember.TypeUsage.EdmType + GetFacetsForDisplay(sSpaceMember.TypeUsage),
                sSpaceMember.Name,
                sSpaceMember.DeclaringType.FullName);
        }

        private string GetFacetsForDisplay(TypeUsage typeUsage)
        {
            Debug.Assert(typeUsage != null);

            ReadOnlyMetadataCollection<Facet> facets = typeUsage.Facets;
            if (facets == null || facets.Count == 0)
            {
                return string.Empty;
            }

            int numFacets = facets.Count;

            StringBuilder facetDisplay = new StringBuilder("[");

            for (int i = 0; i < numFacets-1; ++i)
            {
                facetDisplay.AppendFormat("{0}={1},", facets[i].Name, facets[i].Value ?? string.Empty);
            }

            facetDisplay.AppendFormat("{0}={1}]", facets[numFacets - 1].Name, facets[numFacets-1].Value ?? string.Empty);

            return facetDisplay.ToString();
        }

        #endregion

        #region Nested types
        /// <summary>
        /// Encapsulates state and functionality for loading a modification function mapping.
        /// </summary>
        private class ModificationFunctionMappingLoader
        {
            // Storage mapping loader
            private readonly StorageMappingItemLoader m_parentLoader;

            // Mapped function
            private EdmFunction m_function;

            // Entity set mapped by this function (may be null)
            private readonly EntitySet m_entitySet;

            // Association set mapped by this function (may be null)
            private readonly AssociationSet m_associationSet;

            // Model entity container (used to resolve set names)
            private readonly EntityContainer m_modelContainer;

            // Item collection (used to resolve function and type names)
            private readonly EdmItemCollection m_edmItemCollection;

            // Item collection (used to resolve function and type names)
            private readonly StoreItemCollection m_storeItemCollection;

            // Indicates whether the function can be bound to "current"
            // versions of properties (i.e., inserts and updates)
            private bool m_allowCurrentVersion;

            // Indicates whether the function can be bound to "original"
            // versions of properties (i.e., deletes and updates)
            private bool m_allowOriginalVersion;

            // Tracks which function parameters have been seen so far.
            private readonly Set<FunctionParameter> m_seenParameters;

            // Tracks members navigated to arrive at the current element
            private readonly Stack<EdmMember> m_members;

            // When set, indicates we are interpreting a navigation property on the given set.
            private AssociationSet m_associationSetNavigation;

            // Initialize loader
            internal ModificationFunctionMappingLoader(
                StorageMappingItemLoader parentLoader,
                EntitySetBase extent)
            {
                m_parentLoader = EntityUtil.CheckArgumentNull(parentLoader, "parentLoader");
                // initialize member fields
                m_modelContainer = EntityUtil.CheckArgumentNull<EntitySetBase>(extent, "extent").EntityContainer;
                m_edmItemCollection = parentLoader.EdmItemCollection;
                m_storeItemCollection = parentLoader.StoreItemCollection;
                m_entitySet = extent as EntitySet;
                if (null == m_entitySet)
                {
                    // do a cast here since the extent must either be an entity set
                    // or an association set
                    m_associationSet = (AssociationSet)extent;
                }
                m_seenParameters = new Set<FunctionParameter>();
                m_members = new Stack<EdmMember>();
            }

            internal StorageModificationFunctionMapping LoadEntityTypeModificationFunctionMapping(XPathNavigator nav, EntitySetBase entitySet, bool allowCurrentVersion, bool allowOriginalVersion, EntityType entityType)
            {
                FunctionParameter rowsAffectedParameter;
                m_function = LoadAndValidateFunctionMetadata(nav.Clone(), out rowsAffectedParameter);
                if (m_function == null)
                {
                    return null;
                }
                m_allowCurrentVersion = allowCurrentVersion;
                m_allowOriginalVersion = allowOriginalVersion;

                // Load all parameter bindings and result bindings
                IEnumerable<StorageModificationFunctionParameterBinding> parameters = LoadParameterBindings(nav.Clone(), entityType);
                IEnumerable<StorageModificationFunctionResultBinding> resultBindings = LoadResultBindings(nav.Clone(), entityType);

                StorageModificationFunctionMapping functionMapping = new StorageModificationFunctionMapping(entitySet, entityType, m_function, parameters, rowsAffectedParameter, resultBindings);

                return functionMapping;
            }


            // Loads a function mapping for an association set
            internal StorageModificationFunctionMapping LoadAssociationSetModificationFunctionMapping(XPathNavigator nav, EntitySetBase entitySet, bool isInsert)
            {
                FunctionParameter rowsAffectedParameter;
                m_function = LoadAndValidateFunctionMetadata(nav.Clone(), out rowsAffectedParameter);
                if (m_function == null)
                {
                    return null;
                }
                if (isInsert)
                {
                    m_allowCurrentVersion = true;
                    m_allowOriginalVersion = false;
                }
                else
                {
                    m_allowCurrentVersion = false;
                    m_allowOriginalVersion = true;
                }

                // Load all parameter bindings
                IEnumerable<StorageModificationFunctionParameterBinding> parameters = LoadParameterBindings(nav.Clone(), m_associationSet.ElementType);

                StorageModificationFunctionMapping mapping = new StorageModificationFunctionMapping(entitySet, entitySet.ElementType, m_function, parameters, rowsAffectedParameter, null);
                return mapping;
            }

            // Loads all result bindings.
            private IEnumerable<StorageModificationFunctionResultBinding> LoadResultBindings(XPathNavigator nav, EntityType entityType)
            {
                List<StorageModificationFunctionResultBinding> resultBindings = new List<StorageModificationFunctionResultBinding>();
                IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

                // walk through all children, filtering on result bindings
                if (nav.MoveToChild(XPathNodeType.Element))
                {
                    do
                    {
                        if (nav.LocalName == StorageMslConstructs.ResultBindingElement)
                        {
                            // retrieve attributes
                            string propertyName = m_parentLoader.GetAliasResolvedAttributeValue(nav.Clone(),
                                StorageMslConstructs.ResultBindingPropertyNameAttribute);
                            string columnName = m_parentLoader.GetAliasResolvedAttributeValue(nav.Clone(),
                                StorageMslConstructs.ScalarPropertyColumnNameAttribute);

                            // resolve metadata
                            EdmProperty property = null;
                            if (null == propertyName ||
                                !entityType.Properties.TryGetValue(propertyName, false, out property))
                            {
                                // add a schema error and return if the property does not exist
                                StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                                    Strings.Mapping_ModificationFunction_PropertyNotFound,
                                    propertyName, entityType.Name,
                                    StorageMappingErrorCode.InvalidEdmMember, m_parentLoader.m_sourceLocation,
                                    xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                                return new List<StorageModificationFunctionResultBinding>();
                            }

                            // construct element binding (no type checking is required at mapping load time)
                            StorageModificationFunctionResultBinding resultBinding = new StorageModificationFunctionResultBinding(columnName, property);
                            resultBindings.Add(resultBinding);
                        }
                    } while (nav.MoveToNext(XPathNodeType.Element));
                }

                // check for duplicate mappings of single properties
                KeyToListMap<EdmProperty, string> propertyToColumnNamesMap = new KeyToListMap<EdmProperty, string>(EqualityComparer<EdmProperty>.Default);
                foreach (StorageModificationFunctionResultBinding resultBinding in resultBindings)
                {
                    propertyToColumnNamesMap.Add(resultBinding.Property, resultBinding.ColumnName);
                }
                foreach (EdmProperty property in propertyToColumnNamesMap.Keys)
                {
                    ReadOnlyCollection<string> columnNames = propertyToColumnNamesMap.ListForKey(property);
                    if (1 < columnNames.Count)
                    {
                        StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                            Strings.Mapping_ModificationFunction_AmbiguousResultBinding,
                            property.Name, StringUtil.ToCommaSeparatedString(columnNames),
                            StorageMappingErrorCode.AmbiguousResultBindingInModificationFunctionMapping,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav,
                            m_parentLoader.m_parsingErrors);
                        return new List<StorageModificationFunctionResultBinding>();
                    }
                }

                return resultBindings;
            }

            // Loads parameter bindings from the given node, validating bindings:
            // - All parameters are covered
            // - Referenced names exist in type
            // - Parameter and scalar type are compatible
            // - Legal versions are given
            private IEnumerable<StorageModificationFunctionParameterBinding> LoadParameterBindings(XPathNavigator nav, StructuralType type)
            {
                // recursively retrieve bindings (current member path is empty)
                // immediately construct a list of bindings to force execution of the LoadParameterBindings
                // yield method
                List<StorageModificationFunctionParameterBinding> parameterBindings = new List<StorageModificationFunctionParameterBinding>(
                    LoadParameterBindings(nav.Clone(), type, restrictToKeyMembers: false));

                // check that all parameters have been mapped
                Set<FunctionParameter> unmappedParameters = new Set<FunctionParameter>(m_function.Parameters);
                unmappedParameters.Subtract(m_seenParameters);
                if (0 != unmappedParameters.Count)
                {
                    AddToSchemaErrorWithMemberAndStructure(Strings.Mapping_ModificationFunction_MissingParameter,
                        m_function.FullName, StringUtil.ToCommaSeparatedString(unmappedParameters),
                        StorageMappingErrorCode.InvalidParameterInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, (IXmlLineInfo)nav,
                        m_parentLoader.m_parsingErrors);
                    return new List<StorageModificationFunctionParameterBinding>();
                }

                return parameterBindings;
            }

            private IEnumerable<StorageModificationFunctionParameterBinding> LoadParameterBindings(XPathNavigator nav, StructuralType type,
                bool restrictToKeyMembers)
            {
                // walk through all child bindings
                if (nav.MoveToChild(XPathNodeType.Element))
                {
                    do
                    {
                        switch (nav.LocalName)
                        {
                            case StorageMslConstructs.ScalarPropertyElement:
                                {
                                    StorageModificationFunctionParameterBinding binding = LoadScalarPropertyParameterBinding(
                                        nav.Clone(), type, restrictToKeyMembers);
                                    if (binding != null)
                                    {
                                        yield return binding;
                                    }
                                    else
                                    {
                                        yield break;
                                    }
                                }
                                break;
                            case StorageMslConstructs.ComplexPropertyElement:
                                {
                                    ComplexType complexType;
                                    EdmMember property = LoadComplexTypeProperty(
                                        nav.Clone(), type, out complexType);
                                    if (property != null)
                                    {

                                        // recursively retrieve mappings
                                        m_members.Push(property);
                                        foreach (StorageModificationFunctionParameterBinding binding in
                                            LoadParameterBindings(nav.Clone(), complexType, restrictToKeyMembers))
                                        {
                                            yield return binding;
                                        }
                                        m_members.Pop();
                                    }
                                }
                                break;
                            case StorageMslConstructs.AssociationEndElement:
                                {
                                    AssociationSetEnd toEnd = LoadAssociationEnd(nav.Clone());
                                    if (toEnd != null)
                                    {

                                        // translate the bindings for the association end
                                        m_members.Push(toEnd.CorrespondingAssociationEndMember);
                                        m_associationSetNavigation = toEnd.ParentAssociationSet;
                                        foreach (StorageModificationFunctionParameterBinding binding in
                                            LoadParameterBindings(nav.Clone(), toEnd.EntitySet.ElementType, true /* restrictToKeyMembers */))
                                        {
                                            yield return binding;
                                        }
                                        m_associationSetNavigation = null;
                                        m_members.Pop();
                                    }
                                }
                                break;
                            case StorageMslConstructs.EndPropertyMappingElement:
                                {
                                    AssociationSetEnd end = LoadEndProperty(nav.Clone());
                                    if (end != null)
                                    {

                                        // translate the bindings for the end property
                                        m_members.Push(end.CorrespondingAssociationEndMember);
                                        foreach (StorageModificationFunctionParameterBinding binding in
                                            LoadParameterBindings(nav.Clone(), end.EntitySet.ElementType, true /* restrictToKeyMembers */))
                                        {
                                            yield return binding;
                                        }
                                        m_members.Pop();
                                    }
                                }
                                break;
                        }
                    } while (nav.MoveToNext(XPathNodeType.Element));
                }
            }

            private AssociationSetEnd LoadAssociationEnd(XPathNavigator nav)
            {

                IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

                // retrieve element attributes
                string associationSetName = m_parentLoader.GetAliasResolvedAttributeValue(
                    nav.Clone(), StorageMslConstructs.AssociationSetAttribute);
                string fromRole = m_parentLoader.GetAliasResolvedAttributeValue(
                    nav.Clone(), StorageMslConstructs.FromAttribute);
                string toRole = m_parentLoader.GetAliasResolvedAttributeValue(
                    nav.Clone(), StorageMslConstructs.ToAttribute);

                // retrieve metadata
                RelationshipSet relationshipSet = null;
                AssociationSet associationSet;

                // validate the association set exists
                if (null == associationSetName ||
                    !m_modelContainer.TryGetRelationshipSetByName(associationSetName, false, out relationshipSet) ||
                    BuiltInTypeKind.AssociationSet != relationshipSet.BuiltInTypeKind)
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                        Strings.Mapping_ModificationFunction_AssociationSetDoesNotExist,
                        associationSetName, StorageMappingErrorCode.InvalidAssociationSet,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav,
                        m_parentLoader.m_parsingErrors);
                    return null;
                }
                associationSet = (AssociationSet)relationshipSet;

                // validate the from end exists
                AssociationSetEnd fromEnd = null;
                if (null == fromRole ||
                    !associationSet.AssociationSetEnds.TryGetValue(fromRole, false, out fromEnd))
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                        Strings.Mapping_ModificationFunction_AssociationSetRoleDoesNotExist,
                        fromRole, StorageMappingErrorCode.InvalidAssociationSetRoleInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                // validate the to end exists
                AssociationSetEnd toEnd = null;
                if (null == toRole ||
                    !associationSet.AssociationSetEnds.TryGetValue(toRole, false, out toEnd))
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                    Strings.Mapping_ModificationFunction_AssociationSetRoleDoesNotExist,
                    toRole, StorageMappingErrorCode.InvalidAssociationSetRoleInModificationFunctionMapping,
                    m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                // validate ends reference the current entity set
                if (!fromEnd.EntitySet.Equals(m_entitySet))
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                        Strings.Mapping_ModificationFunction_AssociationSetFromRoleIsNotEntitySet,
                        fromRole, StorageMappingErrorCode.InvalidAssociationSetRoleInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                // validate cardinality of to end (can be at most one)
                if (toEnd.CorrespondingAssociationEndMember.RelationshipMultiplicity != RelationshipMultiplicity.One &&
                    toEnd.CorrespondingAssociationEndMember.RelationshipMultiplicity != RelationshipMultiplicity.ZeroOrOne)
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                    Strings.Mapping_ModificationFunction_AssociationSetCardinality,
                    toRole, StorageMappingErrorCode.InvalidAssociationSetCardinalityInModificationFunctionMapping,
                    m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                // if this is a FK, raise an error or a warning if the mapping would have been allowed in V1
                // (all dependent properties are part of the primary key)
                if (associationSet.ElementType.IsForeignKey)
                {
                    ReferentialConstraint constraint = associationSet.ElementType.ReferentialConstraints.Single();
                    EdmSchemaError error = StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                        Strings.Mapping_ModificationFunction_AssociationEndMappingForeignKeyAssociation,
                        toRole, StorageMappingErrorCode.InvalidModificationFunctionMappingAssociationEndForeignKey, m_parentLoader.m_sourceLocation,
                        xmlLineInfoNav, m_parentLoader.m_parsingErrors);

                    if (fromEnd.CorrespondingAssociationEndMember == constraint.ToRole &&
                        constraint.ToProperties.All(p => m_entitySet.ElementType.KeyMembers.Contains(p)))
                    {
                        // Just a warning...
                        error.Severity = EdmSchemaErrorSeverity.Warning;
                    }
                    else
                    {
                        return null;
                    }
                }
                return toEnd;
            }

            private AssociationSetEnd LoadEndProperty(XPathNavigator nav)
            {
                // retrieve element attributes
                string role = m_parentLoader.GetAliasResolvedAttributeValue(
                    nav.Clone(), StorageMslConstructs.EndPropertyMappingNameAttribute);

                // validate the role exists
                AssociationSetEnd end = null;
                if (null == role ||
                    !m_associationSet.AssociationSetEnds.TryGetValue(role, false, out end))
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                    Strings.Mapping_ModificationFunction_AssociationSetRoleDoesNotExist,
                    role, StorageMappingErrorCode.InvalidAssociationSetRoleInModificationFunctionMapping,
                    m_parentLoader.m_sourceLocation, (IXmlLineInfo)nav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                return end;
            }

            private EdmMember LoadComplexTypeProperty(XPathNavigator nav, StructuralType type, out ComplexType complexType)
            {

                IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

                // retrieve element attributes
                string propertyName = m_parentLoader.GetAliasResolvedAttributeValue(
                    nav.Clone(), StorageMslConstructs.ComplexPropertyNameAttribute);
                string typeName = m_parentLoader.GetAliasResolvedAttributeValue(
                    nav.Clone(), StorageMslConstructs.ComplexTypeMappingTypeNameAttribute);

                // retrieve metadata
                EdmMember property = null;
                if (null == propertyName ||
                    !type.Members.TryGetValue(propertyName, false, out property))
                {
                    // raise exception if the property does not exist
                    StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                        Strings.Mapping_ModificationFunction_PropertyNotFound,
                        propertyName, type.Name, StorageMappingErrorCode.InvalidEdmMember,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    complexType = null;
                    return null;
                }
                complexType = null;
                if (null == typeName ||
                    !m_edmItemCollection.TryGetItem<ComplexType>(typeName, out complexType))
                {
                    // raise exception if the type does not exist
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                    Strings.Mapping_ModificationFunction_ComplexTypeNotFound,
                    typeName, StorageMappingErrorCode.InvalidComplexType,
                    m_parentLoader.m_sourceLocation, xmlLineInfoNav
                    , m_parentLoader.m_parsingErrors);
                    return null;
                }
                if (!property.TypeUsage.EdmType.Equals(complexType) &&
                    !Helper.IsSubtypeOf(property.TypeUsage.EdmType, complexType))
                {
                    // raise exception if the complex type is incorrect
                    StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                        Strings.Mapping_ModificationFunction_WrongComplexType,
                        typeName, property.Name, StorageMappingErrorCode.InvalidComplexType,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav
                        , m_parentLoader.m_parsingErrors);
                    return null;
                }
                return property;
            }

            private StorageModificationFunctionParameterBinding LoadScalarPropertyParameterBinding(XPathNavigator nav, StructuralType type, bool restrictToKeyMembers)
            {
                IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

                // get attribute values
                string parameterName = m_parentLoader.GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ParameterNameAttribute);
                string propertyName = m_parentLoader.GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ScalarPropertyNameAttribute);
                string version = m_parentLoader.GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.ParameterVersionAttribute);

                // determine version
                bool isCurrent = false;
                if (null == version)
                {
                    // use default
                    if (!m_allowOriginalVersion)
                    {
                        isCurrent = true;
                    }
                    else if (!m_allowCurrentVersion)
                    {
                        isCurrent = false;
                    }
                    else
                    {
                        // add a schema error and return as there is no default
                        StorageMappingItemLoader.AddToSchemaErrors(
                            Strings.Mapping_ModificationFunction_MissingVersion,
                            StorageMappingErrorCode.MissingVersionInModificationFunctionMapping, m_parentLoader.m_sourceLocation,
                            xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;

                    }
                }
                else
                {
                    // check the value given by the user
                    isCurrent = version == StorageMslConstructs.ParameterVersionAttributeCurrentValue;
                }
                if (isCurrent && !m_allowCurrentVersion)
                {
                    //Add a schema error and return  since the 'current' property version is not available
                    StorageMappingItemLoader.AddToSchemaErrors(
                        Strings.Mapping_ModificationFunction_VersionMustBeOriginal,
                        StorageMappingErrorCode.InvalidVersionInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav
                        , m_parentLoader.m_parsingErrors);
                    return null;
                }
                if (!isCurrent && !m_allowOriginalVersion)
                {
                    // Add a schema error and return  since the 'original' property version is not available
                    StorageMappingItemLoader.AddToSchemaErrors(
                        Strings.Mapping_ModificationFunction_VersionMustBeCurrent,
                        StorageMappingErrorCode.InvalidVersionInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav
                        , m_parentLoader.m_parsingErrors);
                    return null;
                }

                // retrieve metadata
                FunctionParameter parameter = null;
                if (null == parameterName ||
                    !m_function.Parameters.TryGetValue(parameterName, false, out parameter))
                {
                    //Add a schema error and return  if the parameter does not exist
                    StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                        Strings.Mapping_ModificationFunction_ParameterNotFound,
                        parameterName, m_function.Name,
                        StorageMappingErrorCode.InvalidParameterInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav
                        , m_parentLoader.m_parsingErrors);
                    return null;
                }
                EdmMember property = null;
                if (restrictToKeyMembers)
                {
                    if (null == propertyName ||
                        !((EntityType)type).KeyMembers.TryGetValue(propertyName, false, out property))
                    {
                        // raise exception if the property does not exist
                        StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                            Strings.Mapping_ModificationFunction_PropertyNotKey,
                            propertyName, type.Name,
                            StorageMappingErrorCode.InvalidEdmMember,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;
                    }
                }
                else
                {
                    if (null == propertyName ||
                        !type.Members.TryGetValue(propertyName, false, out property))
                    {
                        // raise exception if the property does not exist
                        StorageMappingItemLoader.AddToSchemaErrorWithMemberAndStructure(
                            Strings.Mapping_ModificationFunction_PropertyNotFound,
                            propertyName, type.Name,
                            StorageMappingErrorCode.InvalidEdmMember,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;
                    }
                }

                // check that the parameter hasn't already been seen
                if (m_seenParameters.Contains(parameter))
                {
                    StorageMappingItemLoader.AddToSchemaErrorsWithMemberInfo(
                        Strings.Mapping_ModificationFunction_ParameterBoundTwice,
                        parameterName, StorageMappingErrorCode.ParameterBoundTwiceInModificationFunctionMapping,
                        m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                int errorCount = m_parentLoader.m_parsingErrors.Count;

                TypeUsage mappedStoreType = Helper.ValidateAndConvertTypeUsage(property,
                                                                               xmlLineInfoNav,
                                                                               m_parentLoader.m_sourceLocation,
                                                                               property.TypeUsage,
                                                                               parameter.TypeUsage,
                                                                               m_parentLoader.m_parsingErrors,
                                                                               m_storeItemCollection);

                // validate type compatibility
                if (mappedStoreType == null && errorCount == m_parentLoader.m_parsingErrors.Count)
                {
                    AddToSchemaErrorWithMessage(
                        Strings.Mapping_ModificationFunction_PropertyParameterTypeMismatch(
                                                             property.TypeUsage.EdmType,
                                                             property.Name,
                                                             property.DeclaringType.FullName,
                                                             parameter.TypeUsage.EdmType,
                                                             parameter.Name,
                                                             m_function.FullName),
                        StorageMappingErrorCode.InvalidModificationFunctionMappingPropertyParameterTypeMismatch,
                        m_parentLoader.m_sourceLocation,
                        xmlLineInfoNav,
                        m_parentLoader.m_parsingErrors);
                }

                // create the binding object
                m_members.Push(property);

                // if the member path includes a FK relationship, remap to the corresponding FK property
                IEnumerable<EdmMember> members = m_members;
                AssociationSet associationSetNavigation = m_associationSetNavigation;
                if (m_members.Last().BuiltInTypeKind == BuiltInTypeKind.AssociationEndMember)
                {
                    AssociationEndMember targetEnd = (AssociationEndMember)m_members.Last();
                    AssociationType associationType = (AssociationType)targetEnd.DeclaringType;
                    if (associationType.IsForeignKey)
                    {
                        ReferentialConstraint constraint = associationType.ReferentialConstraints.Single();
                        if (constraint.FromRole == targetEnd)
                        {
                            int ordinal = constraint.FromProperties.IndexOf((EdmProperty)m_members.First());

                            // rebind to the foreign key (no longer an association set navigation)
                            members = new EdmMember[] { constraint.ToProperties[ordinal], };
                            associationSetNavigation = null;
                        }
                    }
                }
                StorageModificationFunctionParameterBinding binding = new StorageModificationFunctionParameterBinding(parameter, new StorageModificationFunctionMemberPath(
                    members, associationSetNavigation), isCurrent);
                m_members.Pop();

                // remember that we've seen a binding for this parameter
                m_seenParameters.Add(parameter);

                return binding;
            }

            /// <summary>
            /// Loads function metadata and ensures the function is supportable for function mapping.
            /// </summary>
            private EdmFunction LoadAndValidateFunctionMetadata(XPathNavigator nav, out FunctionParameter rowsAffectedParameter)
            {
                IXmlLineInfo xmlLineInfoNav = (IXmlLineInfo)nav;

                // Different operations may be mapped to the same function (e.g. both INSERT and UPDATE are handled by a single
                // UPSERT function). Between loading functions, we can clear the set of seen parameters, because we may see them
                // again and don't want to claim there's a collision in such cases.
                m_seenParameters.Clear();

                // retrieve function attributes from the current element
                string functionName = m_parentLoader.GetAliasResolvedAttributeValue(nav.Clone(), StorageMslConstructs.FunctionNameAttribute);
                rowsAffectedParameter = null;

                // find function metadata
                System.Collections.ObjectModel.ReadOnlyCollection<EdmFunction> functionOverloads =
                    m_storeItemCollection.GetFunctions(functionName);

                if (functionOverloads.Count == 0)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_UnknownFunction, functionName,
                        StorageMappingErrorCode.InvalidModificationFunctionMappingUnknownFunction, m_parentLoader.m_sourceLocation,
                        xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                if (1 < functionOverloads.Count)
                {
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_AmbiguousFunction, functionName,
                        StorageMappingErrorCode.InvalidModificationFunctionMappingAmbiguousFunction, m_parentLoader.m_sourceLocation,
                        xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                EdmFunction function = functionOverloads[0];

                // check function is legal for function mapping
                if (MetadataHelper.IsComposable(function))
                { // only non-composable functions are permitted
                    AddToSchemaErrorsWithMemberInfo(Strings.Mapping_ModificationFunction_NotValidFunction, functionName,
                        StorageMappingErrorCode.InvalidModificationFunctionMappingNotValidFunction, m_parentLoader.m_sourceLocation,
                        xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                    return null;
                }

                // check for parameter
                string rowsAffectedParameterName = GetAttributeValue(nav, StorageMslConstructs.RowsAffectedParameterAttribute);
                if (!string.IsNullOrEmpty(rowsAffectedParameterName))
                {
                    // check that the parameter exists
                    if (!function.Parameters.TryGetValue(rowsAffectedParameterName, false, out rowsAffectedParameter))
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_RowsAffectedParameterDoesNotExist(
                            rowsAffectedParameterName, function.FullName),
                            StorageMappingErrorCode.MappingFunctionImportRowsAffectedParameterDoesNotExist,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;
                    }
                    // check that the parameter is an out parameter
                    if (ParameterMode.Out != rowsAffectedParameter.Mode && ParameterMode.InOut != rowsAffectedParameter.Mode)
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_RowsAffectedParameterHasWrongMode(
                            rowsAffectedParameterName, rowsAffectedParameter.Mode, ParameterMode.Out, ParameterMode.InOut),
                            StorageMappingErrorCode.MappingFunctionImportRowsAffectedParameterHasWrongMode,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;
                    }
                    // check that the parameter type is an integer type
                    PrimitiveType rowsAffectedParameterType = (PrimitiveType)rowsAffectedParameter.TypeUsage.EdmType;

                    if (!TypeSemantics.IsIntegerNumericType(rowsAffectedParameter.TypeUsage))
                    {
                        AddToSchemaErrorWithMessage(Strings.Mapping_FunctionImport_RowsAffectedParameterHasWrongType(
                            rowsAffectedParameterName, rowsAffectedParameterType.PrimitiveTypeKind),
                            StorageMappingErrorCode.MappingFunctionImportRowsAffectedParameterHasWrongType,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;
                    }
                    m_seenParameters.Add(rowsAffectedParameter);
                }

                // check that all parameters are allowed
                foreach (FunctionParameter parameter in function.Parameters)
                {
                    if (ParameterMode.In != parameter.Mode && rowsAffectedParameterName != parameter.Name)
                    { // rows affected is 'out' not 'in'
                        AddToSchemaErrorWithMessage(Strings.Mapping_ModificationFunction_NotValidFunctionParameter(functionName,
                            parameter.Name, StorageMslConstructs.RowsAffectedParameterAttribute), StorageMappingErrorCode.InvalidModificationFunctionMappingNotValidFunctionParameter,
                            m_parentLoader.m_sourceLocation, xmlLineInfoNav, m_parentLoader.m_parsingErrors);
                        return null;
                    }
                }

                return function;
            }
        }
        #endregion

        /// <summary>
        /// Checks whether the <paramref name="typeUsage"/> represents a type usage for an enumeration type and if
        /// this is the case creates a new type usage built using the underlying type of the enumeration type.
        /// </summary>
        /// <param name="typeUsage">TypeUsage to resolve.</param>
        /// <returns>
        /// If <paramref name="typeUsage"/> represents a TypeUsage for enumeration type the method returns a new
        /// TypeUsage instance created using the underlying type of the enumeration type. Otherwise the method 
        /// returns <paramref name="typeUsage"/>.
        /// </returns>
        private static TypeUsage ResolveTypeUsageForEnums(TypeUsage typeUsage)
        {
            Debug.Assert(typeUsage != null, "typeUsage != null");

            return Helper.IsEnumType(typeUsage.EdmType) ?
                TypeUsage.Create(Helper.GetUnderlyingEdmTypeForEnumType(typeUsage.EdmType), typeUsage.Facets) :
                typeUsage;
        }
    }
}