Enum ScoringQuery 

pub enum ScoringQuery {
    Vector(QueryEnum),
    Fusion(FusionInternal),
    OrderBy(OrderBy),
    Formula(ParsedFormula),
    Sample(SampleInternal),
    Mmr(MmrInternal),
}

Same as Query, but with the resolved vector references.

Variants

Vector(QueryEnum)

Score points against some vector(s)

Fusion(FusionInternal)

Reciprocal rank fusion

OrderBy(OrderBy)

Order by a payload field

Formula(ParsedFormula)

Score boosting via an arbitrary formula

Sample(SampleInternal)

Sample points

Mmr(MmrInternal)

Maximal Marginal Relevance

This one behaves a little differently than the other scorings, since it is two parts. It will create one nearest neighbor search in segment space and then try to resolve MMR algorithm higher up.

E.g. If it is the root query of a request:

1. Performs search all the way down to segments.
2. MMR gets calculated once results reach collection level.

Implementations

impl ScoringQuery

pub fn needs_intermediate_results(&self) -> bool

Whether the query needs the prefetches results from all shards to compute the final score

If false, there is a single list of scored points which contain the final score.

pub fn get_vector_name(&self) -> Option<&str>

Get the vector name if it is scored against a vector

Trait Implementations

impl Clone for ScoringQuery

fn clone(&self) -> ScoringQuery

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScoringQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ScoringQuery

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ScoringQuery

fn eq(&self, other: &ScoringQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ScoringQuery

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ScoringQuery