public GuidTypeMapperTests(DatabaseFixture fixture)
{
Fixture = fixture;
OracleTypeMapper.AddTypeHandler <Guid>(new GuidRaw16TypeHandler());
var columns = new[]
{
new TableColumn {
Name = "CustomerId", DataType = OracleMappingType.Raw, Size = 16, PrimaryKey = true
},
new TableColumn {
Name = "Name", DataType = OracleMappingType.Varchar2, Size = 40
},
new TableColumn {
Name = "City", DataType = OracleMappingType.Varchar2, Size = 40
},
new TableColumn {
Name = "OtherGuid", DataType = OracleMappingType.Raw, Size = 16, Nullable = true
},
};
TableCreator.Create(Fixture.Connection, "GuidCustomerTest", columns);
InsertCustomer(new Customer {
CustomerId = customerId, Name = "DIPS AS", City = "Oslo"
});
}
public virtual void GenerateSqlLiteralValue_returns_NonUnicode_String_literal()
{
var literal = new OracleTypeMapper(new RelationalTypeMapperDependencies())
.GetMapping("varchar2").GenerateSqlLiteral("A Non-Unicode String");
Assert.Equal("'A Non-Unicode String'", literal);
}
public override void GenerateSqlLiteral_returns_ByteArray_literal()
{
var value = new byte[] { 0xDA, 0x7A };
var literal = new OracleTypeMapper(new RelationalTypeMapperDependencies())
.GetMapping(typeof(byte[])).GenerateSqlLiteral(value);
Assert.Equal("0xDA7A", literal);
}
public override void GenerateSqlLiteral_returns_DateTimeOffset_literal()
{
var value = new DateTimeOffset(2015, 3, 12, 13, 36, 37, 371, new TimeSpan(-7, 0, 0));
var literal = new OracleTypeMapper(new RelationalTypeMapperDependencies())
.GetMapping(typeof(DateTimeOffset)).GenerateSqlLiteral(value);
Assert.Equal("'2015-03-12T13:36:37.371-07:00'", literal);
}
public override void GenerateSqlLiteral_returns_DateTime_literal()
{
var value = new DateTime(2015, 3, 12, 13, 36, 37, 371);
var literal = new OracleTypeMapper(new RelationalTypeMapperDependencies())
.GetMapping(typeof(DateTime)).GenerateSqlLiteral(value);
Assert.Equal("TO_DATE('2015-03-12 13:36:37', 'YYYY-MM-DD HH24:MI:SS')", literal);
}
public void Does_not_do_rowversion_mapping_for_non_computed_concurrency_tokens()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
property.IsConcurrencyToken = true;
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("BLOB", typeMapping.StoreType);
}
public static ConventionSet Build()
{
var oracleTypeMapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
return(new OracleConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(oracleTypeMapper, currentContext: null, setFinder: null))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(oracleTypeMapper))
.CreateConventionSet()));
}
public void Does_non_key_Oracle_fixed_length_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyBinaryProp", typeof(byte[]));
property.Relational().ColumnType = "raw(100)";
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("raw(100)", typeMapping.StoreType);
}
public static ConventionSet Build()
{
var oracleTypeMapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
return(new OracleConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(oracleTypeMapper, null, null),
new OracleSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies()))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(oracleTypeMapper))
.CreateConventionSet()));
}
public void Binary_key_with_max_length_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"varbinary(100)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType2)).FindProperty("Id")).StoreType);
Assert.Equal(
"varbinary(100)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Relationship1Id")).StoreType);
}
public void Key_with_store_type_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"DECIMAL(29,4)",
mapper.FindMapping(model.FindEntityType(typeof(MyType)).FindProperty("Id")).StoreType);
Assert.Equal(
"DECIMAL(29,4)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType1)).FindProperty("Relationship1Id")).StoreType);
}
public void Does_indexed_column_Oracle_binary_mapping()
{
var entityType = CreateEntityType();
var property = entityType.AddProperty("MyProp", typeof(byte[]));
entityType.AddIndex(property);
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("RAW(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_key_Oracle_binary_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
property.IsNullable = false;
property.DeclaringEntityType.SetPrimaryKey(property);
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("RAW(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", new byte[3]).Size);
}
public void Binary_FK_max_length_is_preferred_if_specified()
{
var model = CreateModel();
var mapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"varbinary(100)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType2)).FindProperty("Id")).StoreType);
Assert.Equal(
"varbinary(767)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Relationship2Id")).StoreType);
}
public void String_FK_unicode_is_preferred_if_specified()
{
var model = CreateModel();
var mapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"VARCHAR2(900)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Id")).StoreType);
Assert.Equal(
"NVARCHAR2(450)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType4)).FindProperty("Relationship2Id")).StoreType);
}
public void String_key_with_unicode_is_picked_up_by_FK()
{
var model = CreateModel();
var mapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"VARCHAR2(900)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType3)).FindProperty("Id")).StoreType);
Assert.Equal(
"VARCHAR2(900)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType4)).FindProperty("Relationship1Id")).StoreType);
}
public void Key_store_type_if_preferred_if_specified()
{
var model = CreateModel();
var mapper = new OracleTypeMapper(new RelationalTypeMapperDependencies());
Assert.Equal(
"DECIMAL(29,4)",
mapper.FindMapping(model.FindEntityType(typeof(MyType)).FindProperty("Id")).StoreType);
Assert.Equal(
"DECIMAL(29,4)",
mapper.FindMapping(model.FindEntityType(typeof(MyRelatedType1)).FindProperty("Relationship2Id")).StoreType);
}
public void Does_non_key_Oracle_rowversion_mapping()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(byte[]));
property.IsConcurrencyToken = true;
property.ValueGenerated = ValueGenerated.OnAddOrUpdate;
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.Binary, typeMapping.DbType);
Assert.Equal("BLOB", typeMapping.StoreType);
Assert.Null(typeMapping.Size);
}
public static ConventionSet Build()
{
var oracleTypeMapper = new OracleTypeMapper(
new CoreTypeMapperDependencies(
new ValueConverterSelector(
new ValueConverterSelectorDependencies())),
new RelationalTypeMapperDependencies());
return(new OracleConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(oracleTypeMapper, null, null, null))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(oracleTypeMapper, null, null))
.CreateConventionSet()));
}
public void Does_key_Oracle_string_mapping_ansi()
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string));
property.IsNullable = false;
property.IsUnicode(false);
property.DeclaringEntityType.SetPrimaryKey(property);
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.AnsiString, typeMapping.DbType);
Assert.Equal("VARCHAR2(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.Size);
Assert.False(typeMapping.IsUnicode);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public void Does_indexed_column_Oracle_string_mapping_ansi()
{
var entityType = CreateEntityType();
var property = entityType.AddProperty("MyProp", typeof(string));
property.IsUnicode(false);
entityType.AddIndex(property);
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(property);
Assert.Equal(DbType.AnsiString, typeMapping.DbType);
Assert.Equal("VARCHAR2(900)", typeMapping.StoreType);
Assert.Equal(900, typeMapping.Size);
Assert.False(typeMapping.IsUnicode);
Assert.Equal(900, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
public static ConventionSet Build()
{
var oracleTypeMapper = new OracleTypeMapper(
new CoreTypeMapperDependencies(
new ValueConverterSelector(
new ValueConverterSelectorDependencies())),
new RelationalTypeMapperDependencies());
return(new OracleConventionSetBuilder(
new RelationalConventionSetBuilderDependencies(oracleTypeMapper, currentContext: null, setFinder: null))
.AddConventions(
new CoreConventionSetBuilder(
new CoreConventionSetBuilderDependencies(
oracleTypeMapper,
new ConstructorBindingFactory()))
.CreateConventionSet()));
}
public BooleanStringTypeMapperTests(DatabaseFixture fixture)
{
Fixture = fixture;
var columns = new[]
{
new NumberColumn {
Name = "Id", DataType = OracleMappingType.Int32, PrimaryKey = true
},
new TableColumn {
Name = "BooleanValue", DataType = OracleMappingType.Char, Size = 1
}
};
OracleTypeMapper.AddTypeHandler(typeof(bool), new BooleanStringTypeHandler("Y", "N"));
TableCreator.Create(Fixture.Connection, "BoolCharTypeMappingTest", columns);
}
public void Does_foreign_key_Oracle_string_mapping(bool?unicode)
{
var property = CreateEntityType().AddProperty("MyProp", typeof(string));
property.IsNullable = false;
property.IsUnicode(unicode);
var fkProperty = property.DeclaringEntityType.AddProperty("FK", typeof(string));
var pk = property.DeclaringEntityType.SetPrimaryKey(property);
property.DeclaringEntityType.AddForeignKey(fkProperty, pk, property.DeclaringEntityType);
var typeMapping = new OracleTypeMapper(new RelationalTypeMapperDependencies()).GetMapping(fkProperty);
Assert.Null(typeMapping.DbType);
Assert.Equal("NVARCHAR2(450)", typeMapping.StoreType);
Assert.Equal(450, typeMapping.Size);
Assert.True(typeMapping.IsUnicode);
Assert.Equal(450, typeMapping.CreateParameter(new TestCommand(), "Name", "Value").Size);
}
