Arel: Introduction to the Ruby Relational Algebra Library

Arel: Ruby Relational Algebra
Bryan Helmkamp
CTO, Efﬁciency 2.0
@brynary

Arel http://bit.ly/ggrc-arel brynary brynary.com

Slides Twitter My blog

Agenda
1. What is Arel?
2. Relational Algebra 101
3. Arel with ActiveRecord 3
4. Arel under the Hood
5. Future Possibilities


What is Arel?
*

* Mermaids do not query databases.
(Thanks, Carl)


What is Arel?
• An object-oriented interpretation of
relational algebra in Ruby
• Written by Nick Kallen (Twitter)
• First commit: December 30, 2007
• Not an ORM!
• http://magicscalingsprinkles.wordpress.com/2010/01/28/why-i-wrote-arel/


ActiveRecord 3

Arel

Algebra Engines

AR Connection Adapters

SQL Database


Relational Algebra 101


What’s a Relation?
{ id: int, name: string, city: string } 
{ 1,       “Francis”,    “NYC”        }
{ 2,       “Trotter”,    “Philly”     }
{ 3,       “Gianni”,     “LA”         }
{ 4,       “Josh”,       “NYC”        }


Header
{ 1,       “Francis”,    “NYC”        }
{ 2,       “Trotter”,    “Philly”     }
{ 3,       “Gianni”,     “LA”         }
{ 4,       “Josh”,       “NYC”        }


Tuples
{ 1,       “Francis”,    “NYC”        }
{ 2,       “Trotter”,    “Philly”     }
{ 3,       “Gianni”,     “LA”         }
{ 4,       “Josh”,       “NYC”        }


Core Operations
• Selection • Union
• Projection • Intersection
• Join • Difference


Core Operations
•Selection • Union


Core Operations
•Projection • Intersection


Core Operations
•Join • Difference


Core Operations
• Selection •Union
• Projection •Intersection
• Join •Difference


Closure!
relation = Rubyist.scoped
# => ActiveRecord::Relation

relation = relation.where(:city => "nyc")

relation = relation.joins("JOIN cities ON cities.id = city_id")

relation = relation.limit(1)

relation.to_sql
# => SELECT * FROM rubyists
     JOIN cities ON cities.id = city_id
     WHERE (city_id = 1) LIMIT 1


Arel with ActiveRecord
(“What’s in it for me today?”)


Original: Hash queries

Rubyist.find(:all, :conditions => {
  :city => "NYC",
  :thirsty => true
})


Rails 2.1: Named scopes
class Rubyist < ActiveRecord::Base
  named_scope :nycrb, :conditions => {
    :city => "NYC"
  }
end

Rubyist.nycrb.class
# => ActiveRecord::NamedScope::Scope


Rails 3.0: Relations

Rubyist.where(:city => "NYC")

Rubyist.where(:city => "NYC").class


Chainable and Reusable

Rubyist.where(:city => "NYC").
  where(:thirsty => true)

nycrb = Rubyist.where(:city => "NYC")
nycrb.order("id DESC").limit(10)


Lazy
# Controller
class RubyistsController
  def nycrb
    @nycrb = Rubyist.where(:city => "NYC")
  end
end

<!‐‐ View ‐‐>
<ul>
  <% @nycrb.each do |user| %>
    <li><%= user.name %></li>
  <% end %>
</ul>


Lazy
# Controller
  def nycrb
  end
end Query does not run yet

<!‐‐ View ‐‐>
<ul>
  <% end %>
</ul>


Lazy
# Controller
  def nycrb
  end
end

SELECT * FROM users WHERE city = 'NYC'
<!‐‐ View ‐‐>
<ul>
  <% end %>
</ul>


Lazy
# Controller
  def nycrb
  end
end

<!‐‐ View ‐‐>
<ul>
  <% cache("nycrb_people") do %>
    <% @nycrb.each do |user| %>
      <li><%= user.name %></li>
    <% end %>
  <% end %>
</ul>

Lazy
# Controller
  def nycrb
  end
end

<!‐‐ View ‐‐> Cache hit
<ul>
      <li><%= user.name %></li>
    <% end %>
  <% end %>
</ul>

Lazy
# Controller
  def nycrb
  end
end

<!‐‐ View ‐‐>
<ul> Block is not run
      <li><%= user.name %></li>
    <% end %>
  <% end %>
</ul>

Lazy
# Controller
  def nycrb
  end
end

<!‐‐ View ‐‐>
<ul> SELECT never run
      <li><%= user.name %></li>
    <% end %>
  <% end %>
