private static bool IsServerGenerated(EdmProperty property) {
     MetadataProperty generated;
     if (property.MetadataProperties.TryGetValue(StoreGeneratedMetadata, false, out generated)) {
         return "Identity" == (string)generated.Value || "Computed" == (string)generated.Value;
     }
     return false;
 }

        internal FunctionImportMappingComposable(
            EdmFunction functionImport,
            EdmFunction targetFunction,
            List<Tuple<StructuralType, List<StorageConditionPropertyMapping>, List<StoragePropertyMapping>>> structuralTypeMappings,
            EdmProperty[] targetFunctionKeys,
            StorageMappingItemCollection mappingItemCollection,
            string sourceLocation,
            LineInfo lineInfo) 
            : base(functionImport, targetFunction)
        {
            EntityUtil.CheckArgumentNull(mappingItemCollection, "mappingItemCollection");
            Debug.Assert(functionImport.IsComposableAttribute, "functionImport.IsComposableAttribute");
            Debug.Assert(targetFunction.IsComposableAttribute, "targetFunction.IsComposableAttribute");
            Debug.Assert(functionImport.EntitySet == null || structuralTypeMappings != null, "Function import returning entities must have structuralTypeMappings.");
            Debug.Assert(structuralTypeMappings == null || structuralTypeMappings.Count > 0, "Non-null structuralTypeMappings must not be empty.");
            EdmType resultType;
            Debug.Assert(
                structuralTypeMappings != null ||
                MetadataHelper.TryGetFunctionImportReturnType<EdmType>(functionImport, 0, out resultType) && TypeSemantics.IsScalarType(resultType),
                "Either type mappings should be specified or the function import should be Collection(Scalar).");
            Debug.Assert(functionImport.EntitySet == null || targetFunctionKeys != null, "Keys must be inferred for a function import returning entities.");
            Debug.Assert(targetFunctionKeys == null || targetFunctionKeys.Length > 0, "Keys must be null or non-empty.");

            m_mappingItemCollection = mappingItemCollection;
            // We will use these parameters to target s-space function calls in the generated command tree. 
            // Since enums don't exist in s-space we need to use the underlying type.
            m_commandParameters = functionImport.Parameters.Select(p => TypeHelpers.GetPrimitiveTypeUsageForScalar(p.TypeUsage).Parameter(p.Name)).ToArray();
            m_structuralTypeMappings = structuralTypeMappings;
            m_targetFunctionKeys = targetFunctionKeys;
            m_sourceLocation = sourceLocation;
            m_lineInfo = lineInfo;
        }

        public override string GetStoreType(EdmProperty property)
        {
            if (property.TypeUsage.EdmType.Name == "int")
                return "INTEGER";

            return base.GetStoreType(property);
        }

        public string GetGenerationOption(EdmProperty property, EntityType entity)
        {
            string result = "";
            bool isPk = entity.KeyMembers.Contains(property);
            MetadataProperty storeGeneratedPatternProperty = null;
            string storeGeneratedPatternPropertyValue = "None";

            if (property.MetadataProperties.TryGetValue(MetadataConstants.EDM_ANNOTATION_09_02 + ":StoreGeneratedPattern", false, out storeGeneratedPatternProperty))
                storeGeneratedPatternPropertyValue = storeGeneratedPatternProperty.Value.ToString();

            PrimitiveType edmType = (PrimitiveType)property.TypeUsage.EdmType;
            if (edmType == null && property.TypeUsage.EdmType is EnumType)
            {
                EnumType enumType = property.TypeUsage.EdmType as EnumType;
                edmType = enumType.UnderlyingType;
            }
            if (storeGeneratedPatternPropertyValue == "Computed")
            {
                result = ".HasDatabaseGeneratedOption(new Nullable<DatabaseGeneratedOption>(DatabaseGeneratedOption.Computed))";
            }
            else if ((edmType.ClrEquivalentType == typeof(int)) || (edmType.ClrEquivalentType == typeof(short)) || (edmType.ClrEquivalentType == typeof(long)))
            {
                if (isPk && (storeGeneratedPatternPropertyValue != "Identity"))
                    result = ".HasDatabaseGeneratedOption(new Nullable<DatabaseGeneratedOption>(DatabaseGeneratedOption.None))";
                else if ((!isPk || (entity.KeyMembers.Count > 1)) && (storeGeneratedPatternPropertyValue == "Identity"))
                    result = ".HasDatabaseGeneratedOption(new Nullable<DatabaseGeneratedOption>(DatabaseGeneratedOption.Identity))";
            }
            return result;
        }

        internal StorageModificationFunctionResultBinding(string columnName, EdmProperty property)
        {
            //Contract.Requires(columnName != null);
            //Contract.Requires(property != null);

            ColumnName = columnName;
            Property = property;
        }

 /// <summary>
 /// Construct a new instance of the FieldDescriptor class that describes a property
 /// on items of the supplied type.
 /// </summary>
 /// <param name="itemType">Type of object whose property is described by this FieldDescriptor.</param>
 /// <param name="isReadOnly">
 /// <b>True</b> if property value on item can be modified; otherwise <b>false</b>.
 /// </param>
 /// <param name="property">
 /// EdmProperty that describes the property on the item.
 /// </param>
 internal FieldDescriptor(Type itemType, bool isReadOnly, EdmProperty property)
     : base(property.Name, null)
 {
     _itemType = itemType;
     _property = property;
     _isReadOnly = isReadOnly;
     _fieldType = DetermineClrType(_property.TypeUsage);
     System.Diagnostics.Debug.Assert(_fieldType != null, "FieldDescriptor's CLR type has unexpected value of null.");
 }

 public override string WriteCreateColumn(EdmProperty property, Version targetVersion)
 {
     var notnull = (property.Nullable ? "" : "NOT NULL");
     var identity = GetIdentity(property, targetVersion);
     return string.Format("{0} {1} {2} {3}",
                          FormatName(property.Name),
                          GetStoreType(property),
                          identity, notnull).Trim();
 }

 /// <summary>
 /// Construct a new Scalar EdmProperty mapping object
 /// </summary>
 /// <param name="member"></param>
 /// <param name="columnMember"></param>
 internal StorageScalarPropertyMapping(EdmProperty member, EdmProperty columnMember)
     : base(member) {
     Debug.Assert(columnMember != null);
     Debug.Assert(
         Helper.IsScalarType(member.TypeUsage.EdmType), 
         "StorageScalarPropertyMapping must only map primitive or enum types");
     Debug.Assert(Helper.IsPrimitiveType(columnMember.TypeUsage.EdmType), "StorageScalarPropertyMapping must only map primitive types");
     this.m_columnMember = columnMember;
 }

        private bool DetermineIsForeignKeyComponent(EdmProperty property) {
            var navigationProperties = property.DeclaringType.Members.OfType<NavigationProperty>();

            // Look at all NavigationProperties (i.e. strongly-type relationship columns) of the table this column belong to and
            // see if there is a foreign key that matches this property
            // If this is a 1 to 0..1 relationship and we are processing the more primary side. i.e in the Student in Student-StudentDetail
            // and this is the primary key we don't want to check the relationship type since if there are no constraints we will treat the primary key as a foreign key.
            return navigationProperties.Any(n => EFCodeFirstAssociationProvider.GetDependentPropertyNames(n, !IsPrimaryKey /* checkRelationshipType */).Contains(property.Name));
        }

 /// <summary>
 /// Construct a new condition Property mapping object
 /// </summary>
 /// <param name="cdmMember"></param>
 /// <param name="columnMember"></param>
 /// <param name="value"></param>
 /// <param name="isNull"></param>
 internal StorageConditionPropertyMapping(EdmProperty cdmMember, EdmProperty columnMember
     , object value, Nullable<bool> isNull) : base(cdmMember) {
     Debug.Assert((cdmMember != null) || (columnMember != null), "Both CDM and Column Members can not be specified for Condition Mapping");
     Debug.Assert((cdmMember == null) || (columnMember == null), "Either CDM or Column Members has to be specified for Condition Mapping");
     Debug.Assert((isNull.HasValue) || (value != null), "Both Value and IsNull can not be specified on Condition Mapping");
     Debug.Assert(!(isNull.HasValue) || (value == null), "Either Value or IsNull has to be specified on Condition Mapping");
     this.m_columnMember = columnMember;
     this.m_value = value;
     this.m_isNull = isNull;
 }

 internal StateManagerMemberMetadata(ObjectPropertyMapping memberMap, EdmProperty memberMetadata, bool isPartOfKey)
 {
     // if memberMap is null, then this is a shadowstate
     Debug.Assert(null != memberMap, "shadowstate not supported");
     Debug.Assert(null != memberMetadata, "CSpace should never be null");
     _clrProperty = memberMap.ClrProperty;
     _edmProperty = memberMetadata;
     _isPartOfKey = isPartOfKey;
     _isComplexType = (Helper.IsEntityType(_edmProperty.TypeUsage.EdmType) ||
                       Helper.IsComplexType(_edmProperty.TypeUsage.EdmType));
 }

 public override string GetStoreType(EdmProperty property)
 {
     switch (property.TypeUsage.EdmType.Name)
     {
         case "datetime":
             return "DATE";
         case "nvarchar":
             return property.ToStoreType().Replace("nvarchar", "VARCHAR");
         default:
             return base.GetStoreType(property);
     }
 }

 static string GenerateColumn(EdmProperty property)
 {
     var column = new StringBuilder();
     column.Append(SqlGenerator.QuoteIdentifier(property.Name));
     column.Append(" ");
     column.Append(SqlGenerator.GetSqlPrimitiveType(property.TypeUsage));
     if (MetadataHelpers.IsStoreGeneratedIdentity(property))
     {
         column.Append(" GENERATED BY DEFAULT AS IDENTITY");
     }
     if (!property.Nullable)
     {
         column.Append(" NOT NULL");
     }
     return column.ToString();
 }

        /// <summary>
        /// Given a property on the principal end of a referential constraint, returns the corresponding property on the dependent end.
        /// Requires: The association has a referential constraint, and the specified principalProperty is one of the properties on the principal end.
        /// </summary>
        public EdmProperty GetCorrespondingDependentProperty(NavigationProperty navProperty, EdmProperty principalProperty)
        {
            if (navProperty == null)
            {
                throw new ArgumentNullException("navProperty");
            }

            if (principalProperty == null)
            {
                throw new ArgumentNullException("principalProperty");
            }

            ReadOnlyMetadataCollection<EdmProperty> fromProperties = GetPrincipalProperties(navProperty);
            ReadOnlyMetadataCollection<EdmProperty> toProperties = GetDependentProperties(navProperty);
            return toProperties[fromProperties.IndexOf(principalProperty)];
        }

 /// <summary>
 /// Add a mapping from the propertyRef (of the old type) to the 
 /// corresponding property in the new type.
 /// 
 /// NOTE: Only to be used by StructuredTypeInfo
 /// </summary>
 /// <param name="propertyRef"></param>
 /// <param name="newProperty"></param>
 internal void AddPropertyMapping(PropertyRef propertyRef, EdmProperty newProperty)
 {
     m_propertyMap[propertyRef] = newProperty;
     if (propertyRef is TypeIdPropertyRef)
     {
         m_typeIdProperty = newProperty;
     }
     else if (propertyRef is EntitySetIdPropertyRef)
     {
         m_entitySetIdProperty = newProperty;
     }
     else if (propertyRef is NullSentinelPropertyRef)
     {
         m_nullSentinelProperty = newProperty;
     }
 }

        internal EntityDataSourceMemberPath(MetadataWorkspace ocWorkspace, EntityDataSourceMemberPath parent, EdmProperty property, bool isLocallyInteresting)
        {
            EntityDataSourceUtil.CheckArgumentNull(ocWorkspace, "ocWorkspace");
            EntityDataSourceUtil.CheckArgumentNull(property, "property");
            
            this.property = property;
            this.parent = parent;
            this.isLocallyInteresting = isLocallyInteresting;
            this.clrType = EntityDataSourceUtil.GetMemberClrType(ocWorkspace, property);
            this.isKey = IsPropertyAKey(property);

            // retrieve PropertyInfo (with respect to parent CLR type)
            StructuralType parentType = property.DeclaringType;
            Type parentClrType = EntityDataSourceUtil.GetClrType(ocWorkspace, parentType);

            this.propertyInfo = EntityDataSourceUtil.GetPropertyInfo(parentClrType, this.property.Name);
        }

        private static string CreateDisplayName(EntityDataSourceReferenceGroup group, EdmProperty keyMember)
        {
            EntityDataSourceUtil.CheckArgumentNull(group, "group");
            EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");

            NavigationProperty navigationProperty;

            string result;

            if (EntityDataSourceUtil.TryGetCorrespondingNavigationProperty(group.End.CorrespondingAssociationEndMember, out navigationProperty))
            {
                result = navigationProperty.Name + "." + keyMember.Name;
            }
            else
            {
                // if there is no Navigation property, use the TargetTole and KeyMember name
                // TargetRole.KeyMember
                result = group.End.Name + "." + keyMember.Name;
            }

            return result;
        }

 private bool IsPropertyAKey(EdmProperty property)
 {
     bool isKey = false;
     EntityType entityType = property.DeclaringType as EntityType;
     if (null != entityType)
     {
         isKey = entityType.KeyMembers.Contains(property);
     }
     return isKey;
 }

    private string GetFacetString(EdmProperty column)
    {
      StringBuilder sql = new StringBuilder();
      Facet facet;
      Facet fcDateTimePrecision = null;

      ReadOnlyMetadataCollection<Facet> facets = column.TypeUsage.Facets;

      if (column.TypeUsage.EdmType.BaseType.Name == "String")
      {
        // types tinytext, mediumtext, text & longtext don't have a length.
        if (!column.TypeUsage.EdmType.Name.EndsWith("text", StringComparison.OrdinalIgnoreCase))
        {
          if (facets.TryGetValue("MaxLength", true, out facet))
            sql.AppendFormat(" ({0})", facet.Value);
        }
      }
      else if (column.TypeUsage.EdmType.BaseType.Name == "Decimal")
      {
        Facet fcScale;
        Facet fcPrecision;
        if (facets.TryGetValue("Scale", true, out fcScale) && facets.TryGetValue("Precision", true, out fcPrecision))
        {
          // Enforce scale to a reasonable value.
          int scale = fcScale.Value == null ? 0 : ( int )( byte )fcScale.Value;
          if (scale == 0)
            scale = MySqlProviderManifest.DEFAULT_DECIMAL_SCALE;
          sql.AppendFormat("( {0}, {1} ) ", fcPrecision.Value, scale);
        }
      }
      else if (column.TypeUsage.EdmType.BaseType.Name == "DateTime")
      {
        if (serverVersion >= new Version(5, 6) && facets.TryGetValue("Precision", true, out fcDateTimePrecision))
        {        
           if (Convert.ToByte(fcDateTimePrecision.Value) >= 1)
              sql.AppendFormat("( {0} ) ", fcDateTimePrecision.Value);            
        }
      }
      

      if (facets.TryGetValue("Nullable", true, out facet) && (bool)facet.Value == false)
        sql.Append(" NOT NULL");

      if (facets.TryGetValue("StoreGeneratedPattern", true, out facet))
      {
        if (facet.Value.Equals(StoreGeneratedPattern.Identity))
        {

          if (column.TypeUsage.EdmType.BaseType.Name.StartsWith("Int"))
            sql.Append(" AUTO_INCREMENT UNIQUE");
          else if (column.TypeUsage.EdmType.BaseType.Name == "Guid")
            _guidIdentityColumns.Add(column.Name);
          else if (serverVersion >= new Version(5, 6) && column.TypeUsage.EdmType.BaseType.Name == "DateTime")
            sql.AppendFormat(" DEFAULT CURRENT_TIMESTAMP{0}", fcDateTimePrecision != null && Convert.ToByte(fcDateTimePrecision.Value) >= 1 ? "( " + fcDateTimePrecision.Value.ToString() + " )" : "");                              
          else
            throw new MySqlException("Invalid identity column type.");
        }      
      }
      return sql.ToString();
    }

        internal EntityDataSourceReferenceKeyColumn(MetadataWorkspace workspace, EntityDataSourceReferenceGroup group, EdmProperty keyMember, EntityDataSourceColumn dependent)
            : base(CreateDisplayName(group, keyMember), dependent)
        {
            EntityDataSourceUtil.CheckArgumentNull(group, "group");
            EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
            Debug.Assert(EntityDataSourceUtil.IsScalar(keyMember.TypeUsage.EdmType), "Expected primitive or enum type for key members.");

            this.group = group;
            this.keyMember = keyMember;
            this.clrType = EntityDataSourceUtil.GetMemberClrType(workspace, keyMember);

            // if the association end is optional (0..1), make sure the CLR type
            // is also nullable
            if (this.group.End.CorrespondingAssociationEndMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne)
            {
                this.clrType = EntityDataSourceUtil.MakeNullable(clrType);
                this.isNullable = true;
            }
        }