You are currently browsing legacy 5.3 version of documentation. Click here to switch to the newest 6.2 version.
    We can help you with migration to the latest RavenDB
    Contact Us Now
    See on GitHub

    Filter Query Results

    Where - equals 

    // Basic filtering using "whereEquals":
// ====================================

const filteredEmployees = await session
     // Query an index 
    .query({ indexName: "Employees/ByFirstAndLastName" })
     // The filtering predicate
    .whereEquals("FirstName", "Robert")
     // By default AND is applied between both 'where' predicates
    .whereEquals("LastName", "King")
     // Execute the query, send it to the server for processing
    .all();

// Results will include all Employee documents 
// with FirstName equals to 'Robert' AND LastName equal to 'King'
    class Employees_ByFirstAndLastName extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("employees", employee => {
            return {
                FirstName: employee.FirstName,
                LastName: employee.LastName
            };
        });
    }
}
    from index "Employees/ByFirstAndLastName"
where FirstName == "Robert" and LastName == "King"

    Where - numeric Property 

    // Filter with "whereGreaterThan":
// ===============================

const filteredProducts = await session
     // Query an index 
    .query({ indexName: "Products/ByUnitsInStock" })
     // The filtering predicate
    .whereGreaterThan("UnitsInStock", 20)
    .all();

// Results will include all Product documents having 'UnitsInStock' > 20
    class Products_ByUnitsInStock extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("products", product => {
            return {
                UnitsInStock: product.UnitsInStock
            };
        });
    }
}
    from index "Products/ByUnitsInStock"
where UnitsInStock > 20

    // Filter with "whereLessThan":
// ============================

const filteredProducts = await session
     // Query an index 
    .query({ indexName: "Products/ByUnitsInStock" })
     // The filtering predicate
    .whereLessThan("UnitsInStock", 20)
    .all();

// Results will include all Product documents having 'UnitsInStock'< 20
    class Products_ByUnitsInStock extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("products", product => {
            return {
                UnitsInStock: product.UnitsInStock
            };
        });
    }
}
    from index "Products/ByUnitsInStock"
where UnitsInStock < 20

    Where - nested property 

    // Filter by a nested property:
// ============================

const filteredOrders = await session
     // Query a collection
    .query({ collection: "Orders" })
     // Filter by the nested property 'ShipTo.City' from the Order document
    .whereEquals("ShipTo.City", "Albuquerque")
    .all();

// * Results will include all Order documents with an order that ships to 'Albuquerque'
// * An auto-index will be created
    from "Orders"
where ShipTo.City == "Albuquerque"

    Where - multiple values 

    // Filter by multiple values:
// ==========================

const filteredOrders = await session
     // Query an index 
    .query({ indexName: "Orders/ByProductNamesPerOrderLine" })
     // Filter by multiple values 
    .whereEquals("ProductName", "Teatime Chocolate Biscuits")
    .all();

// Results will include all Order documents that contain ALL values in "Teatime Chocolate Biscuits"
    class Orders_ByProductNamesPerOrderLine extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("orders", order => {
            return {
                // Index field 'ProductNames' will contain the product names per Order Line
                ProductNames: order.Lines.map(x => x.ProductName)
            };
        });
    }
}
    from index "Orders/ByProductNamesPerOrderLine"
where ProductNames == "Teatime Chocolate Biscuits"

    Where - in

    Use whereIn when you want to filter by a single value out of multiple given values. 

    // Filter with "whereIn":
// ======================

const filteredEmployees = await session
     // Query an index 
    .query({ indexName: "Employees/ByFirstAndLastName" })
     // The filtering predicate
    .whereIn("FirstName", [ "Robert", "Nancy" ]) 
    .all();

// Results will include all Employee documents that have either 'Robert' OR 'Nancy' in their 'FirstName' field
    class Employees_ByFirstAndLastName extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("employees", employee => {
            return {
                FirstName: employee.FirstName,
                LastName: employee.LastName
            };
        });
    }
}
    from index "Employees/ByFirstAndLastName"
