AddWhereCondition() public méthode

public AddWhereCondition ( Expression translatedExpression ) : void
translatedExpression System.Linq.Expressions.Expression
Résultat void
SqlStatementBuilder Class Documentation
Exemple #1
0
    public void AddWhereCondition_MultipleWhereCondition ()
    {
      var statementBuilder = new SqlStatementBuilder ();

      var expression1 = Expression.Constant (true);
      statementBuilder.AddWhereCondition (expression1);
      var expression2 = Expression.Constant (false);
      statementBuilder.AddWhereCondition (expression2);

      Assert.That (((BinaryExpression) statementBuilder.WhereCondition).Left, Is.EqualTo (expression1));
      Assert.That (((BinaryExpression) statementBuilder.WhereCondition).Right, Is.EqualTo (expression2));
      Assert.That (statementBuilder.WhereCondition.NodeType, Is.EqualTo (ExpressionType.AndAlso));
    }
Exemple #2
0
    public ITableInfo VisitUnresolvedGroupReferenceTableInfo (UnresolvedGroupReferenceTableInfo tableInfo)
    {
      var groupSourceSubStatementTableInfo = tableInfo.ReferencedGroupSource.GetResolvedTableInfo() as ResolvedSubStatementTableInfo;
      if (groupSourceSubStatementTableInfo == null)
      {
        var message = string.Format (
            "This SQL generator only supports sequences in from expressions if they are members of an entity or if they come from a GroupBy operator. "
            + "Sequence: '{0}'", tableInfo);
        throw new NotSupportedException (message);
      }

      var groupingSelectExpression = groupSourceSubStatementTableInfo.SqlStatement.SelectProjection as SqlGroupingSelectExpression;
      if (groupingSelectExpression == null)
      {
        throw new NotSupportedException (
            "When a sequence retrieved by a subquery is used in a from expression, the subquery must end with a GroupBy operator.");
      }

      var elementSelectingStatementBuilder = new SqlStatementBuilder (groupSourceSubStatementTableInfo.SqlStatement) { GroupByExpression = null };

      var currentKeyExpression = Expression.MakeMemberAccess (
          new SqlTableReferenceExpression (tableInfo.ReferencedGroupSource), 
          groupingSelectExpression.Type.GetProperty ("Key"));

      var groupKeyJoinCondition = _stage.ResolveWhereExpression (
          Expression.OrElse (
              Expression.AndAlso (new SqlIsNullExpression (groupingSelectExpression.KeyExpression), new SqlIsNullExpression (currentKeyExpression)),
              Expression.AndAlso (
                  Expression.AndAlso (
                      new SqlIsNotNullExpression (groupingSelectExpression.KeyExpression), 
                      new SqlIsNotNullExpression (currentKeyExpression)),
                  Expression.Equal (groupingSelectExpression.KeyExpression, currentKeyExpression))), 
          _context);
      elementSelectingStatementBuilder.AddWhereCondition (groupKeyJoinCondition);

      elementSelectingStatementBuilder.SelectProjection = groupingSelectExpression.ElementExpression;
      elementSelectingStatementBuilder.RecalculateDataInfo (groupingSelectExpression);

      return new ResolvedJoinedGroupingTableInfo (
          _generator.GetUniqueIdentifier("q"), 
          elementSelectingStatementBuilder.GetSqlStatement(), 
          groupingSelectExpression,
          groupSourceSubStatementTableInfo.TableAlias);
    }
Exemple #3
0
    public void AddWhereCondition_SingleWhereCondition ()
    {
      var statementBuilder = new SqlStatementBuilder ();

      var expression = Expression.Constant ("whereTest");
      statementBuilder.AddWhereCondition (expression);

      Assert.That (statementBuilder.WhereCondition, Is.EqualTo (expression));
    }