Our RQL (Raven Query Language) allows you to execute all available types of queries and is a part of our JavaScript patching API. Based on SQL, it can be easily assimilated with few additions of our own.

from Orders                                             // select
where Lines.Count > 4                                   // filter
select Lines[].ProductName as ProductNames,             // project
OrderedAt, ShipTo.City                                  

RQL

from Orders as o                                        // select
load o.Company as c                                     // load related data
select {                                                // project using JavaScript
    Name: c.Name.toLowerCase(),                         
    Country: c.Address.Country,
    LinesCount: o.Lines.length
}

RQL

from Orders                                             // select
group by Company                                        // group
where count() > 5                                       // filter
order by count() desc                                   // order
select count() as Count, key() as Company               // project
include Company                                         // side-load related data

Read More

Perform advanced full-text search operations over one or more fields at once with the ability to supply your own custom analyzer.

// return all of the companies
// which one of the words in 'Name' is 'store'
from Companies
where search(Name, 'store')

// return all of the companies
// which one of the words in 'Name' is 'store'
var companies = session
    .Query<Company>
    .Search(x => x.Name, "store")
    .ToList();

// return all of the companies
// which one of the words in 'name' is 'store'
List<Company> companies = session
                .query(Company.class)
                .search("name", "store")
                .toList();

// return all of the companies
// which one of the words in 'name' is 'store'
const companies = await session
    .query({ collection: "companies" })
    .search("name", "store")
    .all();

Read More

Perform calculations such as counts, sums, averages, min and max on aggregated data and split it into defined ranges without a fuss.

In order to execute faceted search a static index is required. It can be as simple as follows:

C#

private class Cameras_ByManufacturerModelCostDateOfListingAndMegapixels :
    AbstractIndexCreationTask<Camera>
{
    public Cameras_ByManufacturerModelCostDateOfListingAndMegapixels()
    {
        Map = cameras => from camera in cameras
            select new
            {
                camera.Manufacturer,
                camera.Model,
                camera.Cost,
                camera.DateOfListing,
                camera.Megapixels
            };
    }
}

Those are all the requirements for faceted search.
Now queries can be executed against all index fields as follows:

// return 3 facet results for cameras 
// using 'Cameras/ByManufacturerModelCostDateOfListingAndMegapixels' index
// - first result will return aggregations (Count) based on 'Manufacturer'
// - second result will return aggregations (Count, Sum) based on 'Cost' 
//   and divided into supplied 'Cost' ranges
// - third result will return aggregations (Count, Min, Max, Average) based on 'Cost'
//   and divided into supplied 'Megapixels' ranges
from index 'Cameras/ByManufacturerModelCostDateOfListingAndMegapixels' 
where Cost between 100 and 300
select 	facet(Manufacturer), 
		facet(Cost < 200, Cost >= 200 and Cost < 400, Cost >= 400 and Cost < 600, Cost >= 600 and Cost < 800, Cost >= 800, sum(Cost)), 
		facet(Megapixels < 3, Megapixels >= 3 and Megapixels < 7, Megapixels >= 7 and Megapixels < 10, Megapixels >= 10, min(Cost), max(Cost), average(Cost))

// return 3 facet results for cameras 
// using 'Cameras/ByManufacturerModelCostDateOfListingAndMegapixels' index
// - first result will return aggregations (Count) based on 'Manufacturer'
// - second result will return aggregations (Count, Sum) based on 'Cost' 
//   and divided into supplied 'Cost' ranges
// - third result will return aggregations (Count, Min, Max, Average) based on 'Cost'
//   and divided into supplied 'Megapixels' ranges
Dictionary<string, FacetResult> facetResults = session
    .Query<Camera, Cameras_ByManufacturerModelCostDateOfListingAndMegapixels>()
    .Where(x => x.Cost >= 100 && x.Cost <= 300)
    .AggregateBy(builder => builder.ByField(x => x.Manufacturer))
    .AndAggregateBy(builder => builder
        .ByRanges(
            camera => camera.Cost < 200m,
            camera => camera.Cost >= 200m && camera.Cost < 400m,
            camera => camera.Cost >= 400m && camera.Cost < 600m,
            camera => camera.Cost >= 600m && camera.Cost < 800m,
            camera => camera.Cost >= 800m)
        .SumOn(x => x.Cost))
    .AndAggregateBy(builder => builder
        .ByRanges(
            camera => camera.Megapixels < 3.0,
            camera => camera.Megapixels >= 3.0 && camera.Megapixels < 7.0,
            camera => camera.Megapixels >= 7.0 && camera.Megapixels < 10.0,
            camera => camera.Megapixels >= 10.0)
        .MinOn(x => x.Cost)
        .MaxOn(x => x.Cost)
        .AverageOn(x => x.Cost))
    .Execute();

Read More

Finding similar documents has never been easier! Use our built-in MoreLikeThis feature to retrieve them.

Let's start by defining an index, where we will index contents of the articles (ArticleBody) using 'StandardAnalyzer' from Lucene and storing the results inside the Lucene index.

C#

public class Articles_ByArticleBody : AbstractIndexCreationTask<Article>
{
    public Articles_ByArticleBody()
    {
        Map = docs => from doc in docs
                      select new
                      {
                          doc.ArticleBody
                      };

        Stores.Add(x => x.ArticleBody, FieldStorage.Yes);
        Analyzers.Add(x => x.ArticleBody, "StandardAnalyzer");
    }
}

At this point everything needed to use MoreLikeThis is done and we can search for our similar articles:

• RQL
• C#

