Enum rs_es::query::Filter [−] [src]

pub enum Filter {
    And(AndFilter),
    Bool(BoolFilter),
    Exists(ExistsFilter),
    GeoBoundingBox(GeoBoundingBoxFilter),
    GeoDistance(GeoDistanceFilter),
    GeoPolygon(GeoPolygonFilter),
    GeoShape(GeoShapeFilter),
    GeohashCell(GeohashCellFilter),
    HasChild(HasChildFilter),
    HasParent(HasParentFilter),
    Ids(IdsFilter),
    Indices(IndicesFilter),
    MatchAll(MatchAllFilter),
    Missing(MissingFilter),
    Nested(NestedFilter),
    Not(NotFilter),
    Or(OrFilter),
    Prefix(PrefixFilter),
    Query(QueryFilter),
    Range(RangeFilter),
    Regexp(RegexpFilter),
    Script(ScriptFilter),
    Term(TermFilter),
    Terms(TermsFilter),
    Type(TypeFilter),
}

Variants

`And`
`Bool`
`Exists`
`GeoBoundingBox`
`GeoDistance`
`GeoPolygon`
`GeoShape`
`GeohashCell`
`HasChild`
`HasParent`
`Ids`
`Indices`
`MatchAll`
`Missing`
`Nested`
`Not`
`Or`
`Prefix`
`Query`
`Range`
`Regexp`
`Script`
`Term`
`Terms`
`Type`

Methods

`impl Filter`

`fn build_and() -> AndFilter`

`fn build_bool() -> BoolFilter`

`fn build_exists<A: Into<String>>(field: A) -> ExistsFilter`

`fn build_geo_bounding_box<A: Into<String>, B: Into<GeoBox>>(field: A, geo_box: B) -> GeoBoundingBoxFilter`

`fn build_geo_distance<A: Into<String>, B: Into<Location>, C: Into<Distance>>(field: A, location: B, distance: C) -> GeoDistanceFilter`

`fn build_geo_polygon<A: Into<String>, B: Into<Vec<Location>>>(field: A, points: B) -> GeoPolygonFilter`

`fn build_geo_shape<A: Into<String>>(field: A) -> GeoShapeFilter`

`fn build_geohash_cell<A: Into<String>, B: Into<Location>>(field: A, location: B) -> GeohashCellFilter`

`fn build_has_child<A: Into<String>>(doc_type: A) -> HasChildFilter`

`fn build_has_parent<A: Into<String>>(parent_type: A) -> HasParentFilter`

`fn build_ids<A: Into<Vec<String>>>(values: A) -> IdsFilter`

`fn build_indices() -> IndicesFilter`

`fn build_match_all() -> MatchAllFilter`

`fn build_missing<A: Into<String>>(field: A) -> MissingFilter`

`fn build_nested<A: Into<String>, B: Into<Box<Filter>>>(path: A, filter: B) -> NestedFilter`

`fn build_not<A: Into<Box<Filter>>>(filter: A) -> NotFilter`

`fn build_or<A: Into<Vec<Filter>>>(filters: A) -> OrFilter`

`fn build_prefix<A: Into<String>, B: Into<String>>(field: A, value: B) -> PrefixFilter`

`fn build_query<A: Into<Box<Query>>>(query: A) -> QueryFilter`

`fn build_range<A: Into<String>>(field: A) -> RangeFilter`

`fn build_regexp<A: Into<String>, B: Into<String>>(field: A, value: B) -> RegexpFilter`

`fn build_script<A: Into<String>>(script: A) -> ScriptFilter`

`fn build_term<A: Into<String>, B: Into<JsonVal>>(field: A, value: B) -> TermFilter`

`fn build_terms<A: Into<String>, B: Into<Vec<JsonVal>>>(field: A, values: B) -> TermsFilter`

`fn build_type<A: Into<String>>(value: A) -> TypeFilter`

Trait Implementations

`impl ToJson for Filter`

`fn to_json(&self) -> Json`

Derived Implementations

`impl Debug for Filter`

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`