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)); }