activerecord & arel

ActiveRecord & ARel

Awkward friends

ARel is not...

A replacement for ActiveRecord!

ARel is...

• Active Relation

• Really neat• Still under development

• The safest way to write SQL

• SQL engine agnostic!

• An OOP interpretation of Relational Algebra

• A DSL• Docs? Documentation?

Uh, he's sick.• Use it!• All examples assume

PSQL

How to use ARel

ARel can be used independently of ActiveRecord, but I'm not going to focus on that, because it's not my use case.

The easiest way to use ARel, with ActiveRecord, is to access the #arel_table of your ActiveRecord models. This method exposes the Arel::Table object associated with your model. Through this object you can do many ARel-y things.

There are a few other class level methods, which will be covered in a bit.

Accessing attributes

• Model.arel_table[:attr]

• Model.arel_table[:attr].as("alias").to_sql

The essential building block for AR & AR interaction. All of the model's attributes are available as keys to the arel_table.

"model"."attr" AS alias

Notice the result is canonically referenced and properly quoted (very portable)

Predicates

• Model.arel_table[:id].eq(1).to_sql• Model.arel_table[:id].not_eq(1).to_sql• Model.arel_table[:id].in([1,2]).to_sql• Model.arel_table[:id].not_in([1,2]).

to_sql• Model.arel_table[:name].matches("a%").

to_sql• Model.arel_table[:name].

does_not_match("a%").to_sql• Model.arel_table[:id].gt(1).to_sql• Model.arel_table[:id].gteq(1).to_sql• Model.arel_table[:id].lt(1).to_sql• Model.arel_table[:id].lteq(1).to_sql

• "model"."id" = 1• "model"."id" != 1• "model"."id" IN (1,2)• "model"."id" NOT IN

(1,2)• "model"."name" ILIKE

"a%"• "model"."name" NOT

ILIKE "a%"• "model"."id" > 1• "model"."id" >= 1• "model"."id" < 1• "model"."id" <= 1

Predicate alternates

Each basic predicate supports two additional types, _any and _all. These methods each accept arrays of values, ie

Model.arel_table[:id].eq_any([1,2]).to_sql=> SELECT "models".* FROM "models" WHERE ("models"."id" = 1 OR "models"."id" = 2)

Model.arel_table[:id].in_all([[1,2],[3,4]]).to_sql=> SELECT "models".* FROM "models" WHERE ("models"."id" IN (1,2) AND "models"."id" IN (3,4))

Aggregate Functions

• Model.arel_table[:int].average.to_sql

• Model.arel_table[:int].average.as("alias").to_sql

• Model.arel_table[:int].count.to_sql

• Model.arel_table[:int].count.as("alias").to_sql

• Model.arel_table[:int].maximum.to_sql

• Model.arel_table[:int].minimum.to_sql

• Model.arel_table[:int].sum.to_sql

• AVG("models"."int") AS avg_id

• AVG("models"."int") AS alias• COUNT("models"."int")• COUNT("models"."int") AS

alias• MAX("models"."int") AS

max_id• MIN("models"."int") AS

min_id• SUM("models"."int") AS

sum_id

Infix operators

m = Model.arel_table

• m[:int1] + m[:int2]• m[:int1] - m[:int2]• m[:int1] * m[:int2]• m[:int1] * m[:int2].as "int"• m[:int1] / m[:int2]• m[:int1] / m[:int2].as "int"• Model.select(

m[:int1] * m[:int2].    as("product")).to_sql

No support for bitwise operators or aliasing addition / subtraction

• (int1 + int2)• (int1 - int2)• int1 * int2• int1 * int2 AS int• int1 / int2• int1 / int2 AS int• SELECT

"models"."int1" * "models"."int2" AS product FROM "models"

Mixing ActiveRecord & ARel

Where inconsistencies collide

Selecting results

m = Model.arel_table

