protected virtual void FlattenSubQuery(
SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex)
{
ArgumentUtility.CheckNotNull("subQueryExpression", subQueryExpression);
ArgumentUtility.CheckNotNull("fromClause", fromClause);
ArgumentUtility.CheckNotNull("queryModel", queryModel);
CheckFlattenable(subQueryExpression.QueryModel);
var innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
public void VisitUnknownNonExtensionExpression_Ignored()
{
var expression = new UnknownExpression(typeof(object));
var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, true);
Assert.That(result, Is.SameAs(expression));
}
public void VisitSubQuery_ExpressionUnchanged()
{
var expression = new SubQueryExpression(ExpressionHelper.CreateQueryModel <Cook> ());
var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, false);
Assert.That(((SubQueryExpression)result).QueryModel, Is.SameAs(expression.QueryModel));
}
public void VisitUnmappedReference_IgnoreTrue_Ignored()
{
var expression = new QuerySourceReferenceExpression(ExpressionHelper.CreateMainFromClause_Int());
var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, false);
Assert.That(result, Is.SameAs(expression));
}
public void VisitSubQuery_PassesFlagToInner_Throw()
{
var expression = new SubQueryExpression(ExpressionHelper.CreateQueryModel <Cook> ());
expression.QueryModel.SelectClause.Selector = new QuerySourceReferenceExpression(expression.QueryModel.MainFromClause);
ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, true);
}
public void Replaces_NestedExpressions()
{
var expression = Expression.Negate(new QuerySourceReferenceExpression(_oldFromClause));
var result = (UnaryExpression)ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, true);
Assert.That(((QuerySourceReferenceExpression)result.Operand).ReferencedQuerySource, Is.SameAs(_newFromClause));
}
public void Replaces_QuerySourceReferenceExpressions()
{
var expression = new QuerySourceReferenceExpression(_oldFromClause);
var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, true);
Assert.That(((QuerySourceReferenceExpression)result).ReferencedQuerySource, Is.SameAs(_newFromClause));
}
protected virtual Expression ReplaceClauseReferences(
[NotNull] Expression expression, [NotNull] QuerySourceMapping querySourceMapping)
{
Check.NotNull(expression, "expression");
Check.NotNull(querySourceMapping, "querySourceMapping");
return(ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(expression, querySourceMapping, throwOnUnmappedReferences: false));
}
public IEnumerable <T> ExecuteCollection <T>(QueryModel queryModel)
{
var itemHolder = new ItemHolder();
var currentItemExpression = Expression.Property(Expression.Constant(itemHolder), "Current");
var luceneQueryModel = PrepareQuery(queryModel);
var mapping = new QuerySourceMapping();
mapping.AddMapping(queryModel.MainFromClause, currentItemExpression);
queryModel.TransformExpressions(e => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(e, mapping, throwOnUnmappedReferences: false));
var projection = GetProjector <T>(queryModel);
var projector = projection.Compile();
var searcherHandle = CheckoutSearcher();
using (searcherHandle)
{
var searcher = searcherHandle.Searcher;
var skipResults = luceneQueryModel.SkipResults;
var maxResults = Math.Min(luceneQueryModel.MaxResults, searcher.MaxDoc - skipResults);
var query = luceneQueryModel.Query;
var scoreFunction = luceneQueryModel.GetCustomScoreFunction <TDocument>();
if (scoreFunction != null)
{
query = new DelegatingCustomScoreQuery <TDocument>(query, ConvertDocumentForCustomBoost, scoreFunction);
}
var executionContext = new QueryExecutionContext(searcher, query, luceneQueryModel.Filter);
PrepareSearchSettings(executionContext);
var hits = searcher.Search(executionContext.Query, executionContext.Filter, maxResults + skipResults, luceneQueryModel.Sort);
if (luceneQueryModel.Last)
{
skipResults = hits.ScoreDocs.Length - 1;
if (skipResults < 0)
{
yield break;
}
}
var tracker = luceneQueryModel.DocumentTracker as IRetrievedDocumentTracker <TDocument>;
executionContext.Phase = QueryExecutionPhase.ConvertResults;
executionContext.Hits = hits;
foreach (var p in EnumerateHits(hits, executionContext, searcher, tracker, itemHolder, skipResults, projector))
{
yield return(p);
}
}
}
protected override void FlattenSubQuery(
[NotNull] SubQueryExpression subQueryExpression,
[NotNull] FromClauseBase fromClause,
[NotNull] QueryModel queryModel,
int destinationIndex)
{
Check.NotNull(subQueryExpression, nameof(subQueryExpression));
Check.NotNull(fromClause, nameof(fromClause));
Check.NotNull(queryModel, nameof(queryModel));
var subQueryModel = subQueryExpression.QueryModel;
VisitQueryModel(subQueryModel);
if (subQueryModel.ResultOperators
.Any(ro => !(ro is OfTypeResultOperator)) ||
subQueryModel.BodyClauses.Any(bc => bc is OrderByClause))
{
return;
}
var innerMainFromClause
= subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping
.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex =>
ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
foreach (var resultOperator in subQueryModel.ResultOperators.Reverse())
{
queryModel.ResultOperators.Insert(0, resultOperator);
}
foreach (var queryAnnotation
in _queryAnnotations
.Where(qa => qa.QuerySource == subQueryExpression.QueryModel.MainFromClause))
{
queryAnnotation.QuerySource = fromClause;
}
}
public void VisitExtensionExpression_ChildrenAreProcessed()
{
var extensionExpression = new TestExtensionExpression(new QuerySourceReferenceExpression(_oldFromClause));
var result = (TestExtensionExpression)ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(extensionExpression, _querySourceMapping, true);
var expectedExpression = new TestExtensionExpression(new QuerySourceReferenceExpression(_newFromClause));
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
private static ClientSideSelect CreateClientSideSelect(Expression expression, QueryModel queryModel)
{
// TODO - don't like calling GetGenericArguments here...
var parameter = Expression.Parameter(expression.Type.GetGenericArguments()[0], "inputParameter");
var mapping = new QuerySourceMapping();
mapping.AddMapping(queryModel.MainFromClause, parameter);
var body = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(queryModel.SelectClause.Selector, mapping, false);
var lambda = Expression.Lambda(body, parameter);
return(new ClientSideSelect(lambda));
}
public void Replaces_SubQueryExpressions_WithCorrectCloneContext()
{
var subQueryModel = ExpressionHelper.CreateQueryModel <Cook> ();
var referencedClause = ExpressionHelper.CreateMainFromClause_Int();
subQueryModel.SelectClause.Selector = new QuerySourceReferenceExpression(referencedClause);
var expression = new SubQueryExpression(subQueryModel);
var newReferenceExpression = new QuerySourceReferenceExpression(ExpressionHelper.CreateMainFromClause_Int());
_querySourceMapping.AddMapping(referencedClause, newReferenceExpression);
var result = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, false);
var newSubQuerySelectClause = ((SubQueryExpression)result).QueryModel.SelectClause;
Assert.That(newSubQuerySelectClause.Selector, Is.SameAs(newReferenceExpression));
}
private Expression ReplaceClauseReferences(Expression expression)
{
var isNestedQuery = _parentQueryModelVisitor != null;
var resultExpression
= ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(
expression,
_querySourceMapping,
throwOnUnmappedReferences: !isNestedQuery);
if (isNestedQuery)
{
resultExpression
= _parentQueryModelVisitor.ReplaceClauseReferences(resultExpression);
}
return(resultExpression);
}
public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
{
var subQuery = fromClause.FromExpression as SubQueryExpression;
if (subQuery == null)
{
return;
}
var subQueryModel = subQuery.QueryModel;
if (!IsLeftJoin(subQueryModel))
{
return;
}
var mainFromClause = subQueryModel.MainFromClause;
var restrictions = subQueryModel.BodyClauses
.OfType <WhereClause>()
.Select(w => new NhWithClause(w.Predicate));
var join = new NhJoinClause(mainFromClause.ItemName,
mainFromClause.ItemType,
mainFromClause.FromExpression,
restrictions);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryModel.SelectClause.Selector);
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));
queryModel.BodyClauses.RemoveAt(index);
queryModel.BodyClauses.Insert(index, @join);
InsertBodyClauses(subQueryModel.BodyClauses.Where(b => !(b is WhereClause)), queryModel, index + 1);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(@join));
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
protected override void FlattenSubQuery(
SubQueryExpression subQueryExpression,
FromClauseBase fromClause,
QueryModel queryModel,
int destinationIndex)
{
var subQueryModel = subQueryExpression.QueryModel;
if (!(subQueryModel.ResultOperators.Count <= 0 &&
!subQueryModel.BodyClauses.Any(bc => bc is OrderByClause)))
{
return;
}
var innerMainFromClause
= subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(innerMainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(
ex => ReferenceReplacingExpressionTreeVisitor
.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
private static void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel, int destinationIndex)
{
if (!CheckFlattenable(subQueryExpression.QueryModel))
{
return;
}
var mainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(mainFromClause, fromClause);
var innerSelectorMapping = new QuerySourceMapping();
innerSelectorMapping.AddMapping(fromClause, subQueryExpression.QueryModel.SelectClause.Selector);
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));
InsertBodyClauses(subQueryExpression.QueryModel.BodyClauses, queryModel, destinationIndex);
InsertResultOperators(subQueryExpression.QueryModel.ResultOperators, queryModel);
var innerBodyClauseMapping = new QuerySourceMapping();
innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(fromClause));
queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
}
public IEnumerable <T> ExecuteCollection <T>(QueryModel queryModel)
{
var itemHolder = new ItemHolder();
var currentItemExpression = Expression.Property(Expression.Constant(itemHolder), "Current");
var luceneQueryModel = PrepareQuery(queryModel);
var mapping = new QuerySourceMapping();
mapping.AddMapping(queryModel.MainFromClause, currentItemExpression);
queryModel.TransformExpressions(e => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(e, mapping, throwOnUnmappedReferences: true));
var projection = GetProjector <T>(queryModel);
var projector = projection.Compile();
var searcherHandle = CheckoutSearcher();
using (searcherHandle)
{
var searcher = searcherHandle.Searcher;
var skipResults = luceneQueryModel.SkipResults;
var maxResults = Math.Min(luceneQueryModel.MaxResults, searcher.MaxDoc - skipResults);
var query = luceneQueryModel.Query;
var scoreFunction = luceneQueryModel.GetCustomScoreFunction <TDocument>();
if (scoreFunction != null)
{
query = new DelegatingCustomScoreQuery <TDocument>(query, ConvertDocumentForCustomBoost, scoreFunction);
}
var executionContext = new QueryExecutionContext(searcher, query, luceneQueryModel.Filter);
PrepareSearchSettings(executionContext);
var hits = searcher.Search(executionContext.Query, executionContext.Filter, maxResults + skipResults, luceneQueryModel.Sort);
if (luceneQueryModel.Last)
{
skipResults = hits.ScoreDocs.Length - 1;
if (skipResults < 0)
{
yield break;
}
}
var tracker = luceneQueryModel.DocumentTracker as IRetrievedDocumentTracker <TDocument>;
executionContext.Phase = QueryExecutionPhase.ConvertResults;
executionContext.Hits = hits;
for (var i = skipResults; i < hits.ScoreDocs.Length; i++)
{
executionContext.CurrentHit = i;
executionContext.CurrentScoreDoc = hits.ScoreDocs[i];
var doc = hits.ScoreDocs[i].Doc;
var item = ConvertDocument(searcher.Doc(doc), executionContext);
if (tracker != null)
{
if (tracker.IsMarkedForDeletion(item))
{
continue;
}
TDocument tracked;
if (tracker.TryGetTrackedDocument(item, out tracked))
{
item = tracked;
}
else
{
var copy = ConvertDocument(searcher.Doc(doc), executionContext);
tracker.TrackDocument(item, copy);
}
}
itemHolder.Current = item;
yield return(projector(itemHolder.Current));
}
}
}
public void VisitUnmappedReference_IgnoreFalse_Throws()
{
var expression = new QuerySourceReferenceExpression(ExpressionHelper.CreateMainFromClause_Int());
ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, true);
}
