public static void TryGetAdjustedName_correctly_retrieves_the_adjusted_identifier_associated_with_an_object() { const string identifier = "Identifier"; const string adjustedIdentifier1 = "Identifier1"; const string adjustedIdentifier2 = "Identifier2"; const string adjustedIdentifier3 = "Identifier3"; string adjustedIdentifier; var value1 = new object(); var value2 = new object(); var value3 = new object(); var service = new UniqueIdentifierService(); service.RegisterUsedIdentifier(identifier); Assert.Equal(adjustedIdentifier1, service.AdjustIdentifier(identifier, value1)); Assert.Equal(adjustedIdentifier2, service.AdjustIdentifier(identifier, value2)); Assert.Equal(adjustedIdentifier3, service.AdjustIdentifier(identifier, value3)); Assert.True(service.TryGetAdjustedName(value1, out adjustedIdentifier)); Assert.Equal(adjustedIdentifier, adjustedIdentifier1); Assert.True(service.TryGetAdjustedName(value2, out adjustedIdentifier)); Assert.Equal(adjustedIdentifier, adjustedIdentifier2); Assert.True(service.TryGetAdjustedName(value3, out adjustedIdentifier)); Assert.Equal(adjustedIdentifier, adjustedIdentifier3); }
public static void AdjustIdentifier_with_Ordinal_comparer_and_identity_transform_returns_expected_result() { const string identifier = "Identifier"; const string adjustedIdentifier1 = "Identifier1"; const string adjustedIdentifier2 = "Identifier2"; const string adjustedIdentifier3 = "Identifier3"; var service = new UniqueIdentifierService(StringComparer.Ordinal); service.RegisterUsedIdentifier(identifier); Assert.Equal(adjustedIdentifier1, service.AdjustIdentifier(identifier)); Assert.Equal(adjustedIdentifier2, service.AdjustIdentifier(identifier)); Assert.Equal(adjustedIdentifier3, service.AdjustIdentifier(identifier)); }
private static string CreateModelName(string storeName, UniqueIdentifierService uniqueNameService) { Debug.Assert(!string.IsNullOrEmpty(storeName), "storeName cannot be null or empty string"); Debug.Assert(uniqueNameService != null, "uniqueNameService != null"); return(uniqueNameService.AdjustIdentifier(CreateModelName(storeName))); }
public static void AdjustIdentifier_with_OrdinalIgnoreCase_comparer_and_custom_transform_returns_expected_result() { const string identifier = "My.Identifier"; const string usedIdentifier = "My_IdENtIfiEr"; const string adjustedIdentifier1 = "My_Identifier1"; const string adjustedIdentifier2 = "My_Identifier2"; const string adjustedIdentifier3 = "My_Identifier3"; Func<string, string> transform = s => s.Replace(".", "_"); var service = new UniqueIdentifierService(StringComparer.OrdinalIgnoreCase, transform); service.RegisterUsedIdentifier(usedIdentifier); Assert.Equal(adjustedIdentifier1, service.AdjustIdentifier(identifier)); Assert.Equal(adjustedIdentifier2, service.AdjustIdentifier(identifier)); Assert.Equal(adjustedIdentifier3, service.AdjustIdentifier(identifier)); }
// internal for testing internal ComplexType CreateComplexTypeFromRowType(SimpleMappingContext mappingContext, RowType rowType, string typeName) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(!string.IsNullOrEmpty(typeName), "typeName cannot be null or empty string."); Debug.Assert(rowType != null, "rowType != null"); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(typeName); return (ComplexType.Create( typeName, _namespaceName, DataSpace.CSpace, rowType.Properties.Select(p => GenerateScalarProperty(mappingContext, p, uniquePropertyNameService)), null)); }
// internal for testing internal EntityType GenerateEntityType( SimpleMappingContext mappingContext, EntityType storeEntityType, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeEntityType != null, "storeEntityType != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); var conceptualEntityTypeName = CreateModelName( (_pluralizationService != null) ? _pluralizationService.Singularize(storeEntityType.Name) : storeEntityType.Name, globallyUniqueTypeNames); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(conceptualEntityTypeName); var edmMembers = new List <EdmMember>(); var keyMemberNames = new List <string>(); foreach (var storeProperty in storeEntityType.Properties) { // cannot skip this even if the store property is foreign key and generating foreign keys is disabled // since it creates property mappings the will be used when mapping association types. var conceptualProperty = GenerateScalarProperty(mappingContext, storeProperty, uniquePropertyNameService); if (_generateForeignKeyProperties || !mappingContext.StoreForeignKeyProperties.Contains(storeProperty) || storeEntityType.KeyMembers.Contains(storeProperty)) { edmMembers.Add(conceptualProperty); if (storeEntityType.KeyMembers.Contains(storeProperty)) { keyMemberNames.Add(conceptualProperty.Name); } } } var conceptualEntity = EntityType.Create( conceptualEntityTypeName, _namespaceName, DataSpace.CSpace, keyMemberNames, edmMembers, null); mappingContext.AddMapping(storeEntityType, conceptualEntity); return(conceptualEntity); }
// internal for testing internal FunctionParameter CreateFunctionParameter( FunctionDetailsRowView functionDetailsRow, UniqueIdentifierService uniqueIdentifierService, int parameterIndex, IList<EdmSchemaError> errors) { Debug.Assert(functionDetailsRow != null, "functionDetailsRow != null"); Debug.Assert(uniqueIdentifierService != null, "uniqueIdentifierService != null"); Debug.Assert(errors != null, "errors != null"); var parameterType = GetFunctionParameterType(functionDetailsRow, parameterIndex, errors); if (parameterType == null) { return null; } ParameterMode parameterMode; if (!functionDetailsRow.TryGetParameterMode(out parameterMode)) { errors.Add( new EdmSchemaError( string.Format( CultureInfo.InvariantCulture, Resources_VersioningFacade.ParameterDirectionNotValid, functionDetailsRow.ProcedureName, functionDetailsRow.ParameterName, functionDetailsRow.ProcParameterMode), (int)ModelBuilderErrorCode.ParameterDirectionNotValid, EdmSchemaErrorSeverity.Warning)); return null; } var parameterName = uniqueIdentifierService.AdjustIdentifier( ModelGeneratorUtils.CreateValidEcmaName(functionDetailsRow.ParameterName, 'p')); return FunctionParameter.Create(parameterName, parameterType, parameterMode); }
internal AssociationSet TryCreateAssociationSet( List<RelationshipDetailsRow> relationshipDetailsRows, EntityRegister entityRegister, List<AssociationType> associationTypes) { Debug.Assert(relationshipDetailsRows.Count > 0, "relationshipDetailsRows.Count > 0"); var firstRow = relationshipDetailsRows.First(); var errors = new List<EdmSchemaError>(); AssociationType associationType; var isValidAssociationType = false; var typeName = _usedTypeNames.AdjustIdentifier(firstRow.RelationshipName); AssociationEndMember pkEnd = null; AssociationEndMember fkEnd = null; ReferentialConstraint constraint = null; var pkEntityType = TryGetEndEntity(entityRegister, firstRow.GetMostQualifiedPrimaryKey(), errors); var fkEntityType = TryGetEndEntity(entityRegister, firstRow.GetMostQualifiedForeignKey(), errors); if (ValidateEndEntities(relationshipDetailsRows, pkEntityType, fkEntityType, errors)) { var someFKColumnsAreNullable = _targetEntityFrameworkVersion == EntityFrameworkVersion.Version1 ? AreAllFKColumnsNullable(relationshipDetailsRows, fkEntityType) : AreAnyFKColumnsNullable(relationshipDetailsRows, fkEntityType); var usedEndNames = new UniqueIdentifierService(StringComparer.OrdinalIgnoreCase); pkEnd = AssociationEndMember.Create( usedEndNames.AdjustIdentifier(pkEntityType.Name), pkEntityType.GetReferenceType(), someFKColumnsAreNullable ? RelationshipMultiplicity.ZeroOrOne : RelationshipMultiplicity.One, firstRow.RelationshipIsCascadeDelete ? OperationAction.Cascade : OperationAction.None, null); fkEnd = AssociationEndMember.Create( usedEndNames.AdjustIdentifier(fkEntityType.Name), fkEntityType.GetReferenceType(), !someFKColumnsAreNullable && AreRelationshipColumnsTheFullKey(relationshipDetailsRows, fkEntityType, r => r.FKColumn) ? RelationshipMultiplicity.ZeroOrOne : RelationshipMultiplicity.Many, OperationAction.None, null); constraint = TryCreateReferentialConstraint(relationshipDetailsRows, pkEnd, fkEnd, errors); if (constraint != null && ValidateReferentialConstraint(constraint, _generateForeignKeyProperties, typeName, associationTypes, errors)) { isValidAssociationType = true; } } associationType = AssociationType.Create( typeName, _namespaceName, false, DataSpace.SSpace, pkEnd, fkEnd, constraint, CreateMetadataProperties(!isValidAssociationType, errors)); associationTypes.Add(associationType); return isValidAssociationType ? CreateAssociationSet(associationType, entityRegister) : null; }
public void GenerateFunction_returns_function_with_unique_return_type_name() { var storeReturnType = CreateRowType(CreateProperty("foo", PrimitiveTypeKind.Int32)).GetCollectionType(); var returnParameter = FunctionParameter.Create("ReturnType", storeReturnType, ParameterMode.ReturnValue); var storeFunction = EdmFunction.Create( "foo*", "bar", DataSpace.SSpace, new EdmFunctionPayload { ReturnParameters = new[] { returnParameter } }, null); var uniqueContainerNames = new UniqueIdentifierService(); uniqueContainerNames.AdjustIdentifier("foo_"); var globallyUniqueTypeNames = new UniqueIdentifierService(); globallyUniqueTypeNames.AdjustIdentifier("foo_1_Result"); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); var functionImport = CreateOneToOneMappingBuilder() .GenerateFunction(mappingContext, storeFunction, uniqueContainerNames, globallyUniqueTypeNames); Assert.NotNull(functionImport); Assert.Equal( "myModel.foo_1_Result1", ((CollectionType)functionImport.ReturnParameter.TypeUsage.EdmType).TypeUsage.EdmType.FullName); Assert.Empty(mappingContext.Errors); }
public void GenerateEntityType_entity_type_name_is_sanitized_and_uniquified() { var storeEntityType = EntityType.Create( "foo$", "bar", DataSpace.SSpace, new[] { "Id" }, new[] { EdmProperty.CreatePrimitive("Id", GetStoreEdmType("int")) }, null); var uniqueEntityTypeName = new UniqueIdentifierService(); uniqueEntityTypeName.AdjustIdentifier("foo_"); var conceptualEntityType = CreateOneToOneMappingBuilder() .GenerateEntityType( new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true), storeEntityType, uniqueEntityTypeName); Assert.Equal("foo_1", conceptualEntityType.Name); }
public void GenerateScalarProperty_converts_and_uniquifies_property_names() { var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier("p_1"); var storeProperty = EdmProperty.CreatePrimitive("p*1", GetStoreEdmType("int")); var conceptualProperty = OneToOneMappingBuilder .GenerateScalarProperty( new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true), storeProperty, uniquePropertyNameService); Assert.Equal("p_11", conceptualProperty.Name); }
public void GenerateEntitySet_entity_set_name_sanitized_and_uniquified() { var storeEntityType = EntityType.Create( "foo", "bar", DataSpace.SSpace, new[] { "Id" }, new[] { EdmProperty.CreatePrimitive("Id", GetStoreEdmType("int")) }, null); var storeEntitySet = EntitySet.Create("foo$", "bar", null, null, storeEntityType, null); var uniqueEntityContainerNames = new UniqueIdentifierService(); uniqueEntityContainerNames.AdjustIdentifier("foo_"); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); CreateOneToOneMappingBuilder() .GenerateEntitySet( mappingContext, storeEntitySet, uniqueEntityContainerNames, new UniqueIdentifierService()); var conceptualModelEntitySet = mappingContext[storeEntitySet]; Assert.Equal("foo_1", conceptualModelEntitySet.Name); Assert.Equal("foo", conceptualModelEntitySet.ElementType.Name); }
public void CreateFunctionParameter_applies_ECMA_name_conversion_and_uniquifies_parameter_name() { var errors = new List<EdmSchemaError>(); var uniquifiedIdentifierService = new UniqueIdentifierService(); uniquifiedIdentifierService.AdjustIdentifier("p_r_m"); var parameter = CreateStoreModelBuilder() .CreateFunctionParameter( CreateFunctionDetailsRow( functionName: "function", paramName: "p@r@m", paramTypeName: "smallint", parameterDirection: "INOUT"), uniquifiedIdentifierService, 1, errors); Assert.NotNull(parameter); Assert.Empty(errors); Assert.Equal("p_r_m1", parameter.Name); Assert.Equal("smallint", parameter.TypeUsage.EdmType.Name); Assert.Equal(ParameterMode.InOut, parameter.Mode); }
// internal for testing internal EntityType GenerateEntityType( SimpleMappingContext mappingContext, EntityType storeEntityType, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeEntityType != null, "storeEntityType != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); var conceptualEntityTypeName = CreateModelName( (_pluralizationService != null) ? _pluralizationService.Singularize(storeEntityType.Name) : storeEntityType.Name, globallyUniqueTypeNames); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(conceptualEntityTypeName); var edmMembers = new List<EdmMember>(); var keyMemberNames = new List<string>(); foreach (var storeProperty in storeEntityType.Properties) { // cannot skip this even if the store property is foreign key and generating foreign keys is disabled // since it creates property mappings the will be used when mapping association types. var conceptualProperty = GenerateScalarProperty(mappingContext, storeProperty, uniquePropertyNameService); if (_generateForeignKeyProperties || !mappingContext.StoreForeignKeyProperties.Contains(storeProperty) || storeEntityType.KeyMembers.Contains(storeProperty)) { edmMembers.Add(conceptualProperty); if (storeEntityType.KeyMembers.Contains(storeProperty)) { keyMemberNames.Add(conceptualProperty.Name); } } } var conceptualEntity = EntityType.Create( conceptualEntityTypeName, _namespaceName, DataSpace.CSpace, keyMemberNames, edmMembers, null); mappingContext.AddMapping(storeEntityType, conceptualEntity); return conceptualEntity; }
private static string CreateModelName(string storeName, UniqueIdentifierService uniqueNameService) { Debug.Assert(!string.IsNullOrEmpty(storeName), "storeName cannot be null or empty string"); Debug.Assert(uniqueNameService != null, "uniqueNameService != null"); return uniqueNameService.AdjustIdentifier(CreateModelName(storeName)); }
// internal for testing internal ComplexType CreateComplexTypeFromRowType(SimpleMappingContext mappingContext, RowType rowType, string typeName) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(!string.IsNullOrEmpty(typeName), "typeName cannot be null or empty string."); Debug.Assert(rowType != null, "rowType != null"); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(typeName); return ComplexType.Create( typeName, _namespaceName, DataSpace.CSpace, rowType.Properties.Select(p => GenerateScalarProperty(mappingContext, p, uniquePropertyNameService)), null); }