• Model.select([m[:id], m[:name]).to_sql

• Model.select(m[:int1].average.as("int1")).to_sql

• Model.select(m[:int1] + m[:int2]).to_sql

• SELECT "models"."id", "models"."name"FROM "models"

• SELECT AVG("models"."int1") AS int1FROM "models"

• SELECT ("models"."int1" + "models"."int2")FROM "models"

Filtering results (where)

m = Model.arel_table

• Model.where(m[:id].gteq(10)).to_sql

• Model.where(m.grouping(m[:id].gt(10). and(m[:name].matches("foo%")).or(m[:int1].in([1,2])))

• Model.where(m[:int1] + m[:int2].gteq(100))

• SELECT "models".*FROM "models"WHERE "models"."id" >= 10

• SELECT "models".*FROM "models"WHERE ((("models"."id" > 10 AND"models"."name" ILIKE "foo%")OR "models"."int1" IN (1,2)))

• SELECT "models".*FROM "models"WHERE "models"."int1" + "models"."int2" >= 100

Grouping and Having results

• ARelo Model.select(m[:name]).group(m[:name]).to_sql

• ActiveRecordo Model.select(:name).group(:name).to_sql

The ARel methods are important, because ActiveRecord does not canonically reference fields

• SELECT "models"."name" FROM "models" GROUP BY "models"."name"

• SELECT nameFROM "models" GROUP BY name

Ordering results

m = Model.arel_table

• m[:id].asc• m[:id].desc• m[:string].lower• ARel

o Model.order(m[:id].asc).to_sql

• ActiveRecordo Model.order(:id).to_sql

The ARel methods are important, because ActiveRecord does not canonically reference fields

• "models"."id" ASC• "models"."id" DESC• LOWER("models"."string")• SELECT "models".*

FROM "models" ORDER BY "models"."id" ASC

• SELECT "models".* FROM "models" ORDER BY id

Limiting results

• Model.skip(10).to_sql

• Model.take(100).to_sql

• Model.skip(10).take(100).to_sql

Take must be the last method in the chain, always.

• SELECT "models".*FROM "models"OFFSET 10

• SELECT "models".*FROM "models"LIMIT 100

• SELECT "models".*FROM "models"LIMIT 100OFFSET 10

Sub Selects

sub = Models.joins(:others).      as("alias")

Models.select('*').from(sub).to_sql

SELECT * FROM (  SELECT "models".*   FROM "models"     INNER JOIN "others" ON       "others"."model_id" =          "models"."id") alias

Unions

m = Model.arel_tableo = Other.arel_table

• Model.select(m[:id]).union(Other.select(o[:id])).to_sql

• ( SELECT "models"."id" FROM "models" UNION SELECT "others"."id" FROM "others" )

Complex joins

Polymorphic join

m = Model.arel_tableo = Other.arel_tablesql =  m.joins(o).on(    m[:id].eq(o[:able_id]).    and(o[:able_type].eq("O"))  ).to_sqlModel.joins(sql).to_sql

SELECT "models".*FROM "models"  INNER JOIN "others" ON    ("models"."id" =        "others"."able_id"      AND      "others"."able_type" =         "O"     )

Arbitrary SQL functions

m = Model.arel_table

• Model.select(Arel::Nodes::NamedFunction.new(:coalesce, [m[:id], 0])).to_sql

• Model.select(Arel::Nodes::NamedFunction.new(:coalesce, [m[:id], 0], "foo")).to_sql

• SELECT coalesce("models"."id", 0)FROM "models"

• SELECT coalesce("models"."id", 0)  AS fooFROM "models"

Easier Arbitrary SQL Functions

config/initializers/arel_extensions.rb

Arel::Table.class_eval do |base|  def function(name, expr, aliaz = nil)    Arel::Nodes::NamedFunction.new(name, expr, aliaz)  endend

m = Model.arel_tableModel.select(m.function(:coalesce, [m[:id], 0], "foo"))

Peeking and poking

m = Model.arel_tablequery = Model.  joins(:others).  merge(Other.where(id: 1)).  order(m[:id].desc).  skip(10).  take(100)• query.join_sql• query.where_sql• query.to_sql

• INNER JOIN "others" ON "models"."id" = "others"."model_id"

• WHERE ("others"."id" = 1)• SELECT "models".*

FROM "model"  INNER JOIN "others" ON   "models"."id" =   "others"."model_id"WHERE ("others"."id" = 1)ORDER BY "models"."id" DESC OFFSET 10 LIMIT 100

Links

• http://magicscalingsprinkles.wordpress.com/2010/01/28/why-i-wrote-arel/• https://github.com/rails/arel• http://www.railsdispatch.com/posts/activerelation• http://m.onkey.org/active-record-query-interface• http://www.bigbinary.com/videos/5-how-arel-works• https://github.com/stevecj/arel-presentation-slides/blob/master/one/01_slide.md• http://railscasts.com/episodes/215-advanced-queries-in-rails-3