public Nest.QueryContainer CreateNextPaginationFilter(Nest.QueryContainerDescriptor <ScoreRecord> q, ScoreRecord pivot)
{
// ( score < pivot.score) OR (score == pivot.score AND createdOn > pivot.createdOn)
return(q.Bool(b1 => b1.Should(
q1 => q1.Range(r => r.Field(record => record.Score).LessThan(pivot.Score)),
q1 => q1.Bool(b2 => b2.Must(
q2 => q2.Term(t => t.Field(record => record.Score).Value(pivot.Score)),
q2 => q2.DateRange(r => r.Field(record => record.CreatedOn).GreaterThan(pivot.CreatedOn))
))
)));
}
private Nest.QueryContainer addOperation <T>(Nest.QueryContainerDescriptor <T> descriptor,
IFieldDefinition definition) where T : class
{
var operation = Operation.FromValue(definition.Op);
if (operation == Operation.Equal)
{
return(descriptor.Term(term => term.Field(definition.Field).Value(definition.Value).Boost(definition.Boost)));
}
if (operation == Operation.Contains)
{
return(descriptor.Match(match => match.Field(definition.Field).Query(definition.Value).Boost(definition.Boost)));
}
if (operation == Operation.GreaterThan)
{
return(descriptor.Range(number => number.Field(definition.Field).GreaterThan(double.Parse(definition.Value)).Boost(definition.Boost)));
}
if (operation == Operation.GreaterThanOrEqual)
{
return(descriptor.Range(number => number.Field(definition.Field).GreaterThanOrEquals(double.Parse(definition.Value)).Boost(definition.Boost)));
}
if (operation == Operation.LessThan)
{
return(descriptor.Range(number => number.Field(definition.Field).LessThan(double.Parse(definition.Value)).Boost(definition.Boost)));
}
if (operation == Operation.LessThanOrEqual)
{
return(descriptor.Range(number => number.Field(definition.Field).LessThanOrEquals(double.Parse(definition.Value)).Boost(definition.Boost)));
}
if (operation == Operation.NotEqual)
{
return(!descriptor.Term(term => term.Field(definition.Field).Value(definition.Value).Boost(definition.Boost)));
}
if (operation == Operation.Autocomplete)
{
return(descriptor.MultiMatch(match => match.Fields(f => f
.Field($"{definition.Field}.default", 10)
.Field($"{definition.Field}.stemmed", 2)
.Field($"{definition.Field}.shingles", 2)
.Field($"{definition.Field}.ngram"))
.Query(definition.Value)
.Operator(Nest.Operator.And)
));
}
throw new ArgumentException($"operation {definition.Op} is not supported");
}
/// <summary>
/// 初始化Sql生成器辅助操作
/// </summary>
/// <param name="dialect">方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体别名注册器</param>
/// <param name="parameterManager">参数管理器</param>
public Helper(IEntityResolver resolver, Nest.QueryContainerDescriptor <TEntity> queryContainerDescriptor)
{
_resolver = resolver;
_queryContainerDescriptor = queryContainerDescriptor;
}
private Nest.QueryContainer CreateQuery(
Nest.QueryContainerDescriptor <ScoreRecord> desc,
LeaderboardQuery rq,
Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> additionalContraints = null)
{
return(desc.Bool(s2 =>
{
var mustClauses = Enumerable.Empty <Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> >();
if (rq.FriendsIds.Any())
{
mustClauses = mustClauses.Concat(new Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer>[] {
q => q.Terms(t => t.Field(s => s.PlayerId).Terms(rq.FriendsIds.Select(i => i.ToString())))
});
}
if (rq.FieldFilters != null && rq.FieldFilters.Any())
{
mustClauses = mustClauses.Concat(rq.FieldFilters.Select <FieldFilter, Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> >(f =>
{
return q => q.Term("document." + f.Field, f.Value);
}));
}
if (rq.ScoreFilters != null && rq.ScoreFilters.Any())
{
mustClauses = mustClauses.Concat(rq.ScoreFilters.Select <ScoreFilter, Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> >(f =>
{
return q => q.Range(r =>
{
r = r.Field(s3 => s3.Score);
switch (f.Type)
{
case ScoreFilterType.GreaterThan:
r = r.GreaterThan(f.Value);
break;
case ScoreFilterType.GreaterThanOrEqual:
r = r.GreaterThanOrEquals(f.Value);
break;
case ScoreFilterType.LesserThan:
r = r.LessThan(f.Value);
break;
case ScoreFilterType.LesserThanOrEqual:
r = r.LessThanOrEquals(f.Value);
break;
default:
break;
}
return r;
});
}));
}
if (additionalContraints != null)
{
mustClauses = mustClauses.Concat(new[] { additionalContraints });
}
return s2.Must(mustClauses);
}));
}
/// <summary>
/// 初始化谓词表达式解析器
/// </summary>
/// <param name="dialect">方言</param>
/// <param name="resolver">实体解析器</param>
/// <param name="register">实体别名注册器</param>
/// <param name="parameterManager">参数管理器</param>
public PredicateExpressionResolver(IEntityResolver resolver, Nest.QueryContainerDescriptor <TEntiy> queryContainerDescriptor)
{
_helper = new Helper <TEntiy>(resolver, queryContainerDescriptor);
_queryContainerDescriptor = queryContainerDescriptor;
}