</ul>

New Finder Methods
• where • offset

• having • joins

• select • includes

• group • lock

• order • readonly

• limit • from


Quacks like ActiveRecord::Base
• new(attributes) • delete(id_or_array)

• create(attributes) • delete_all

• create!(attributes) • update(ids, updates)

• ﬁnd(id_or_array) • update_all(updates)

• destroy(id_or_array) • exists?

• destroy_all


Example

class Rubyist
  scope :nycrb, where(:city => "NYC")
end


Example

class Rubyist
  self.scope(:nycrb, self.where(:city => "NYC"))
end


Example

Rubyist.scope :nycrb, 
  Rubyist.where(:city => "NYC")


Example

nycrb = Rubyist.where(:city => "NYC")
Rubyist.scope :nycrb, nycrb


def self.scope(name, scope_options = {}, &block)
  name = name.to_sym
  valid_scope_name?(name)

  extension = Module.new(&block) if block_given?

  scopes[name] = lambda do |*args|
    options = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options

    relation = if options.is_a?(Hash)
      scoped.apply_finder_options(options)
    elsif options
      scoped.merge(options)
    else
      scoped
    end

    extension ? relation.extending(extension) : relation
  end

  singleton_class.send(:redefine_method, name, &scopes[name])
end


def self.scope(name, scope_options = {})

    if scope_options.is_a?(Hash)
      scoped.apply_finder_options(scope_options)
    elsif scope_options
      scoped.merge(scope_options)
    else
      scoped
    end
  end

end


def self.scope(name, scope_options = {})

    scoped.merge(scope_options)
  end

end


class Rubyist
  def self.nycrb
    where(:city => "NYC")
  end
end


Arel Under the Hood


Arel Objects
City.arel_table
# => <Arel::Table>

City.arel_table[:population]
# => <Arel::Sql::Attributes::Integer population>

City.arel_table[:population].gt(750_000)
#=> <Arel::Predicates::GreaterThan>


Exposing the Attributes

class ActiveRecord::Base
  def self.[](column_name)
    arel_table[column_name]
  end
end


Arel Predicates

City.where(City[:population].gt(750_000))


Arel Operators
• eq • matches
• not_eq • not_matches
• lt • in
• lteq • not_in
• gt • *_any
• gteq • *_all

Compound Predicates
hometown  = City[:name].eq("Detroit")
big       = City[:population].gt(750_000)
awesome   = City[:awesome].eq(true)

City.where(hometown.or(big.and(awesome))).to_sql
# => SELECT * FROM cities
     WHERE name = 'Detroit'
        OR (population > 750000 AND awesome = 't')


Future
Possibilities
`
ActiveRecord 3.1? 4.0?


Map any relation to a class
class Signup < ActiveRecord::Base
  users = Arel::Table.new(:users)
  emails = Arel::Table.new(:emails)

  set_relation users_table.
    join(emails).
    on(users[:email_id].eq(emails[:id]))
end


May any relation as an association
class User
  orders = Arel::Table.new(:orders)

  last_orders_by_user = orders.
    group(orders[:user_id]).
    project(orders[:id].maximum.as(:id))

  has_one :last_order, orders.
    where(orders[:id].in(last_orders_by_user[:id]))
end

User.includes(:last_order).each do |user|
  # ...
end

Custom Engines


ActiveRecord 3

Arel
Engines
Algebra SQL Memory

AR Connection Adapters

SQL Database


class Arel::Sql::Engine
      def initialize(ar = nil)
        @ar = ar
      end

      def connection
        @ar ? @ar.connection : nil
      end

      def create(relation)
        # ...
        connection.insert(relation.to_sql(false), nil, relation.primary_key)
      end

      def read(relation)
        rows = connection.select_rows(relation.to_sql)
        Array.new(rows, relation.attributes)
      end

      def update(relation)
        connection.update(relation.to_sql)
      end

      def delete(relation)
        connection.delete(relation.to_sql)
      end
    end

Possible Arel Engines

• NoSQL (e.g. Redis, CouchDB)
• Memcache
• Web service APIs (e.g. AWS, Twitter)
• File system


Cross-Engine Joins


Thank You


Arel: Introduction to the Ruby Relational Algebra Library

Recommended

Recommended

More Related Content

Similar to Arel: Introduction to the Ruby Relational Algebra Library

Similar to Arel: Introduction to the Ruby Relational Algebra Library (20)

Recently uploaded

Recently uploaded (20)

Arel: Introduction to the Ruby Relational Algebra Library

Editor's Notes