private static void AddAttributeAnnotation(EdmProperty property, Attribute a) { if (property != null) { var clrAttributes = property.Annotations.GetClrAttributes(); if (clrAttributes != null) { if (!clrAttributes.Contains(a)) { clrAttributes.Add(a); } } else { property.Annotations.SetClrAttributes( new List<Attribute> { a }); } } }
private Tuple <FunctionParameter, bool> GetParameter(EdmProperty column, bool originalValue = false) { DebugCheck.NotNull(column); var columnMappings = (from esm in _entityContainerMapping.EntitySetMappings from etm in esm.EntityTypeMappings from mf in etm.MappingFragments from cm in mf.FlattenedProperties where cm.ColumnProperty.EdmEquals(column) && cm.ColumnProperty.DeclaringType.EdmEquals(column.DeclaringType) select cm) .ToList(); var parameterBindings = _currentFunctionMapping .ParameterBindings .Where( pb => columnMappings .Any(cm => pb.MemberPath.Members.Reverse().SequenceEqual(cm.PropertyPath))) .ToList(); if (!parameterBindings.Any()) { var iaColumnMappings = (from asm in _entityContainerMapping.AssociationSetMappings from tm in asm.TypeMappings from mf in tm.MappingFragments from epm in mf.PropertyMappings.OfType <EndPropertyMapping>() from pm in epm.PropertyMappings where pm.Column.EdmEquals(column) && pm.Column.DeclaringType.EdmEquals(column.DeclaringType) select new EdmMember[] { pm.Property, epm.AssociationEnd }) .ToList(); parameterBindings = _currentFunctionMapping .ParameterBindings .Where( pb => iaColumnMappings .Any(epm => pb.MemberPath.Members.SequenceEqual(epm))) .ToList(); } if ((parameterBindings.Count == 0) && column.IsPrimaryKeyColumn) { // Store generated key: Introduce a fake parameter which can // be replaced by a local variable in the sproc body. return (Tuple.Create( new FunctionParameter( _storeGeneratedKeys[_nextStoreGeneratedKey++].Name, column.TypeUsage, ParameterMode.In), true)); } if (parameterBindings.Count == 1) { return(Tuple.Create(parameterBindings[0].Parameter, parameterBindings[0].IsCurrent)); } if (parameterBindings.Count == 0) { return(null); } Debug.Assert(parameterBindings.Count == 2); var parameterBinding = originalValue ? parameterBindings.Single(pb => !pb.IsCurrent) : parameterBindings.Single(pb => pb.IsCurrent); return(Tuple.Create(parameterBinding.Parameter, parameterBinding.IsCurrent)); }
internal void Configure( DbDatabaseMapping databaseMapping, MappingFragment fragment, EntityType entityType, DbProviderManifest providerManifest) { DebugCheck.NotNull(fragment); DebugCheck.NotNull(providerManifest); var discriminatorColumn = fragment.Table.Properties .SingleOrDefault(c => string.Equals(c.Name, Discriminator, StringComparison.Ordinal)); if (discriminatorColumn == null) { var typeUsage = providerManifest.GetStoreType(DatabaseMappingGenerator.DiscriminatorTypeUsage); discriminatorColumn = new EdmProperty(Discriminator, typeUsage) { Nullable = false }; TablePrimitiveOperations.AddColumn(fragment.Table, discriminatorColumn); } if (AnyBaseTypeToTableWithoutColumnCondition( databaseMapping, entityType, fragment.Table, discriminatorColumn)) { discriminatorColumn.Nullable = true; } var existingConfiguration = discriminatorColumn.GetConfiguration() as Properties.Primitive.PrimitivePropertyConfiguration; if (Value != null) { ConfigureColumnType(providerManifest, existingConfiguration, discriminatorColumn); fragment.AddDiscriminatorCondition(discriminatorColumn, Value); } else { if (string.IsNullOrWhiteSpace(discriminatorColumn.TypeName)) { var typeUsage = providerManifest.GetStoreType(DatabaseMappingGenerator.DiscriminatorTypeUsage); discriminatorColumn.PrimitiveType = (PrimitiveType)typeUsage.EdmType; discriminatorColumn.MaxLength = DatabaseMappingGenerator.DiscriminatorMaxLength; discriminatorColumn.Nullable = false; } GetOrCreateConfiguration <Properties.Primitive.PrimitivePropertyConfiguration>().IsNullable = true; fragment.AddNullabilityCondition(discriminatorColumn, true); } if (_configuration == null) { return; } if (existingConfiguration != null) { string errorMessage; if ((existingConfiguration.OverridableConfigurationParts & OverridableConfigurationParts.OverridableInCSpace) != OverridableConfigurationParts.OverridableInCSpace && !existingConfiguration.IsCompatible( _configuration, inCSpace: true, errorMessage: out errorMessage)) { throw Error.ConflictingColumnConfiguration(discriminatorColumn, fragment.Table, errorMessage); } } if (_configuration.IsNullable != null) { discriminatorColumn.Nullable = _configuration.IsNullable.Value; } _configuration.Configure(discriminatorColumn, fragment.Table, providerManifest); }
private static StorageMappingFragment GetFragmentForPropertyMapping( StorageEntityTypeMapping entityTypeMapping, EdmProperty property) { return(entityTypeMapping.MappingFragments .SingleOrDefault(tmf => tmf.ColumnMappings.Any(pm => pm.PropertyPath.Last() == property))); }
/// <summary> /// Converts the DbExpression equivalent of: /// /// SELECT CASE /// WHEN a._from0 THEN SUBTYPE1() /// ... /// WHEN a._from[n-2] THEN SUBTYPE_n-1() /// ELSE SUBTYPE_n /// FROM /// SELECT /// b.C1..., b.Cn /// CASE WHEN b.Discriminator = SUBTYPE1_Value THEN true ELSE false AS _from0 /// ... /// CASE WHEN b.Discriminator = SUBTYPE_n_Value THEN true ELSE false AS _from[n-1] /// FROM TSet AS b /// WHERE b.Discriminator = SUBTYPE1_Value... OR x.Discriminator = SUBTYPE_n_Value /// AS a /// WHERE a._from0... OR a._from[n-1] /// /// into the DbExpression equivalent of the following, which is matched as a TPH discriminator /// by the <see cref="System.Data.Mapping.ViewGeneration.GeneratedView"/> class and so allows a <see cref="System.Data.Mapping.ViewGeneration.DiscriminatorMap"/> /// to be produced for the view, which would not otherwise be possible. Note that C1 through Cn /// are only allowed to be scalars or complex type constructors based on direct property references /// to the store entity set's scalar properties. /// /// SELECT CASE /// WHEN y.Discriminator = SUBTTYPE1_Value THEN SUBTYPE1() /// ... /// WHEN y.Discriminator = SUBTYPE_n-1_Value THEN SUBTYPE_n-1() /// ELSE SUBTYPE_n() /// FROM /// SELECT x.C1..., x.Cn, Discriminator FROM TSet AS x /// WHERE x.Discriminator = SUBTYPE1_Value... OR x.Discriminator = SUBTYPE_n_Value /// AS y /// /// </summary> private static DbExpression SimplifyNestedTphDiscriminator(DbExpression expression) { DbProjectExpression entityProjection = (DbProjectExpression)expression; DbFilterExpression booleanColumnFilter = (DbFilterExpression)entityProjection.Input.Expression; DbProjectExpression rowProjection = (DbProjectExpression)booleanColumnFilter.Input.Expression; DbFilterExpression discriminatorFilter = (DbFilterExpression)rowProjection.Input.Expression; List <DbExpression> predicates = FlattenOr(booleanColumnFilter.Predicate).ToList(); List <DbPropertyExpression> propertyPredicates = predicates.OfType <DbPropertyExpression>() .Where(px => px.Instance.ExpressionKind == DbExpressionKind.VariableReference && ((DbVariableReferenceExpression)px.Instance).VariableName == booleanColumnFilter.Input.VariableName).ToList(); if (predicates.Count != propertyPredicates.Count) { return(null); } List <string> predicateColumnNames = propertyPredicates.Select(px => px.Property.Name).ToList(); Dictionary <object, DbComparisonExpression> discriminatorPredicates = new Dictionary <object, DbComparisonExpression>(); if (!TypeSemantics.IsEntityType(discriminatorFilter.Input.VariableType) || !TryMatchDiscriminatorPredicate(discriminatorFilter, (compEx, discValue) => discriminatorPredicates.Add(discValue, compEx))) { return(null); } EdmProperty discriminatorProp = (EdmProperty)((DbPropertyExpression)((DbComparisonExpression)discriminatorPredicates.First().Value).Left).Property; DbNewInstanceExpression rowConstructor = (DbNewInstanceExpression)rowProjection.Projection; RowType resultRow = TypeHelpers.GetEdmType <RowType>(rowConstructor.ResultType); Dictionary <string, DbComparisonExpression> inputPredicateMap = new Dictionary <string, DbComparisonExpression>(); Dictionary <string, DbComparisonExpression> selectorPredicateMap = new Dictionary <string, DbComparisonExpression>(); Dictionary <string, DbExpression> columnValues = new Dictionary <string, DbExpression>(rowConstructor.Arguments.Count); for (int idx = 0; idx < rowConstructor.Arguments.Count; idx++) { string propName = resultRow.Properties[idx].Name; DbExpression columnVal = rowConstructor.Arguments[idx]; if (predicateColumnNames.Contains(propName)) { if (columnVal.ExpressionKind != DbExpressionKind.Case) { return(null); } DbCaseExpression casePredicate = (DbCaseExpression)columnVal; if (casePredicate.When.Count != 1 || !TypeSemantics.IsBooleanType(casePredicate.Then[0].ResultType) || !TypeSemantics.IsBooleanType(casePredicate.Else.ResultType) || casePredicate.Then[0].ExpressionKind != DbExpressionKind.Constant || casePredicate.Else.ExpressionKind != DbExpressionKind.Constant || (bool)((DbConstantExpression)casePredicate.Then[0]).Value != true || (bool)((DbConstantExpression)casePredicate.Else).Value != false) { return(null); } DbPropertyExpression comparedProp; object constValue; if (!TryMatchPropertyEqualsValue(casePredicate.When[0], rowProjection.Input.VariableName, out comparedProp, out constValue) || comparedProp.Property != discriminatorProp || !discriminatorPredicates.ContainsKey(constValue)) { return(null); } inputPredicateMap.Add(propName, discriminatorPredicates[constValue]); selectorPredicateMap.Add(propName, (DbComparisonExpression)casePredicate.When[0]); } else { columnValues.Add(propName, columnVal); } } // Build a new discriminator-based filter that only includes the same rows allowed by the higher '_from0' column-based filter DbExpression newDiscriminatorPredicate = Helpers.BuildBalancedTreeInPlace <DbExpression>(new List <DbExpression>(inputPredicateMap.Values), (left, right) => DbExpressionBuilder.Or(left, right)); discriminatorFilter = discriminatorFilter.Input.Filter(newDiscriminatorPredicate); DbCaseExpression entitySelector = (DbCaseExpression)entityProjection.Projection; List <DbExpression> newWhens = new List <DbExpression>(entitySelector.When.Count); List <DbExpression> newThens = new List <DbExpression>(entitySelector.Then.Count); for (int idx = 0; idx < entitySelector.When.Count; idx++) { DbPropertyExpression propWhen = (DbPropertyExpression)entitySelector.When[idx]; DbNewInstanceExpression entityThen = (DbNewInstanceExpression)entitySelector.Then[idx]; DbComparisonExpression discriminatorWhen; if (!selectorPredicateMap.TryGetValue(propWhen.Property.Name, out discriminatorWhen)) { return(null); } newWhens.Add(discriminatorWhen); DbExpression inputBoundEntityConstructor = ValueSubstituter.Substitute(entityThen, entityProjection.Input.VariableName, columnValues); newThens.Add(inputBoundEntityConstructor); } DbExpression newElse = ValueSubstituter.Substitute(entitySelector.Else, entityProjection.Input.VariableName, columnValues); DbCaseExpression newEntitySelector = DbExpressionBuilder.Case(newWhens, newThens, newElse); DbExpression result = discriminatorFilter.BindAs(rowProjection.Input.VariableName).Project(newEntitySelector); return(result); }
protected virtual void VisitEdmProperty(EdmProperty item) { VisitEdmNamedMetadataItem(item); if (item.PropertyType != null) { VisitEdmTypeReference(item.PropertyType); } }
private string GetFacetString(EdmProperty column) { StringBuilder sql = new StringBuilder(); Facet facet; Facet fcDateTimePrecision = null; ReadOnlyMetadataCollection<Facet> facets = column.TypeUsage.Facets; if (column.TypeUsage.EdmType.BaseType.Name == "String") { // types tinytext, mediumtext, text & longtext don't have a length. if (!column.TypeUsage.EdmType.Name.EndsWith("text", StringComparison.OrdinalIgnoreCase)) { if (facets.TryGetValue("MaxLength", true, out facet)) sql.AppendFormat(" ({0})", facet.Value); } } else if (column.TypeUsage.EdmType.BaseType.Name == "Decimal") { Facet fcScale; Facet fcPrecision; if (facets.TryGetValue("Scale", true, out fcScale) && facets.TryGetValue("Precision", true, out fcPrecision)) { // Enforce scale to a reasonable value. int scale = fcScale.Value == null ? 0 : ( int )( byte )fcScale.Value; if (scale == 0) scale = MySqlProviderManifest.DEFAULT_DECIMAL_SCALE; sql.AppendFormat("( {0}, {1} ) ", fcPrecision.Value, scale); } } else if (column.TypeUsage.EdmType.BaseType.Name == "DateTime") { if (serverVersion >= new Version(5, 6) && facets.TryGetValue("Precision", true, out fcDateTimePrecision)) { if (Convert.ToByte(fcDateTimePrecision.Value) >= 1) sql.AppendFormat("( {0} ) ", fcDateTimePrecision.Value); } } if (facets.TryGetValue("Nullable", true, out facet) && (bool)facet.Value == false) sql.Append(" NOT NULL"); if (facets.TryGetValue("StoreGeneratedPattern", true, out facet)) { if (facet.Value.Equals(StoreGeneratedPattern.Identity)) { if (column.TypeUsage.EdmType.BaseType.Name.StartsWith("Int")) sql.Append(" AUTO_INCREMENT UNIQUE"); else if (column.TypeUsage.EdmType.BaseType.Name == "Guid") _guidIdentityColumns.Add(column.Name); else if (serverVersion >= new Version(5, 6) && column.TypeUsage.EdmType.BaseType.Name == "DateTime") sql.AppendFormat(" DEFAULT CURRENT_TIMESTAMP{0}", fcDateTimePrecision != null && Convert.ToByte(fcDateTimePrecision.Value) >= 1 ? "( " + fcDateTimePrecision.Value.ToString() + " )" : ""); else throw new MySqlException("Invalid identity column type."); } } return sql.ToString(); }
protected virtual void VisitEdmProperty(EdmProperty item) { VisitMetadataItem(item); }
protected virtual void Visit(EdmProperty edmProperty) { Visit(edmProperty.TypeUsage); }
/// <summary> /// Gets the name of the column for the property from the metadata. /// Set nestedProperty for the property of a complex type to lookup. /// </summary> /// <param name="mappingFragment">EF metadata for finding mappings.</param> /// <param name="edmProperty">The of the model to find the column for (for simple types), or for complex types this is the containing complex type.</param> /// <param name="nestedProperty">Only required to map complex types. The property of the complex type to find the column name for.</param> /// <returns>The column name for the property</returns> /// <exception cref="EnumGeneratorException"> /// </exception> private static string GetColumnName(StructuralTypeMapping mappingFragment, EdmProperty edmProperty, EdmProperty nestedProperty = null) { var propertyMapping = GetPropertyMapping(mappingFragment, edmProperty); if (nestedProperty != null) { var complexPropertyMapping = propertyMapping as ComplexPropertyMapping; if (complexPropertyMapping == null) { throw new EnumGeneratorException(string.Format( "Failed to cast complex property mapping for {0}.{1} to ComplexPropertyMapping", edmProperty, nestedProperty)); } var complexTypeMappings = complexPropertyMapping.TypeMappings; if (complexTypeMappings.Count() != 1) { throw new EnumGeneratorException(string.Format( "{0} complexPropertyMapping TypeMappings found for property {1}.{2}", complexTypeMappings.Count(), edmProperty, nestedProperty)); } var complexTypeMapping = complexTypeMappings.Single(); var propertyMappings = complexTypeMapping.PropertyMappings.Where(pm => pm.Property.Name == nestedProperty.Name).ToList(); if (propertyMappings.Count() != 1) { throw new EnumGeneratorException(string.Format( "{0} complexMappings found for property {1}.{2}", propertyMappings.Count(), edmProperty, nestedProperty)); } propertyMapping = propertyMappings.Single(); } return(GetColumnNameFromPropertyMapping(edmProperty, propertyMapping)); }
/// <summary> /// Creates a ValueConditionMapping instance. /// </summary> /// <param name="propertyOrColumn">An EdmProperty that specifies a property or column.</param> /// <param name="value">An object that specifies the value to compare with.</param> public ValueConditionMapping(EdmProperty propertyOrColumn, object value) : base(Check.NotNull(propertyOrColumn, "propertyOrColumn"), Check.NotNull(value, "value"), null) { }
private static PropertyMapping GetPropertyMapping(StructuralTypeMapping mappingFragment, EdmProperty edmProperty) { var matches = mappingFragment.PropertyMappings.Where(m => m.Property.Name == edmProperty.Name).ToList(); if (matches.Count() != 1) { throw new EnumGeneratorException(string.Format( "{0} matches found for property {1}", matches.Count(), edmProperty)); } var match = matches.Single(); return(match); }
protected override void VisitEdmProperty(EdmProperty item) { Dispatch(item); base.VisitEdmProperty(item); }
private static IList <FunctionParameter> GetStoreReturnParameters( this DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute) { ParameterInfo returnParameterInfo = methodInfo.ReturnParameter; if (returnParameterInfo == null || returnParameterInfo.ParameterType == typeof(void)) { throw new NotSupportedException($"The return type of {methodInfo.Name} is not supported."); } ParameterAttribute returnParameterAttribute = returnParameterInfo.GetCustomAttribute <ParameterAttribute>(); ResultTypeAttribute[] returnTypeAttributes = methodInfo.GetCustomAttributes <ResultTypeAttribute>().ToArray(); if (functionAttribute.Type == FunctionType.StoredProcedure) { if (returnParameterAttribute != null) { throw new NotSupportedException( $"{nameof(ParameterAttribute)} for return value of method {methodInfo.Name} is not supported."); } return(new FunctionParameter[0]); } if (returnTypeAttributes.Any()) { throw new NotSupportedException($"{nameof(ResultTypeAttribute)} for method {methodInfo.Name} is not supported."); } if (functionAttribute.Type == FunctionType.TableValuedFunction) { if (returnParameterAttribute != null) { throw new NotSupportedException( $"{nameof(ParameterAttribute)} for return value of method {methodInfo.Name} is not supported."); } /* * <CollectionType> * <RowType> * <Property Name="PersonID" Type="int" Nullable="false" /> * <Property Name="FirstName" Type="nvarchar" MaxLength="50" /> * <Property Name="LastName" Type="nvarchar" MaxLength="50" /> * <Property Name="JobTitle" Type="nvarchar" MaxLength="50" /> * <Property Name="BusinessEntityType" Type="nvarchar" MaxLength="50" /> * </RowType> * </CollectionType> */ // returnParameterInfo.ParameterType is IQueryable<T>. Type storeReturnParameterClrType = returnParameterInfo.ParameterType.GetGenericArguments().Single(); StructuralType modelReturnParameterStructuralType = model.GetModelStructualType( storeReturnParameterClrType, methodInfo); ComplexType modelReturnParameterComplexType = modelReturnParameterStructuralType as ComplexType; RowType storeReturnParameterRowType; if (modelReturnParameterComplexType != null) { storeReturnParameterRowType = RowType.Create( modelReturnParameterComplexType.Properties.Select(property => EdmProperty.Create(property.Name, model.ProviderManifest.GetStoreType(property.TypeUsage))), null); } else { EntityType modelReturnParameterEntityType = modelReturnParameterStructuralType as EntityType; if (modelReturnParameterEntityType != null) { storeReturnParameterRowType = RowType.Create( modelReturnParameterEntityType.Properties.Select(property => property.Clone()), null); } else { throw new NotSupportedException($"Structural type {modelReturnParameterStructuralType.FullName} of method {methodInfo.Name} cannot be converted to {nameof(RowType)}."); } } return(new FunctionParameter[] { FunctionParameter.Create( "ReturnType", storeReturnParameterRowType.GetCollectionType(), // Collection of RowType. ParameterMode.ReturnValue) }); } if (functionAttribute.Type == FunctionType.NonComposableScalarValuedFunction) { // Non-composable scalar-valued function. return(new FunctionParameter[0]); } // Composable scalar-valued/Aggregate/Built in/Niladic function. // <Function Name="ufnGetProductListPrice" Aggregate="false" BuiltIn="false" NiladicFunction="false" IsComposable="true" ParameterTypeSemantics="AllowImplicitConversion" Schema="dbo" // ReturnType ="money"> PrimitiveType storeReturnParameterPrimitiveType = model.GetStoreParameterPrimitiveType(methodInfo, returnParameterInfo, functionAttribute); return(new FunctionParameter[] { FunctionParameter.Create("ReturnType", storeReturnParameterPrimitiveType, ParameterMode.ReturnValue) }); }
internal void WritePropertyElementHeader(EdmProperty property) { _xmlWriter.WriteStartElement(CsdlConstants.Element_Property); _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Name, property.Name); _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Type, GetTypeReferenceName(property.PropertyType)); if (property.CollectionKind != EdmCollectionKind.Default) { _xmlWriter.WriteAttributeString( CsdlConstants.Attribute_CollectionKind, property.CollectionKind.ToString()); } if (property.ConcurrencyMode == EdmConcurrencyMode.Fixed) { _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_ConcurrencyMode, CsdlConstants.Value_Fixed); } if (property.Annotations.GetClrAttributes() != null) { var epmCount = 0; foreach (var a in property.Annotations.GetClrAttributes()) { if (a.GetType().FullName.Equals(DataServicesMimeTypeAttribute, StringComparison.Ordinal)) { var mimeType = a.GetType().GetProperty("MimeType").GetValue(a, null) as string; _xmlWriter.WriteAttributeString(DataServicesPrefix, "MimeType", DataServicesNamespace, mimeType); } else if (a.GetType().FullName.Equals( DataServicesEntityPropertyMappingAttribute, StringComparison.Ordinal)) { var suffix = epmCount == 0 ? String.Empty : string.Format(CultureInfo.InvariantCulture, "_{0}", epmCount); var sourcePath = a.GetType().GetProperty("SourcePath").GetValue(a, null) as string; var slashIndex = sourcePath.IndexOf("/", StringComparison.Ordinal); if (slashIndex != -1 && slashIndex + 1 < sourcePath.Length) { _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_SourcePath" + suffix, DataServicesNamespace, sourcePath.Substring(slashIndex + 1)); } // There are three ways to write out this attribute var syndicationItem = a.GetType().GetProperty("TargetSyndicationItem").GetValue(a, null); var keepInContext = a.GetType().GetProperty("KeepInContent").GetValue(a, null).ToString(); var criteriaValueProperty = a.GetType().GetProperty("CriteriaValue"); string criteriaValue = null; if (criteriaValueProperty != null) { criteriaValue = criteriaValueProperty.GetValue(a, null) as string; } if (criteriaValue != null) { _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_TargetPath" + suffix, DataServicesNamespace, SyndicationItemPropertyToString(syndicationItem)); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_KeepInContent" + suffix, DataServicesNamespace, keepInContext); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_CriteriaValue" + suffix, DataServicesNamespace, criteriaValue); } else if (string.Equals( syndicationItem.ToString(), "CustomProperty", StringComparison.Ordinal)) { var targetPath = a.GetType().GetProperty("TargetPath").GetValue(a, null).ToString(); var targetNamespacePrefix = a.GetType().GetProperty("TargetNamespacePrefix").GetValue(a, null).ToString(); var targetNamespaceUri = a.GetType().GetProperty("TargetNamespaceUri").GetValue(a, null).ToString(); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_TargetPath" + suffix, DataServicesNamespace, targetPath); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_NsUri" + suffix, DataServicesNamespace, targetNamespaceUri); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_NsPrefix" + suffix, DataServicesNamespace, targetNamespacePrefix); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_KeepInContent" + suffix, DataServicesNamespace, keepInContext); } else { var contextKind = a.GetType().GetProperty("TargetTextContentKind").GetValue(a, null); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_TargetPath" + suffix, DataServicesNamespace, SyndicationItemPropertyToString(syndicationItem)); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_ContentKind" + suffix, DataServicesNamespace, SyndicationTextContentKindToString(contextKind)); _xmlWriter.WriteAttributeString( DataServicesPrefix, "FC_KeepInContent" + suffix, DataServicesNamespace, keepInContext); } epmCount++; } } } WritePropertyTypeFacets(property.PropertyType); DataModelAnnotation annotation; if (property.Annotations.TryGetByName(SsdlConstants.Attribute_StoreGeneratedPattern, out annotation)) { _xmlWriter.WriteAttributeString( SsdlConstants.Attribute_StoreGeneratedPattern, CsdlConstants.AnnotationNamespace, annotation.Value.ToString()); } }
/// <summary> /// When overriden returns <c>true</c> if <paramref name="dependentProperty" /> should be part of the foreign key. /// </summary> /// <param name="associationType"> The association type being configured. </param> /// <param name="dependentAssociationEnd"> The dependent end. </param> /// <param name="dependentProperty"> The candidate property on the dependent end. </param> /// <param name="principalEntityType"> The principal end entity type. </param> /// <param name="principalKeyProperty"> A key property on the principal end that is a candidate target for the foreign key. </param> /// <returns>true if dependentProperty should be a part of the foreign key; otherwise, false.</returns> protected abstract bool MatchDependentKeyProperty( AssociationType associationType, AssociationEndMember dependentAssociationEnd, EdmProperty dependentProperty, EntityType principalEntityType, EdmProperty principalKeyProperty);
protected override void VisitEdmProperty(EdmProperty item) { _schemaWriter.WritePropertyElementHeader(item); base.VisitEdmProperty(item); _schemaWriter.WriteEndElement(); }
/// <summary> /// Initialises a new instance of the <see cref="PropertyPath"/> class for the specified <see cref="EdmProperty"/> with no next path segment. /// </summary> /// <param name="property">The <see cref="EdmProperty"/> that the path segment represents.</param> private PropertyPath(EdmProperty property) : this(property, null) { }
/// <summary> /// Determines whether given property is concurrency check property. /// </summary> /// <param name="edmProperty">The edm property.</param> /// <returns></returns> private static bool? IsConcurrencyProperty(EdmProperty edmProperty) { foreach (var facet in edmProperty.TypeUsage.Facets) if (facet.Name == "ConcurrencyMode" && facet.Value != null && facet.IsUnbounded == false) return facet.Value.ToString() == "Fixed"; return null; }
/// <summary> /// Initialises a new instance of the <see cref="PropertyPath"/> class for the specified <see cref="EdmProperty"/> with the next path segment. /// </summary> /// <param name="property">The <see cref="EdmProperty"/> that the path segment represents.</param> /// <param name="next">The next <see cref="PropertyPath"/> in the property path.</param> private PropertyPath(EdmProperty property, PropertyPath next) { Property = property; Next = next; }
/// <summary> /// Initialises a new instance of the <see cref="PropertyAccessNode"/> class. /// </summary> /// <param name="property">The property being referenced in the query.</param> internal PropertyAccessNode(EdmProperty property) { this.Property = property; }
/// <summary> /// Creates the <see cref="PropertyPath"/> for the given <see cref="EdmProperty"/>. /// </summary> /// <param name="property">The <see cref="EdmProperty"/> that the path segment represents.</param> /// <returns>The <see cref="PropertyPath"/> for the given EdmProperty.</returns> internal static PropertyPath For(EdmProperty property) => s_edmPropertyCache.GetOrAdd(property ?? throw new ArgumentNullException(nameof(property)), p => new PropertyPath(p));
/// <summary> /// Constrcut a new member mapping metadata object /// </summary> /// <param name="edmProperty"> </param> /// <param name="clrProperty"> </param> internal ObjectComplexPropertyMapping(EdmProperty edmProperty, EdmProperty clrProperty) : base(edmProperty, clrProperty) { }
public ColumnAssertions(EdmProperty column) { _column = column; }
public void Can_create_non_composable_function_with_multiple_results() { DbProviderManifest providerManifest; var containerMapping = GetContainerMapping(out providerManifest); var cTypeUsageInt = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new[] { Facet.Create(MetadataItem.NullableFacetDescription, false) }); var sTypeUsageInt = TypeUsage.Create( providerManifest.GetStoreType(cTypeUsageInt).EdmType, new[] { Facet.Create(MetadataItem.NullableFacetDescription, false) }); var cTypeUsageString = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var sTypeUsageString = providerManifest.GetStoreType(cTypeUsageString); var complexType = ComplexType.Create( "RT1", "N", DataSpace.CSpace, new[] { EdmProperty.Create("P1", cTypeUsageInt), EdmProperty.Create("P2", cTypeUsageString) }, null); var entityType = EntityType.Create( "RT2", "N", DataSpace.CSpace, new[] { "P3" }, new[] { EdmProperty.Create("P3", cTypeUsageInt), EdmProperty.Create("P4", cTypeUsageString), }, null); var rowType1 = RowType.Create( new[] { EdmProperty.Create("C1", sTypeUsageInt), EdmProperty.Create("C2", sTypeUsageString) }, null); var rowType2 = RowType.Create( new[] { EdmProperty.Create("C3", sTypeUsageInt), EdmProperty.Create("C4", sTypeUsageString) }, null); var functionImport = EdmFunction.Create( "F", "N", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = false, ReturnParameters = new[] { FunctionParameter.Create("R1", complexType.GetCollectionType(), ParameterMode.ReturnValue), FunctionParameter.Create("R2", entityType.GetCollectionType(), ParameterMode.ReturnValue) }, EntitySets = new[] { new EntitySet(), new EntitySet() } }, null); var targetFunction = EdmFunction.Create( "SF", "N", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = false, ReturnParameters = new[] { FunctionParameter.Create("R1", rowType1.GetCollectionType(), ParameterMode.ReturnValue), FunctionParameter.Create("R2", rowType2.GetCollectionType(), ParameterMode.ReturnValue) }, EntitySets = new [] { new EntitySet(), new EntitySet() } }, null); var resultMappings = new List <FunctionImportResultMapping> { new FunctionImportResultMapping(), new FunctionImportResultMapping() }; resultMappings[0].AddTypeMapping(new FunctionImportComplexTypeMapping( complexType, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P1", "C1"), new FunctionImportReturnTypeScalarPropertyMapping("P2", "C2"), })); resultMappings[1].AddTypeMapping(new FunctionImportEntityTypeMapping( Enumerable.Empty <EntityType>(), new [] { entityType }, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P3", "C3"), new FunctionImportReturnTypeScalarPropertyMapping("P4", "C4") }, Enumerable.Empty <FunctionImportEntityTypeMappingCondition>())); var functionImportMapping = new FunctionImportMappingNonComposable( functionImport, targetFunction, resultMappings, containerMapping); Assert.Equal(resultMappings.Count, functionImportMapping.ResultMappings.Count); functionImportMapping.ResultMappings.Each(m => Assert.False(m.IsReadOnly)); functionImportMapping.SetReadOnly(); functionImportMapping.ResultMappings.Each(m => Assert.True(m.IsReadOnly)); }
public PropertyAssertions(EdmProperty property, IEnumerable <EdmProperty> columns) { _property = property; _columns = columns; }
private void AppendType(EdmProperty column) { var type = column.TypeUsage; // check for rowversion-like configurations Facet storeGenFacet; var isTimestamp = false; if (type.EdmType.Name == "binary" && 8 == type.GetMaxLength() && column.TypeUsage.Facets.TryGetValue("StoreGeneratedPattern", false, out storeGenFacet) && storeGenFacet.Value != null && StoreGeneratedPattern.Computed == (StoreGeneratedPattern)storeGenFacet.Value) { isTimestamp = true; AppendIdentifier("rowversion"); } else { var typeName = type.EdmType.Name; // Special case: the EDM treats 'nvarchar(max)' as a type name, but SQL Server treats // it as a type 'nvarchar' and a type qualifier. As such, we can't escape the entire // type name as the EDM sees it. const string maxSuffix = "(max)"; if (type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType && typeName.EndsWith(maxSuffix, StringComparison.Ordinal)) { Debug.Assert( new[] { "nvarchar(max)", "varchar(max)", "varbinary(max)" }.Contains(typeName), "no other known SQL Server primitive types types accept (max)"); AppendIdentifier(typeName.Substring(0, typeName.Length - maxSuffix.Length)); AppendSql("(max)"); } else { AppendIdentifier(typeName); } switch (type.EdmType.Name) { case "decimal": case "numeric": AppendSqlInvariantFormat("({0}, {1})", type.GetPrecision(), type.GetScale()); break; case "datetime2": case "datetimeoffset": case "time": AppendSqlInvariantFormat("({0})", type.GetPrecision()); break; case "binary": case "varbinary": case "nvarchar": case "varchar": case "char": case "nchar": AppendSqlInvariantFormat("({0})", type.GetMaxLength()); break; default: break; } } AppendSql(column.Nullable ? " null" : " not null"); if (!isTimestamp && column.TypeUsage.Facets.TryGetValue("StoreGeneratedPattern", false, out storeGenFacet) && storeGenFacet.Value != null) { var storeGenPattern = (StoreGeneratedPattern)storeGenFacet.Value; if (storeGenPattern == StoreGeneratedPattern.Identity) { if (type.EdmType.Name == "uniqueidentifier") { AppendSql(" default newid()"); } else { AppendSql(" identity"); } } } }
internal virtual CollectionColumnMap CreateColumnMapFromReaderAndClrType( DbDataReader reader, Type type, MetadataWorkspace workspace) { DebugCheck.NotNull(reader); DebugCheck.NotNull(type); DebugCheck.NotNull(workspace); // we require a default constructor var constructor = type.GetDeclaredConstructor(); if (type.IsAbstract() || (null == constructor && !type.IsValueType())) { throw new InvalidOperationException(Strings.ObjectContext_InvalidTypeForStoreQuery(type)); } // build a LINQ expression used by result assembly to create results var memberInfo = new List <Tuple <MemberAssignment, int, EdmProperty> >(); foreach (var prop in type.GetInstanceProperties() .Select(p => p.GetPropertyInfoForSet())) { // for enums unwrap the type if nullable var propertyUnderlyingType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType; var propType = propertyUnderlyingType.IsEnum() ? propertyUnderlyingType.GetEnumUnderlyingType() : prop.PropertyType; EdmType modelType; int ordinal; if (TryGetColumnOrdinalFromReader(reader, prop.Name, out ordinal) && workspace.TryDetermineCSpaceModelType(propType, out modelType) && (Helper.IsScalarType(modelType)) && prop.CanWriteExtended() && prop.GetIndexParameters().Length == 0 && null != prop.Setter()) { memberInfo.Add( Tuple.Create( Expression.Bind(prop, Expression.Parameter(prop.PropertyType, "placeholder")), ordinal, new EdmProperty(prop.Name, TypeUsage.Create(modelType)))); } } // initialize members in the order in which they appear in the reader var members = new MemberInfo[memberInfo.Count]; var memberBindings = new MemberBinding[memberInfo.Count]; var propertyMaps = new ColumnMap[memberInfo.Count]; var modelProperties = new EdmProperty[memberInfo.Count]; var i = 0; foreach (var memberGroup in memberInfo.GroupBy(tuple => tuple.Item2).OrderBy(tuple => tuple.Key)) { // make sure that a single column isn't contributing to multiple properties if (memberGroup.Count() != 1) { throw new InvalidOperationException( Strings.ObjectContext_TwoPropertiesMappedToSameColumn( reader.GetName(memberGroup.Key), String.Join(", ", memberGroup.Select(tuple => tuple.Item3.Name).ToArray()))); } var member = memberGroup.Single(); var assignment = member.Item1; var ordinal = member.Item2; var modelProp = member.Item3; members[i] = assignment.Member; memberBindings[i] = assignment; propertyMaps[i] = new ScalarColumnMap(modelProp.TypeUsage, modelProp.Name, 0, ordinal); modelProperties[i] = modelProp; i++; } var newExpr = null == constructor?Expression.New(type) : Expression.New(constructor); var init = Expression.MemberInit(newExpr, memberBindings); var initMetadata = InitializerMetadata.CreateProjectionInitializer( (EdmItemCollection)workspace.GetItemCollection(DataSpace.CSpace), init); // column map (a collection of rows with InitializerMetadata markup) var rowType = new RowType(modelProperties, initMetadata); var rowMap = new RecordColumnMap( TypeUsage.Create(rowType), "DefaultTypeProjection", propertyMaps, null); CollectionColumnMap collectionMap = new SimpleCollectionColumnMap( rowType.GetCollectionType().TypeUsage, rowType.Name, rowMap, null, null); return(collectionMap); }
/// <summary>Creates an IsNullConditionMapping instance.</summary> /// <param name="propertyOrColumn">An EdmProperty that specifies a property or column.</param> /// <param name="isNull">A boolean that indicates whether to perform a null or a not-null check.</param> public IsNullConditionMapping(EdmProperty propertyOrColumn, bool isNull) : base(Check.NotNull <EdmProperty>(propertyOrColumn, nameof(propertyOrColumn)), (object)null, new bool?(isNull)) { }
private string GetIndexName(IndexAttribute index, EdmProperty property) { return(index.Name == null?IndexNameCreator.CreateName(entitySet.ElementType.GetTableName(), property.Name) : NameCreator.EscapeName(index.Name)); }
internal void WriteDelaredKeyPropertyRefElement(EdmProperty property) { _xmlWriter.WriteStartElement(CsdlConstants.Element_PropertyRef); _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Name, property.Name); _xmlWriter.WriteEndElement(); }
protected internal override void VisitEdmProperty(EdmProperty item) { _schemaWriter.WritePropertyElementHeader(item); base.VisitEdmProperty(item); _schemaWriter.WriteEndElement(); }
private void WriteScalarPropertyElement(EdmProperty property, DbTableColumnMetadata column) { _xmlWriter.WriteStartElement(MslConstants.Element_ScalarProperty); _xmlWriter.WriteAttributeString(MslConstants.Attribute_Name, property.Name); _xmlWriter.WriteAttributeString(MslConstants.Attribute_ColumnName, column.Name); _xmlWriter.WriteEndElement(); }
// <summary> // Validates the scalar property on the cspace side and ospace side and creates a new // ObjectPropertyMapping, if everything maps property // </summary> private static ObjectPropertyMapping LoadScalarPropertyMapping(EdmProperty edmProperty, EdmProperty objectProperty) { Debug.Assert( Helper.IsScalarType(edmProperty.TypeUsage.EdmType), "Only edm scalar properties expected"); Debug.Assert( Helper.IsScalarType(objectProperty.TypeUsage.EdmType), "Only object scalar properties expected"); return(new ObjectPropertyMapping(edmProperty, objectProperty)); }
static GenerateColumnResult GenerateColumn(EdmProperty property) { var column = new StringBuilder(); var columnComments = new Dictionary<string, string>(); column.Append(SqlGenerator.QuoteIdentifier(property.Name)); column.Append(" "); column.Append(SqlGenerator.GetSqlPrimitiveType(property.TypeUsage)); switch (MetadataHelpers.GetEdmType<PrimitiveType>(property.TypeUsage).PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: column.AppendFormat(" CHECK ({0} IN (1,0))", SqlGenerator.QuoteIdentifier(property.Name)); columnComments.Add(property.Name, "#BOOL#"); break; case PrimitiveTypeKind.Guid: columnComments.Add(property.Name, "#GUID#"); break; } if (!property.Nullable) { column.Append(" NOT NULL"); } return new GenerateColumnResult() { ColumnName = column.ToString(), ColumnComments = columnComments }; }
public PropertyMappingFake(EdmProperty property) : base(property) { }
/// <summary> /// Gets the scale. /// </summary> /// <param name="edmProperty">The EDM property.</param> /// <returns></returns> private static int? GetScale(EdmProperty edmProperty) { foreach (var facet in edmProperty.TypeUsage.Facets) if (facet.Name == "Scale" && facet.Value != null && facet.IsUnbounded == false) return Convert.ToInt32(facet.Value); return null; }
/// <summary> /// Determines whether the given query view matches the discriminator map pattern. /// </summary> internal static bool TryCreateDiscriminatorMap(EntitySet entitySet, DbExpression queryView, out DiscriminatorMap discriminatorMap) { discriminatorMap = null; if (queryView.ExpressionKind != DbExpressionKind.Project) { return(false); } var project = (DbProjectExpression)queryView; if (project.Projection.ExpressionKind != DbExpressionKind.Case) { return(false); } var caseExpression = (DbCaseExpression)project.Projection; if (project.Projection.ResultType.EdmType.BuiltInTypeKind != BuiltInTypeKind.EntityType) { return(false); } // determine value domain by walking filter if (project.Input.Expression.ExpressionKind != DbExpressionKind.Filter) { return(false); } var filterExpression = (DbFilterExpression)project.Input.Expression; var discriminatorDomain = new HashSet <object>(); if ( !ViewSimplifier.TryMatchDiscriminatorPredicate( filterExpression, (equalsExp, discriminatorValue) => discriminatorDomain.Add(discriminatorValue))) { return(false); } var typeMap = new List <KeyValuePair <object, EntityType> >(); var propertyMap = new Dictionary <EdmProperty, DbExpression>(); var relPropertyMap = new Dictionary <RelProperty, DbExpression>(); var typeToRelPropertyMap = new Dictionary <EntityType, List <RelProperty> >(); DbPropertyExpression discriminator = null; EdmProperty discriminatorProperty = null; for (var i = 0; i < caseExpression.When.Count; i++) { var when = caseExpression.When[i]; var then = caseExpression.Then[i]; var projectionVariableName = project.Input.VariableName; DbPropertyExpression currentDiscriminator; object discriminatorValue; if ( !ViewSimplifier.TryMatchPropertyEqualsValue( when, projectionVariableName, out currentDiscriminator, out discriminatorValue)) { return(false); } // must be the same discriminator in every case if (null == discriminatorProperty) { discriminatorProperty = (EdmProperty)currentDiscriminator.Property; } else if (discriminatorProperty != currentDiscriminator.Property) { return(false); } discriminator = currentDiscriminator; // right hand side must be entity type constructor EntityType currentType; if (!TryMatchEntityTypeConstructor(then, propertyMap, relPropertyMap, typeToRelPropertyMap, out currentType)) { return(false); } // remember type + discriminator value typeMap.Add(new KeyValuePair <object, EntityType>(discriminatorValue, currentType)); // remove discriminator value from domain discriminatorDomain.Remove(discriminatorValue); } // make sure only one member of discriminator domain remains... if (1 != discriminatorDomain.Count) { return(false); } // check default case EntityType elseType; if (null == caseExpression.Else || !TryMatchEntityTypeConstructor(caseExpression.Else, propertyMap, relPropertyMap, typeToRelPropertyMap, out elseType)) { return(false); } typeMap.Add(new KeyValuePair <object, EntityType>(discriminatorDomain.Single(), elseType)); // Account for cases where some type in the hierarchy specifies a rel-property, but another // type in the hierarchy does not if (!CheckForMissingRelProperties(relPropertyMap, typeToRelPropertyMap)) { return(false); } // since the store may right-pad strings, ensure discriminator values are unique in their trimmed // form var discriminatorValues = typeMap.Select(map => map.Key); var uniqueValueCount = discriminatorValues.Distinct(TrailingSpaceComparer.Instance).Count(); var valueCount = typeMap.Count; if (uniqueValueCount != valueCount) { return(false); } discriminatorMap = new DiscriminatorMap(discriminator, typeMap, propertyMap, relPropertyMap, entitySet); return(true); }
/// <summary> /// /// </summary> /// <param name="entityMap"></param> /// <param name="edmProperty"></param> /// <param name="i"></param> /// <param name="prefix"></param> private void MapProperty(EntityMap entityMap, EdmProperty edmProperty, ref int i, ref string prefix) { var identity = entityMap.EdmType.FullName; var entityMembers = TphData[identity].Properties; var columnName = edmProperty.Name; if (entityMembers.Length <= i) { return; } EdmMember edmMember = entityMembers[i]; // check if is complex type if (string.IsNullOrEmpty(prefix) && edmMember.TypeUsage.EdmType.GetType() == typeof(ComplexType)) { prefix = edmMember.Name; ++i; } string propName; if (prefix != null) { if (columnName.StartsWith(prefix + "_")) { propName = columnName.Replace('_', '.'); } else { prefix = null; propName = edmMember.Name; ++i; } } else { propName = entityMembers[i++].Name; } var propInfo = entityMap.Type.GetProperty(propName, '.'); if (propInfo == null) { // entity does not contain such property return; } PropertyMap propertyMap; try { /* var mi = SqlProviderServices.Instance.GetType().GetMethod("GetSqlDbType", BindingFlags.NonPublic | BindingFlags.Static); var parameterInfos = mi.GetParameters(); var parameters = new List<object>(); parameters.Add(edmProperty.TypeUsage); parameters.Add(false); parameters.Add(SqlVersion); parameters.Add(null); parameters.Add(null); parameters.Add(null); parameters.Add(null); SqlDbType sqlDbType = (SqlDbType) mi.Invoke(null, parameters.ToArray()); */ propertyMap = entityMap.MapProperty(propName, columnName); propertyMap.EdmProperty = edmProperty; propertyMap.EdmMember = edmMember; propertyMap.IsNavigationProperty = edmMember is NavigationProperty; propertyMap.IsFk = propertyMap.IsNavigationProperty || _fks.ContainsKey(edmMember); if (propertyMap.IsFk && _fks.ContainsKey(edmMember)) { propertyMap.FkTargetEdmMember = _fks[edmMember]; entityMap.AddFk(propertyMap); } } catch (Exception ex) { var errorMessage = string.Format("Failed to map propName {0} to column {1} on table {2} ({3})", propName, columnName, entityMap.TableName, entityMap.TypeFullName); throw new Exception(errorMessage, ex); } if (_pks[entityMap.TableName].Contains(columnName)) { propertyMap.IsPk = true; entityMap.AddPk(propertyMap); } foreach (var facet in edmProperty.TypeUsage.Facets) { //System.Data.Entity.Core.Common.DbProviderManifest.ScaleFacetName switch (facet.Name) { case "SRID": try { propertyMap.SRID = (int?)facet.Value; } catch { // nothing to do } break; case "IsStrict": propertyMap.IsStrict = facet.Value != null && (bool)facet.Value; break; case "Unicode": propertyMap.Unicode = facet.Value != null && (bool)facet.Value; break; case "FixedLength": propertyMap.FixedLength = facet.Value != null && (bool)facet.Value; break; case "Precision": propertyMap.Precision = (byte)facet.Value; break; case "Scale": propertyMap.Scale = (byte)facet.Value; break; case "Nullable": propertyMap.IsRequired = !(bool)facet.Value; break; case "DefaultValue": propertyMap.DefaultValue = facet.Value; break; case "StoreGeneratedPattern": propertyMap.IsIdentity = (StoreGeneratedPattern)facet.Value == StoreGeneratedPattern.Identity; propertyMap.Computed = (StoreGeneratedPattern)facet.Value == StoreGeneratedPattern.Computed; break; case "MaxLength": if (facet.Value == null) { propertyMap.MaxLength = int.MaxValue; } else { int result; var val = facet.Value.ToString(); if (!Int32.TryParse(val, out result)) { if (val == "Max") { propertyMap.MaxLength = int.MaxValue; } } propertyMap.MaxLength = result; } break; } } }
public void AsPrimitive_should_create_property_type_and_facets() { var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); Assert.NotNull(property.TypeUsage); }
private static IEnumerable<IndexInfo> GetIndexes(EdmProperty prop) { var indexMetadata = prop.MetadataProperties .FirstOrDefault(x => x.Name == "http://schemas.microsoft.com/ado/2013/11/edm/customannotation:Index"); if (indexMetadata == null) { yield break; } // Use dynamic in order to not force the need of EF6.1 dynamic indexAnnotation = indexMetadata.Value; foreach (dynamic index in indexAnnotation.Indexes) { yield return GetIndexInfo(index); } }
public void Can_generate_function_mappings_for_entity_type() { var functionMappingGenerator = new ModificationFunctionMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest); var databaseMapping = new DbDatabaseMapping() .Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace)); var entityType = new EntityType("E", "N", DataSpace.CSpace); var intProperty = EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); entityType.AddKeyMember(intProperty); var stringProperty = EdmProperty.CreatePrimitive("Name", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(stringProperty); var entitySetMapping = databaseMapping.AddEntitySetMapping( databaseMapping.Model.AddEntitySet("ES", entityType)); var storageEntityTypeMapping = new EntityTypeMapping( new EntitySetMapping(new EntitySet(), databaseMapping.EntityContainerMappings.Single())); storageEntityTypeMapping.AddType(entityType); var storageMappingFragment = new MappingFragment(new EntitySet(), storageEntityTypeMapping, false); storageMappingFragment.AddColumnMapping( new ColumnMappingBuilder(new EdmProperty("C0", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })), new[] { intProperty })); storageMappingFragment.AddColumnMapping( new ColumnMappingBuilder(new EdmProperty("C1", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })), new[] { stringProperty })); storageEntityTypeMapping.AddFragment(storageMappingFragment); entitySetMapping.AddTypeMapping(storageEntityTypeMapping); functionMappingGenerator.Generate(entityType, databaseMapping); var modificationFunctionMapping = entitySetMapping.ModificationFunctionMappings.Single(); Assert.NotNull(modificationFunctionMapping); var functionMapping = modificationFunctionMapping.InsertFunctionMapping; Assert.NotNull(functionMapping); Assert.Equal(2, functionMapping.ParameterBindings.Count); Assert.Null(functionMapping.ResultBindings); var function = functionMapping.Function; Assert.NotNull(function); Assert.Equal("E_Insert", function.Name); Assert.Equal(2, function.Parameters.Count); functionMapping = modificationFunctionMapping.UpdateFunctionMapping; Assert.NotNull(functionMapping); Assert.Equal(2, functionMapping.ParameterBindings.Count); Assert.Null(functionMapping.ResultBindings); function = functionMapping.Function; Assert.NotNull(function); Assert.Equal("E_Update", function.Name); Assert.Equal(2, function.Parameters.Count); functionMapping = modificationFunctionMapping.DeleteFunctionMapping; Assert.NotNull(functionMapping); Assert.Equal(1, functionMapping.ParameterBindings.Count); Assert.Null(functionMapping.ResultBindings); function = modificationFunctionMapping.DeleteFunctionMapping.Function; Assert.NotNull(function); Assert.Equal("E_Delete", function.Name); Assert.Equal(1, function.Parameters.Count); }