Query Constraints ​

When building queries, Neboa provides you with many different constraints to filter documents.
These constraints are chainable and can be used to build complex queries.

Here we will go over all the constraints available to you and how to use them.

equalTo ​

The equalTo constraint allows you to filter documents by a specific value in a field.

const query = Users.query()
  .equalTo('name', 'John Doe')
  .equalTo('age', 42)

Array values ​

When using the equalTo constraint on an array field, it will check if the array contains the value.

const query = Users.query()
  .equalTo('tags', 'foo')

notEqualTo ​

The notEqualTo constraint allows you to filter documents by a value that is not equal to a specific value in a field.

const query = Users.query()
  .notEqualTo('name', 'John Doe')
  .notEqualTo('age', 42)

Array values ​

When using the notEqualTo constraint on an array field, it will check if the array does not contain the value.

const query = Users.query()
  .notEqualTo('tags', 'foo')

greaterThan ​

The greaterThan constraint allows you to filter documents by a value that is greater than a specific value in a field.

const query = Users.query()
  .greaterThan('age', 42)

greaterThanOrEqualTo ​

The greaterThanOrEqualTo constraint allows you to filter documents by a value that is greater than or equal to a specific value in a field.

const query = Users.query()
  .greaterThanOrEqualTo('age', 42)

lessThan ​

The lessThan constraint allows you to filter documents by a value that is less than a specific value in a field.

const query = Users.query()
  .lessThan('age', 42)

lessThanOrEqualTo ​

The lessThanOrEqualTo constraint allows you to filter documents by a value that is less than or equal to a specific value in a field.

const query = Users.query()
  .lessThanOrEqualTo('age', 42)

containedIn ​

The containedIn constraint is very similar to the equalTo constraint, but it allows you to filter documents by a value that is contained in an array field.

const query = Users.query()
  .containedIn('tags', ['foo', 'bar'])

notContainedIn ​

The notContainedIn constraint is very similar to the notEqualTo constraint, but it allows you to filter documents by a value that is not contained in an array field.

const query = Users.query()
  .notContainedIn('tags', ['foo', 'bar'])

exists ​

The exists constraint allows you to filter documents by a field that exists or does not exist.

const query = Users.query()
  .exists('name')

notExists ​

The notExists constraint allows you to filter documents by a field that does not exist or exists.

const query = Users.query()
  .notExists('name')

matches ​

The matches constraint allows you to filter documents by a field that matches a regular expression.

const query = Users.query()
  .matches('name', /^John/)

doesNotMatch ​

The doesNotMatch constraint allows you to filter documents by a field that does not match a regular expression.

const query = Users.query()
  .doesNotMatch('name', /^John/)

like ​

SQLite does not have a built-in full-text search feature, but Neboa can use LIKE operator to provide a basic search capability.

const query = Users.query()
  .like('name', 'John') // LIKE '%John%'

limit ​

The limit constraint allows you to limit the number of documents returned by the query.

const query = Users.query()
  .limit(10)

skip ​

The skip constraint allows you to skip a number of documents returned by the query.

const query = Users.query()
  .skip(10)

ascending ​

The ascending constraint allows you to sort documents in ascending order by a field.

const query = Users.query()
  .ascending('name')

descending ​

The descending constraint allows you to sort documents in descending order by a field.

const query = Users.query()
  .descending('name')

and ​

The and constraint allows you to combine multiple constraints together.

const query1 = Users.query()
  .equalTo('name', 'John Doe')
  .equalTo('age', 42)

const query2 = Users.query()
  .greaterThan('score', 100)
  .and(query1) // (score > 100) AND (name = 'John Doe' AND age = 42)

or ​

The or constraint allows you to combine multiple constraints together.

const query1 = Users.query()
  .equalTo('name', 'John Doe')
  .equalTo('age', 42)

const query2 = Users.query()
  .greaterThan('score', 100)
  .or(query1) // (score > 100) OR (name = 'John Doe' AND age = 42)

lookup ​

The lookup constraint allows you to lookup documents in another collection.

const query = Users.query()
  .lookup({...})

The lookup method is used for relational data and more complex than the others, therefore it has its own section here.