where FirstName in ("Robert", "Nancy")

    Where - containsAny

    Use containsAny to check if an enumeration contains any of the values from the specified list.

    // Filter with "containsAny":
// ==========================

const filteredOrders = await session
     // Query an index 
    .query({ indexName: "Orders/ByProductNames" })
     // The filtering predicate
    .containsAny("ProductNames", ["Ravioli", "Coffee"])
    .all();

// Results will include all Order documents that have either 'Ravioli' OR 'Coffee' in their order
    class Orders_ByProductNames extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("orders", order => {
            return {
                // Index field 'ProductNames' will contain a list of all product names
                ProductNames: order.Lines.flatMap(x => x.ProductName.split(" "))
            };
        });
    }
}
    from index "Orders/ByProductNames"
where ProductNames in ("ravioli", "coffee")

    Where - containsAll

    Use containsAll to check if an enumeration contains all of the values from the specified list.

    // Filter with "containsAll":
// ==========================

const filteredOrders = await session
     // Query an index 
    .query({ indexName: "Orders/ByProductNames" })
     // The filtering predicate
    .containsAll("ProductNames", ["Ravioli", "Pepper"])
    .all();

// Results will include all Order documents that have both 'Ravioli' AND 'Pepper' in their order
    class Orders_ByProductNames extends AbstractJavaScriptIndexCreationTask {
    constructor() {
        super();

        this.map("orders", order => {
            return {
                // Index field 'ProductNames' will contain a list of all product names
                ProductNames: order.Lines.flatMap(x => x.ProductName.split(" "))
            };
        });
    }
}
    from index "Orders/ByProductNames"
where ProductNames all in ("ravioli", "pepper")

    Where - startsWith 

    // Filter with "whereStartsWith":
// ==============================

const filteredProducts = await session
     // Query a collection
    .query({ collection: "Products" })
     // The filtering predicate
    .whereStartsWith("Name", "ch")
    .all();

// * Results will include all Product documents with a name that starts with 'ch'
// * An auto-index will be created
    from "Products" 
where startsWith(Name, "ch")

    Where - endsWith 

    // Filter with "whereEndsWith":
// ===========================

const filteredProducts = await session
     // Query a collection
    .query({ collection: "Products" })
     // The filtering predicate
    .whereEndsWith("Name", "es")
    .all();

// * Results will include all Product documents with a name that ends with 'es'
// * An auto-index will be created
    from Products 
where endsWith(Name, 'ra')

    Where - exists

    Where - filter by ID

    • Once the property used in the whereEquals clause is recognized as an identity property of a given entity type,
      and there aren't any other fields involved in the query predicate, then this query is considered a "Collection Query".

    • Such collection queries that ask about documents with given IDs, or where identifiers start with a given prefix and don't require any additional handling like ordering, full-text searching, etc, are handled directly by the storage engine.

    • This means that querying by ID doesn't create an auto-index and has no extra cost.
      In terms of efficiency, it is the same as loading documents with session.load usage.

    // Filter by id:
// =============

const order = await session
     // Query a collection
    .query({ collection: "Orders" })
     // The filtering predicate
    .whereEquals("id", "orders/1-A")
    .firstOrNull();

// * Results will include the Order document having ID 'orders/1-A'
// * An auto-index is NOT created
    from "Orders"
where id() == "orders/1-A"

    // Filter by whereStartsWith id:
// =============================

const filteredOrders = await session
    // Query a collection
    .query({ collection: "Orders" })
    // The filtering predicate
    .whereStartsWith("id", "orders/1")
    .all();

// * Results will include all Order documents having ID that starts with 'orders/1'
// * An auto-index is NOT created
    from "Orders"
where startsWith(id(), "orders/1")

    related articlesRelated Articles

    Client API

    Indexes

    Querying

    Home / Docs / Indexes / Querying / Filtering