The query function to provides you with a convenient, fluent interface to fetch streams and non-streams database records.

Entries Function

Because entries are more common than raw querying this documentation will assume you are using entries though methods are interchangeable.

The Query Function

The query function starts a model criteria query for database records that are not powered by Streams though it works all the same for Streams powered database records.

You can start a query from a database table.

{% set results = query()
    .where('active', true)
    .get() %}

Or a model:

{% set results = query('App\Example\TestModel')
    .where('active', true)
    .get() %}

Retrieving Results


If you just need to retrieve a single entry, you may use the first method. This method will return a single decorated entry:

{% set user = entries('users').where('display_name', 'Ryan Thompson').first() %}


The get method returns all of the results of the query.

{% set users = entries('posts', 'categories')
    .orderBy('name', 'ASC')
    .get() %}


The find method allows you to return a single record by it's ID.

{% set user = entries('users').find(request_segments()|last) %}


The findBy by method allows you to find a single query result by a column and value.

{% set admin = entries('roles', 'users').findBy('slug', 'admin') %}

You can also suffix the function name with the CamelCase of the column or field_slug:

{% set admin = entries('roles', 'users').findBySlug('admin') %}


The paginate method returns the results as a pagination object.

{% set paginator = entries('posts').paginate(limit = 15) %}

{% for post in paginator %}
        {{ post.title }}
{% endfor %}

{{ paginator.links|raw }}

Appending Pagination

You can append the pagination query data included in your pagination links by using the appending method:

{{ paginator.appends(request_all()).links|raw }}



The cache method sets the cache TTL in seconds for the query when database caching is enabled.

Database Cache

When enabled, database cache has a default TTL. The cache method is an override.

{% set books = entries('library', 'books').cache(300).get() %}


The fresh method forces non-cached results to be returned.

Database Cache

{% set books = entries('library', 'books').fresh().get() %}


The model criteria also provide a variety of aggregate methods such as count, max, min, avg, and sum. You can call any of these methods after constructing your query.


The count method returns the total number of query results.

{% set activated = entries('users').where('activated', true).count() %}


The sum method returns the sum of the column value.

{% set orders = entries('store', 'orders').where('status', 'complete').sum('subtotal') %}


The max method returns the highest column value.

{% set mostExpensive = entries('store', 'products').where('enabled', true).max('price') %}


The min method returns the lowest column value.

{% set leastExpensive = entries('store', 'products').where('enabled', true).min('price') %}


The avg method returns the average value of the column.

{% set meanPrice = entries('store', 'products').where('enabled', true).avg('price') %}

Where Clauses

The where method adds a where clauses to the query. The most basic call to where requires three arguments. The first argument is the name of the column. The second argument is an operator, which can be any of the database's supported operators. Finally, the third argument is the value to evaluate against the column.


You may chain where constraints together as well as add or where clauses to the query.

{% set users = entries('users').where('votes', '>=', 100).get() %}

You can also assume = and pass only the column and value.

{% set users = entries('users').where('votes', 0).get() %}


{% set = users = entries('users')
    .where('votes', '>', 100)
    .orWhere('name', 'John Doe')
    .get() %}

Similarly, you can also assume = and pass only the column and value.

{% set = users = entries('users')
    .where('votes', 0)
    .orWhere('name', 'John Doe')
    .get() %}


The whereColumn method may be used to test two values with an operator.

{% set users = entries('users').whereColumn('updated_at', '>', 'created_at').get() %}

Similarly to where, you can also assume = and pass only the column and value.

{% set users = entries('users').whereColumn('updated_at', 'created_at').get() %}


The whereBetween method verifies that a column's value is between two values.

{% set users = entries('users').whereBetween('votes', [1, 100]).get() %}


The whereNotBetween method verifies that a column's value lies outside of two values.

{% set users = entries('users').whereNotBetween('votes', [25, 50]).get() %}


The whereIn method verifies that a given column's value is contained within the given array.

{% set users = entries('users').whereIn('id', [1, 2, 3]).get() %}


The whereNotIn method verifies that a given column's value is not contained within the given array.

{% set users = entries('users').whereNotIn('id', [1, 2, 3]).get() %}


The whereNull method verifies that the value of the given column is NULL.

{% set users = entries('users').whereNull('updated_at').get() %}


The whereNotNull method verifies that the column's value is not NULL.

{% set users = entries('users').whereNotNull('updated_at').get() %}


The whereDate method may be used compare a column's value against a date.

{% set users = entries('users').whereDate('created_at', '>=', '2009-10-10').get() %}

Similar to where you may omit the operator and simply pass the column and value.

{% set users = entries('users').whereDate('created_at', '>=', '2009-10-10').get() %}


The whereMonth method may be used compare a column's value against a specific month of an year.

{% set users = entries('users').whereMonth('created_at', '>', '9').get() %}

Similar to where you may omit the operator and simply pass the column and value.

{% set users = entries('users').whereMonth('created_at', '10').get() %}


The whereYear method may be used compare a column's value against a specific year.

{% set users = entries('users').whereYear('created_at', '>', '9').get() %}

Similar to where you may omit the operator and simply pass the column and value.

{% set users = entries('users').whereYear('created_at', '10').get() %}

JSON Where Clauses

Laravel supports querying JSON column types on databases that provide support for JSON column types. You can leverage this the in the criteria queries too. Currently, this includes MySQL 5.7+ and Postgres. To query a JSON column, use the -> operator:

{% set users = entries('users')
    .where('options->language', 'en')
    .get() %}

{% set users = entries('users')
    .whereIn('preferences->dining->meal', ['fish', 'steak'])
    .get() %}

Ordering, Grouping, Limit, & Offset

The Streams Platform supports a number of Laravel methods for ordering, grouping, limit, and offsetting records.


The orderBy method allows you to sort the result of the query by a given column.

{% set users = entries('users').orderBy('name', 'desc').get() %}


The inRandomOrder method may be used to sort the query results randomly. For example, you may use this method to fetch a random record.

{% set user = entries('users').inRandomOrder().first() %}


The groupBy method can be used to group the query results.

{% set users = entries('users').groupBy('category').get() %}


The having method is used often in conjunction with the groupBy method.

{% set users = entries('users')
    .having('account_id', '>', 100)
    .get() %}


The skip method is an alias for offset.

{% set users = entries('users').skip(10).get() %}


The offset method skips a number of results from the query.

{% set users = entries('users').offset(10).get() %}


The take method is an alias for limit.

{% set users = entries('users').take(5).get() %}


The limit method specifies the number of results to return.

{% set users = entries('users').limit(5).get() %}


@todo - Link to searchable models or searchable streams flag or both


The search method returns a new search criteria instance which can be used just like the entry and eloquent criteria.

{% set results = entries('users')
    .get() %}

You can also continue to manipulate the query after searching.

{% set results = entries('users')
    .where('active', true)
    .get() %}