public EntityContainer(string name, DataSpace dataSpace) { Check.NotEmpty(name, "name"); _name = name; DataSpace = dataSpace; _baseEntitySets = new ReadOnlyMetadataCollection<EntitySetBase>(new EntitySetBaseCollection(this)); _functionImports = new ReadOnlyMetadataCollection<EdmFunction>(new MetadataCollection<EdmFunction>()); }
/// <summary> /// Initializes a new instance of Association Type with the given name, namespace, version and ends /// </summary> /// <param name="name">name of the association type</param> /// <param name="namespaceName">namespace of the association type</param> /// <param name="foreignKey">is this a foreign key (FK) relationship?</param> /// <param name="dataSpace">dataSpace in which this AssociationType belongs to</param> /// <exception cref="System.ArgumentNullException">Thrown if either the name, namespace or version attributes are null</exception> internal AssociationType(string name, string namespaceName, bool foreignKey, DataSpace dataSpace) : base(name, namespaceName, dataSpace) { _referentialConstraints = new ReadOnlyMetadataCollection<ReferentialConstraint>(new MetadataCollection<ReferentialConstraint>()); _isForeignKey = foreignKey; }
/// <summary> /// The constructor for constructing the EntityContainer object with the name, namespaceName, and version. /// </summary> /// <param name="name">The name of this entity container</param> /// <param name="dataSpace">dataSpace in which this entity container belongs to</param> /// <exception cref="System.ArgumentNullException">Thrown if the name argument is null</exception> /// <exception cref="System.ArgumentException">Thrown if the name argument is empty string</exception> internal EntityContainer(string name, DataSpace dataSpace) { EntityUtil.CheckStringArgument(name, "name"); _name = name; this.DataSpace = dataSpace; _baseEntitySets = new ReadOnlyMetadataCollection<EntitySetBase>(new EntitySetBaseCollection(this)); _functionImports = new ReadOnlyMetadataCollection<EdmFunction>(new MetadataCollection<EdmFunction>()); }
/// <summary> /// Constructs a new constraint on the relationship /// </summary> /// <param name="fromRole">role from which the relationship originates</param> /// <param name="toRole">role to which the relationship is linked/targeted to</param> /// <param name="toProperties">properties on entity type of from role which take part in the constraint</param> /// <param name="fromProperties">properties on entity type of to role which take part in the constraint</param> /// <exception cref="ArgumentNullException">Argument Null exception if any of the arguments is null</exception> internal ReferentialConstraint(RelationshipEndMember fromRole, RelationshipEndMember toRole, IEnumerable<EdmProperty> fromProperties, IEnumerable<EdmProperty> toProperties) { _fromRole = EntityUtil.GenericCheckArgumentNull(fromRole, "fromRole"); _toRole = EntityUtil.GenericCheckArgumentNull(toRole, "toRole"); _fromProperties = new ReadOnlyMetadataCollection<EdmProperty>(new MetadataCollection<EdmProperty>( EntityUtil.GenericCheckArgumentNull(fromProperties, "fromProperties"))); _toProperties = new ReadOnlyMetadataCollection<EdmProperty>(new MetadataCollection<EdmProperty>( EntityUtil.GenericCheckArgumentNull(toProperties, "toProperties"))); }
/// <summary> /// Constructs a new constraint on the relationship /// </summary> /// <param name="fromRole"> role from which the relationship originates </param> /// <param name="toRole"> role to which the relationship is linked/targeted to </param> /// <param name="toProperties"> properties on entity type of from role which take part in the constraint </param> /// <param name="fromProperties"> properties on entity type of to role which take part in the constraint </param> /// <exception cref="ArgumentNullException">Argument Null exception if any of the arguments is null</exception> public ReferentialConstraint( RelationshipEndMember fromRole, RelationshipEndMember toRole, IEnumerable<EdmProperty> fromProperties, IEnumerable<EdmProperty> toProperties) { _fromRole = Check.NotNull(fromRole, "fromRole"); _toRole = Check.NotNull(toRole, "toRole"); _fromProperties = new ReadOnlyMetadataCollection<EdmProperty>( new MetadataCollection<EdmProperty>( Check.NotNull(fromProperties, "fromProperties"))); _toProperties = new ReadOnlyMetadataCollection<EdmProperty>( new MetadataCollection<EdmProperty>( Check.NotNull(toProperties, "toProperties"))); }
// effects: Creates a foreign key constraint of the form: // <i_childTable, i_childColumns> --> <i_parentTable, i_childColumns> // i_fkeySet is the name of the constraint internal ForeignConstraint(AssociationSet i_fkeySet, EntitySet i_parentTable, EntitySet i_childTable, ReadOnlyMetadataCollection<EdmProperty> i_parentColumns, ReadOnlyMetadataCollection<EdmProperty> i_childColumns) { m_fKeySet = i_fkeySet; m_parentTable = i_parentTable; m_childTable = i_childTable; m_childColumns = new List<MemberPath>(); // Create parent and child paths using the table names foreach (EdmProperty property in i_childColumns) { MemberPath path = new MemberPath(m_childTable, property); m_childColumns.Add(path); } m_parentColumns = new List<MemberPath>(); foreach (EdmProperty property in i_parentColumns) { MemberPath path = new MemberPath(m_parentTable, property); m_parentColumns.Add(path); } }
private IEnumerable<DynamicFilterDefinition> FindFiltersForEntitySet(ReadOnlyMetadataCollection<MetadataProperty> metadataProperties, EntityContainer entityContainer) { var filterList = metadataProperties .Where(mp => mp.Name.Contains("customannotation:" + DynamicFilterConstants.ATTRIBUTE_NAME_PREFIX)) .Select(m => m.Value as DynamicFilterDefinition) .ToList(); if (filterList.Any()) { // Recursively remove any filters that exist in base EntitySets to this entity. // This happens when an entity uses Table-per-Type inheritance. Filters will be added // to all derived EntitySets because of the inheritance in the C# classes. But the database // representation (the EntitySet) does not give access to inherited propeties since they // only exist in the child EntitySet. And on queries of entities involved in TPT, the // query will generate a DbScanExpression for each EntitySet - so we only want the filters // applied to the DbScanExpression to which they apply. // See issue #32. RemoveFiltersForBaseClass(filterList.First().CLRType, filterList, entityContainer); } return filterList; }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// </summary> /// <param name="edmType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("SQLite does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["integer"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["uniqueidentifier"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!TypeHelpers.TryGetPrecision(edmType, out precision)) { precision = 18; } byte scale; if (!TypeHelpers.TryGetScale(edmType, out scale)) { scale = 0; } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: // binary, varbinary, varbinary(max), image, timestamp, rowversion { bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > Int32.MaxValue; int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["blob"], true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["blob"], false); } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["blob"], false, maxLength); } } return(tu); } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, varchar(max), nvarchar(max), ntext, text { bool isUnicode = null == facets["Unicode"].Value || (bool)facets["Unicode"].Value; bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > (isUnicode ? Int32.MaxValue : Int32.MaxValue); int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isUnicode) { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nchar"], true, true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar"], true, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, maxLength); } } } else { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], false, true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } } } return(tu); } case PrimitiveTypeKind.DateTime: // datetime, smalldatetime return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); default: throw new NotSupportedException(String.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format(Resources.TypeNotSupported, edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bool"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["double"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Decimal: { byte precision = 10; byte scale = 0; Facet facet; if (edmType.Facets.TryGetValue("Precision", false, out facet)) { if (!facet.IsUnbounded && facet.Value != null) { precision = (byte)facet.Value; } } if (edmType.Facets.TryGetValue("Scale", false, out facet)) { if (!facet.IsUnbounded && facet.Value != null) { scale = (byte)facet.Value; } } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: { bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > MEDIUMBLOB_MAXLEN; int maxLength = !isMaxLength ? (int)f.Value : LONGBLOB_MAXLEN; string typeName = String.Empty; if (isFixedLength) { if (maxLength < CHAR_MAXLEN) { typeName = "tinyblob"; } else if (maxLength < MEDIUMBLOB_MAXLEN) { typeName = "blob"; } else if (maxLength < LONGTEXT_MAXLEN) { typeName = "mediumblob"; } else { typeName = "longblob"; } } else { typeName = isMaxLength || maxLength > BINARY_MAXLEN ? "varbinary" : "binary"; maxLength = isMaxLength ? VARBINARY_MAXLEN : maxLength; } return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isFixedLength, maxLength)); } case PrimitiveTypeKind.String: { bool isUnicode = null == facets["Unicode"].Value || (bool)facets["Unicode"].Value; bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > MEDIUMTEXT_MAXLEN; int maxLength = !isMaxLength ? (int)f.Value : LONGTEXT_MAXLEN; string typeName = String.Empty; if (isFixedLength) { if (maxLength < CHAR_MAXLEN) { typeName = "char"; } else if (maxLength < LONGTEXT_MAXLEN) { typeName = "mediumtext"; } else { typeName = "longtext"; } } else { typeName = isMaxLength || maxLength > CHAR_MAXLEN ? "varchar" : "char"; maxLength = isMaxLength ? VARCHAR_MAXLEN : maxLength; } if (typeName.EndsWith("char") && isUnicode) { typeName = "n" + typeName; } return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, maxLength)); } case PrimitiveTypeKind.DateTimeOffset: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"])); case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Time: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); default: throw new NotSupportedException(String.Format(Resources.NoStoreTypeForEdmType, edmType, primitiveType.PrimitiveTypeKind)); } }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in SQL Server, taking the store version into consideration. /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } System.Diagnostics.Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint_bool"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["double"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Decimal: // decimal, numeric { byte precision; if (!TypeHelpers.TryGetPrecision(edmType, out precision)) { precision = 9; } byte scale; if (!TypeHelpers.TryGetScale(edmType, out scale)) { scale = 0; } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: // blob { bool isFixedLength = null != facets[MetadataHelpers.FixedLengthFacetName].Value && (bool)facets[MetadataHelpers.FixedLengthFacetName].Value; Facet f = facets[MetadataHelpers.MaxLengthFacetName]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > BinaryMaxSize; int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["blob"], true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["blob"], false); System.Diagnostics.Debug.Assert(tu.Facets["MaxLength"].Description.IsConstant, "blob is not constant!"); } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["blob"], false, maxLength); } } return(tu); } case PrimitiveTypeKind.String: // char, varchar, text blob { bool isUnicode = null == facets[MetadataHelpers.UnicodeFacetName].Value || (bool)facets[MetadataHelpers.UnicodeFacetName].Value; bool isFixedLength = null != facets[MetadataHelpers.FixedLengthFacetName].Value && (bool)facets[MetadataHelpers.FixedLengthFacetName].Value; Facet f = facets[MetadataHelpers.MaxLengthFacetName]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > (isUnicode ? UnicodeVarcharMaxSize : AsciiVarcharMaxSize); int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isUnicode) { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], true, true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["clob"], true, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], true, false, maxLength); } } } else { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], false, true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["clob"], false, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } } } return(tu); } case PrimitiveTypeKind.DateTime: // datetime, date { byte precision; bool useTimestamp; if (TypeHelpers.TryGetPrecision(edmType, out precision)) { if (precision == 0) { useTimestamp = false; } else { useTimestamp = true; } } else { useTimestamp = true; } return(TypeUsage.CreateDefaultTypeUsage(useTimestamp ? StoreTypeNameToStorePrimitiveType["timestamp"] : StoreTypeNameToStorePrimitiveType["date"])); } case PrimitiveTypeKind.Time: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid"])); default: throw new NotSupportedException(string.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
public string CastParameterName(TypeUsage edmType, string name) { if (edmType == null) { throw new ArgumentNullException("edmType"); } PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("Ingres does not support the type '{0}'.", edmType)); } if (edmType == null) { throw new ArgumentNullException("edmType"); } StringBuilder sb = new StringBuilder(); ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: sb.Append("boolean(" + name); break; case PrimitiveTypeKind.SByte: sb.Append("int1(" + name); break; case PrimitiveTypeKind.Byte: sb.Append("int2(" + name); break; case PrimitiveTypeKind.Int16: sb.Append("int2(" + name); break; case PrimitiveTypeKind.Int32: sb.Append("int4(" + name); break; case PrimitiveTypeKind.Int64: sb.Append("int8(" + name); break; case PrimitiveTypeKind.Guid: sb.Append("varchar(" + name); break; case PrimitiveTypeKind.Double: sb.Append("float8(" + name); break; case PrimitiveTypeKind.Single: sb.Append("float4(" + name); break; case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!TypeHelpers.TryGetPrecision(edmType, out precision)) { precision = 18; } byte scale; if (!TypeHelpers.TryGetScale(edmType, out scale)) { scale = 0; } sb.Append(Format("decimal({0}, {1}, {2})", name, precision, scale)); break; } case PrimitiveTypeKind.Binary: // binary, varbinary, varbinary(max), image, timestamp, rowversion { bool isFixedLength = (null != facets["FixedLength"].Value) && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > Int32.MaxValue; int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; if (isFixedLength) { sb.Append("binary(" + name + ", "); sb.Append(maxLength.ToString()); } else { sb.Append("binary(" + name); } break; } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, varchar(max), nvarchar(max), ntext, text { bool isUnicode = (null == facets["Unicode"].Value) || (bool)facets["Unicode"].Value; bool isFixedLength = (null != facets["FixedLength"].Value) && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null bool isMaxLength = f.IsUnbounded || (null == f.Value) || (int)f.Value > (isUnicode ? Int32.MaxValue : Int32.MaxValue); int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; if (isUnicode) { if (isFixedLength) { sb.Append("nchar(" + name + ", "); sb.Append(maxLength.ToString()); } else { sb.Append("nvarchar(" + name); } } else { if (isFixedLength) { sb.Append("char(" + name + ", "); sb.Append(maxLength.ToString()); } else { sb.Append("varchar(" + name); } } break; } case PrimitiveTypeKind.DateTime: // datetime { sb.Append("timestamp(" + name); break; } case PrimitiveTypeKind.Time: // time { sb.Append("interval_dtos(" + name); break; } default: { break; } } // end switch if (sb.Length > 0) { sb.Append(")"); return(sb.ToString()); } else { return(name); } }
/// <summary> /// Generates SQL fragment returning server-generated values. /// Requires: translator knows about member values so that we can figure out /// how to construct the key predicate. /// <code> /// Sample SQL: /// /// select IdentityValue /// from myschema.MyTable /// where __ingres_@@ROWCOUNT > 0 and IdentityValue = LAST_IDENTITY() /// /// The "__ingres_@@ROWCOUNT" will be replaced by /// the IngresDbCommandInterceptor with the number /// returned for recordsAffected in the batch execution. /// /// Note that we filter on rowcount to ensure no rows are returned if no rows were modified. /// </code> /// </summary> /// <param name="commandText">Builder containing command text</param> /// <param name="tree">Modification command tree</param> /// <param name="translator">Translator used to produce DML SQL statement /// for the tree</param> /// <param name="returning">Returning expression. If null, the method returns /// immediately without producing a SELECT statement.</param> /// <param name="wasInsert"> /// Non-zero if this method is being called as part of processing an INSERT; /// otherwise (e.g. UPDATE), zero. /// </param> private static void GenerateReturningSql( StringBuilder commandText, DbModificationCommandTree tree, ExpressionTranslator translator, DbExpression returning, bool wasInsert) { // Nothing to do if there is no Returning expression if (null == returning) { return; } commandText.Append(";"); // semicolon separated batch of SQL statements // to be executed by IngresDbCommandInterceptor // select commandText.Append("SELECT "); returning.Accept(translator); // e.g. "BlogId", "IntComputedValue" commandText.AppendLine(); // from commandText.Append("FROM "); tree.Target.Expression.Accept(translator); // e.g. "Blogs" commandText.AppendLine(); // where // (Ensure prior INSERT statements completed OK using recordsAffected. // The IngresDbCommandInterceptor will cut/paste __ingres_@@ROWCOUNT // with the number returned for recordsAffected.) commandText.Append("WHERE __ingres_@@ROWCOUNT > 0"); EntitySetBase table = ((DbScanExpression)tree.Target.Expression).Target; ReadOnlyMetadataCollection <EdmMember> keyMembers = table.ElementType.KeyMembers; var hasIdentityBeenAlreadyProcessed = false; foreach (var keyMember in keyMembers) { commandText.Append(" AND "); commandText.Append(GenerateMemberTSql(keyMember)); commandText.Append(" = "); // Retrieve member value sql. the translator remembers // member values as it constructs the INSERT/UPDATE // statement (which precedes the "returning" SQL SELECT) DbParameter value; if (translator.MemberValues.TryGetValue(keyMember, out value)) { commandText.Append(value.ParameterName); continue; // move on to the next keyMember in keyMembers } // We have no member value to retrieve the row. Argh! // If INSERT then might be able to use IDENTITY. // Check that the column is an exact numeric data // type in order to qualify as an Identity column. if (wasInsert && IsaIdentityColumnType(keyMember.TypeUsage)) { // If no value is registered for the key member, // it means it is an Identity Column value which can // be retrieved using the LAST_IDENTITY() function if (hasIdentityBeenAlreadyProcessed) { // there can be only one server generated key throw new NotSupportedException(String.Format( "Store-generated keys are only supported for " + "identity columns. More than one key column '{0}' " + "is marked as server generated in table '{1}'.", (keyMember != null) ? keyMember.Name : "<unknown>", table.Name)); } // LAST_IDENTITY() is a sequence expression function that // returns the last value generated for an identity column // in any table for the current session. Since we had just done // a successfull INSERT (recordsAffected > 0) of a row into a // table with an identity column, we expect to retrieve that row. commandText.Append("LAST_IDENTITY()"); hasIdentityBeenAlreadyProcessed = true; } // end if (wasInsert and possible Identity column) else // else UPDATE or not an Identity column { // We cannot even try to use LAST_IDENTITY() at this point // because the LAST_IDENTITY() function is only valid after // an INSERT and this was an UPDATE or not an Identity. throw new NotSupportedException(String.Format( "Missing value for {0} key member '{1}' in table '{2}'.", (wasInsert) ? "INSERT" : "UPDATE", (keyMember != null) ? keyMember.Name : "<unknown>", table.Name)); } } // end foreach (var keyMember in keyMembers) commandText.AppendLine(";"); // mark end of batch statements to be // executed by IngresDbCommandInterceptor }
private static bool IsKatmaiOrNewer(EdmFunction edmFunction) { if (edmFunction.ReturnParameter != null && edmFunction.ReturnParameter.TypeUsage.IsSpatialType() || edmFunction.Parameters.Any <FunctionParameter>((Func <FunctionParameter, bool>)(p => p.TypeUsage.IsSpatialType()))) { return(true); } ReadOnlyMetadataCollection <FunctionParameter> parameters = edmFunction.Parameters; switch (edmFunction.Name.ToUpperInvariant()) { case "COUNT": case "COUNT_BIG": case "MAX": case "MIN": string name1 = ((CollectionType)parameters[0].TypeUsage.EdmType).TypeUsage.EdmType.Name; if (!name1.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) { return(name1.Equals("Time", StringComparison.OrdinalIgnoreCase)); } return(true); case "DAY": case "MONTH": case "YEAR": case "DATALENGTH": case "CHECKSUM": string name2 = parameters[0].TypeUsage.EdmType.Name; if (!name2.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) { return(name2.Equals("Time", StringComparison.OrdinalIgnoreCase)); } return(true); case "DATEADD": case "DATEDIFF": string name3 = parameters[1].TypeUsage.EdmType.Name; string name4 = parameters[2].TypeUsage.EdmType.Name; if (!name3.Equals("Time", StringComparison.OrdinalIgnoreCase) && !name4.Equals("Time", StringComparison.OrdinalIgnoreCase) && !name3.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) { return(name4.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)); } return(true); case "DATENAME": case "DATEPART": string name5 = parameters[1].TypeUsage.EdmType.Name; if (!name5.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) { return(name5.Equals("Time", StringComparison.OrdinalIgnoreCase)); } return(true); case "SYSUTCDATETIME": case "SYSDATETIME": case "SYSDATETIMEOFFSET": return(true); default: return(false); } }
protected override DesignTimeMetadata GetDesignTimeMetadata(bool isDraft) { DesignTimeMetadata metadata = new DesignTimeMetadata(); EntityContainer container = ObjectContext.MetadataWorkspace.GetEntityContainer(ObjectContext.DefaultContainerName, DataSpace.CSpace); var entitySetsDic = (from meta in container.BaseEntitySets where meta.BuiltInTypeKind == BuiltInTypeKind.EntitySet select new { EntitySetName = meta.Name, EntityTypeName = meta.ElementType.Name }).ToDictionary(es => es.EntityTypeName); ItemCollection CSpace = ObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.CSpace); ItemCollection SSpace = ObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); EntityType[] entityEdmTypes = CSpace.GetItems <EntityType>().OrderBy(e => e.Name).ToArray(); ComplexType[] complexEdmTypes = CSpace.GetItems <ComplexType>().OrderBy(e => e.Name).ToArray(); Array.ForEach(complexEdmTypes, (entityEdmType) => { string entityTypeName = entityEdmType.Name; string name = entityTypeName; string[] keys = entityEdmType.Members.Select(m => m.Name).Take(1).ToArray(); Type entityType = GetEntityType2(entityTypeName); DbSetInfo dbSetInfo = new DbSetInfo() { dbSetName = entityTypeName }; dbSetInfo.SetEntityType(entityType); metadata.DbSets.Add(dbSetInfo); EdmProperty[] edmProps = entityEdmType.Properties.ToArray(); GenerateFieldInfos(dbSetInfo, keys, edmProps); }); Array.ForEach(entityEdmTypes, (entityEdmType) => { if (entityEdmType.Abstract) { return; } string entityTypeName = entityEdmType.Name; string name = entityTypeName; if (entityEdmType.BaseType != null) { name = entityEdmType.BaseType.Name; } string[] keys = entityEdmType.KeyMembers.Select(k => k.Name).ToArray(); //var dbEntityEdm = dbEntityEdmTypes[dbTableName]; //Type entityType = this.GetEntityType(entitySetName); //string entitySetName = entitySetsDic[name].EntitySetName; Type entityType = GetEntityType2(entityTypeName); DbSetInfo dbSetInfo = new DbSetInfo() { dbSetName = entityTypeName }; dbSetInfo.SetEntityType(entityType); metadata.DbSets.Add(dbSetInfo); EdmProperty[] edmProps = entityEdmType.Properties.ToArray(); GenerateFieldInfos(dbSetInfo, keys, edmProps); }); IOrderedEnumerable <AssociationType> associations = CSpace.GetItems <AssociationType>().Where(a => a.IsForeignKey).OrderBy(e => e.Name); Func <EdmType, string> fn_name = (EdmType n) => { if (n.FullName.Contains('[')) { Regex regex = new Regex(".*?\\[(.*?)\\].*?"); Match match = regex.Match(n.FullName); string table = match.Groups[1].Value; return(table); } else { return(n.FullName); } }; foreach (AssociationType asstype in associations) { ReadOnlyMetadataCollection <RelationshipEndMember> endMembers = asstype.RelationshipEndMembers; foreach (ReferentialConstraint constraint in asstype.ReferentialConstraints) { try { Association ass = metadata.Associations.Where(a => a.name == constraint.ToString()).FirstOrDefault(); if (ass == null) { RelationshipEndMember parentEnd = (constraint.FromRole.RelationshipMultiplicity == RelationshipMultiplicity.One || constraint.FromRole.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne) ? constraint.FromRole : constraint.ToRole; RelationshipEndMember childEnd = constraint.FromRole == parentEnd ? constraint.ToRole : constraint.FromRole; EdmType parent = parentEnd.TypeUsage.EdmType; EdmType child = childEnd.TypeUsage.EdmType; string parentName = fn_name(parent); string childName = fn_name(child); EntityType parentEntity = entityEdmTypes.Where(en => parentName == en.FullName).First(); EntityType childEntity = entityEdmTypes.Where(en => childName == en.FullName).First(); NavigationProperty parentToChildren = parentEntity.NavigationProperties.Where(np => np.FromEndMember.Name == parentEnd.Name && np.ToEndMember.Name == childEnd.Name).FirstOrDefault(); NavigationProperty childToParent = childEntity.NavigationProperties.Where(np => np.FromEndMember.Name == childEnd.Name && np.ToEndMember.Name == parentEnd.Name).FirstOrDefault(); ass = new Association { name = constraint.ToString() }; metadata.Associations.Add(ass); ass.parentDbSetName = parentEntity.Name; ass.childDbSetName = childEntity.Name; ass.parentToChildrenName = parentToChildren == null ? "" : parentToChildren.Name; ass.childToParentName = childToParent == null ? "" : childToParent.Name; EdmProperty[] parentArr = constraint.FromRole == parentEnd?constraint.FromProperties.ToArray() : constraint.ToProperties.ToArray(); EdmProperty[] childArr = constraint.FromRole == parentEnd?constraint.ToProperties.ToArray() : constraint.FromProperties.ToArray(); for (int i = 0; i < parentArr.Length; ++i) { FieldRel frel = null; frel = ass.fieldRels.Where(fr => fr.parentField == parentArr[i].Name && fr.childField == childArr[i].Name).FirstOrDefault(); if (frel == null) { frel = new FieldRel(); ass.fieldRels.Add(frel); frel.parentField = parentArr[i].Name; frel.childField = childArr[i].Name; } } } } catch (Exception) { throw; } } } return(metadata); }
// just for fun: get all the facet values as a Dictionary public static Dictionary <string, object> AsDictionary(this ReadOnlyMetadataCollection <Facet> facets) { return(facets.ToDictionary(o => o.Name, o => o.Value)); }
private bool DoPropertiesHaveDefaultNames(ReadOnlyMetadataCollection <EdmProperty> properties, ReadOnlyMetadataCollection <EdmProperty> otherEndProperties) { if (properties.Count != otherEndProperties.Count) { return(false); } return(!properties.Where((t, i) => !t.Name.EndsWith("_" + otherEndProperties[i].Name)).Any()); }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in SQL Server, taking the store version into consideration. /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } System.Diagnostics.Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["uniqueidentifier"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!TypeHelpers.TryGetPrecision(edmType, out precision)) { precision = 18; } byte scale; if (!TypeHelpers.TryGetScale(edmType, out scale)) { scale = 0; } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: // binary, varbinary, varbinary(max), image, timestamp, rowversion { bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > binaryMaxSize; int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["binary"], true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary(max)"], false); System.Diagnostics.Debug.Assert(tu.Facets["MaxLength"].Description.IsConstant, "varbinary(max) is not constant!"); } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength); } } return(tu); } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, varchar(max), nvarchar(max), ntext, text, xml { bool isUnicode = null == facets["Unicode"].Value || (bool)facets["Unicode"].Value; bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > (isUnicode ? nvarcharMaxSize : varcharMaxSize); int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isUnicode) { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nchar"], true, true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar(max)"], true, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, maxLength); } } } else { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], false, true, maxLength); } else { if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar(max)"], false, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } } } return(tu); } case PrimitiveTypeKind.DateTime: // datetime, smalldatetime Facet preserveSecondsFacet; bool preserveSeconds; if (edmType.Facets.TryGetValue("PreserveSeconds", true, out preserveSecondsFacet) && null != preserveSecondsFacet.Value) { preserveSeconds = (bool)preserveSecondsFacet.Value; } else { preserveSeconds = true; } return(TypeUsage.CreateDefaultTypeUsage(preserveSeconds ? StoreTypeNameToStorePrimitiveType["datetime"] : StoreTypeNameToStorePrimitiveType["smalldatetime"])); case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["geography"])); case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["geometry"])); default: throw new NotSupportedException(String.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
// get MaxLength as an extension method to the Facets (I think the extension belongs here) public static int?GetMaxLength(this ReadOnlyMetadataCollection <Facet> facets) { return((int?)facets["MaxLength"].Value); }
public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } System.Diagnostics.Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; Facet f; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["boolean"])); case PrimitiveTypeKind.Byte: case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["integer"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["double"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Decimal: // decimal, numeric { byte precision = 9; if (facets.TryGetValue("Precision", false, out f) && !f.IsUnbounded && f.Value != null) { precision = (byte)f.Value; } byte scale = 0; if (facets.TryGetValue("Scale", false, out f) && !f.IsUnbounded && f.Value != null) { scale = (byte)f.Value; } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.String: // char, varchar, text blob { bool isUnicode = true; if (facets.TryGetValue("Unicode", false, out f) && !f.IsUnbounded && f.Value != null) { isUnicode = (bool)f.Value; } bool isFixedLength = true; if (facets.TryGetValue("FixedLength", false, out f) && !f.IsUnbounded && f.Value != null) { isFixedLength = (bool)f.Value; } int maxLength = Int32.MinValue; if (facets.TryGetValue("MaxLength", false, out f) && !f.IsUnbounded && f.Value != null) { maxLength = (int)f.Value; } PrimitiveType storePrimitiveType = StoreTypeNameToStorePrimitiveType[isFixedLength ? "char" : "varchar"]; if (maxLength != Int32.MinValue) { return(TypeUsage.CreateStringTypeUsage(storePrimitiveType, isUnicode, isFixedLength, maxLength)); } return(TypeUsage.CreateStringTypeUsage(storePrimitiveType, isUnicode, isFixedLength)); } case PrimitiveTypeKind.DateTime: // datetime, date { byte precision = 4; if (facets.TryGetValue("Precision", false, out f) && !f.IsUnbounded && f.Value != null) { precision = (byte)f.Value; } bool useTimestamp = (precision != 0); return(TypeUsage.CreateDefaultTypeUsage(useTimestamp ? StoreTypeNameToStorePrimitiveType["datetime"] : StoreTypeNameToStorePrimitiveType["date"])); } case PrimitiveTypeKind.Time: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); case PrimitiveTypeKind.Binary: // blob { bool isFixedLength = true; if (facets.TryGetValue("FixedLength", false, out f) && !f.IsUnbounded && f.Value != null) { isFixedLength = (bool)f.Value; } int maxLength = Int32.MinValue; if (facets.TryGetValue("MaxLength", false, out f) && !f.IsUnbounded && f.Value != null) { maxLength = (int)f.Value; } PrimitiveType storePrimitiveType = StoreTypeNameToStorePrimitiveType["binary"]; if (maxLength != Int32.MinValue) { return(TypeUsage.CreateBinaryTypeUsage(storePrimitiveType, isFixedLength, maxLength)); } return(TypeUsage.CreateBinaryTypeUsage(storePrimitiveType, isFixedLength)); } case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid_char"])); default: throw new NotSupportedException(string.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
// effects: Creates a foreign key constraint of the form: // <i_childTable, i_childColumns> --> <i_parentTable, i_childColumns> // i_fkeySet is the name of the constraint internal ForeignConstraint(AssociationSet i_fkeySet, EntitySet i_parentTable, EntitySet i_childTable, ReadOnlyMetadataCollection <EdmProperty> i_parentColumns, ReadOnlyMetadataCollection <EdmProperty> i_childColumns) { m_fKeySet = i_fkeySet; m_parentTable = i_parentTable; m_childTable = i_childTable; m_childColumns = new List <MemberPath>(); // Create parent and child paths using the table names foreach (EdmProperty property in i_childColumns) { MemberPath path = new MemberPath(m_childTable, property); m_childColumns.Add(path); } m_parentColumns = new List <MemberPath>(); foreach (EdmProperty property in i_parentColumns) { MemberPath path = new MemberPath(m_parentTable, property); m_parentColumns.Add(path); } }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in SQL Server, taking the store version into consideration. /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { EntityUtil.CheckArgumentNull <TypeUsage>(edmType, "edmType"); System.Diagnostics.Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw EntityUtil.Argument(Strings.ProviderDoesNotSupportType(edmType.Identity)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: return(GetStorePrimitiveTypeIfPostSql9("geography", edmType.Identity, primitiveType.PrimitiveTypeKind)); case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: return(GetStorePrimitiveTypeIfPostSql9("geometry", edmType.Identity, primitiveType.PrimitiveTypeKind)); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["uniqueidentifier"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!TypeHelpers.TryGetPrecision(edmType, out precision)) { precision = 18; } byte scale; if (!TypeHelpers.TryGetScale(edmType, out scale)) { scale = 0; } TypeUsage tu = TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale); return(tu); } case PrimitiveTypeKind.Binary: // binary, varbinary, varbinary(max), image, timestamp, rowversion { bool isFixedLength = null != facets[DbProviderManifest.FixedLengthFacetName].Value && (bool)facets[DbProviderManifest.FixedLengthFacetName].Value; Facet f = facets[DbProviderManifest.MaxLengthFacetName]; bool isMaxLength = Helper.IsUnboundedFacetValue(f) || null == f.Value || (int)f.Value > binaryMaxSize; int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["binary"], true, (isMaxLength ? binaryMaxSize : maxLength)); } else { if (isMaxLength) { if (_version != SqlVersion.Sql8) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary(max)"], false); Debug.Assert(tu.Facets[DbProviderManifest.MaxLengthFacetName].Description.IsConstant, "varbinary(max) is not constant!"); } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary"], false, binaryMaxSize); } } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength); } } return(tu); } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, varchar(max), nvarchar(max), ntext, text, xml { bool isUnicode = null == facets[DbProviderManifest.UnicodeFacetName].Value || (bool)facets[DbProviderManifest.UnicodeFacetName].Value; bool isFixedLength = null != facets[DbProviderManifest.FixedLengthFacetName].Value && (bool)facets[DbProviderManifest.FixedLengthFacetName].Value; Facet f = facets[DbProviderManifest.MaxLengthFacetName]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null bool isMaxLength = Helper.IsUnboundedFacetValue(f) || null == f.Value || (int)f.Value > (isUnicode ? nvarcharMaxSize : varcharMaxSize); int maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isUnicode) { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nchar"], true, true, (isMaxLength ? nvarcharMaxSize : maxLength)); } else { if (isMaxLength) { // nvarchar(max) (SQL 9) or ntext (SQL 8) if (_version != SqlVersion.Sql8) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar(max)"], true, false); Debug.Assert(tu.Facets[DbProviderManifest.MaxLengthFacetName].Description.IsConstant, "NVarchar(max) is not constant!"); } else { // if it is unknown, fallback to nvarchar[4000] instead of ntext since it has limited store semantics tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, nvarcharMaxSize); } } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, maxLength); } } } else // !isUnicode { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], false, true, (isMaxLength ? varcharMaxSize : maxLength)); } else { if (isMaxLength) { // nvarchar(max) (SQL 9) or ntext (SQL 8) if (_version != SqlVersion.Sql8) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar(max)"], false, false); Debug.Assert(tu.Facets[DbProviderManifest.MaxLengthFacetName].Description.IsConstant, "varchar(max) is not constant!"); } else { // if it is unknown, fallback to varchar[8000] instead of text since it has limited store semantics tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, varcharMaxSize); } } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } } } return(tu); } case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.DateTimeOffset: return(GetStorePrimitiveTypeIfPostSql9("datetimeoffset", edmType.Identity, primitiveType.PrimitiveTypeKind)); case PrimitiveTypeKind.Time: return(GetStorePrimitiveTypeIfPostSql9("time", edmType.Identity, primitiveType.PrimitiveTypeKind)); default: throw EntityUtil.NotSupported(Strings.NoStoreTypeForEdmType(edmType.Identity, primitiveType.PrimitiveTypeKind)); } }
private bool DoPropertiesHaveDefaultNames(ReadOnlyMetadataCollection <EdmProperty> properties, string roleName, ReadOnlyMetadataCollection <EdmProperty> otherEndProperties) { if (properties.Count != otherEndProperties.Count) { return(false); } for (int i = 0; i < properties.Count; ++i) { if (!properties[i].Name.EndsWith("_" + otherEndProperties[i].Name)) { return(false); } } return(true); }
/// <summary> /// Main code generator method. /// </summary> /// <param name="namespaceString">Namespace where the class will reside</param> /// <param name="className">Generated class name</param> /// <param name="attributeNamespace">The 'EdmFunction' attribute parameter</param> /// <param name="pascalCaseFunctionNames">If the input function names need to be pascal cased.</param> public StringWriter GenerateCode(string namespaceString, string className, string attributeNamespace, Boolean pascalCaseFunctionNames) { StringWriter newCode = new StringWriter(); Boolean isAggregateFunction; bool hasSByteParameterOrReturnType; bool hasStringInParameterName; String separator; GenerateFileHeader(newCode, className); GenerateUsingStatements(newCode); newCode.WriteLine("namespace " + namespaceString); newCode.WriteLine("{"); GenerateClassHeader(newCode, className, attributeNamespace); foreach (System.Data.Metadata.Edm.EdmFunction function in _functions) { isAggregateFunction = false; hasSByteParameterOrReturnType = false; hasStringInParameterName = false; separator = ""; String functionNameToUse = FindCorrectFunctionName(function.Name, pascalCaseFunctionNames); GenerateFunctionHeader(newCode, attributeNamespace, function.Name); Type returnType = ((PrimitiveType)(function.ReturnParameter.TypeUsage.EdmType)).ClrEquivalentType; //Suppress warning that 'SByte' is not CLS-compliant. if (returnType == typeof(SByte)) { hasSByteParameterOrReturnType = true; } StringBuilder functionSignatureString = new StringBuilder(); AppendSpaces(functionSignatureString, 8); functionSignatureString.Append("public static "); WriteType(functionSignatureString, returnType); functionSignatureString.Append(functionNameToUse + "("); ReadOnlyMetadataCollection <FunctionParameter> functionParameters = function.Parameters; Type parameterType; foreach (System.Data.Metadata.Edm.FunctionParameter parameter in functionParameters) { String parameterNameToUse = parameter.Name; parameterNameToUse = FindCorrectParameterName(parameterNameToUse); //Detect aggregate functions. They have just one parameter and so stub can be generated here. if (parameter.TypeUsage.EdmType.GetType() == typeof(System.Data.Metadata.Edm.CollectionType)) { isAggregateFunction = true; if (parameterNameToUse.ToLowerInvariant().Contains("string")) { hasStringInParameterName = true; } System.Data.Metadata.Edm.CollectionType collectionType = (System.Data.Metadata.Edm.CollectionType)parameter.TypeUsage.EdmType; parameterType = ((PrimitiveType)(collectionType.TypeUsage.EdmType)).ClrEquivalentType; //Detect if there is an 'SByte' parameter to suppress non-CLS-compliance warning. //Generate the attribute only once for each function. if (parameterType == typeof(SByte)) { hasSByteParameterOrReturnType = true; } //Generate stub for non-nullable input parameters functionSignatureString.Append("IEnumerable<" + parameterType.ToString()); //Supress fxcop message and CLS non-compliant attributes GenerateFunctionAttributes(newCode, hasStringInParameterName, hasSByteParameterOrReturnType); //Use the constructed function signature newCode.Write(functionSignatureString.ToString()); GenerateAggregateFunctionStub(newCode, parameterType, returnType, parameterNameToUse, false); //Generate stub for nullable input parameters //Special Case: Do not generate nullable stub for input parameter of types Byte[] //and String, since they are nullable. if (!IsNullableType(parameterType)) { GenerateFunctionHeader(newCode, attributeNamespace, function.Name); //Supress fxcop message and CLS non-compliant attributes GenerateFunctionAttributes(newCode, hasStringInParameterName, hasSByteParameterOrReturnType); //Use the constructed function signature newCode.Write(functionSignatureString.ToString()); GenerateAggregateFunctionStub(newCode, parameterType, returnType, parameterNameToUse, true); } } //End of processing parameters for aggregate functions. //Process each parameter in case of non-aggregate functions. else { parameterType = ((PrimitiveType)(parameter.TypeUsage.EdmType)).ClrEquivalentType; functionSignatureString.Append(separator); WriteType(functionSignatureString, parameterType); functionSignatureString.Append(parameterNameToUse); separator = ", "; //Detect if there is an 'SByte' parameter to suppress non-CLS-compliance warning. if (parameterType == typeof(SByte)) { hasSByteParameterOrReturnType = true; } if (parameterNameToUse.ToLowerInvariant().Contains("string")) { hasStringInParameterName = true; } } } //End for each parameter //Generate stub for Non-aggregate functions after all input parameters are found. if (!isAggregateFunction) { //Supress fxcop supression and CLS non-compliant attributes GenerateFunctionAttributes(newCode, hasStringInParameterName, hasSByteParameterOrReturnType); newCode.WriteLine(functionSignatureString.ToString() + ")"); AppendSpaces(newCode, 8); newCode.WriteLine("{"); WriteExceptionStatement(newCode); } } //End for each function AppendSpaces(newCode, 4); newCode.WriteLine("}"); newCode.WriteLine("}"); newCode.Close(); return(newCode); }
private void ResetEntitySetsCache(object sender, EventArgs e) { if (_entitySetsCache != null) { lock (_baseEntitySetsLock) { if (_entitySetsCache != null) { _entitySetsCache = null; _baseEntitySets.SourceAccessed -= ResetEntitySetsCache; } } } }
static bool DoPropertiesHaveDefaultNames(ReadOnlyMetadataCollection <EdmProperty> properties, ReadOnlyMetadataCollection <EdmProperty> otherEndProperties) { if (properties.Count != otherEndProperties.Count) { return(false); } for (int i = 0; i < properties.Count; ++i) { if (!properties[i].Name.EndsWith("_" + otherEndProperties[i].Name, StringComparison.OrdinalIgnoreCase)) { return(false); } } return(true); }
private static bool IsKatmaiOrNewer(EdmFunction edmFunction) { // Spatial types are only supported from Katmai onward; any functions using them must therefore also be Katmai or newer. if ((edmFunction.ReturnParameter != null && Helper.IsSpatialType(edmFunction.ReturnParameter.TypeUsage)) || edmFunction.Parameters.Any(p => Helper.IsSpatialType(p.TypeUsage))) { return(true); } ReadOnlyMetadataCollection <FunctionParameter> funParams = edmFunction.Parameters; switch (edmFunction.Name.ToUpperInvariant()) { case "COUNT": case "COUNT_BIG": case "MAX": case "MIN": { string name = ((CollectionType)funParams[0].TypeUsage.EdmType).TypeUsage.EdmType.Name; return((name.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) || (name.Equals("Time", StringComparison.OrdinalIgnoreCase))); } case "DAY": case "MONTH": case "YEAR": case "DATALENGTH": case "CHECKSUM": { string name = funParams[0].TypeUsage.EdmType.Name; return((name.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) || (name.Equals("Time", StringComparison.OrdinalIgnoreCase))); } case "DATEADD": case "DATEDIFF": { string param1Name = funParams[1].TypeUsage.EdmType.Name; string param2Name = funParams[2].TypeUsage.EdmType.Name; return((param1Name.Equals("Time", StringComparison.OrdinalIgnoreCase)) || (param2Name.Equals("Time", StringComparison.OrdinalIgnoreCase)) || (param1Name.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) || (param2Name.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase))); } case "DATENAME": case "DATEPART": { string name = funParams[1].TypeUsage.EdmType.Name; return((name.Equals("DateTimeOffset", StringComparison.OrdinalIgnoreCase)) || (name.Equals("Time", StringComparison.OrdinalIgnoreCase))); } case "SYSUTCDATETIME": case "SYSDATETIME": case "SYSDATETIMEOFFSET": return(true); default: break; } return(false); }
private static void PopulateDataTable <TEnity>(DataTable dataTable, ObjectContext objectContext, IList <TEnity> list, ReadOnlyMetadataCollection <EdmMember> storageSpaceMembers) where TEnity : class { Type typeOfEntity = typeof(TEnity); ReadOnlyMetadataCollection <EdmMember> objectSpaceMembers = objectContext.MetadataWorkspace.GetItem <EntityType>(typeOfEntity.FullName, true, DataSpace.OSpace).Members; EntitySetBase entitySetBase = objectContext.MetadataWorkspace.GetEntityContainer(objectContext.DefaultContainerName, DataSpace.CSpace).BaseEntitySets.FirstOrDefault(baseEntitySet => baseEntitySet.ElementType.Name.Equals(typeOfEntity.Name, StringComparison.OrdinalIgnoreCase)); EntityType entityType = (EntityType)entitySetBase.ElementType; foreach (TEnity entity in list) { DataRow dataRow = dataTable.NewRow(); foreach (EdmProperty edmProperty in entityType.Properties) { dataRow[storageSpaceMembers[objectSpaceMembers.IndexOf(objectSpaceMembers[edmProperty.Name])].Name] = (GetPropertyValue <object>(entity, edmProperty.Name) == null)?DBNull.Value: GetPropertyValue <object>(entity, edmProperty.Name); } if (entityType.NavigationProperties.Count > 0) { ICollection <ReferentialConstraint> referentialConstraints = GetReferentialConstraints(objectContext, typeOfEntity, entitySetBase); foreach (NavigationProperty navigationProperty in entityType.NavigationProperties) { IEnumerable <ReferentialConstraint> filteredReferentialConstraints = referentialConstraints.Where(referentialConstraint => referentialConstraint.FromRole.Name.Equals(navigationProperty.Name, StringComparison.OrdinalIgnoreCase)); foreach (ReferentialConstraint referentialConstraint in filteredReferentialConstraints) { dataRow[referentialConstraint.ToProperties[0].Name] = GetPropertyValue <object>(GetPropertyValue <object>(entity, referentialConstraint.FromRole.Name), referentialConstraint.FromProperties[0].Name); } } } dataTable.Rows.Add(dataRow); } }
private IEnumerable<DynamicFilterDefinition> FindFiltersForEntitySet(ReadOnlyMetadataCollection<MetadataProperty> metadataProperties) { var configuration = metadataProperties.FirstOrDefault(p => p.Name == "Configuration")?.Value; if (configuration == null) return new List<DynamicFilterDefinition>(); // The "Annotations" property will not exist if this is a navigation property (because configuration // is a NavigationPropertyConfiguration object not an EntityTypeConfiguration object. // That happens if we use the entry.Load() command to load a child collection. See issue #71. var annotations = configuration.GetType().GetProperty("Annotations")?.GetValue(configuration, null) as Dictionary<string, object>; if (annotations == null) return new List<DynamicFilterDefinition>(); var filterList = annotations.Select(a => a.Value as DynamicFilterDefinition).Where(a => a != null).ToList(); // Note: Prior to the switch to use CSpace (which was done to allow filters on navigation properties), // we had to remove filters that exist in base EntitySets to this entity to fix issues with // Table-per-Type inheritance (issue #32). In CSpace none of that is necessary since we are working // with the actual c# models now (in CSpace) so we always have the correct filters and access to all // the inherited properties that we need. return filterList; }
//"doFixup" equals to False is called from EntityCollection & Ref code only internal void Delete(bool doFixup) { ValidateState(); if (doFixup) { if (State != EntityState.Deleted) //for deleted ObjectStateEntry its a no-op { //Find two ends of the relationship EntityEntry entry1 = _cache.GetEntityEntry((EntityKey)GetCurrentRelationValue(0)); IEntityWrapper wrappedEntity1 = entry1.WrappedEntity; EntityEntry entry2 = _cache.GetEntityEntry((EntityKey)GetCurrentRelationValue(1)); IEntityWrapper wrappedEntity2 = entry2.WrappedEntity; // If one end of the relationship is a KeyEntry, entity1 or entity2 is null. // It is not possible that both ends of relationship are KeyEntries. if (wrappedEntity1.Entity != null && wrappedEntity2.Entity != null) { // Obtain the ro role name and relationship name // We don't create a full NavigationRelationship here because that would require looking up // additional information like property names that we don't need. ReadOnlyMetadataCollection <AssociationEndMember> endMembers = _relationshipWrapper.AssociationEndMembers; string toRole = endMembers[1].Name; string relationshipName = ((AssociationSet)_entitySet).ElementType.FullName; wrappedEntity1.RelationshipManager.RemoveEntity(toRole, relationshipName, wrappedEntity2); } else { // One end of relationship is a KeyEntry, figure out which one is the real entity and get its RelationshipManager // so we can update the DetachedEntityKey on the EntityReference associated with this relationship EntityKey targetKey = null; RelationshipManager relationshipManager = null; if (wrappedEntity1.Entity == null) { targetKey = entry1.EntityKey; relationshipManager = wrappedEntity2.RelationshipManager; } else { targetKey = entry2.EntityKey; relationshipManager = wrappedEntity1.RelationshipManager; } Debug.Assert(relationshipManager != null, "Entity wrapper returned a null RelationshipManager"); // Clear the detachedEntityKey as well. In cases where we have to fix up the detachedEntityKey, we will not always be able to detect // if we have *only* a Deleted relationship for a given entity/relationship/role, so clearing this here will ensure that // even if no other relationships are added, the key value will still be correct and we won't accidentally pick up an old value. // devnote: Since we know the target end of this relationship is a key entry, it has to be a reference, so just cast AssociationEndMember targetMember = this.RelationshipWrapper.GetAssociationEndMember(targetKey); EntityReference entityReference = (EntityReference)relationshipManager.GetRelatedEndInternal(targetMember.DeclaringType.FullName, targetMember.Name); entityReference.DetachedEntityKey = null; // Now update the state if (this.State == EntityState.Added) { // Remove key entry if necessary DeleteUnnecessaryKeyEntries(); // Remove relationship entry // devnote: Using this method instead of just changing the state because the entry // may have already been detached along with the key entry above. However, // if there were other relationships using the key, it would not have been deleted. DetachRelationshipEntry(); } else { // Non-added entries should be deleted _cache.ChangeState(this, this.State, EntityState.Deleted); State = EntityState.Deleted; } } } } else { switch (State) { case EntityState.Added: // Remove key entry if necessary DeleteUnnecessaryKeyEntries(); // Remove relationship entry // devnote: Using this method instead of just changing the state because the entry // may have already been detached along with the key entry above. However, // if there were other relationships using the key, it would not have been deleted. DetachRelationshipEntry(); break; case EntityState.Modified: Debug.Assert(false, "RelationshipEntry cannot be in Modified state"); break; case EntityState.Unchanged: _cache.ChangeState(this, EntityState.Unchanged, EntityState.Deleted); State = EntityState.Deleted; break; //case DataRowState.Deleted: no-op } } }
/// <summary> /// Emit static factory method which creates an instance of the class and initializes /// non-nullable properties (taken as arguments) /// </summary> /// <param name="typeDecl"></param> protected virtual void EmitFactoryMethod(CodeTypeDeclaration typeDecl) { // build list of non-nullable properties ReadOnlyMetadataCollection <EdmProperty> properties = GetProperties(); List <EdmProperty> parameters = new List <EdmProperty>(properties.Count); foreach (EdmProperty property in properties) { bool include = IncludeFieldInFactoryMethod(property); if (include) { parameters.Add(property); } } // if there are no parameters, we don't emit anything (1 is for the null element) // nor do we emit everything if this is the Ref propertied ctor and the parameter list is the same as the many parametered ctor if (parameters.Count < 1) { return; } CodeMemberMethod method = new CodeMemberMethod(); CodeTypeReference typeRef = TypeReference.FromString(Item.Name); UniqueIdentifierService uniqueIdentifierService = new UniqueIdentifierService(Generator.IsLanguageCaseSensitive); string instanceName = uniqueIdentifierService.AdjustIdentifier(Utils.CamelCase(Item.Name)); // public static Class CreateClass(...) method.Attributes = MemberAttributes.Static | MemberAttributes.Public; method.Name = "Create" + Item.Name; if (NavigationPropertyEmitter.IsNameAlreadyAMemberName(Item, method.Name, Generator.LanguageAppropriateStringComparer)) { Generator.AddError(Strings.GeneratedFactoryMethodNameConflict(method.Name, Item.Name), ModelBuilderErrorCode.GeneratedFactoryMethodNameConflict, EdmSchemaErrorSeverity.Error); } method.ReturnType = typeRef; AttributeEmitter.AddGeneratedCodeAttribute(method); // output method summary comments CommentEmitter.EmitSummaryComments(Strings.FactoryMethodSummaryComment(Item.Name), method.Comments); // Class class = new Class(); CodeVariableDeclarationStatement createNewInstance = new CodeVariableDeclarationStatement( typeRef, instanceName, new CodeObjectCreateExpression(typeRef)); method.Statements.Add(createNewInstance); CodeVariableReferenceExpression instanceRef = new CodeVariableReferenceExpression(instanceName); // iterate over the properties figuring out which need included in the factory method foreach (EdmProperty property in parameters) { // CreateClass( ... , propType propName ...) PropertyEmitter propertyEmitter = new PropertyEmitter(Generator, property, UsingStandardBaseClass); CodeTypeReference propertyTypeReference = propertyEmitter.PropertyType; String parameterName = uniqueIdentifierService.AdjustIdentifier(Utils.FixParameterName(propertyEmitter.PropertyName, "argument")); parameterName = Utils.SetSpecialCaseForFxCopOnPropertyName(parameterName); CodeParameterDeclarationExpression paramDecl = new CodeParameterDeclarationExpression( propertyTypeReference, parameterName); CodeArgumentReferenceExpression paramRef = new CodeArgumentReferenceExpression(paramDecl.Name); method.Parameters.Add(paramDecl); // add comment describing the parameter CommentEmitter.EmitParamComments(paramDecl, Strings.FactoryParamCommentGeneral(propertyEmitter.PropertyName), method.Comments); CodeExpression newPropertyValue; if (TypeSemantics.IsComplexType(propertyEmitter.Item.TypeUsage)) { List <CodeExpression> complexVerifyParameters = new List <CodeExpression>(); complexVerifyParameters.Add(paramRef); complexVerifyParameters.Add(new CodePrimitiveExpression(propertyEmitter.PropertyName)); // if (null == param) { throw new ArgumentNullException("PropertyName"); } method.Statements.Add( new CodeConditionStatement( EmitExpressionEqualsNull(paramRef), new CodeThrowExceptionStatement( new CodeObjectCreateExpression( TypeReference.ForType(typeof(ArgumentNullException)), new CodePrimitiveExpression(parameterName) ) ) ) ); newPropertyValue = paramRef; } else { newPropertyValue = paramRef; } // Scalar property: // Property = param; // Complex property: // Property = StructuralObject.VerifyComplexObjectIsNotNull(param, propertyName); method.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(instanceRef, propertyEmitter.PropertyName), newPropertyValue)); } // return class; method.Statements.Add(new CodeMethodReturnStatement(instanceRef)); // actually add the method to the class typeDecl.Members.Add(method); }
internal void ResetKeyPropertiesCache() { // PERF: this code written this way since it's part of a hotpath, consider its performance when refactoring. See codeplex #2298. if (_keyProperties != null) { lock (_keyPropertiesSync) { if (_keyProperties != null) { _keyProperties = null; KeyMembers.SourceAccessed -= KeyMembersSourceAccessedEventHandler; } } } }
private static string GetTableNameByClrName(ReadOnlyMetadataCollection<EntitySet> EntitySets,string tablename) { return EntitySets.First(x=>x.Name == tablename).Table; }
public override TypeUsage GetStoreType(TypeUsage edmType) { bool bUse32DataTypes = ODTSettings.m_bUse32DataTypes; if (EFProviderSettings.s_tracingEnabled) { EFProviderSettings.Instance.Trace(EFProviderSettings.EFTraceLevel.Entry, " (ENTRY) EFOracleProviderManifest::GetStoreType() \n"); } EntityUtils.CheckArgumentNull <TypeUsage>(edmType, nameof(edmType)); PrimitiveType edmType1 = edmType.EdmType as PrimitiveType; if (edmType1 == null) { throw new ArgumentException(EFProviderSettings.Instance.GetErrorMessage(-1703, "Oracle Data Provider for .NET", edmType.EdmType.FullName)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; if (EFProviderSettings.s_tracingEnabled) { EFProviderSettings.Instance.Trace(EFProviderSettings.EFTraceLevel.Entry, " (EXIT) EFOracleProviderManifest::GetStoreType() \n"); } switch (edmType1.PrimitiveTypeKind) { case PrimitiveTypeKind.Binary: bool flag1 = facets["FixedLength"].Value != null && (bool)facets["FixedLength"].Value; Facet facet1 = facets["MaxLength"]; bool flag2 = !bUse32DataTypes ? facet1.IsUnbounded || facet1.Value == null || (int)facet1.Value > 2000 : facet1.IsUnbounded || facet1.Value == null || (int)facet1.Value > this.BinaryMaxSize_12c; int maxLength1 = !flag2 ? (int)facet1.Value : int.MinValue; return(!flag1 ? (!flag2 ? TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["raw"], false, maxLength1) : TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["blob"], false)) : (!bUse32DataTypes ? TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["raw"], true, flag2 ? 2000 : maxLength1) : TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["raw"], true, flag2 ? this.BinaryMaxSize_12c : maxLength1))); case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], (byte)EFOracleProviderManifest.m_edmMappingMaxBOOL, (byte)0)); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], (byte)EFOracleProviderManifest.m_edmMappingMaxBYTE, (byte)0)); case PrimitiveTypeKind.DateTime: if (facets == null || facets["Precision"].Value == null) { return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["date"])); } if ((int)(byte)facets["Precision"].Value > 9) { return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["timestamp with local time zone"])); } return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["timestamp"])); case PrimitiveTypeKind.Decimal: byte precision; byte scale; if (EF6MetadataHelpers.TryGetPrecision(edmType, out precision) && EF6MetadataHelpers.TryGetScale(edmType, out scale)) { if ((int)precision == 250 && (int)scale == 0) { return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["interval year to month"], (byte)9, (byte)0)); } if ((int)precision == 251 && (int)scale == 0) { return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["interval day to second"], (byte)9, (byte)0)); } return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], precision, scale)); } if (EF6MetadataHelpers.TryGetPrecision(edmType, out precision)) { return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], precision, (byte)0)); } if (EF6MetadataHelpers.TryGetScale(edmType, out scale)) { return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], (byte)38, scale)); } return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["number"])); case PrimitiveTypeKind.Double: if (this._version < EFOracleVersion.Oracle10gR1) { return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["number"])); } return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["binary_double"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["guid raw"])); case PrimitiveTypeKind.Single: if (this._version < EFOracleVersion.Oracle10gR1) { return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["number"])); } return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["binary_float"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], (byte)EFOracleProviderManifest.m_edmMappingMaxINT16, (byte)0)); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], (byte)EFOracleProviderManifest.m_edmMappingMaxINT32, (byte)0)); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["number"], (byte)EFOracleProviderManifest.m_edmMappingMaxINT64, (byte)0)); case PrimitiveTypeKind.String: bool flag3 = facets["Unicode"].Value == null || (bool)facets["Unicode"].Value; bool flag4 = facets["FixedLength"].Value != null && (bool)facets["FixedLength"].Value; Facet facet2 = facets["MaxLength"]; bool flag5 = !bUse32DataTypes ? facet2.IsUnbounded || facet2.Value == null || (int)facet2.Value > (flag3 ? 4000 : 4000) : facet2.IsUnbounded || facet2.Value == null || (int)facet2.Value > (flag3 ? this.Nvarchar2MaxSize_12c : this.Varchar2MaxSize_12c); int maxLength2 = !flag5 ? (int)facet2.Value : int.MinValue; return(!flag3 ? (!flag4 ? (!flag5 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar2"], false, false, maxLength2) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["clob"], false, false)) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["char"], false, true, flag5 ? 2000 : maxLength2)) : (!flag4 ? (!flag5 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar2"], true, false, maxLength2) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nclob"], true, false)) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nchar"], true, true, flag5 ? 2000 : maxLength2))); case PrimitiveTypeKind.DateTimeOffset: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["timestamp with time zone"])); default: throw new NotSupportedException(EFProviderSettings.Instance.GetErrorMessage(-1703, "Oracle Data Provider for .NET", edmType1.PrimitiveTypeKind.ToString())); } }
private string GetFacetString(EdmProperty column, bool IsKeyMember) { 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."); } } else if (facet.Value.Equals(StoreGeneratedPattern.Computed)) { 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() + " )" : ""); } } } return(sql.ToString()); }
private static Mock<EntityType> CreateMockEntityType(params string[] keyNames) { var metadataCollection = new ReadOnlyMetadataCollection<EdmMember>( keyNames.Select( k => { var mockEdmMember1 = new Mock<EdmMember>(); mockEdmMember1.Setup(m => m.Name).Returns(k); return mockEdmMember1.Object; }).ToList()); var mockEntityType = new Mock<EntityType>(); mockEntityType.Setup(m => m.KeyMembers).Returns(metadataCollection); mockEntityType.Setup(m => m.IsAssignableFrom(mockEntityType.Object)).Returns(true); mockEntityType.Setup(m => m.KeyMemberNames).Returns(keyNames.Select(k => k).ToArray()); return mockEntityType; }
internal void UpdateForeignKeyValues( IEntityWrapper dependentEntity, IEntityWrapper principalEntity, Dictionary <int, object> changedFKs, bool forceChange) { ReferentialConstraint referentialConstraint = ((AssociationType)this.RelationMetadata).ReferentialConstraints[0]; bool flag = (object)this.WrappedOwner.EntityKey != null && !this.WrappedOwner.EntityKey.IsTemporary && this.IsDependentEndOfReferentialConstraint(true); ObjectStateManager objectStateManager = this.ObjectContext.ObjectStateManager; objectStateManager.TransactionManager.BeginForeignKeyUpdate(this); try { EntitySet entitySet1 = ((AssociationSet)this.RelationshipSet).AssociationSetEnds[this.ToEndMember.Name].EntitySet; StateManagerTypeMetadata managerTypeMetadata1 = objectStateManager.GetOrAddStateManagerTypeMetadata(principalEntity.IdentityType, entitySet1); EntitySet entitySet2 = ((AssociationSet)this.RelationshipSet).AssociationSetEnds[this.FromEndMember.Name].EntitySet; StateManagerTypeMetadata managerTypeMetadata2 = objectStateManager.GetOrAddStateManagerTypeMetadata(dependentEntity.IdentityType, entitySet2); ReadOnlyMetadataCollection <EdmProperty> fromProperties = referentialConstraint.FromProperties; int count = fromProperties.Count; string[] array = (string[])null; object[] compositeKeyValues = (object[])null; if (count > 1) { array = entitySet1.ElementType.KeyMemberNames; compositeKeyValues = new object[count]; } for (int index1 = 0; index1 < count; ++index1) { int olayerMemberName1 = managerTypeMetadata1.GetOrdinalforOLayerMemberName(fromProperties[index1].Name); object obj = managerTypeMetadata1.Member(olayerMemberName1).GetValue(principalEntity.Entity); int olayerMemberName2 = managerTypeMetadata2.GetOrdinalforOLayerMemberName(referentialConstraint.ToProperties[index1].Name); bool changingForeignKeyValue = !ByValueEqualityComparer.Default.Equals(managerTypeMetadata2.Member(olayerMemberName2).GetValue(dependentEntity.Entity), obj); if (forceChange || changingForeignKeyValue) { if (flag) { this.ValidateSettingRIConstraints(principalEntity, obj == null, changingForeignKeyValue); } if (changedFKs != null) { object x; if (changedFKs.TryGetValue(olayerMemberName2, out x)) { if (!ByValueEqualityComparer.Default.Equals(x, obj)) { throw new InvalidOperationException(Strings.Update_ReferentialConstraintIntegrityViolation); } } else { changedFKs[olayerMemberName2] = obj; } } dependentEntity.SetCurrentValue(dependentEntity.ObjectStateEntry, managerTypeMetadata2.Member(olayerMemberName2), -1, dependentEntity.Entity, obj); } if (count > 1) { int index2 = Array.IndexOf <string>(array, fromProperties[index1].Name); compositeKeyValues[index2] = obj; } else { this.SetCachedForeignKey(obj == null ? (EntityKey)null : new EntityKey((EntitySetBase)entitySet1, obj), dependentEntity.ObjectStateEntry); } } if (count > 1) { this.SetCachedForeignKey(((IEnumerable <object>)compositeKeyValues).Any <object>((Func <object, bool>)(v => v == null)) ? (EntityKey)null : new EntityKey((EntitySetBase)entitySet1, compositeKeyValues), dependentEntity.ObjectStateEntry); } if (this.WrappedOwner.ObjectStateEntry == null) { return; } objectStateManager.ForgetEntryWithConceptualNull(this.WrappedOwner.ObjectStateEntry, false); } finally { objectStateManager.TransactionManager.EndForeignKeyUpdate(); } }
/// <summary> /// Initializes a new instance of Entity Type /// </summary> /// <param name="name">name of the entity type</param> /// <param name="namespaceName">namespace of the entity type</param> /// <param name="version">version of the entity type</param> /// <param name="dataSpace">dataSpace in which this edmtype belongs to</param> /// <exception cref="System.ArgumentNullException">Thrown if either name, namespace or version arguments are null</exception> internal EntityTypeBase(string name, string namespaceName, DataSpace dataSpace) : base(name, namespaceName, dataSpace) { _keyMembers = new ReadOnlyMetadataCollection<EdmMember>(new MetadataCollection<EdmMember>()); }
public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format(Resources.TypeNotSupported, edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bool"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["utinyint"])); case PrimitiveTypeKind.SByte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["double"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Decimal: { byte precision = DEFAULT_DECIMAL_PRECISION; byte scale = DEFAULT_DECIMAL_SCALE; Facet facet; if (edmType.Facets.TryGetValue("Precision", false, out facet)) { if (!facet.IsUnbounded && facet.Value != null) { precision = (byte)facet.Value; } } if (edmType.Facets.TryGetValue("Scale", false, out facet)) { if (!facet.IsUnbounded && facet.Value != null) { scale = (byte)facet.Value; } } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: { bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > MEDIUMBLOB_MAXLEN; int maxLength = !isMaxLength ? (int)f.Value : LONGBLOB_MAXLEN; string typeName = String.Empty; // now this applies for both isFixedLength and !isFixedLength if (maxLength < CHAR_MAXLEN) { typeName = "tinyblob"; } else if (maxLength < MEDIUMBLOB_MAXLEN) { typeName = "blob"; } else if (maxLength < LONGTEXT_MAXLEN) { typeName = "mediumblob"; } else { typeName = "longblob"; } return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isFixedLength, maxLength)); } case PrimitiveTypeKind.String: { string typeName = String.Empty; bool isUnicode = null != facets["Unicode"].Value && (bool)facets["Unicode"].Value; bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; int maxLenghtValue; Facet maxLengthFacet = facets["MaxLength"]; if (isFixedLength) { typeName = isUnicode ? "nchar" : "char"; if (maxLengthFacet.Value != null && Int32.TryParse(maxLengthFacet.Value.ToString(), out maxLenghtValue) && maxLenghtValue <= CHAR_MAXLEN) { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, (int)maxLengthFacet.Value)); } else if (maxLengthFacet.Value != null && maxLengthFacet.Value.ToString() == "Max") { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, CHAR_MAXLEN)); } else { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength)); } } else { typeName = isUnicode ? "nvarchar" : "varchar"; if (maxLengthFacet.Value != null && Int32.TryParse(maxLengthFacet.Value.ToString(), out maxLenghtValue)) { if (maxLenghtValue > VARCHAR_MAXLEN && maxLenghtValue <= MEDIUMTEXT_MAXLEN) { typeName = "mediumtext"; } else if ((int)maxLengthFacet.Value > MEDIUMTEXT_MAXLEN) { typeName = "longtext"; } return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, (int)maxLengthFacet.Value)); } else if (maxLengthFacet.Value != null && (maxLengthFacet.Value.ToString() == "Max")) { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["longtext"], isUnicode, isFixedLength)); } else { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength)); } } } case PrimitiveTypeKind.DateTimeOffset: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"])); case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Time: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); #if NET_45_OR_GREATER case PrimitiveTypeKind.Geometry: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["geometry"])); #endif default: throw new NotSupportedException(String.Format(Resources.NoStoreTypeForEdmType, edmType, primitiveType.PrimitiveTypeKind)); } }
internal void ValidateEntityKey( MetadataWorkspace workspace, EntitySet entitySet, bool isArgumentException, string argumentName) { if (entitySet == null) { return; } ReadOnlyMetadataCollection <EdmMember> keyMembers = ((EntitySetBase)entitySet).ElementType.KeyMembers; if (this._singletonKeyValue != null) { if (keyMembers.Count != 1) { if (isArgumentException) { throw new ArgumentException(Strings.EntityKey_IncorrectNumberOfKeyValuePairs((object)entitySet.ElementType.FullName, (object)keyMembers.Count, (object)1), argumentName); } throw new InvalidOperationException(Strings.EntityKey_IncorrectNumberOfKeyValuePairs((object)entitySet.ElementType.FullName, (object)keyMembers.Count, (object)1)); } EntityKey.ValidateTypeOfKeyValue(workspace, keyMembers[0], this._singletonKeyValue, isArgumentException, argumentName); if (!(this._keyNames[0] != keyMembers[0].Name)) { return; } if (isArgumentException) { throw new ArgumentException(Strings.EntityKey_MissingKeyValue((object)keyMembers[0].Name, (object)entitySet.ElementType.FullName), argumentName); } throw new InvalidOperationException(Strings.EntityKey_MissingKeyValue((object)keyMembers[0].Name, (object)entitySet.ElementType.FullName)); } if (this._compositeKeyValues == null) { return; } if (keyMembers.Count != this._compositeKeyValues.Length) { if (isArgumentException) { throw new ArgumentException(Strings.EntityKey_IncorrectNumberOfKeyValuePairs((object)entitySet.ElementType.FullName, (object)keyMembers.Count, (object)this._compositeKeyValues.Length), argumentName); } throw new InvalidOperationException(Strings.EntityKey_IncorrectNumberOfKeyValuePairs((object)entitySet.ElementType.FullName, (object)keyMembers.Count, (object)this._compositeKeyValues.Length)); } for (int index1 = 0; index1 < this._compositeKeyValues.Length; ++index1) { EdmMember keyMember = ((EntitySetBase)entitySet).ElementType.KeyMembers[index1]; bool flag = false; for (int index2 = 0; index2 < this._compositeKeyValues.Length; ++index2) { if (keyMember.Name == this._keyNames[index2]) { EntityKey.ValidateTypeOfKeyValue(workspace, keyMember, this._compositeKeyValues[index2], isArgumentException, argumentName); flag = true; break; } } if (!flag) { if (isArgumentException) { throw new ArgumentException(Strings.EntityKey_MissingKeyValue((object)keyMember.Name, (object)entitySet.ElementType.FullName), argumentName); } throw new InvalidOperationException(Strings.EntityKey_MissingKeyValue((object)keyMember.Name, (object)entitySet.ElementType.FullName)); } } }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in Jet /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } System.Diagnostics.Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!edmType.TryGetPrecision(out precision)) { precision = 18; } byte scale; if (!edmType.TryGetScale(out scale)) { scale = 0; } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: // binary, varbinary, image { bool isFixedLength = edmType.GetIsFixedLength(); bool isMaxLength = edmType.GetMaxLength() > BINARY_MAXSIZE; int maxLength = edmType.GetMaxLength(); TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["binary"], true, maxLength); } else if (isMaxLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["image"], false); System.Diagnostics.Debug.Assert(tu.Facets["MaxLength"].Description.IsConstant, "varbinary(max) is not constant!"); } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength); } return(tu); } case PrimitiveTypeKind.String: // char, varchar, text { bool isUnicode = edmType.GetIsUnicode(); // We do not handle unicode (everything's unicode in Jet) bool isFixedLength = edmType.GetIsFixedLength(); bool isMaxLength = edmType.GetMaxLength() > VARCHAR_MAXSIZE; int maxLength = edmType.GetMaxLength(); TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], false, true, maxLength); } else if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["text"], false, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } return(tu); } case PrimitiveTypeKind.DateTime: // datetime return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Time: // time return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); default: throw new NotSupportedException(String.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
private void ResetNavigationProperties(object sender, EventArgs e) { if (_navigationPropertiesCache != null) { lock (_navigationPropertiesCacheLock) { if (_navigationPropertiesCache != null) { _navigationPropertiesCache = null; Members.SourceAccessed -= ResetNavigationProperties; } } } }
public override TypeUsage GetStoreType(TypeUsage edmType) { Check.NotNull <TypeUsage>(edmType, nameof(edmType)); PrimitiveType edmType1 = edmType.EdmType as PrimitiveType; if (edmType1 == null) { throw new ArgumentException(Strings.ProviderDoesNotSupportType((object)edmType.EdmType.Name)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (edmType1.PrimitiveTypeKind) { case PrimitiveTypeKind.Binary: bool flag1 = facets["FixedLength"].Value != null && (bool)facets["FixedLength"].Value; Facet facet1 = facets["MaxLength"]; bool flag2 = facet1.IsUnbounded || facet1.Value == null || (int)facet1.Value > 8000; int maxLength1 = !flag2 ? (int)facet1.Value : int.MinValue; return(!flag1 ? (!flag2 ? TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength1) : (this._version == SqlVersion.Sql8 ? TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["varbinary"], false, 8000) : TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["varbinary(max)"], false))) : TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["binary"], true, flag2 ? 8000 : maxLength1)); case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Decimal: byte precision; if (!edmType.TryGetPrecision(out precision)) { precision = (byte)18; } byte scale; if (!edmType.TryGetScale(out scale)) { scale = (byte)0; } return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["uniqueidentifier"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.String: bool flag3 = facets["Unicode"].Value == null || (bool)facets["Unicode"].Value; bool flag4 = facets["FixedLength"].Value != null && (bool)facets["FixedLength"].Value; Facet facet2 = facets["MaxLength"]; bool flag5 = facet2.IsUnbounded || facet2.Value == null || (int)facet2.Value > (flag3 ? 4000 : 8000); int maxLength2 = !flag5 ? (int)facet2.Value : int.MinValue; return(!flag3 ? (!flag4 ? (!flag5 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength2) : (this._version == SqlVersion.Sql8 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar"], false, false, 8000) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar(max)"], false, false))) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["char"], false, true, flag5 ? 8000 : maxLength2)) : (!flag4 ? (!flag5 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, maxLength2) : (this._version == SqlVersion.Sql8 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, 4000) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar(max)"], true, false))) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nchar"], true, true, flag5 ? 4000 : maxLength2))); case PrimitiveTypeKind.Time: return(this.GetStorePrimitiveTypeIfPostSql9("time", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); case PrimitiveTypeKind.DateTimeOffset: return(this.GetStorePrimitiveTypeIfPostSql9("datetimeoffset", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: return(this.GetStorePrimitiveTypeIfPostSql9("geometry", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: return(this.GetStorePrimitiveTypeIfPostSql9("geography", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); default: throw new NotSupportedException(Strings.NoStoreTypeForEdmType((object)edmType.EdmType.Name, (object)edmType1.PrimitiveTypeKind)); } }
public void GetProperties_returns_row_type_properties() { var properties = new ReadOnlyMetadataCollection<EdmProperty>(); var mockEdmType = new Mock<RowType>(); mockEdmType.Setup(m => m.BuiltInTypeKind).Returns(BuiltInTypeKind.RowType); mockEdmType.Setup(m => m.Properties).Returns(properties); Assert.Same(properties, TypeUsage.Create(mockEdmType.Object).GetProperties()); }
internal NextResultGenerator(ObjectContext context, EntityCommand entityCommand, EdmType[] edmTypes, ReadOnlyMetadataCollection <EntitySet> entitySets, MergeOption mergeOption, int resultSetIndex) { _context = context; _entityCommand = entityCommand; _entitySets = entitySets; _edmTypes = edmTypes; _resultSetIndex = resultSetIndex; _mergeOption = mergeOption; }
private IEnumerable<DynamicFilterDefinition> FindFiltersForEntitySet(ReadOnlyMetadataCollection<MetadataProperty> metadataProperties, EntityContainer entityContainer) { var filterList = metadataProperties .Where(mp => mp.Name.Contains("customannotation:" + DynamicFilterConstants.ATTRIBUTE_NAME_PREFIX)) .Select(m => m.Value as DynamicFilterDefinition) .ToList(); // Note: Prior to the switch to use CSpace (which was done to allow filters on navigation properties), // we had to remove filters that exist in base EntitySets to this entity to fix issues with // Table-per-Type inheritance (issue #32). In CSpace none of that is necessary since we are working // with the actual c# models now (in CSpace) so we always have the correct filters and access to all // the inherited properties that we need. if (filterList.Any()) { // Recursively remove any filters that exist in base EntitySets to this entity. // This happens when an entity uses Table-per-Type inheritance. Filters will be added // to all derived EntitySets because of the inheritance in the C# classes. But the database // representation (the EntitySet) does not give access to inherited propeties since they // only exist in the child EntitySet. And on queries of entities involved in TPT, the // query will generate a DbScanExpression for each EntitySet - so we only want the filters // applied to the DbScanExpression to which they apply. // See issue #32. RemoveFiltersForBaseClass(filterList.First().CLRType, filterList, entityContainer); } return filterList; }
/// <summary> /// This method attempts to determine if the specified table has an integer /// primary key (i.e. "rowid"). If so, it sets the /// <paramref name="primaryKeyMember" /> parameter to the right /// <see cref="EdmMember" />; otherwise, the /// <paramref name="primaryKeyMember" /> parameter is set to null. /// </summary> /// <param name="table">The table to check.</param> /// <param name="keyMembers"> /// The collection of key members. An attempt is always made to set this /// parameter to a valid value. /// </param> /// <param name="primaryKeyMember"> /// The <see cref="EdmMember" /> that represents the integer primary key /// -OR- null if no such <see cref="EdmMember" /> exists. /// </param> /// <returns> /// Non-zero if the specified table has an integer primary key. /// </returns> private static bool IsIntegerPrimaryKey( EntitySetBase table, out ReadOnlyMetadataCollection<EdmMember> keyMembers, out EdmMember primaryKeyMember ) { keyMembers = table.ElementType.KeyMembers; if (keyMembers.Count == 1) /* NOTE: The "rowid" only? */ { EdmMember keyMember = keyMembers[0]; PrimitiveTypeKind typeKind; if (MetadataHelpers.TryGetPrimitiveTypeKind( keyMember.TypeUsage, out typeKind) && (typeKind == PrimitiveTypeKind.Int64)) { primaryKeyMember = keyMember; return true; } } primaryKeyMember = null; return false; }
/// <summary> /// This method attempts to determine if all the specified key members have /// values available. /// </summary> /// <param name="translator"> /// The <see cref="ExpressionTranslator" /> to use. /// </param> /// <param name="keyMembers"> /// The collection of key members to check. /// </param> /// <param name="missingKeyMember"> /// The first missing key member that is found. This is only set to a valid /// value if the method is returning false. /// </param> /// <returns> /// Non-zero if all key members have values; otherwise, zero. /// </returns> private static bool DoAllKeyMembersHaveValues( ExpressionTranslator translator, ReadOnlyMetadataCollection<EdmMember> keyMembers, out EdmMember missingKeyMember ) { foreach (EdmMember keyMember in keyMembers) { if (!translator.MemberValues.ContainsKey(keyMember)) { missingKeyMember = keyMember; return false; } } missingKeyMember = null; return true; }
//Return a set of integers that represent the indexes of first set of properties in the second set private static Set<int> GetPropertyIndexes( IEnumerable<EdmProperty> properties1, ReadOnlyMetadataCollection<EdmProperty> properties2) { var propertyIndexes = new Set<int>(); foreach (var prop in properties1) { propertyIndexes.Add(properties2.IndexOf(prop)); } return propertyIndexes; }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in Ingres, taking the store version into consideration. /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); var primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.SByte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["integer"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, money return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], TypeHelpers.GetPrecision(edmType, 18), TypeHelpers.GetScale(edmType, 0))); case PrimitiveTypeKind.Binary: // byte, byte varying, long byte { var isFixedLength = facets["FixedLength"].GetValue <bool>(false); var maxLengthFacet = facets["MaxLength"]; var maxLength = maxLengthFacet.GetValue <int?>(); if (maxLengthFacet.IsUnbounded || maxLength == null || maxLength.Value > binaryMaxSize) { maxLength = null; } var storeTypeName = isFixedLength ? "byte" : maxLength == null ? "long byte" : "byte varying"; return(CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType[storeTypeName], isFixedLength, maxLength)); } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, long varchar, long nvarchar { var isUnicode = facets["Unicode"].GetValue <bool>(false); var isFixedLength = facets["FixedLength"].GetValue <bool>(false); var maxLengthFacet = facets["MaxLength"]; var maxLength = maxLengthFacet.GetValue <int?>(); if (maxLengthFacet.IsUnbounded || maxLength == null || maxLength.Value > varcharMaxSize) { maxLength = null; } var storeTypeName = isFixedLength ? "char" : "varchar"; storeTypeName = isUnicode ? "n" + storeTypeName : storeTypeName; storeTypeName = (maxLength == null) ? "long " + storeTypeName : storeTypeName; return(CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[storeTypeName], isUnicode, isFixedLength, maxLength)); } case PrimitiveTypeKind.DateTime: // ingresdate return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["ingresdate"])); case PrimitiveTypeKind.Time: // time return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); default: throw new NotSupportedException(String.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }