public void Transform_ChildrenTransformedBeforeParent()
{
var inputChildExpression = CreateSimpleExpression(0);
var transformedChildExpression = CreateSimpleExpression(1);
var inputParentExpression = Expression.UnaryPlus(inputChildExpression);
var transformedParentExpression = CreateSimpleExpression(2);
var providerMock = MockRepository.GenerateStrictMock <IExpressionTranformationProvider> ();
providerMock
.Expect(mock => mock.GetTransformations(inputChildExpression))
.Return(new ExpressionTransformation[] { expr => transformedChildExpression });
providerMock
.Expect(mock => mock.GetTransformations(transformedChildExpression))
.Return(new ExpressionTransformation[0]);
providerMock
.Expect(mock => mock.GetTransformations(
Arg <Expression> .Matches(expr => expr is UnaryExpression && ((UnaryExpression)expr).Operand == transformedChildExpression)))
.Return(new ExpressionTransformation[] { expr => transformedParentExpression });
providerMock
.Expect(mock => mock.GetTransformations(transformedParentExpression))
.Return(new ExpressionTransformation[0]);
providerMock.Replay();
var result = TransformingExpressionTreeVisitor.Transform(inputParentExpression, providerMock);
providerMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(transformedParentExpression));
}
private static void AssertLambda(LambdaExpression lambda, string expected)
{
var expression = lambda.Body;
expression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(expression);
expression = TransformingExpressionTreeVisitor.Transform(expression, _transformationProvider);
var result = SDataExpressionBuilderVisitor.BuildExpression(expression);
Assert.That(result, Is.EqualTo(expected));
}
public static string GetN1QlSelectNewExpression(NewExpression expression, N1QlQueryGenerationContext queryGenerationContext)
{
// Ensure that any date/time expressions are properly converted to Unix milliseconds as needed
expression = (NewExpression)TransformingExpressionTreeVisitor.Transform(expression,
ExpressionTransformers.DateTimeTransformationRegistry.Default);
var visitor = new N1QlExpressionTreeVisitor(queryGenerationContext);
visitor.VisitSelectNewExpression(expression);
return(visitor.GetN1QlExpression());
}
public void Transform_NullExpression()
{
var providerMock = MockRepository.GenerateStrictMock <IExpressionTranformationProvider> ();
providerMock.Replay();
var result = TransformingExpressionTreeVisitor.Transform(null, providerMock);
providerMock.VerifyAllExpectations();
Assert.That(result, Is.Null);
}
private string GetN1QlExpression(Expression expression)
{
if (_groupingStatus == GroupingStatus.AfterGroupSubquery)
{
// SELECT, HAVING, and ORDER BY clauses must be remapped to refer directly to the extents in the grouping subquery
// rather than refering to the output of the grouping subquery
expression = TransformingExpressionTreeVisitor.Transform(expression, _groupingExpressionTransformerRegistry);
}
return(N1QlExpressionTreeVisitor.GetN1QlExpression(expression, _queryGenerationContext));
}
public void Transform_NoMatchingTransformation()
{
var inputExpression = CreateSimpleExpression(0);
var providerMock = MockRepository.GenerateStrictMock <IExpressionTranformationProvider> ();
providerMock
.Expect(mock => mock.GetTransformations(inputExpression))
.Return(new ExpressionTransformation[0]);
providerMock.Replay();
var result = TransformingExpressionTreeVisitor.Transform(inputExpression, providerMock);
providerMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(inputExpression));
}
public void Transform_TwoMatchingTransformations_FirstTransformationChangesExpression()
{
var inputExpression = CreateSimpleExpression(0);
var transformedExpression = CreateSimpleExpression(0);
var providerMock = MockRepository.GenerateStrictMock <IExpressionTranformationProvider> ();
providerMock
.Expect(mock => mock.GetTransformations(inputExpression))
.Return(new ExpressionTransformation[] {
expr => transformedExpression,
expr => { throw new InvalidOperationException("Must not be called."); }
});
providerMock
.Expect(mock => mock.GetTransformations(transformedExpression))
.Return(new ExpressionTransformation[0]);
providerMock.Replay();
var result = TransformingExpressionTreeVisitor.Transform(inputExpression, providerMock);
providerMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(transformedExpression));
}
public Expression Process(Expression expressionTree)
{
return(TransformingExpressionTreeVisitor.Transform(expressionTree, _provider));
}
public Expression Process(Expression expressionTree)
{
ArgumentUtility.CheckNotNull("expressionTree", expressionTree);
return(TransformingExpressionTreeVisitor.Transform(expressionTree, _provider));
}
private string GetSelectParameters(SelectClause selectClause, QueryModel queryModel)
{
string expression;
if (selectClause.Selector.GetType() == typeof(QuerySourceReferenceExpression))
{
if (_queryPartsAggregator.AggregateFunction == null)
{
expression = GetN1QlExpression(selectClause.Selector);
if (_queryPartsAggregator.QueryType != N1QlQueryType.Array)
{
expression = string.Concat(expression, ".*");
}
}
else
{
// for aggregates, just use "*" (i.e. AggregateFunction = "COUNT", expression = "*" results in COUNT(*)"
expression = "*";
}
}
else if (selectClause.Selector.NodeType == ExpressionType.New)
{
if (_queryPartsAggregator.QueryType != N1QlQueryType.Array)
{
var selector = selectClause.Selector as NewExpression;
if (_groupingStatus == GroupingStatus.AfterGroupSubquery)
{
// SELECT clauses must be remapped to refer directly to the extents in the grouping subquery
// rather than refering to the output of the grouping subquery
selector = (NewExpression)TransformingExpressionTreeVisitor.Transform(selector, _groupingExpressionTransformerRegistry);
}
expression =
N1QlExpressionTreeVisitor.GetN1QlSelectNewExpression(selector, _queryGenerationContext);
}
else
{
expression = GetN1QlExpression(selectClause.Selector);
}
}
else
{
expression = GetN1QlExpression(selectClause.Selector);
if ((_queryPartsAggregator.QueryType == N1QlQueryType.Subquery) || (_queryPartsAggregator.QueryType == N1QlQueryType.Array))
{
// For LINQ, this subquery is expected to return a list of the specific property being selected
// But N1QL will always return a list of objects with a single property
// So we need to use an ARRAY statement to convert the list
_queryPartsAggregator.ArrayPropertyExtractionPart = N1QlHelpers.EscapeIdentifier("result");
expression += " as " + _queryPartsAggregator.ArrayPropertyExtractionPart;
}
}
return(expression);
}
private string GetSelectParameters(SelectClause selectClause, QueryModel queryModel)
{
string expression;
if (selectClause.Selector.GetType() == typeof(QuerySourceReferenceExpression))
{
if (_queryPartsAggregator.AggregateFunction == null)
{
expression = GetN1QlExpression(selectClause.Selector);
if (_queryPartsAggregator.QueryType != N1QlQueryType.Array)
{
expression = string.Concat(expression, ".*");
}
}
else
{
// for aggregates, just use "*" (i.e. AggregateFunction = "COUNT", expression = "*" results in COUNT(*)"
ResultExtractionRequired = true;
_queryPartsAggregator.PropertyExtractionPart = N1QlHelpers.EscapeIdentifier("result");
expression = "*";
}
}
else if (selectClause.Selector.NodeType == ExpressionType.New)
{
if (_queryPartsAggregator.QueryType != N1QlQueryType.Array)
{
var selector = selectClause.Selector as NewExpression;
if (_groupingStatus == GroupingStatus.AfterGroupSubquery)
{
// SELECT clauses must be remapped to refer directly to the extents in the grouping subquery
// rather than refering to the output of the grouping subquery
selector = (NewExpression)TransformingExpressionTreeVisitor.Transform(selector, _groupingExpressionTransformerRegistry);
}
expression =
N1QlExpressionTreeVisitor.GetN1QlSelectNewExpression(selector, _queryGenerationContext);
}
else
{
expression = GetN1QlExpression(selectClause.Selector);
}
}
else
{
expression = GetN1QlExpression(selectClause.Selector);
if (_queryPartsAggregator.QueryType == N1QlQueryType.Subquery)
{
// For LINQ, this subquery is expected to return a list of the specific property being selected
// But N1QL will always return a list of objects with a single property
// So we need to use an ARRAY statement to convert the list
_queryPartsAggregator.PropertyExtractionPart = N1QlHelpers.EscapeIdentifier("result");
expression += " as " + _queryPartsAggregator.PropertyExtractionPart;
}
else
{
// This is a select expression on the main query that doesn't use a "new" clause, and isn't against an extent
// So it will return an array of objects with properties, while LINQ is expecting an array of values
// Since we can't extract the properties from the object in N1QL like we can with subqueries
// We need to indicate to the BucketQueryExecutor that it will need to extract the properties
_queryPartsAggregator.PropertyExtractionPart = N1QlHelpers.EscapeIdentifier("result");
ResultExtractionRequired = true;
}
}
return(expression);
}