Advanced Data Modeling Using Pacer

Brought to you by

Traversing Extended Routes

def orders
    self.out_e(:PURCHASED).in_v(type: "Order")
end

Consider our Customer extension.

Instead of the following route extension method

def orders
    self.out_e(:PURCHASED).in_v(NorthWind::Order)
end

We can define

* Assuming we have created a NorthWind::Order extension.

Now, we can traverse the graph by chaining extension methods:

# Get a customer from the graph
c = g.v(NorthWind::Customer).first

# Get their orders
c.orders

# Chain the result (the `Order` extension has a 
# `products` route extension method).
c.orders.products

# If all of our extensions are returning extended routes,
# our traversals start looking like this:
c.orders.products.categories.uniq

Traversing Extended Routes

Exercise

Go over all the extensions you've created, and make sure that extension methods return extended routes.

category = g.v(NorthWind::Category).first

category.products

category.products.orders.customers

# And even a slightly more complex traversal ...
g.v(NorthWind::Customer)
   .lookahead(max: 1) do |c| 
      c.orders.employees.uniq
   end 
.uniq

When you're done, try to run some traversals in the IRB.

For example:

Properties

Instead of getting/setting properties as follows:

jruby-1.7.18 :018 > e = g.v(Employee).first
 => #<V[n202] Michael Suyama, Sales Representative>

jruby-1.7.18 :019 > e[:title] = "Senior Sales Representative"
 => "Senior Sales Representative"

jruby-1.7.18 :020 > e[:title]
 => "Senior Sales Representative"

We can define properties as vertex extensions

  def title
    self[:title]
  end

  def title=(new_title)
    self[:title] = new_title
  end

Properties

And use them

jruby-1.7.18 :021 > e = g.v(Employee).first
 => #<V[n202] Michael Suyama, Senior Sales Representative>

jruby-1.7.18 :022 > e.title = "Sales Representative"
 => "Sales Representative"

jruby-1.7.18 :023 > e.title
 => "Sales Representative"

Properties

# We don't actually store a `name` property.
# Instead, we compute it on demand.

def name
    "#{self[:firstName]} #{self[:lastName]}"
end

Simple technique that leads to slightly cleaner code:

e[:title]
e[:title] = 'Boss'

e.title
e.title = 'Boss'

VS.

Properties that are computed on-demand

Exercise

• Add a name property to the Product extension.
• The property methods (name and name=) should get/set the underlying companyName property.

After reloading the code, you should be able to do

product = g.v(Product).first

# Test the getter
name = product.name

# Test the setter
product.name = 'foo'

Edge Extensions

Let's look at how orders are stored:

jruby-1.7.18 :205 > o = g.v(Order).first
 => #<V[n819] Order 10853>

jruby-1.7.18 :206 > o.out_e
#<E[e1589]:n819-PRODUCT-n108>

jruby-1.7.18 :207 > o.out_e(:PRODUCT).properties
{"unitPrice"=>62.5, "quantity"=>10.0}

Essentially, the edge from an Order to a Product serves as an order item:

Edge Extensions

Create an edge extension, in a file called order_item.rb

module NorthWind
    module OrderItem
        module Edge  # Containing Edge extension methods

	    def order
		self.out_vertex(NorthWind::Order)
	    end

	    def product
		self.in_vertex(NorthWind::Product)
	    end

	    # ...
	end
    end
end

Edge Extensions

Use the extension

jruby-1.7.18 :207 > load 'order_item.rb'
 => true

jruby-1.7.18 :208 > o = g.v(Order).first
 => #<V[n819] Order 10853>

jruby-1.7.18 :209 > o.out_e(OrderItem)
#<E[e1589]:10.0 units of Carnarvon Tigers at 62.5$/unit>
Total: 1
 => #<outE -> E>

jruby-1.7.18 :210 > o.out_e(OrderItem).first.order
 => #<V[n819] Order 10853>

jruby-1.7.18 :211 > o.out_e(OrderItem).first.product
 => #<V[n108] Carnarvon Tigers, 62.5$>

Exercise

Add the following edge extension methods to OrderItem:

• display_name
• quantity property getter and setter
• price property getter and setter

Edge Extensions

As you might expect, we can define which edges can be extended by OrderItem

module NorthWind
    module OrderItem

        # Extend only edges whose label is PRODUCT
        def self.route_conditions(graph)
            :PRODUCT
    	end

        # ...

Edge Extensions

We can also create route extension methods.

module NorthWind
    module OrderItem

        # ...

        module Route

            def products
        	self.in_v(NorthWind::Product)
            end

            # ...
        end
       
        # ...

Edge Extensions

Use the products extensions method on a route of order items:

# Get (a route containing) a few order items
items = g.e(NorthWind::OrderItem).limit(3)

# And their products
items.products

Exercise

Add the orders route extensions method to OrderItem.

• Return a route of vertices
• Extended by the Order extension

Edge Extensions

NOTE: Although Pacer supports edge extensions, we recommend to keep your edges property-free, if possible.

Indexing

Index properties frequently used for searching.

jruby-1.7.18 :068 > g.v(type: 'foo')
Total: 0
 => #<GraphV -> V-Property(type=="foo")>

jruby-1.7.18 :069 > g.create_key_index :type

jruby-1.7.18 :070 > g.v(type: 'foo')
Total: 0
 => #<V-Index(type: "foo")>

Create an index on the type property:

What's next?

We will see a demo of a full web application, backed by a graph database.

In this demo, we will

• Use Pacer with Neo4j
• Expose our traversals as a web API, using Sinatra