Indexes: Map Indexes

Map indexes, sometimes referred to as simple indexes, contain one (or more) mapping functions that indicate which fields from the documents should be indexed. They indicate which documents can be searched by which fields.

These mapping functions are LINQ-based functions and can be considered the core of indexes.

What Can be Indexed

You can:

• index single fields
• combined multiple fields together
• index partial field data
• index nested data
• index fields from related documents
• index fields from multiple collections
• ...and more.

Indexing Single Fields

Let's create an index that will help us search for Employees by their FirstName, LastName, or both.

• First, let's create an index called Employees/ByFirstAndLastName

class Employees_ByFirstAndLastName extends AbstractIndexCreationTask {
    // ...
}

• The next step is to create the indexing function itself. This is done by setting the map field with mapping function in the constructor.

constructor() {
    super();

    this.map = `docs.Employees.Select(employee => new {     
        FirstName = employee.FirstName,     
        LastName = employee.LastName 
    })`;
}

• The final step is to deploy it to the server and issue a query using the session Query method:

const employees1 = await session.query({ indexName: "Employees/ByFirstAndLastName" })
    .whereEquals("FirstName", "Robert")
    .all();

const employees2 = await session.query({ indexName: "Employees/ByFirstAndLastName" })
    .whereEquals("FirstName", "Robert")
    .all();

from index 'Employees/ByFirstAndLastName'
where FirstName = 'Robert'

from employee in docs.Employees
select new
{
	Age = employee.Age
}

from employee in docs.Employees
select new
{
	Age = employee.Age.ToString()
}

from employee in docs.Employees
select new
{
	FirstName = employee.firstName,
	LastName = employee.lastName
}

Combining Multiple Fields Together

Since each index contains a LINQ function, you can combine multiple fields into one.

Example I

class Employees_ByFullName extends AbstractIndexCreationTask {
    constructor() {
        super();

        this.map = `docs.Employees.Select(employee => new {     
            FullName = (employee.FirstName + " ") + employee.LastName 
        })`;
    }
}

const employees = await session
    .query({ indexName: "Employees/ByFullName" })
    .whereEquals("FullName", "Robert King")
    .ofType(Employee)
    .all();

from index 'Employees/ByFullName'
where FullName = 'Robert King'

Example II

class Employees_Query extends AbstractIndexCreationTask {
    constructor() {
        super();

        this.map = `docs.Employees.Select(employee => new {     
            Query = new [] { 
                employee.FirstName, 
                employee.LastName, 
                employee.Title, 
                employee.Address.City 
            } 
        })`;

        this.index("Query", "Search");
    }
}

const employees = await session
    .query({ indexName: "Employees/Query" })
    .search("Query", "John Doe")
    .ofType(Employee)
    .all();

from index 'Employees/Query'
where search(Query, 'John Doe')

Indexing Partial Field Data

Imagine that you would like to return all employees that were born in a specific year. You can do it by indexing Birthday from Employee in the following way:

class Employees_ByBirthday extends AbstractIndexCreationTask {

    constructor() {
        super();

        this.map = `docs.Employees.Select(employee => new {     
            Birthday = employee.Birthday 
        })`;
    }
}

const startDate = new Date(1963, 1, 1);
const endDate = new Date(1963, 12, 31, 23, 59, 59, 999);
const employees = await session
    .query({ indexName: "Employees/ByBirthday" })
    .whereBetween("Birthday", startDate, endDate)
    .ofType(Employee)
    .all();

from index 'Employees/ByBirthday '
where Birthday between '1963-01-01' and '1963-12-31T23:59:59.9990000'

RavenDB gives you the ability to extract field data and to index by it. A different way to achieve our goal will look as follows:

class Employees_ByYearOfBirth extends AbstractIndexCreationTask {

    constructor() {
        super();

        this.map = `docs.Employees.Select(employee => new {     
            YearOfBirth = employee.Birthday.Year
        })`;
    }
}

const employees = await session
    .query({ indexName: "Employees/ByYearOfBirth" })
    .whereEquals("YearOfBirth", 1963)
    .ofType(Employee)
    .all();

from index 'Employees/ByYearOfBirth'
where YearOfBirth = 1963

Indexing Nested Data

If your document contains nested data, e.g. Employee contains Address, you can index on its fields by accessing them directly in the index. Let's say that we would like to create an index that returns all employees that were born in a specific Country:

class Employees_ByCountry extends AbstractIndexCreationTask {

    constructor() {
        super();

        this.map = `docs.Employees.Select(employee => new {     
            Country = employee.Address.Country 
        })`;
    }
}

const employees = await session
    .query({ indexName: "Employees/ByCountry" })
    .whereEquals("Country", "USA")
    .ofType(Employee)
    .all();

from index 'Employees/ByCountry'
where Country = 'USA'

If a document relationship is represented by the document's ID, you can use the LoadDocument method to retrieve such a document. More about it can be found here.

Indexing Multiple Collections

Read the article dedicated to Multi-Map indexes here.