Advanced Graph Traversal Using Pacer

Brought to you by

Routes

Collections/streams

• Composable
• Lazily-loaded
• Reusable
• Implement Ruby's Enumerable interface

One of Pacer's most fundamental building blocks

Routes

Two phases:

1. Build
2. Execute

Routes

We have seen some basic routes:

• out_e, in_e, both_e

• out_v, in_v, both_v

These routes are used for traversals.

Next, we will look at routes that are used for filtering ...

Filters - Property Match

Filters - Where Condition

g.v.where("type = 'person' and age > 21")

g.e.where("timestamp > :t", {t: (Time.now - 60) } )

 * Safe way to handle user input and avoid injection attacks.

Filters - Block Of Code

# Find vertices with palindromic names
g.v.filter {|v| v[:name] == v[:name].reverse }

Filter each element based on the result of a block of code.

Filters

Property Match

Where Condition

Block of Code

filter(foo: 'a')

where("age > 21")

filter do |v|
    depends_on(v)
end

Fastest

Fast

Slower

Least expressive

expressive

Most

expressive

Exercise

Take a look at the Pacer documentation.

You may find some useful route methods that will help you solve this exercise.

Implement the functions in ex2.rb, until you pass all test cases.

# Return (a route containing) posts 10 or more comments

def trending(posts)



    # Your code goes here ...

    

end

Filters

Filters - Lookahead

# Return (a route containing) posts 10 or more comments

def trending(posts)

    posts.lookahead(min: 10) do |post|
        post.in_e(:IS_ABOUT).out_v(type: 'comment')
    end

end

Filter items based on a traversal

Exercise

Hints:

1. Re-use functions from previous exercises.
2. Before you implement the last function of this exercise, read about negative-lookahead in the lookahead section of the docs.  

Implement the functions in ex3.rb, until you pass all test cases.

is / is_not

is(element)

is_not(element)

Filter based on a single of elements

Filters - By Elements

Filters - Example

# Return followers of followers of the given user.
# 2nd degree only! The result does not include the 
# user or any of their direct followers.
def followers_of_followers(user)

    followers = user.in_e(:FOLLOWS).out_v

    followers
        .in_e(:FOLLOWS).out_v
        .except(followers)
        .is_not(user)

end

Filters

# Return followers of followers of the given user.
# 2nd degree only! The result does not include the 
# user or any of their direct followers.
def followers_of_followers(user)

   
    # Your code goes here ...   

      

end

Filters

# Return followers of followers of the given user.
# 2nd degree only! The result does not include the 
# user or any of their direct followers.
def followers_of_followers(user)

    user.as(:me)
        .in_e(:FOLLOWS).out_v.as(:followers) 
        .in_e(:FOLLOWS).out_v
        .is_not(:me).is_not(:followers)

end

One more improvement ...

The user argument can be either a vertex or a route, and the method will run efficiently.

Exercise

Hints: 

1. Re-use functions from previous exercises.
2. You can implement complex traversals efficiently by combining a number of the advanced filtering techniques we've seen.

Implement the functions in ex4.rb, until you pass all test cases.

What we've seen so far ...

• Basic traversal routes

  • out_e, in_e, out_v, etc.

• Filtering routes
  • Property match, where-condition, block of code

  • lookahead

  • only, except, is, is_not

Next, we will look at advanced traversal routes ...

Traversals - Branching

Traversals - Loops

Example: For a given post in a social network, get its comment, and their comments, and their comments, and their comments, and so on ...

Traversals - Loops

def get_all_comments(post)
    comments = []
    c = post.in_e(:IS_ABOUT).out_v(type: 'comment')

    while (c.count > 0)
        comments += c.as_a
        c = c.in_e(:IS_ABOUT).out_v(type: 'comment')
    end
end

Naive example:

Traversals - Loops

Traversals - Loops

def get_all_comments(post)

    post
    .loop do |comment_or_post|
        comment_or_post
          .in_e(:IS_ABOUT).out_v(type: 'comment')
    end

    .while do |comment, depth| 
        if depth == 0
            :loop
        else depth <= MAX_DEPTH
            :loop_and_emit
        else
            false
        end
    end

end

Exercise

Implement the functions in ex5.rb, until you pass all test cases.

Traversals - Sections

def sample_posts(people)
    posts = []

    people.each do |person|
        posts += person
                  .out_e(:POSTED).in_v(type: 'post')
                  .limit(3).to_a
    end

    return posts
end

Given a route of people, we want to get their posts.

But ... we want to get at most 3 posts per person.

Problem:   Performance overhead of building routes

Goal:         Do the same using a single route

Traversals - Sections

def sample_posts(people, posts_per_person)
    people.as(:person)
          .out_e(:POSTED).in_v(type: 'post')
          .limit_section(:person, posts_per_person)
end

Using as and limit_section ...

• As we've seen before, the as method names an intermediate point in the route.
• Every element that goes through this point of the route "marks a section" of the traversal.
  
• Let's see a picture ...

Traversals - Sections

Traversals - Sections

There are a number of methods that take advantage of sections:

• limit_section

• sort_section

• count_section

• uniq_in_section

The names of these methods are fairly self-descriptive, and you can read more about them in the docs.

Exercise

Implement the functions in ex6.rb, until you pass all test cases.

What's next?

At this point, you know a fair bit about graph traversals and Pacer routes.

Next, we will look at the problem of data modeling, and introduce Pacer extensions.

Extensions & routes go hand in hand:

• Routes let you traverse the graph efficiently.
• Extensions let you write these traversals in your own domain-specific language.