public EdmProperty BuildString(string name, bool isUnicode, bool isFixedLength, int maxLength)
{
var typeUsage = TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
isUnicode,
isFixedLength,
maxLength);
var property = EdmProperty.Create(
name,
typeUsage);
return(property);
}
public void Visit_DbIsNullExpression_creates_equivalent_legacy_DbIsNullExpression()
{
var isNullExpression =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)).Null().IsNull();
var legacyIsNullExpression =
_legacyDbExpressionConverter.Visit(isNullExpression) as LegacyCommandTrees.DbIsNullExpression;
Assert.NotNull(legacyIsNullExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.IsNull, legacyIsNullExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Null, legacyIsNullExpression.Argument.ExpressionKind);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyIsNullExpression.ResultType, isNullExpression.ResultType);
}
public void GetComplexPropertyMappings_should_return_all_complex_property_mappings_for_type()
{
var databaseMapping = new DbDatabaseMapping()
.Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));
var entitySet = new EntitySet
{
Name = "ES"
};
var entitySetMapping = databaseMapping.AddEntitySetMapping(entitySet);
var entityTypeMapping = new EntityTypeMapping(null);
entitySetMapping.AddTypeMapping(entityTypeMapping);
var entityTypeMappingFragment = new MappingFragment(entitySet, entityTypeMapping, false);
entityTypeMapping.AddFragment(entityTypeMappingFragment);
var complexType = new ComplexType("C");
var propertyMapping1
= new ColumnMappingBuilder(
new EdmProperty("C", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})),
new[]
{
EdmProperty.CreateComplex("P1", complexType),
EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))
});
var type = typeof(object);
complexType.GetMetadataProperties().SetClrType(type);
entityTypeMappingFragment.AddColumnMapping(propertyMapping1);
var propertyMapping2
= new ColumnMappingBuilder(
new EdmProperty("C", TypeUsage.Create(new PrimitiveType()
{
DataSpace = DataSpace.SSpace
})),
new List <EdmProperty>
{
EdmProperty.CreateComplex("P3", complexType),
EdmProperty.CreatePrimitive(
"P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
});
entityTypeMappingFragment.AddColumnMapping(propertyMapping2);
Assert.Equal(2, databaseMapping.GetComplexPropertyMappings(typeof(object)).Count());
}
public void Apply_should_set_correct_defaults_for_unconfigured_binary()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary));
entityType.AddMember(property);
((IEdmConvention <EntityType>) new PropertyMaxLengthConvention())
.Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.Null(property.IsUnicode);
Assert.Equal(false, property.IsFixedLength);
Assert.Null(property.MaxLength);
}
public void ComplexType_apply_should_set_correct_defaults_for_unconfigured_binary()
{
var entityType = new ComplexType("C");
var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary));
entityType.AddMember(property);
(new PropertyMaxLengthConvention())
.Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.Null(property.IsUnicode);
Assert.Equal(false, property.IsFixedLength);
Assert.Null(property.MaxLength);
}
public void Apply_should_set_correct_defaults_for_binary_key()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary));
entityType.AddMember(property);
entityType.AddKeyMember(property);
(new PropertyMaxLengthConvention())
.Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.Null(property.IsUnicode);
Assert.Equal(128, property.MaxLength);
}
/// <summary>
/// Creates a SQLiteParameter given a name, type, and direction
/// </summary>
internal static SQLiteParameter CreateSQLiteParameter(string name, TypeUsage type, ParameterMode mode,
object value)
{
int?size;
if (type.GetPrimitiveTypeKind() == PrimitiveTypeKind.Guid)
{
type = TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
false, true);
}
var result = new SQLiteParameter(name, value);
// .Direction
var direction = MetadataHelpers.ParameterModeToParameterDirection(mode);
if (result.Direction != direction)
{
result.Direction = direction;
}
// .Size and .DbType
// output parameters are handled differently (we need to ensure there is space for return
// values where the user has not given a specific Size/MaxLength)
var isOutParam = mode != ParameterMode.In;
var sqlDbType = GetSQLiteDbType(type, isOutParam, out size);
if (result.DbType != sqlDbType)
{
result.DbType = sqlDbType;
}
// Note that we overwrite 'facet' parameters where either the value is different or
// there is an output parameter.
if (size.HasValue && (isOutParam || result.Size != size.Value))
{
result.Size = size.Value;
}
// .IsNullable
var isNullable = type.GetIsNullable();
if (isOutParam || isNullable != result.IsNullable)
{
result.IsNullable = isNullable;
}
return(result);
}
public void Apply_should_ignore_when_type_is_derived()
{
var entityType = new EntityType();
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
entityType.BaseType = new EntityType();
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel());
Assert.False(entityType.DeclaredKeyProperties.Contains(property));
}
public void Apply_should_match_simple_short_key()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
entityType.AddKeyMember(property);
((IEdmConvention <EntityType>) new StoreGeneratedIdentityKeyConvention())
.Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.Equal(
StoreGeneratedPattern.Identity,
entityType.KeyProperties.Single().GetStoreGeneratedPattern());
}
public void Generate_can_map_independent_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
var type = typeof(object);
principalEntityType.GetMetadataProperties().SetClrType(type);
var property = EdmProperty.CreatePrimitive("Id1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property);
var idProperty1 = property;
principalEntityType.AddKeyMember(idProperty1);
var property1 = EdmProperty.CreatePrimitive("Id2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property1);
var idProperty2 = property1;
principalEntityType.AddKeyMember(idProperty2);
var dependentEntityType = model.AddEntityType("D");
var type1 = typeof(string);
dependentEntityType.GetMetadataProperties().SetClrType(type1);
model.AddEntitySet("PSet", principalEntityType);
model.AddEntitySet("DSet", dependentEntityType);
var associationType
= model.AddAssociationType(
"P_D",
principalEntityType, RelationshipMultiplicity.One,
dependentEntityType, RelationshipMultiplicity.Many);
model.AddAssociationSet("P_DSet", associationType);
associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade;
var databaseMapping = CreateDatabaseMappingGenerator().Generate(model);
var foreignKeyConstraint
=
databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table.ForeignKeyBuilders.Single();
Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count());
Assert.Equal(associationType.Name, foreignKeyConstraint.Name);
Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().AssociationSetMappings.Count());
Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction);
var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First();
Assert.False(foreignKeyColumn.Nullable);
Assert.Equal("P_Id1", foreignKeyColumn.Name);
}
public void HasStoreGeneratedPattern_should_return_true_when_not_null_or_none()
{
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
Assert.False(property.HasStoreGeneratedPattern());
property.SetStoreGeneratedPattern(StoreGeneratedPattern.None);
Assert.False(property.HasStoreGeneratedPattern());
property.SetStoreGeneratedPattern(StoreGeneratedPattern.Computed);
Assert.True(property.HasStoreGeneratedPattern());
}
public void ComplexType_apply_should_set_correct_defaults_for_non_unicode_fixed_length_strings()
{
var entityType = new ComplexType("C");
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
property.IsFixedLength = true;
property.IsUnicode = false;
entityType.AddMember(property);
((IEdmConvention <ComplexType>) new SqlCePropertyMaxLengthConvention())
.Apply(entityType, CreateEdmModel());
Assert.Equal(4000, property.MaxLength);
}
public void Apply_should_set_correct_defaults_for_fixed_length_binary()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
property.IsFixedLength = true;
entityType.AddMember(property);
((IEdmConvention <EntityType>) new SqlCePropertyMaxLengthConvention())
.Apply(entityType, CreateEdmModel());
Assert.Null(property.IsUnicode);
Assert.Equal(4000, property.MaxLength);
}
public void Apply_should_ignore_when_key_already_specified()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
entityType.AddKeyMember(EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)));
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.False(entityType.KeyProperties.Contains(property));
}
private static EnumType CreateEnumType()
{
var enumTypeCtor =
typeof(EnumType).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)
.Single(c => c.GetParameters().Count() == 5);
var enumType = (EnumType)enumTypeCtor.Invoke(BindingFlags.NonPublic | BindingFlags.Instance, null,
new object[]
{
"TestEnumType", "Model", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false,
DataSpace.CSpace
},
CultureInfo.InvariantCulture);
return enumType;
}
public void Apply_should_ignore_when_type_is_derived()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
entityType.BaseType = new EntityType("E", "N", DataSpace.CSpace);
(new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.False(entityType.KeyProperties.Contains(property));
}
public void Apply_should_match_simple_long_key()
{
var entityType = new EntityType();
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int64));
entityType.AddKeyMember(property);
((IEdmConvention <EntityType>) new StoreGeneratedIdentityKeyConvention())
.Apply(entityType, new EdmModel().Initialize());
Assert.Equal(
StoreGeneratedPattern.Identity,
entityType.DeclaredKeyProperties.Single().GetStoreGeneratedPattern());
}
private EntityType CreateEntityTypeWithProperties(params PropertyInfo[] props)
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
foreach (var prop in props)
{
var property = EdmProperty.CreatePrimitive(prop.Name, PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
entityType.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == prop.Name).SetClrPropertyInfo(prop);
}
return(entityType);
}
public void ComplexType_apply_should_set_correct_defaults_for_fixed_length_binary()
{
var entityType = new ComplexType("C");
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary));
property.IsFixedLength = true;
entityType.AddMember(property);
((IEdmConvention <ComplexType>) new PropertyMaxLengthConvention())
.Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.Null(property.IsUnicode);
Assert.Equal(128, property.MaxLength);
Assert.False(property.IsMaxLength);
}
public void ComplexType_apply_should_set_correct_defaults_for_unconfigured_strings()
{
var entityType = new ComplexType("C");
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
((IEdmConvention <ComplexType>) new PropertyMaxLengthConvention())
.Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.Equal(true, property.IsUnicode);
Assert.Equal(false, property.IsFixedLength);
Assert.Null(property.MaxLength);
Assert.Equal(true, property.IsMaxLength);
}
public void Map_should_set_correct_name_and_type()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var mappingContext
= new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), new EdmModel(DataSpace.CSpace));
new PropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(typeof(int), "Foo"), entityType, () => new EntityTypeConfiguration(typeof(object)));
Assert.Equal(1, entityType.DeclaredProperties.Count);
var property = entityType.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "Foo");
Assert.Equal(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), property.PrimitiveType);
}
public void Map_should_map_complex_type_properties()
{
var complexType = new ComplexType("C");
var mappingContext
= new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), new EdmModel(DataSpace.CSpace));
new PropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(typeof(int), "Foo"), complexType, () => new ComplexTypeConfiguration(typeof(object)));
Assert.Equal(1, complexType.Properties.Count);
var property = complexType.Properties.SingleOrDefault(p => p.Name == "Foo");
Assert.Equal(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), property.PrimitiveType);
}
public void MetadataWorkspace_initialized_from_DbQueryCommandTree()
{
var workspace = new MetadataWorkspace();
var commandTreeFacts =
new CommandTreeFacts(
new DbQueryCommandTree(
workspace,
DataSpace.CSpace,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)).Null(),
validate: false));
Assert.Same(workspace, commandTreeFacts.MetadataWorkspace);
}
public void Apply_should_set_correct_defaults_for_non_unicode_fixed_length_strings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
property.IsFixedLength = true;
property.IsUnicode = false;
entityType.AddMember(property);
((IEdmConvention <EntityType>) new PropertyMaxLengthConvention())
.Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.Equal(128, property.MaxLength);
Assert.False(property.IsMaxLength);
}
public void Visit_DbParameterRefExpression_creates_equivalent_legacy_DbParameterRefExpression()
{
var paramRefExpression =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))
.Parameter("foo");
var legacyParamRefExpression =
_legacyDbExpressionConverter.Visit(paramRefExpression) as LegacyCommandTrees.DbParameterReferenceExpression;
Assert.NotNull(legacyParamRefExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.ParameterReference, legacyParamRefExpression.ExpressionKind);
Assert.Equal("foo", legacyParamRefExpression.ParameterName);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyParamRefExpression.ResultType, paramRefExpression.ResultType);
}
private static MetadataProperty CreateAnnotationMetadataProperty(string name, string value)
{
return
(MetadataProperty.Create(
string.Format(
CultureInfo.InvariantCulture,
"{0}:{1}",
SchemaManager.AnnotationNamespace,
name),
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
isUnicode: false,
isFixedLength: false),
value));
}
public void Apply_should_ignore_case()
{
var entityType = new EntityType
{
Name = "Foo"
};
var property1 = EdmProperty.Primitive("foOid", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel());
Assert.True(entityType.DeclaredKeyProperties.Contains(property));
}
public void ComplexType_apply_should_set_correct_defaults_for_unicode_fixed_length_strings()
{
var entityType = new ComplexType("C");
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
property.IsFixedLength = true;
entityType.AddMember(property);
(new PropertyMaxLengthConvention())
.Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.Equal(true, property.IsUnicode);
Assert.Equal(128, property.MaxLength);
Assert.False(property.IsMaxLength);
}
public void Visit_DbCastExpression_creates_equivalent_legacy_DbCastExpression()
{
var castExpression =
DbExpressionBuilder.Constant(42).CastTo(
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Decimal)));
var legacyCastExpression =
_legacyDbExpressionConverter.Visit(castExpression) as LegacyCommandTrees.DbCastExpression;
Assert.NotNull(legacyCastExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Cast, legacyCastExpression.ExpressionKind);
Assert.Equal(42, (int)((LegacyCommandTrees.DbConstantExpression)legacyCastExpression.Argument).Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyCastExpression.ResultType, castExpression.ResultType);
}
public void AddColumn_should_set_properties_and_add_to_columns()
{
var table = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var tableColumn = new EdmProperty(
"Foo",
ProviderRegistry.Sql2008_ProviderManifest.GetStoreType(
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))));
table.AddColumn(tableColumn);
Assert.NotNull(tableColumn);
Assert.Equal("Foo", tableColumn.Name);
Assert.True(table.Properties.Contains(tableColumn));
}