public static ResolvedJoinInfo CreateResolvedJoinInfo(Type type)
{
var primaryColumn = new SqlColumnDefinitionExpression(typeof(int), "k", "ID", false);
var foreignColumn = new SqlColumnDefinitionExpression(typeof(int), "s", "ID", false);
var foreignTableInfo = new ResolvedSimpleTableInfo(type, "Table", "s");
return(new ResolvedJoinInfo(foreignTableInfo, Expression.Equal(primaryColumn, foreignColumn)));
}
public virtual Expression VisitSqlColumnDefinition(SqlColumnDefinitionExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
AppendColumn(expression.ColumnName, expression.OwningTableAlias, null);
return(expression);
}
public void VisitAggregationExpression_Count()
{
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var expression = new AggregationExpression(typeof(int), columnExpression, AggregationModifier.Count);
SqlGeneratingExpressionVisitor.GenerateSql(expression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("COUNT(*)"));
}
public void VisitNamedExpression_NameIsNotNull()
{
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var expression = new NamedExpression("test", columnExpression);
SqlGeneratingSelectExpressionVisitor.GenerateSql(expression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[c].[Name] AS [test]"));
}
public void GenerateSql_VisitSqlColumnExpression()
{
SqlColumnExpression sqlColumnExpression = new SqlColumnDefinitionExpression(typeof(int), "s", "ID", false);
SqlGeneratingExpressionVisitor.GenerateSql(
sqlColumnExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[s].[ID]"));
}
private ResolvedJoinInfo CreateResolvedJoinInfo(
Type type, string originalTableAlias, string leftSideKeyName, string joinedTableName, string joinedTableAlias, string rightSideKeyName)
{
var foreignTableSource = new ResolvedSimpleTableInfo(type, joinedTableName, joinedTableAlias);
var primaryColumn = new SqlColumnDefinitionExpression(typeof(int), originalTableAlias, leftSideKeyName, false);
var foreignColumn = new SqlColumnDefinitionExpression(typeof(int), joinedTableAlias, rightSideKeyName, false);
return(new ResolvedJoinInfo(foreignTableSource, Expression.Equal(primaryColumn, foreignColumn)));
}
private IEnumerable <SqlColumnDefinitionExpression> BuildForeignKeyColumnDefinitions(PropertyDescriptor referencingProperty, ColumnInfo[] columnInfos)
{
var relatedPropertyTypeDescriptor = this.model.GetTypeDescriptor(referencingProperty.PropertyType);
var referencedTableName = relatedPropertyTypeDescriptor.PersistedName;
var valueRequired = (referencingProperty.ValueRequiredAttribute != null && referencingProperty.ValueRequiredAttribute.Required) ||
referencingProperty.IsPrimaryKey;
var supportsInlineForeignKeys = this.sqlDialect.SupportsFeature(SqlFeature.InlineForeignKeys);
var foreignObjectConstraintAttribute = referencingProperty.ForeignObjectConstraintAttribute;
foreach (var foreignKeyColumn in columnInfos)
{
var retval = this.BuildColumnDefinition(foreignKeyColumn);
if (columnInfos.Length == 1 && supportsInlineForeignKeys)
{
var names = new[] { foreignKeyColumn.DefinitionProperty.PersistedName };
var newConstraints = new List <Expression>(retval.ConstraintExpressions);
var referencesColumnExpression = new SqlReferencesColumnExpression
(
new SqlTableExpression(referencedTableName),
SqlColumnReferenceDeferrability.InitiallyDeferred,
names,
FixAction((foreignObjectConstraintAttribute != null && ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnDeleteAction) != null) ? ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnDeleteAction).Value : (valueRequired ? SqlColumnReferenceAction.Restrict : SqlColumnReferenceAction.SetNull)),
FixAction((foreignObjectConstraintAttribute != null && ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnDeleteAction) != null) ? ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnUpdateAction).Value : SqlColumnReferenceAction.NoAction)
);
newConstraints.Add(referencesColumnExpression);
retval = new SqlColumnDefinitionExpression(retval.ColumnName, retval.ColumnType, newConstraints);
}
yield return(retval);
}
if (columnInfos.Length > 1 || !supportsInlineForeignKeys)
{
var currentTableColumnNames = columnInfos.Select(c => c.ColumnName);
var referencedTableColumnNames = columnInfos.Select(c => c.GetTailColumnName());
var referencesColumnExpression = new SqlReferencesColumnExpression
(
new SqlTableExpression(referencedTableName),
SqlColumnReferenceDeferrability.InitiallyDeferred,
referencedTableColumnNames,
FixAction((foreignObjectConstraintAttribute != null && ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnDeleteAction) != null) ? ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnDeleteAction).Value : (valueRequired ? SqlColumnReferenceAction.Restrict : SqlColumnReferenceAction.SetNull)),
FixAction((foreignObjectConstraintAttribute != null && ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnDeleteAction) != null) ? ToSqlColumnReferenceAction(foreignObjectConstraintAttribute.OnUpdateAction).Value : SqlColumnReferenceAction.NoAction)
);
var foreignKeyConstraint = new SqlForeignKeyConstraintExpression(null, currentTableColumnNames, referencesColumnExpression);
currentTableConstraints.Add(foreignKeyConstraint);
}
}
public void Update()
{
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "columnName", false);
var result = columnExpression.Update(typeof(char), "f", "test", false);
var expectedResult = new SqlColumnDefinitionExpression(typeof(char), "f", "test", false);
SqlExpressionTreeComparer.CheckAreEqualTrees(result, expectedResult);
}
public void ResolveMemberExpression_WithSqlColumnExpression()
{
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "CustomerID", true);
var memberInfo = typeof(DataContextTestClass.Customer).GetProperty("CustomerID");
var result = _mappingResolver.ResolveMemberExpression(columnExpression, memberInfo);
var expectedExpression = columnExpression;
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void ResolveMemberExpression_NonPrimaryKey()
{
var sqlEntityExpression = new SqlEntityDefinitionExpression(typeof(DataContextTestClass.Customer), "c", null, e => e);
var memberInfo = typeof(DataContextTestClass.Customer).GetProperty("CompanyName");
Expression result = _mappingResolver.ResolveMemberExpression(sqlEntityExpression, memberInfo);
var expectedExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "CompanyName", false);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void ResolveMemberExpression()
{
var sqlEntityExpression = new SqlEntityDefinitionExpression(typeof(PersonTestClass), "p", null, e => e);
var memberInfo = typeof(PersonTestClass).GetProperty("First");
Expression result = _mappingResolver.ResolveMemberExpression(sqlEntityExpression, memberInfo);
var expectedExpression = new SqlColumnDefinitionExpression(typeof(string), "p", "FirstName", true);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public void HandleResultOperator_NoConstantExpression()
{
var takeExpression = new SqlColumnDefinitionExpression(typeof(int), "c", "ID", true);
var resultOperator = new TakeResultOperator(takeExpression);
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stage, _context);
Assert.That(_sqlStatementBuilder.TopExpression, Is.SameAs(takeExpression));
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(Cook))));
}
protected virtual Expression VisitColumnDefinition(SqlColumnDefinitionExpression columnDefinitionExpression)
{
var constraints = this.VisitExpressionList(columnDefinitionExpression.ConstraintExpressions);
if (constraints != columnDefinitionExpression.ConstraintExpressions)
{
return(new SqlColumnDefinitionExpression(columnDefinitionExpression.ColumnName, columnDefinitionExpression.ColumnType, constraints));
}
return(columnDefinitionExpression);
}
public void ResolveMemberExpression_IDMember()
{
var property = typeof(Order).GetProperty("ID");
var entityExpression = CreateFakeEntityExpression(typeof(Order));
var fakeIDColumnExpression = new SqlColumnDefinitionExpression(typeof(ObjectID), "c", "ID", true);
_storageSpecificExpressionResolverStub
.Stub(stub => stub.ResolveIDProperty(entityExpression, MappingConfiguration.Current.GetTypeDefinition(typeof(Order))))
.Return(fakeIDColumnExpression);
var result = (SqlColumnExpression)_resolver.ResolveMemberExpression(entityExpression, property);
Assert.That(result, Is.SameAs(fakeIDColumnExpression));
}
public void HandleResultOperator_GroupByAfterSetOperations()
{
_sqlStatementBuilder.SetOperationCombinedStatements.Add(SqlStatementModelObjectMother.CreateSetOperationCombinedStatement());
var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var stage = CreateDefaultSqlPreparationStage();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, stage, _context);
AssertStatementWasMovedToSubStatement(_sqlStatementBuilder);
}
public override void SetUp()
{
base.SetUp();
_storageSpecificExpressionResolverStub = MockRepository.GenerateStub <IStorageSpecificExpressionResolver>();
_storageNameProviderStub = MockRepository.GenerateStub <IStorageNameProvider>();
_storageNameProviderStub.Stub(stub => stub.GetIDColumnName()).Return("ID");
_storageNameProviderStub.Stub(stub => stub.GetClassIDColumnName()).Return("ClassID");
_storageNameProviderStub.Stub(stub => stub.GetTimestampColumnName()).Return("Timestamp");
_resolver = new MappingResolver(_storageSpecificExpressionResolverStub);
_generator = new UniqueIdentifierGenerator();
_orderTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Order), "Order", "o"), JoinSemantics.Inner);
_fakeSimpleTableInfo = new ResolvedSimpleTableInfo(typeof(Order), "OrderTable", "o");
_fakeColumnDefinitionExpression = new SqlColumnDefinitionExpression(typeof(int), "o", "ColumnName", false);
_fakeJoinInfo = new ResolvedJoinInfo(_fakeSimpleTableInfo, Expression.Constant(true));
}
protected override Expression VisitColumnDefinition(SqlColumnDefinitionExpression columnDefinitionExpression)
{
this.WriteQuotedIdentifier(columnDefinitionExpression.ColumnName);
this.Write(' ');
this.Visit(columnDefinitionExpression.ColumnType);
if (columnDefinitionExpression.ConstraintExpressions.Count > 0)
{
this.Write(' ');
}
this.WriteDeliminatedListOfItems(columnDefinitionExpression.ConstraintExpressions, c => this.Visit(c), " ");
return(columnDefinitionExpression);
}
public void ResolveSubStatementReferenceExpression_CreatesColumnExpression_ForNamedExpression()
{
var referencedExpression = new NamedExpression("test", Expression.Constant(0));
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(referencedExpression);
var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement);
var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(
referencedExpression, tableInfo, sqlTable, _context);
var expectedResult = new SqlColumnDefinitionExpression(typeof(int), "q0", "test", false);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void TryResolveOptimizedIdentity_ForeignKeyOnTheLeft()
{
var tableInfo = new ResolvedSimpleTableInfo(typeof(DataContextTestClass.ClassWithOneToOneRelation_ForeignKeySide), "X", "x");
var originatingEntity = new SqlEntityDefinitionExpression(
tableInfo.ItemType, tableInfo.TableAlias, null, e => e.GetColumn(typeof(int), "ID", true));
var relationMember = tableInfo.ItemType.GetProperty("VirtualSide");
var entityRefMemberExpression = new SqlEntityRefMemberExpression(originatingEntity, relationMember);
var result = _mappingResolver.TryResolveOptimizedIdentity(entityRefMemberExpression);
var orderForeignKey = new SqlColumnDefinitionExpression(typeof(int), tableInfo.TableAlias, "VirtualSideID", false);
SqlExpressionTreeComparer.CheckAreEqualTrees(orderForeignKey, result);
}
public void HandleResultOperator_GroupByAfterTopExpression()
{
var topExpression = Expression.Constant("top");
_sqlStatementBuilder.TopExpression = topExpression;
var stage = CreateDefaultSqlPreparationStage();
var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, stage, _context);
AssertStatementWasMovedToSubStatement(_sqlStatementBuilder);
}
public void GenerateTextForJoinKeyExpression()
{
var expression = new SqlColumnDefinitionExpression(typeof(int), "c", "ID", false);
var stageMock = MockRepository.GeneratePartialMock <DefaultSqlGenerationStage>();
stageMock
.Expect(mock => CallGenerateTextForNonSelectExpression(mock, expression))
.WhenCalled(c => _commandBuilder.Append("test"));
stageMock.Replay();
stageMock.GenerateTextForJoinCondition(_commandBuilder, expression);
stageMock.VerifyAllExpectations();
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("test"));
}
public void VisitChildren_ChangeColumn()
{
var newColumnExpression = new SqlColumnDefinitionExpression(typeof(string), "o", "Test", false);
var visitorMock = MockRepository.GenerateMock <ExpressionTreeVisitor>();
var expectedColumns = new[] { _columnExpression1, newColumnExpression, _columnExpression3 };
visitorMock.Expect(mock => mock.VisitAndConvert(_originalColumnsReadonly, "VisitChildren")).Return(Array.AsReadOnly(expectedColumns));
visitorMock.Replay();
var expression = (SqlEntityExpression)ExtensionExpressionTestHelper.CallVisitChildren(_entityExpression, visitorMock);
Assert.That(expression, Is.Not.SameAs(_entityExpression));
Assert.That(expression.Type, Is.SameAs(_entityExpression.Type));
Assert.That(expression.Columns, Is.EqualTo(expectedColumns));
}
public void ResolveMemberAccess()
{
var sourceExpression = new SqlColumnDefinitionExpression(typeof(Cook), "c", "Substitution", false);
var memberInfo = typeof(Cook).GetProperty("Name");
var fakeResolvedExpression = new SqlLiteralExpression("Hugo");
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(sourceExpression, memberInfo))
.Return(fakeResolvedExpression);
_resolverMock.Replay();
var result = _stage.ResolveMemberAccess(sourceExpression, memberInfo, _resolverMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResolvedExpression));
}
public void ResolveMemberAccess_OnColumnExpression()
{
var memberInfo = typeof(Cook).GetProperty("Substitution");
var constantExpression = Expression.Constant("test");
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(columnExpression, memberInfo))
.Return(constantExpression);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(columnExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(constantExpression));
}
public void ResolveMemberAccess_OnUnaryExpression_Convert()
{
var operand = new SqlColumnDefinitionExpression(typeof(Cook), "c", "ID", false);
var convertExpression = Expression.Convert(Expression.Convert(operand, typeof(Chef)), typeof(Chef));
var memberInfo = typeof(Chef).GetProperty("LetterOfRecommendation");
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(operand, memberInfo))
.Return(fakeResult);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(convertExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void HandleResultOperator_GroupByAfterGroupBy()
{
var groupByExpression = Expression.Constant("group");
_sqlStatementBuilder.GroupByExpression = groupByExpression;
var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var fakeFromExpressionInfo = new FromExpressionInfo(
new SqlTable(new ResolvedSubStatementTableInfo("sc", _sqlStatementBuilder.GetSqlStatement()), JoinSemantics.Inner), new Ordering[0], elementSelector, null);
var originalStatement = _sqlStatementBuilder.GetSqlStatement();
var originalDataInfo = _sqlStatementBuilder.DataInfo;
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(keySelector, _context))
.Return(keySelector);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(elementSelector, _context))
.Return(elementSelector);
_stageMock
.Expect(
mock => mock.PrepareFromExpression(Arg <Expression> .Is.Anything, Arg.Is(_context), Arg <Func <ITableInfo, SqlTable> > .Is.Anything))
.Return(fakeFromExpressionInfo)
.WhenCalled(
mi =>
{
var fromExpression = (Expression)mi.Arguments[0];
CheckExpressionMovedIntoSubStatement(fromExpression, originalStatement);
});
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.GroupByExpression, Is.SameAs(keySelector));
Assert.That(_sqlStatementBuilder.SqlTables.Count, Is.EqualTo(1));
Assert.That(_sqlStatementBuilder.SqlTables[0], Is.SameAs(fakeFromExpressionInfo.SqlTable));
Assert.That(_sqlStatementBuilder.DataInfo, Is.Not.SameAs(originalDataInfo));
Assert.That(
_sqlStatementBuilder.DataInfo.DataType,
Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(IGrouping <,>).MakeGenericType(typeof(string), typeof(string)))));
}
public void BuildOrderBy_WithSingleOrderByClause()
{
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "t", "Name", false);
var orderByClause = new Ordering(columnExpression, OrderingDirection.Asc);
var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement(new SqlStatementBuilder {
Orderings = { orderByClause }
});
_stageMock.Expect(mock => mock.GenerateTextForOrdering(_commandBuilder, orderByClause))
.WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[Name] ASC"));
_stageMock.Replay();
_generator.BuildOrderByPart(sqlStatement, _commandBuilder);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" ORDER BY [t].[Name] ASC"));
_stageMock.VerifyAllExpectations();
}
public void SetUp()
{
_stageMock = MockRepository.GenerateStrictMock <ISqlGenerationStage> ();
_commandBuilder = new SqlCommandBuilder();
_visitor = new TestableSqlGeneratingOuterSelectExpressionVisitor(_commandBuilder, _stageMock);
_namedIntExpression = new NamedExpression("test", Expression.Constant(0));
_nameColumnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
_entityExpression = new SqlEntityDefinitionExpression(
typeof(Cook),
"c",
"test",
e => e,
new SqlColumnDefinitionExpression(typeof(int), "c", "ID", true),
_nameColumnExpression,
new SqlColumnDefinitionExpression(typeof(string), "c", "FirstName", false)
);
}
public void ResolveSimpleTableInfo()
{
var simpleTableInfo = new ResolvedSimpleTableInfo(typeof(DataContextTestClass.Region), "dbo.Region", "t0");
SqlEntityDefinitionExpression resolvedExpr = _mappingResolver.ResolveSimpleTableInfo(simpleTableInfo, _generator);
SqlColumnExpression expectedPrimaryColumn = new SqlColumnDefinitionExpression(typeof(int), simpleTableInfo.TableAlias, "RegionID", true);
SqlColumnExpression expectedDescriptionColumn =
new SqlColumnDefinitionExpression(typeof(string), simpleTableInfo.TableAlias, "RegionDescription", false);
Assert.That(resolvedExpr.Type, Is.SameAs(typeof(DataContextTestClass.Region)));
Assert.That(resolvedExpr.TableAlias, Is.EqualTo("t0"));
Assert.That(resolvedExpr.Name, Is.Null);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedPrimaryColumn, resolvedExpr.GetIdentityExpression());
Assert.That(resolvedExpr.Columns, Has.Count.EqualTo(2));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedPrimaryColumn, resolvedExpr.Columns[0]);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedDescriptionColumn, resolvedExpr.Columns[1]);
}
public void ResolveMemberAccess_OnNamedExpression()
{
var operand = new SqlColumnDefinitionExpression(typeof(Cook), "c", "ID", false);
var namedExpression = new NamedExpression("two", new NamedExpression("one", operand));
var memberInfo = typeof(Cook).GetProperty("FirstName");
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(operand, memberInfo))
.Return(fakeResult);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(namedExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
