/// <summary>
/// Replaces the top level predicate to a new LogicalPredicate that
/// contains the original top level predicate and a given predicate
/// encapsulated by two individual LogicalClause with the given occurence.
/// </summary>
public void AddClause(SnQueryPredicate clause, Occurence occurence)
{
QueryTree = new LogicalPredicate(new[]
{
new LogicalClause(QueryTree, occurence),
new LogicalClause(clause, occurence),
});
}
public override SnQueryPredicate Visit(SnQueryPredicate predicate)
{
if (predicate is SnLinqVisitor.BooleanMemberPredicate boolMemberPredicate)
{
return(VisitBooleanMemberQuery(boolMemberPredicate));
}
return(base.Visit(predicate));
}
public override SnQueryPredicate Visit(SnQueryPredicate predicate)
{
if (!_initialized)
{
_topLevelLogicalPredicate = predicate as LogicalPredicate;
_initialized = true;
}
return(base.Visit(predicate));
}
private static SnQueryPredicate GetAutoFilterClause(IQueryContext context)
{
if (_autoFilterClause == null)
{
var parser = new CqlParser();
_autoFilterClause = parser.Parse("IsSystemContent:no", context).QueryTree;
}
return(_autoFilterClause);
}
private void NormalizerVisitorTest(SnQueryPredicate inputPredicate, string expectedQuery)
{
var context = new TestQueryContext(QuerySettings.AdminSettings, 0, _indexingInfo, new TestQueryEngine(null, null));
using (SenseNet.Tests.Tools.Swindle(typeof(SnQuery), "_permissionFilterFactory", new EverythingAllowedPermissionFilterFactory()))
{
var queryIn = SnQuery.Create(inputPredicate);
NormalizerVisitorTest(queryIn, context, expectedQuery);
}
}
/// <summary>
/// Dispatches the predicate to one of the more specialized visit methods in this class.
/// </summary>
/// <param name="predicate">The predicate to visit.</param>
/// <returns>The modified predicate, if it or any child was modified; otherwise, returns the original predicate.</returns>
public virtual SnQueryPredicate Visit(SnQueryPredicate predicate)
{
switch (predicate)
{
case null:
return(null);
case SimplePredicate simple:
return(VisitSimplePredicate(simple));
case RangePredicate range:
return(VisitRangePredicate(range));
case LogicalPredicate logic:
return(VisitLogicalPredicate(logic));
}
throw new NotSupportedException("Unknown predicate type: " + predicate.GetType().FullName);
}
private static SnQueryPredicate CombinePathPredicate(SnQueryPredicate predicate, string contextPath, PathUsageMode pathUsageMode)
{
if (predicate == null)
{
return(null);
}
var pathQuery = GetPathPredicate(contextPath, pathUsageMode == PathUsageMode.InTreeAnd || pathUsageMode == PathUsageMode.InTreeOr);
if (pathQuery == null)
{
return(predicate);
}
var occur = pathUsageMode == PathUsageMode.InFolderOr || pathUsageMode == PathUsageMode.InTreeOr
? Occurence.Should
: Occurence.Must;
return(new LogicalPredicate(new[]
{ new LogicalClause(predicate, occur), new LogicalClause(pathQuery, occur) }));
}
internal static SnQueryPredicate OptimizeBooleans(SnQueryPredicate predicate)
{
var v = new OptimizeBooleansVisitor();
var optimizedPredicate = v.Visit(predicate);
if (!(optimizedPredicate is LogicalPredicate logicalPredicate))
{
return(optimizedPredicate);
}
var clauses = logicalPredicate.Clauses;
if (clauses.Count != 1)
{
return(logicalPredicate);
}
if (clauses[0].Occur != Occurence.MustNot)
{
return(logicalPredicate);
}
logicalPredicate.Clauses.Add(new LogicalClause(SnQuery.FullSetPredicate, Occurence.Must));
return(logicalPredicate);
}
/* ============================================================================ */
private void AddBooleanClause(LogicalPredicate boolNode, SnQueryPredicate query, Occurence occur)
{
if (!(query is LogicalPredicate boolQ))
{
boolNode.Clauses.Add(new LogicalClause(query, occur));
return;
}
var clauses = boolQ.Clauses;
if (clauses.Count == 0)
{
throw ParserError("Empty BooleanNode");
}
if (clauses.Count > 1)
{
boolNode.Clauses.Add(new LogicalClause(query, occur));
return;
}
// boolQ has one clause: combine occurs
var clause = clauses[0];
var clauseOccur = clause.Occur;
Occurence effectiveOccur;
if (_defaultOperator == DefaultOperator.Or)
{
// in cl eff
// ? _ ==> _
// ? + ==> +
// ? - ==> -
// _ _ ==> _
// _ + ==> +
// _ - ==> -
// + _ ==> +
// + + ==> +
// + - ==> -
// - _ ==> -
// - + ==> -
// - - ==> -
if (occur == Occurence.Default || occur == Occurence.Should)
{
effectiveOccur = clauseOccur;
}
else if (occur == Occurence.MustNot)
{
effectiveOccur = occur;
}
else if (clauseOccur == Occurence.MustNot)
{
effectiveOccur = clauseOccur;
}
else
{
effectiveOccur = occur;
}
}
else
{
// in cl eff
// ? _ ==> _
// ? + ==> +
// ? - ==> -
// _ _ ==> _
// _ + ==> _
// _ - ==> -
// + _ ==> +
// + + ==> +
// + - ==> -
// - _ ==> -
// - + ==> -
// - - ==> -
if (occur == Occurence.Default)
{
effectiveOccur = clauseOccur;
}
else if (occur == Occurence.MustNot)
{
effectiveOccur = occur;
}
else if (clauseOccur == Occurence.MustNot)
{
effectiveOccur = clauseOccur;
}
else
{
effectiveOccur = occur;
}
}
clause.Occur = effectiveOccur;
boolNode.Clauses.Add(clause);
}
private static SnQuery BuildSnQuery(Expression expression, Type sourceCollectionItemType, string contextPath, ChildrenDefinition childrenDef, out string elementSelection)
{
SnQueryPredicate q0 = null;
elementSelection = null;
SnLinqVisitor v = null;
// #1 compiling linq expression
if (expression != null)
{
var v1 = new SetExecVisitor();
var expr1 = v1.Visit(expression);
var expr2 = expr1;
if (v1.HasParameter)
{
var v2 = new ExecutorVisitor(v1.GetExpressions());
expr2 = v2.Visit(expr1);
}
v = new SnLinqVisitor();
v.Visit(expr2);
q0 = v.GetPredicate(sourceCollectionItemType, childrenDef);
elementSelection = v.ElementSelection;
}
// #2 combining with additional query clause
SnQuery lq = null;
if (!string.IsNullOrEmpty(childrenDef?.ContentQuery))
{
var queryText = TemplateManager.Replace(typeof(ContentQueryTemplateReplacer), childrenDef.ContentQuery);
lq = SnQuery.Parse(queryText, new SnQueryContext(QuerySettings.Default, User.Current.Id));
q0 = q0 == null
? lq.QueryTree
: CombineQueries(q0, lq.QueryTree);
}
// #3 combining with context path
if (q0 == null)
{
if (childrenDef != null && childrenDef.PathUsage != PathUsageMode.NotUsed && contextPath != null)
{
q0 = GetPathPredicate(contextPath, childrenDef.PathUsage == PathUsageMode.InTreeAnd || childrenDef.PathUsage == PathUsageMode.InTreeOr);
}
}
else
{
if (childrenDef != null && childrenDef.PathUsage != PathUsageMode.NotUsed && contextPath != null)
{
q0 = CombinePathPredicate(q0, contextPath, childrenDef.PathUsage);
}
}
// #4 empty query substitution
if (q0 == null)
{
q0 = new RangePredicate(IndexFieldName.NodeId, new IndexValue(0), null, true, false);
}
var q1 = OptimizeBooleans(q0);
// #5 configuring query by linq expression (the smallest priority)
var query = SnQuery.Create(q1);
if (v != null)
{
query.Skip = v.Skip;
query.Top = v.Top;
query.CountOnly = v.CountOnly;
query.Sort = v.Sort.ToArray();
query.ThrowIfEmpty = v.ThrowIfEmpty;
query.ExistenceOnly = v.ExistenceOnly;
}
// #6 configuring query by children definition
if (childrenDef != null)
{
if (childrenDef.Skip > 0)
{
query.Skip = childrenDef.Skip;
}
if (childrenDef.Top > 0)
{
query.Top = childrenDef.Top;
}
if (childrenDef.Sort != null)
{
query.Sort = childrenDef.Sort.ToArray();
}
if (childrenDef.CountAllPages != null)
{
query.CountAllPages = childrenDef.CountAllPages.Value;
}
if (childrenDef.EnableAutofilters != FilterStatus.Default)
{
query.EnableAutofilters = childrenDef.EnableAutofilters;
}
if (childrenDef.EnableLifespanFilter != FilterStatus.Default)
{
query.EnableLifespanFilter = childrenDef.EnableLifespanFilter;
}
if (childrenDef.QueryExecutionMode != QueryExecutionMode.Default)
{
query.QueryExecutionMode = childrenDef.QueryExecutionMode;
}
}
// #7 configuring query by additional query clause (the biggest priority)
if (lq != null)
{
if (lq.Skip > 0)
{
query.Skip = lq.Skip;
}
if (lq.Top > 0 && lq.Top != int.MaxValue)
{
query.Top = lq.Top;
}
if (lq.Sort != null && lq.Sort.Length > 0)
{
query.Sort = lq.Sort;
}
if (lq.EnableAutofilters != FilterStatus.Default)
{
query.EnableAutofilters = lq.EnableAutofilters;
}
if (lq.EnableLifespanFilter != FilterStatus.Default)
{
query.EnableLifespanFilter = lq.EnableLifespanFilter;
}
if (lq.QueryExecutionMode != QueryExecutionMode.Default)
{
query.QueryExecutionMode = lq.QueryExecutionMode;
}
if (lq.AllVersions)
{
query.AllVersions = true;
}
}
return(query);
}
private static SnQueryPredicate CombineQueries(SnQueryPredicate p1, SnQueryPredicate p2)
{
return(new LogicalPredicate(new[]
{ new LogicalClause(p1, Occurence.Must), new LogicalClause(p2, Occurence.Must) }));
}
/// <summary>
/// Replaces the top level predicate to a new LogicalPredicate that
/// contains the original top level predicate and a given predicate
/// encapsulated by two individual LogicalClause with "Should" occurence.
/// </summary>
public void AddOrClause(SnQueryPredicate clause)
{
AddClause(clause, Occurence.Should);
}
/// <summary>
/// Replaces the top level predicate to a new LogicalPredicate that
/// contains the original top level predicate and a given predicate
/// encapsulated by two individual LogicalClause with "Must" occurence.
/// </summary>
public void AddAndClause(SnQueryPredicate clause)
{
AddClause(clause, Occurence.Must);
}
/// <summary>
/// Creates an SnQuery instance from the given predicate.
/// </summary>
public static SnQuery Create(SnQueryPredicate predicate)
{
return(new SnQuery {
QueryTree = predicate
});
}
