Filters

You can use the filters interface to filter the search results.

Filters are available for numeric, boolean, string, enum, and geopoint properties. Depending on the type of the property, you can use different operators.

String operators

On string properties it performs an exact matching on tokens so it is advised to disable stemming for the properties you want to use filters on (when using the default tokenizer you can provide the stemmerSkipProperties configuration property).

If we consider the following schema:

const db = await create({
  schema: {
    title: "string",
    tag: "string",
  },
  components: {
    tokenizer: {
      stemming: true,
      stemmerSkipProperties: ["tag"],
    },
  },
});

const results = await search(db, {
  term: "prestige",
  where: {
    tag: "new",
  },
});

The results will contain all documents that contain the word prestige in the title property and have tags property equal to new.

You can also specify a list of string, in this case it will return all documents that contain at least one of the values provided:

const results = await search(db, {
  term: "prestige",
  where: {
    tag: ["favorite", "new"],
  },
});

Number operators

The number properties support the following operators:

Operator	Description	Example
gt	Greater than	year: { gt: 2000 }
gte	Greater than or equal to	year: { gte: 2000 }
lt	Less than	year: { lt: 2000 }
lte	Less than or equal to	year: { lte: 2000 }
eq	Equal to	year: { eq: 2000 }
between	Between two values (inclusive)	year: { between: [2000, 2008] }

const db = await create({
  schema: {
    id: "string",
    title: "string",
    year: "number",
    meta: {
      rating: "number",
      length: "number",
      favorite: "boolean",
      tags: "string",
    },
  },
  components: {
    tokenizer: {
      stemming: true,
      stemmerSkipProperties: ["meta.tags"],
    },
  },
});

const results = await search(db, {
  term: "prestige",
  where: {
    year: {
      gte: 2000,
    },
    "meta.rating": {
      between: [5, 10],
    },
    "meta.length": {
      lte: 60,
    },
  },
});

Boolean operators

For boolean properties, you can simply set the property to true or false:

const results = await search(db, {
  term: "prestige",
  where: {
    "meta.favorite": true,
  },
});

String[] | Number[] | Boolean[] operators

The available operators depend on the type (string, number of boolean) as described in the previous sections. A document matches if at least one of the array elements matches the filter condition.

const db = await create({
  schema: {
    title: "string",
    tags: "string[]",
    editions: "number[]",
    limited: "boolean[]",
  }
});

await insertMultiple(db, [
  {title: "a", tags: ["foo", "bar"], editions: [1990, 2024], limited: [false, false]},
  {title: "b", tags: ["foo"], editions: [1942, 2024], limited: [false, true]},
  {title: "c", tags: ["bar"], editions: [2020], limited: [false]},
])

// Books with tag foo
await search(db, {where: {tags: "foo"}}); // returns  a, b

// Books tagged either as foo or bar
await search(db, {where: {tags: ["foo", "bar"]}}); // returns a, b, c

// Books with a 2024 edition
await search(db, {where: {editions: {eq: 2024}}}); // returns a, b

// Books with a limited edition
await search(db, {where: {limited: true}}); // returns b

Enum operators

The enum properties support the following operators:

Operator	Description	Example
eq	Equal to	genre: { eq: 'drama' }
in	Contained in the given array	genre: { in: ['drama', 'horror'] }
nin	Not contained in the given array	genre: { nin: ['commedy'] }

Enum[] operators

The enum properties support the following operators:

Operator	Description	Example
containsAll	Contains all the given values	genre: { containsAll: ['comedy', 'action'] }

Geosearch

Starting from Orama v2.0.0, you can perform geosearch queries.

Even though the APIs are very simple, we decided to dedicate a separate section for them. This lets us explain the concepts behind the geosearch and how it works with more details.

Read more about geosearch