public void Visit_DbLikeExpression_creates_equivalent_legacy_DbLikeExpression()
{
var propertyExpression =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Name");
var stringTypeUsage =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var likeExpression = propertyExpression.Like(stringTypeUsage.Constant("foo"), stringTypeUsage.Constant("bar"));
var legacyLikeExpression =
_legacyDbExpressionConverter.Visit(likeExpression) as LegacyCommandTrees.DbLikeExpression;
Assert.NotNull(legacyLikeExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Like, legacyLikeExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Property, legacyLikeExpression.Argument.ExpressionKind);
Assert.Equal("foo", (string)((LegacyCommandTrees.DbConstantExpression)legacyLikeExpression.Pattern).Value);
Assert.Equal("bar", (string)((LegacyCommandTrees.DbConstantExpression)legacyLikeExpression.Escape).Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyLikeExpression.ResultType, likeExpression.ResultType);
}
public void Visit_DbSkipExpression_creates_equivalent_legacy_DbSkipExpression()
{
var scanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan();
var idProperty =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Id");
var skipExpression =
scanExpression
.BindAs("Table")
.Skip(new[] { idProperty.ToSortClause() }, DbExpressionBuilder.Constant(42));
var legacySkipExpression =
_legacyDbExpressionConverter.Visit(skipExpression) as LegacyCommandTrees.DbSkipExpression;
Assert.NotNull(legacySkipExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Skip, legacySkipExpression.ExpressionKind);
Assert.Equal("Table", legacySkipExpression.Input.VariableName);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacySkipExpression.Input.Expression.ExpressionKind);
Assert.Equal(
"Id",
((LegacyCommandTrees.DbPropertyExpression)legacySkipExpression.SortOrder.Single().Expression).Property.Name);
Assert.Equal(42, ((LegacyCommandTrees.DbConstantExpression)legacySkipExpression.Count).Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacySkipExpression.ResultType, skipExpression.ResultType);
}
public void Visit_DbCrossJoinExpression_creates_equivalent_DbCrossJoinExpression()
{
var bindings =
new[]
{
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan()
.BindAs("table1"),
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "OtherEntitiesSet")
.Scan()
.BindAs("table2")
};
var crossJoinExpression = DbExpressionBuilder.CrossJoin(bindings);
var legacyCrossJoinExpression =
_legacyDbExpressionConverter.Visit(crossJoinExpression) as LegacyCommandTrees.DbCrossJoinExpression;
Assert.NotNull(legacyCrossJoinExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.CrossJoin, legacyCrossJoinExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacyCrossJoinExpression.Inputs[0].Expression.ExpressionKind);
Assert.Equal("EntitiesSet", ((LegacyCommandTrees.DbScanExpression)legacyCrossJoinExpression.Inputs[0].Expression).Target.Name);
Assert.Equal("table1", legacyCrossJoinExpression.Inputs[0].VariableName);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacyCrossJoinExpression.Inputs[1].Expression.ExpressionKind);
Assert.Equal(
"OtherEntitiesSet", ((LegacyCommandTrees.DbScanExpression)legacyCrossJoinExpression.Inputs[1].Expression).Target.Name);
Assert.Equal("table2", legacyCrossJoinExpression.Inputs[1].VariableName);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyCrossJoinExpression.ResultType, crossJoinExpression.ResultType);
}
public void Visit_DbFitlerExpression_creates_equivalent_legacy_DbFilterExpression()
{
var scanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan();
var filterExpression =
scanExpression
.BindAs("Table")
.Filter(
DbExpressionBuilder.Constant(911).Equal(DbExpressionBuilder.Constant(911)));
var legacyFilterExpression =
_legacyDbExpressionConverter.Visit(filterExpression) as LegacyCommandTrees.DbFilterExpression;
Assert.NotNull(legacyFilterExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Filter, legacyFilterExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacyFilterExpression.Input.Expression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Equals, legacyFilterExpression.Predicate.ExpressionKind);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyFilterExpression.ResultType, filterExpression.ResultType);
}
public void Visit_DbSortExpression_creates_equivalent_legacy_DbSortExpression()
{
var scanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan();
var idProperty =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Id");
var nameProperty =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Name");
var sortExpression =
scanExpression
.BindAs("Table")
.Sort(
new[]
{
idProperty.ToSortClause(),
nameProperty.ToSortClause("testCollationAscending"),
nameProperty.ToSortClauseDescending(),
nameProperty.ToSortClauseDescending("testCollationDescending")
});
var legacySortExpression =
_legacyDbExpressionConverter.Visit(sortExpression) as LegacyCommandTrees.DbSortExpression;
Assert.NotNull(legacySortExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Sort, legacySortExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacySortExpression.Input.Expression.ExpressionKind);
Assert.Equal("Table", legacySortExpression.Input.VariableName);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacySortExpression.Input.VariableType, sortExpression.Input.VariableType);
Assert.Equal(4, legacySortExpression.SortOrder.Count);
Assert.True(
legacySortExpression.SortOrder.All(
e => e.Expression.ExpressionKind == LegacyCommandTrees.DbExpressionKind.Property));
Assert.True(legacySortExpression.SortOrder[0].Ascending);
Assert.Empty(legacySortExpression.SortOrder[0].Collation);
Assert.True(legacySortExpression.SortOrder[1].Ascending);
Assert.Equal("testCollationAscending", legacySortExpression.SortOrder[1].Collation);
Assert.False(legacySortExpression.SortOrder[2].Ascending);
Assert.Empty(legacySortExpression.SortOrder[2].Collation);
Assert.False(legacySortExpression.SortOrder[3].Ascending);
Assert.Equal("testCollationDescending", legacySortExpression.SortOrder[3].Collation);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacySortExpression.ResultType, sortExpression.ResultType);
}
public void Visit_DbIntersectExpression_creates_equivalent_legacy_DbIntersectExpression()
{
var left = DbExpressionBuilder.NewCollection(new DbExpression[] { DbExpressionBuilder.Constant(42) });
var right = DbExpressionBuilder.NewCollection(new DbExpression[] { DbExpressionBuilder.Constant(24) });
var intersectExpression = left.Intersect(right);
var legacyIntersectExpression =
_legacyDbExpressionConverter.Visit(intersectExpression) as LegacyCommandTrees.DbIntersectExpression;
Assert.NotNull(legacyIntersectExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Intersect, legacyIntersectExpression.ExpressionKind);
Assert.Equal(
42,
((LegacyCommandTrees.DbConstantExpression)
((LegacyCommandTrees.DbNewInstanceExpression)legacyIntersectExpression.Left).Arguments.Single())
.Value);
Assert.Equal(
24,
((LegacyCommandTrees.DbConstantExpression)
((LegacyCommandTrees.DbNewInstanceExpression)legacyIntersectExpression.Right).Arguments.Single())
.Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyIntersectExpression.ResultType, intersectExpression.ResultType);
}
public void GetFacetDescriptions_returns_correct_facets_for_all_primitive_types()
{
var storeTypes =
ProviderManifestWrapper
.GetStoreTypes()
.OrderBy(t => t.Name)
.ToArray();
var legacyStoreTypes =
LegacyProviderManifest
.GetStoreTypes()
.OrderBy(t => t.Name)
.ToArray();
for (var i = 0; i < storeTypes.Length; i++)
{
var facetDescriptions =
ProviderManifestWrapper.GetFacetDescriptions(storeTypes[i]).OrderBy(f => f.FacetName).ToArray();
var legacyFacetDescriptions =
LegacyProviderManifest.GetFacetDescriptions(legacyStoreTypes[i]).OrderBy(f => f.FacetName).ToArray();
Assert.Equal(facetDescriptions.Length, legacyFacetDescriptions.Length);
for (var j = 0; j < facetDescriptions.Count(); j++)
{
TypeUsageVerificationHelper.VerifyFacetDescriptionsEquivalent(facetDescriptions[j], legacyFacetDescriptions[j]);
}
}
}
public void Visit_DbPropertyExpression_creates_equivalent_legacy_DbPropertyExpression()
{
var propertyExpression =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Id");
var legacyPropertyExpression =
_legacyDbExpressionConverter.Visit(propertyExpression) as LegacyCommandTrees.DbPropertyExpression;
Assert.NotNull(legacyPropertyExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Property, legacyPropertyExpression.ExpressionKind);
Assert.Equal(
LegacyCommandTrees.DbExpressionKind.VariableReference,
legacyPropertyExpression.Instance.ExpressionKind);
Assert.Equal(
"Table",
((LegacyCommandTrees.DbVariableReferenceExpression)legacyPropertyExpression.Instance)
.VariableName);
Assert.Equal("Id", legacyPropertyExpression.Property.Name);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyPropertyExpression.Property.TypeUsage, propertyExpression.Property.TypeUsage);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyPropertyExpression.ResultType, propertyExpression.ResultType);
}
public void Visit_DbNewInstanceExpression_rowtype_creates_equivalent_legacy_DbNewInstanceExpression()
{
var propertyExpression =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Id");
var newInstanceExpressionRowType =
DbExpressionBuilder.NewRow(
new[]
{
new KeyValuePair <string, DbExpression>("Id", propertyExpression),
new KeyValuePair <string, DbExpression>("Const", DbExpressionBuilder.Constant(42))
});
var legacyNewInstanceExpressionRowType =
_legacyDbExpressionConverter.Visit(newInstanceExpressionRowType) as
LegacyCommandTrees.DbNewInstanceExpression;
Assert.NotNull(legacyNewInstanceExpressionRowType);
Assert.Equal(
LegacyCommandTrees.DbExpressionKind.NewInstance,
legacyNewInstanceExpressionRowType.ExpressionKind);
Assert.Equal(2, legacyNewInstanceExpressionRowType.Arguments.Count);
Assert.IsType <LegacyCommandTrees.DbPropertyExpression>(legacyNewInstanceExpressionRowType.Arguments[0]);
Assert.IsType <LegacyCommandTrees.DbConstantExpression>(legacyNewInstanceExpressionRowType.Arguments[1]);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyNewInstanceExpressionRowType.ResultType, newInstanceExpressionRowType.ResultType);
}
public void GetEdmType_returns_correct_type_usages_for_specific_String_type_usages()
{
foreach (var isUnicode in new[] { true, false })
{
foreach (var isFixedLength in new[] { true, false })
{
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetEdmType(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateStringTypeUsage(LegacyEdmPrimitiveTypes["String"], isUnicode, isFixedLength))),
ProviderManifestWrapper.GetEdmType(
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateStringTypeUsage(EdmPrimitiveTypes["String"], isUnicode, isFixedLength))));
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetEdmType(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateStringTypeUsage(
LegacyEdmPrimitiveTypes["String"], isUnicode, isFixedLength, maxLength: 1000))),
ProviderManifestWrapper.GetEdmType(
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateStringTypeUsage(EdmPrimitiveTypes["String"], isUnicode, isFixedLength, maxLength: 1000))));
}
}
}
public void GetEdmType_returns_correct_default_type_usages_for_all_primitive_types()
{
var storeTypes = ProviderManifestWrapper.GetStoreTypes().ToDictionary(t => t.Name, t => t);
foreach (var legacyStoreType in LegacyProviderManifest.GetStoreTypes())
{
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetEdmType(LegacyMetadata.TypeUsage.CreateDefaultTypeUsage(legacyStoreType)),
ProviderManifestWrapper.GetEdmType(TypeUsage.CreateDefaultTypeUsage(storeTypes[legacyStoreType.Name])));
}
}
private void ConvertAndVerifyJoinExpressions(
Func <DbExpressionBinding, DbExpressionBinding, DbExpression, DbJoinExpression> createJoinExpression)
{
var leftScanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan();
var leftPropertyExpression =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("leftTable")
.Property("Id");
var rightScanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "OtherEntitiesSet")
.Scan();
var rightPropertyExpression =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "OtherEntities"))
.Variable("rightTable")
.Property("Id");
var joinExpression =
createJoinExpression(
leftScanExpression.BindAs("leftTable"),
rightScanExpression.BindAs("rightTable"),
leftPropertyExpression.Equal(rightPropertyExpression));
var legacyJoinExpression =
_legacyDbExpressionConverter.Visit(joinExpression) as LegacyCommandTrees.DbJoinExpression;
Assert.NotNull(legacyJoinExpression);
Assert.Equal((int)joinExpression.ExpressionKind, (int)legacyJoinExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacyJoinExpression.Left.Expression.ExpressionKind);
Assert.Equal("EntitiesSet", ((LegacyCommandTrees.DbScanExpression)legacyJoinExpression.Left.Expression).Target.Name);
Assert.Equal("leftTable", legacyJoinExpression.Left.VariableName);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacyJoinExpression.Right.Expression.ExpressionKind);
Assert.Equal("OtherEntitiesSet", ((LegacyCommandTrees.DbScanExpression)legacyJoinExpression.Right.Expression).Target.Name);
Assert.Equal("rightTable", legacyJoinExpression.Right.VariableName);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Equals, legacyJoinExpression.JoinCondition.ExpressionKind);
var comparisonExpression = (LegacyCommandTrees.DbComparisonExpression)legacyJoinExpression.JoinCondition;
Assert.Equal("Entities", ((LegacyCommandTrees.DbPropertyExpression)comparisonExpression.Left).Property.DeclaringType.Name);
Assert.Equal("OtherEntities", ((LegacyCommandTrees.DbPropertyExpression)comparisonExpression.Right).Property.DeclaringType.Name);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyJoinExpression.ResultType, joinExpression.ResultType);
}
public void GetStoreType_returns_correct_default_type_usages_for_all_primitive_types()
{
// SqlProvider does not support SByte
foreach (var legacyEdmPrimitiveType in LegacyEdmPrimitiveTypes.Where(t => t.Key != "SByte"))
{
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateDefaultTypeUsage(legacyEdmPrimitiveType.Value)),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateDefaultTypeUsage(EdmPrimitiveTypes[legacyEdmPrimitiveType.Key])));
}
}
public void Visit_DbNullExpression_creates_equivalent_legacy_DbNullExpression()
{
var nullExpression =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)).Null();
var legacyNullExpression =
_legacyDbExpressionConverter.Visit(nullExpression) as LegacyCommandTrees.DbNullExpression;
Assert.NotNull(legacyNullExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Null, legacyNullExpression.ExpressionKind);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyNullExpression.ResultType, nullExpression.ResultType);
}
public void Visit_DbNotExpression_creates_equivalent_legacy_DbNotExpression()
{
var notExpression = DbExpressionBuilder.True.Not();
var legacyNotExpression =
_legacyDbExpressionConverter.Visit(notExpression) as LegacyCommandTrees.DbNotExpression;
Assert.NotNull(legacyNotExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Not, legacyNotExpression.ExpressionKind);
Assert.True((bool)((LegacyCommandTrees.DbConstantExpression)legacyNotExpression.Argument).Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyNotExpression.ResultType, notExpression.ResultType);
}
public void GetStoreType_returns_correct_type_usages_for_specific_Time_type_usages()
{
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateTimeTypeUsage(LegacyEdmPrimitiveTypes["Time"], precision: null)),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateTimeTypeUsage(EdmPrimitiveTypes["Time"], precision: null)));
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateTimeTypeUsage(LegacyEdmPrimitiveTypes["Time"], precision: 6)),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateTimeTypeUsage(EdmPrimitiveTypes["Time"], precision: 6)));
}
public void GetStoreType_returns_correct_type_usages_for_specific_Binary_type_usages()
{
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateBinaryTypeUsage(LegacyEdmPrimitiveTypes["Binary"], isFixedLength: false)),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateBinaryTypeUsage(EdmPrimitiveTypes["Binary"], isFixedLength: false)));
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateBinaryTypeUsage(LegacyEdmPrimitiveTypes["Binary"], isFixedLength: true)),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateBinaryTypeUsage(EdmPrimitiveTypes["Binary"], isFixedLength: true)));
}
public void GetStoreType_returns_correct_type_usages_for_specific_Decimal_type_usages()
{
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateDecimalTypeUsage(LegacyEdmPrimitiveTypes["Decimal"])),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateDecimalTypeUsage(EdmPrimitiveTypes["Decimal"])));
TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent(
LegacyProviderManifest.GetStoreType(
LegacyMetadata.TypeUsage.CreateDecimalTypeUsage(LegacyEdmPrimitiveTypes["Decimal"], precision: 6, scale: 10)),
ProviderManifestWrapper.GetStoreType(
TypeUsage.CreateDecimalTypeUsage(EdmPrimitiveTypes["Decimal"], precision: 6, scale: 10)));
}
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);
}
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 Visit_DbOrExpression_creates_equivalent_legacy_DbOrExpression()
{
var orExpression =
DbExpressionBuilder.False
.Or(DbExpressionBuilder.True);
var legacyOrExpression =
_legacyDbExpressionConverter.Visit(orExpression) as LegacyCommandTrees.DbOrExpression;
Assert.NotNull(legacyOrExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Or, legacyOrExpression.ExpressionKind);
Assert.False((bool)((LegacyCommandTrees.DbConstantExpression)legacyOrExpression.Left).Value);
Assert.True((bool)((LegacyCommandTrees.DbConstantExpression)legacyOrExpression.Right).Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyOrExpression.ResultType, orExpression.ResultType);
}
public void Visit_DbScanExpression_creates_equivalent_legacy_DbScanExpression()
{
var scanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan();
var legacyScanExpression =
_legacyDbExpressionConverter.Visit(scanExpression) as LegacyCommandTrees.DbScanExpression;
Assert.NotNull(legacyScanExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Scan, legacyScanExpression.ExpressionKind);
Assert.Equal(scanExpression.Target.Name, legacyScanExpression.Target.Name);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyScanExpression.ResultType, scanExpression.ResultType);
}
Visit_DbVariableReferenceExpression_creates_equivalent_legacy_DbVariableReferenceExpression_for_CSpace_type()
{
var variableReference =
TypeUsage
.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))
.Variable("variable");
var legacyVariableReference =
_legacyDbExpressionConverter.Visit(variableReference) as
LegacyCommandTrees.DbVariableReferenceExpression;
Assert.NotNull(legacyVariableReference);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.VariableReference, legacyVariableReference.ExpressionKind);
Assert.Equal(variableReference.VariableName, legacyVariableReference.VariableName);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyVariableReference.ResultType, variableReference.ResultType);
}
private void ConvertAndVerifyArithmeticExpression(DbArithmeticExpression arithmeticExpression)
{
var legacyArithmeticExpression =
_legacyDbExpressionConverter.Visit(arithmeticExpression) as LegacyCommandTrees.DbArithmeticExpression;
Assert.NotNull(arithmeticExpression);
Assert.Equal((int)arithmeticExpression.ExpressionKind, (int)legacyArithmeticExpression.ExpressionKind);
Assert.Equal(arithmeticExpression.Arguments.Count, legacyArithmeticExpression.Arguments.Count);
Assert.True(
arithmeticExpression.Arguments.Zip(
legacyArithmeticExpression.Arguments,
(e1, e2) => ((DbConstantExpression)e1).Value == ((LegacyCommandTrees.DbConstantExpression)e2).Value)
.All(r => r));
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyArithmeticExpression.ResultType, arithmeticExpression.ResultType);
}
public void Visit_DbProjectExpression_creates_equivalent_legacy_DbProjectExpression()
{
var scanExpression =
_storeItemCollection
.GetEntityContainer("AdventureWorksModelStoreContainer")
.EntitySets.Single(e => e.Name == "EntitiesSet")
.Scan();
var propertyExpression =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("Table")
.Property("Id");
var newInstanceExpression =
DbExpressionBuilder.NewRow(
new[]
{
new KeyValuePair <string, DbExpression>("Id", propertyExpression),
new KeyValuePair <string, DbExpression>("Const", DbExpressionBuilder.Constant(42))
});
var projectExpression =
scanExpression
.BindAs("Table")
.Project(newInstanceExpression);
var legacyProjectExpression =
_legacyDbExpressionConverter.Visit(projectExpression) as LegacyCommandTrees.DbProjectExpression;
Assert.NotNull(legacyProjectExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Project, legacyProjectExpression.ExpressionKind);
Assert.Equal(
LegacyCommandTrees.DbExpressionKind.NewInstance,
legacyProjectExpression.Projection.ExpressionKind);
Assert.Equal(projectExpression.Input.VariableName, legacyProjectExpression.Input.VariableName);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyProjectExpression.Input.VariableType, projectExpression.Input.VariableType);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyProjectExpression.ResultType, projectExpression.ResultType);
}
private void ConvertAndVerifyComparisonExpression(DbComparisonExpression comparisonExpression)
{
var legacyComparisonExpression =
_legacyDbExpressionConverter.Visit(comparisonExpression) as LegacyCommandTrees.DbComparisonExpression;
Assert.NotNull(legacyComparisonExpression);
Assert.Equal((int)comparisonExpression.ExpressionKind, (int)legacyComparisonExpression.ExpressionKind);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Constant, legacyComparisonExpression.Left.ExpressionKind);
Assert.Equal(
((DbConstantExpression)comparisonExpression.Left).Value,
((LegacyCommandTrees.DbConstantExpression)legacyComparisonExpression.Left).Value);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Constant, legacyComparisonExpression.Right.ExpressionKind);
Assert.Equal(
((DbConstantExpression)comparisonExpression.Right).Value,
((LegacyCommandTrees.DbConstantExpression)legacyComparisonExpression.Right).Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyComparisonExpression.ResultType, comparisonExpression.ResultType);
}
Visit_DbVariableReferenceExpression_creates_equivalent_legacy_DbVariableReferenceExpression_for_SSpace_type()
{
var variableReference =
TypeUsage
.CreateDefaultTypeUsage(
_storeItemCollection.GetItems <EntityType>().Single(e => e.Name == "Entities"))
.Variable("variable");
var legacyVariableReference =
_legacyDbExpressionConverter.Visit(variableReference) as
LegacyCommandTrees.DbVariableReferenceExpression;
Assert.NotNull(legacyVariableReference);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.VariableReference, legacyVariableReference.ExpressionKind);
Assert.Equal(variableReference.VariableName, legacyVariableReference.VariableName);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyVariableReference.ResultType, variableReference.ResultType);
}
public void Visit_DbElementExpression_creates_equivalent_legacy_DbElementExpression()
{
var elementExpression =
DbExpressionBuilder.NewCollection(new DbExpression[] { DbExpressionBuilder.Constant(42) })
.Element();
var legacyElementExpression
= _legacyDbExpressionConverter.Visit(elementExpression) as LegacyCommandTrees.DbElementExpression;
Assert.NotNull(legacyElementExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Element, legacyElementExpression.ExpressionKind);
Assert.Equal(
42,
(((LegacyCommandTrees.DbConstantExpression)
((LegacyCommandTrees.DbNewInstanceExpression)legacyElementExpression.Argument).Arguments.Single())
.Value));
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyElementExpression.ResultType, elementExpression.ResultType);
}
public void GetStoreTypes_returns_all_store_types_correctly()
{
var storeTypes =
new LegacyDbProviderManifestWrapper(LegacyProviderManifest)
.GetStoreTypes()
.OrderBy(t => t.Name)
.ToArray();
var legacyStoreTypes =
LegacyProviderManifest
.GetStoreTypes()
.OrderBy(t => t.Name)
.ToArray();
Assert.Equal(storeTypes.Length, legacyStoreTypes.Length);
for (var idx = 0; idx < storeTypes.Length; idx++)
{
TypeUsageVerificationHelper.VerifyEdmTypesEquivalent(legacyStoreTypes[idx], storeTypes[idx]);
}
}
public void Visit_DbConstantExpression_creates_equivalent_legacy_DbConstantExpression()
{
var typeUsage =
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
isUnicode: false,
isFixedLength: true,
maxLength: 1000);
var constantExpression = typeUsage.Constant("test");
var legacyConstantExpression =
_legacyDbExpressionConverter.Visit(constantExpression) as LegacyCommandTrees.DbConstantExpression;
Assert.NotNull(legacyConstantExpression);
Assert.Equal(LegacyCommandTrees.DbExpressionKind.Constant, legacyConstantExpression.ExpressionKind);
Assert.Equal(constantExpression.Value, legacyConstantExpression.Value);
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyConstantExpression.ResultType, constantExpression.ResultType);
}