// return all articles
// similar to 'articles/1'
// using 'Articles/ByArticleBody' index
from index 'Articles/ByArticleBody' 
where morelikethis(id() = 'articles/1')

// return all articles
// similar to 'articles/1'
// using 'Articles/ByArticleBody' index
List<Article> articles = session
    .Query<Article, Articles_ByArticleBody>()
    .MoreLikeThis(builder => builder
        .UsingDocument(x => x.Id == "articles/1"))
    .ToList();

Read More

Spatial field can be created from Coordinates (latitude and longitude), or directly from WKT shape using following strategies:

• with BoundingBox or QuadPrefixTree
• Geographical with BoundingBox, GeohashPrefixTree (default) or QuadPrefixTree

RQL itself and our Client API contain built-in methods to help you find the documents with the search areas that can be defined using:

• within (and within radius)
• contains
• disjoin
• intersect
• custom relation to WKT shape

• RQL
• C#
• Java
• Node.js

// return all the companies 
// within radius of 300km 
// from 45 latitude and 4 longitude coordinate
from Companies
where spatial.within(
    spatial.point(Address.Location.Latitude, Address.Location.Longitude), 
    spatial.circle(300, 45, 4))

// return all the companies 
// within radius of 300km 
// from 45 latitude and 4 longitude coordinate
List<Company> companies = session
    .Query<Company>()
    .Spatial(
        factory => factory
            .Point(    
                x => x.Address.Location.Latitude,
                x => x.Address.Location.Longitude),
        criteria => criteria.WithinRadius(300, 45, 4))
    .ToList();

// return all the companies 
// within radius of 300km 
// from 45 latitude and 4 longitude coordinate
List<Company> companies = session
                .query(Company.class)
                .spatial(
                        new PointField("address.location.latitude", "address.location.longitude"),
                        factory -> factory.withinRadius(300, 45, 4))
                .toList();

// return all the companies 
// within radius of 300km 
// from 45 latitude and 4 longitude coordinate
const companies = await session
    .query({ collection: "companies" })
    .spatial(
        new PointField("address.location.latitude", "address.location.longitude"),
        factory => factory.withinRadius(300, 45, 4))
    .all();

Read More

Update documents directly on the server-side using our integrated JavaScript-based patching API, a part of RQL syntax.

Filter-out an array item

from Orders 
update { 
    this.Lines = this.Lines.filter(l => l.Product != 'products/1-A');
}

Denormalize the company name

from Orders as o
load o.Company as c
update { 
    o.CompanyName = c.Name;
}

Use the JavaScript to patch

from index 'Orders/Totals' as i
where i.Total > 10000
load i.Company as c
update { 
    i.LowerName = c.Name.toLowerCase();
}

Read More

Our RQL (Raven Query Language) allows you to execute graph pattern match queries, while re-using existing knowledge and expertise of RQL.

RQL

// query for an order with specific Id. 
match (Orders as o where id() = 'orders/825-A')

RQL

// fetch a specific order, go through its Order Lines and fetch all the ordered products
// in the SELECT clause include the order, its order-line and a product for each order line

match (Orders  as o where id() = 'orders/825-A')-[Lines as l select Product]->(Products as p) 
select o,l,p

RQL

// fetch a specific order, go through its Order Lines and fetch ordered products where the product name is 'Chang'

match (Orders  as o where id() = 'orders/825-A')-[Lines where ProductName = 'Chang' select Product]->(Products as p) 
select p.Name as Name

RQL

// fetch a management hierarchy for each employee.
// this is a recursive query, so its output will include arbitrary-length hierarchy chains of employee -> manager -> manager -> manager

match (Employees as e)-recursive { [ReportsTo]->(Employees as boss) }

RQL

// fetch a management hierarchy for specific employee.
// this is a recursive query with a 'longest' option, so it would retrieve the longest possible hierarchy chain of managers

match (Employees as e where id() = 'employees/7-A')-recursive as n (longest) { [ReportsTo as m]->(Employees as intermediary) }-[ReportsTo]->(Employees as boss)
select e.FirstName as Employee, n.m as MiddleManagement, boss.FirstName as Boss

RQL

// fetch all orders that have the products that have 'cost per unit' more than 200
// note that this query considers index entries as nodes in the graph

with {from index 'Orders/Totals'} as o
with {from index 'Product/Search'} as p
match (o)-[Lines where PricePerUnit > 200 select Product]->(p)

RQL

// fetch all beers, their styles and the breweries that make them
match (Breweries as brewery)<-[Brewery]-(Beers as beer)-[Style]->(BeerStyles as beerStyle)

// the query above and the one below are equivalent
match (Beers as beer)-[Style]->(BeerStyles as beerStyle) and (beer)-[Brewery]->(Breweries as brewery)

RQL

// a query that checks the permissions that of a certain user to access an issue and retrieves a list of those issues names
// the permissions can be either direct or come from a 'permissions group' that inherit permissions from each other
// note: the switch 'all' used as the recursion parameter means that we will iterate all possible permutations of the hierarchy to try and find a match

with {  from Users where id() = 'users/234'   }   as u

match   (u)<-[Users]-(Issues as i)  or   //check direct permissions
        (Issues as i)-[Groups]->(Groups as direct)-recursive (0, all) { [Parents]->(Groups) }-[Parents]->(Groups as g)<-[Groups]-(u) or  //check hierarchical group permissions
        (Issues as i)-[Groups]->(Groups as direct)<-[Groups]-(u)  //check direct group permissions

select  i.Name as Issue, 
        u.Name as User

Read More