numericFilters

Type: list of strings

Engine default: []

Parameter syntax

'numericFilters' => [
  'numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value',
  'attribute:lower_value TO higher_value',
  ...
]

numericFilters: [
  'numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value',
  'attribute:lower_value TO higher_value',
  ...
]

numericFilters: [
  'numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value',
  'attribute:lower_value TO higher_value',
  ...
]

'numericFilters': [
  'numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value',
  'attribute:lower_value TO higher_value',
  ...
]

numericFilters = [
  "numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value",
  "attribute:lower_value TO higher_value"
]

numericFilters {
    and {
        // "numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value"
        comparison("attribute", NumericOperator.Less, 0f)
        comparison("attribute", NumericOperator.LessOrEquals, 0f)
        comparison("attribute", NumericOperator.Equals, 0f)
        comparison("attribute", NotEquals, 0f)
        comparison("attribute", Greater, 0f)
        comparison("attribute", GreaterOrEquals, 0f)

        comparison("attribute", GreaterOrEquals, 0f, isNegated = true) // Negate a numeric filter
    }
    or {
        // "attribute:lowerBound TO upperBound"
        range("attribute", 0..10)
        range("attribute", 0f, 10f)
    }
}

.NumericFilters(@"
  numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value,
  attribute:lower_value TO higher_value
")

.setNumericFilters(Arrays.asList(
  "numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value",
  "attribute:lower_value TO higher_value",
  ...
))

opt.NumericFilter("numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value")
opt.NumericFilter("attribute:lower_value TO higher_value")

numericFilters = Some(Seq(
  "numeric_attribute [= | != | > | >= | < | <=](#numeric-comparisons) numeric_value",
  "attribute:lower_value TO higher_value"
))

Can be used in these methods:
search, browseObjects, deleteBy, searchForFacetValues, generateSecuredApiKey, addApiKey, updateApiKey search, browse_objects, delete_by, search_for_facet_values, generate_secured_api_key, add_api_key, update_api_key search, browseObjects, deleteBy, searchForFacetValues, generateSecuredApiKey, addApiKey, updateApiKey search, browse_objects, delete_by, search_for_facet_values, generate_secured_api_key, add_api_key, update_api_key search, browse, deleteBy, searchForFacetValues, generateSecuredApiKey, addAPIKey, updateAPIKey search, browseObjects, deleteObjectBy, searchForFacetValues, generateSecuredApiKey, addApiKey, updateApiKey Search, Browse, DeleteBy, SearchForFacetValues, GenerateSecuredApiKey, AddApiKey, UpdateApiKey Search, browse, deleteBy, searchForFacetValues, generateSecuredApiKey, addApiKey, updateApiKey Search, BrowseObjects, DeleteBy, SearchForFacetValues, GenerateSecuredAPIKey, AddAPIKey, UpdateAPIKey search, browse index, delete by, search into facet values, generateSecuredApiKey, add key, update key

See code examples

About this parameter

Filter on numeric attributes.

In most cases, use the filters parameter instead of numericFilters since filters has a more straightforward, SQL-like syntax and supports both filters and facets. However, sometimes you may want to combine filters and numericFilters in the same search.

Numeric comparisons

Format: ${attributeName} ${operator} ${operand}
Example: inStock = 1.

These operatores are supported: <, <=, =, !=, >=, and >.

Numeric range

Format: ${attributeName}:${lowerBound} TO ${upperBound}
Example: price:5.99 TO 100

${lowerBound} and ${upperBound} must be numeric. Both bounds are included in the range.

Combining `filters` and `numericFilters`

As for facetFilters, you can also combine filters and numericFilters. For example:

Copy
index.search('',{
  filters:'("county:Maricopa" OR "county:Pima")',
  numericFilters:["employees > 500"]
});

Which is the equivalent of saying “List all organizations with more than 500 employees in Maricopa OR Pima county”

Usage notes

No boolean operators: you can’t use boolean operators like AND and OR.
Multiple filters: if you specify multiple filters, they’re interpreted as a conjunction (AND). If you want to use a disjunction (OR), use a nested array.
Supported values: you can use positive or negative numbers with an absolute value of up to 4611686018427387.
Precision limit: numeric filters support up to the third decimal point. Digits after the fourth decimal point are lost when filtering.

Examples

Apply numeric filters on a search query

Copy

1
2
3
4
5
6
7
8
9
$results = $index->search('query', [
  'numericFilters' => [
    [
      "inStock = 1",
      "deliveryDate < 1441755506"
    ],
    "price < 1000"
  ]
]);

1
2
3
4
5
6
7
8
9
10
11
index.search('query', {
  numericFilters: [
    [
      'inStock = 1',
      'deliveryDate < 1441755506'
    ],
    'price < 1000'
  ]
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
7
8
9
results = index.search('query', {
    'numericFilters': [
        [
            "inStock = 1",
            "deliveryDate < 1441755506"
        ],
        "price < 1000"
    ]
})

1
2
3
4
5
6
7
8
9
10
11
let query = Query("query")
  .set(\.numericFilters, to: [
    .or("inStock = 1", "deliveryDate < 1441755506"),
    "price < 1000"
  ])

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
val query = query("query") {
    numericFilters {
        or {
            comparison("inStock", Equals, 0f)
            comparison("deliveryDate", Less, 1441755506)
        }
        and {
            comparison("price", Less, 1000)
        }
    }
}

index.search(query)

1
2
3
4
5
6
7
8
index.Search<Book>(new Query("query")
{
    NumericFilters = new List<List<string>> 
    { 
      new List<string> { "inStock = 1", "deliveryDate < 1441755506"  },
      new List<string> { "price < 1000" }
    };
});

1
2
3
4
5
6
7
8
9
10
11
index.search(
  new Query("query").setNumericFilters(
          Arrays.asList(
                  Arrays.asList(
                          "inStock = 1",
                          "deliveryDate < 1441755506"
                  ),
                  Collections.singletonList("price < 1000")
          )
  )
);

1
2
3
4
5
6
7
8
9
10
11
12
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    numericFilters = Some(Seq(
      Some(Seq(
        "inStock = 1",
        "deliveryDate < 1441755506"
      )),
      "price < 1000"
    ))
  )
}

[["inStock = 1", "deliveryDate < 1441755506"], "price < 1000"] translates as (inStock = 1 OR deliveryDate < 1441755506) AND price < 1000

Did you find this page helpful?