This project is archived.
Squeel lets you write your Active Record queries with fewer strings, and more Ruby, by making the Arel awesomeness that lies beneath Active Record more accessible.
Squeel lets you rewrite...
Article.where ['created_at >= ?', 2.weeks.ago]...as...
Article.where{created_at >= 2.weeks.ago}This is a good thing. If you don't agree, Squeel might not be for you. The above is just a simple example -- Squeel's capable of a whole lot more. Keep reading.
In your Gemfile:
gem "squeel" # Last officially released gem
# gem "squeel", :git => "git://github.com/activerecord-hackery/squeel.git" # Track git repoThen bundle as usual.
If you'd like to customize Squeel's functionality by enabling core extensions for hashes or symbols, or aliasing some predicates, you can create a sample initializer with:
$ rails g squeel:initializerSqueel enhances the normal Active Record query methods by enabling them to accept
blocks. Inside a block, the Squeel query DSL can be used. Note the use of curly braces
in these examples instead of parentheses. {} denotes a Squeel DSL query.
Stubs and keypaths are the two primary building blocks used in a Squeel DSL query, so we'll start by taking a look at them. Most of the other examples that follow will be based on this "symbol-less" block syntax.
An important gotcha, before we begin: The Squeel DSL works its magic using instance_eval.
If you've been working with Ruby for a while, you'll know immediately that this means that
inside a Squeel DSL block, self isn't the same thing that it is outside the block.
This carries with it an important implication: Instance variables and instance methods inside the block won't refer to your object's variables/methods.
Don't worry, Squeel's got you covered. Use one of the following methods to get access to your object's methods and variables:
- Assign the variable locally before the DSL block, and access it as you would normally.
- Supply an arity to the DSL block, as in
Person.where{|q| q.name == @my_name}Downside: You'll need to prefix stubs, keypaths, and functions (explained below) with the DSL object. - Wrap the method or instance variable inside the block with
my{}.Person.where{name == my{some_method_to_return_a_name}}
Stubs are, for most intents and purposes, just like Symbols in a normal call to
Relation#where (note the need for doubling up on the curly braces here, the first ones
start the block, the second are the hash braces):
Person.where{{name => 'Ernie'}}
# => SELECT "people".* FROM "people" WHERE "people"."name" = 'Ernie'You normally wouldn't bother using the DSL in this case, as a simple hash would suffice. However, stubs serve as a building block for keypaths, and keypaths are very handy.
A Squeel keypath is essentially a more concise and readable alternative to a deeply nested hash. For instance, in standard Active Record, you might join several associations like this to perform a query:
Person.joins(:articles => {:comments => :person})
# => SELECT "people".* FROM "people"
# INNER JOIN "articles" ON "articles"."person_id" = "people"."id"
# INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
# INNER JOIN "people" "people_comments" ON "people_comments"."id" = "comments"."person_id"With a keypath, this would look like:
Person.joins{articles.comments.person}A keypath can exist in the context of a hash, and is normally interpreted relative to the current level of nesting. It can be forced into an "absolute" path by anchoring it with a ~, like:
~articles.comments.personThis isn't quite so useful in the typical hash context, but can be very useful when it comes to interpreting functions and the like. We'll cover those later.
All of the Arel "predication" methods can be accessed inside the Squeel DSL, via
their method name, an alias, or an an operator, to create Arel predicates, which are
used in WHERE or HAVING clauses.
| SQL | Predication | Operator | Alias |
|---|---|---|---|
| = | eq | == | |
| != | not_eq | != (1.9 only), ^ (1.8) | |
| LIKE | matches | =~ | like |
| NOT LIKE | does_not_match | !~ (1.9 only) | not_like |
| < | lt | < | |
| <= | lteq | <= | lte |
| > | gt | > | |
| >= | gteq | >= | gte |
| IN | in | >> | |
| NOT IN | not_in | << |
Let's say we want to generate this simple query:
SELECT "people".* FROM people WHERE "people"."name" = 'Joe Blow'
All of the following will generate the above SQL:
Person.where(:name => 'Joe Blow')
Person.where{{name => 'Joe Blow'}}
Person.where{{name.eq => 'Joe Blow'}}
Person.where{name.eq 'Joe Blow'}
Person.where{name == 'Joe Blow'}Not a very exciting example since equality is handled just fine via the first example in standard Active Record. But consider the following query:
SELECT "people".* FROM people
WHERE ("people"."name" LIKE 'Ernie%' AND "people"."salary" < 50000)
OR ("people"."name" LIKE 'Joe%' AND "people"."salary" > 100000)To do this with standard Active Record, we'd do something like:
Person.where(
'(name LIKE ? AND salary < ?) OR (name LIKE ? AND salary > ?)',
'Ernie%', 50000, 'Joe%', 100000
)With Squeel:
Person.where{(name =~ 'Ernie%') & (salary < 50000) | (name =~ 'Joe%') & (salary > 100000)}Here, we're using & and | to generate AND and OR, respectively.
There are two obvious but important differences between these two code samples, and both of them have to do with context.
-
To read code with SQL interpolation, the structure of the SQL query must first be considered, then we must cross-reference the values to be substituted with their placeholders. This carries with it a small but perceptible (and annoying!) context shift during which we stop thinking about the comparison being performed, and instead play "count the arguments", or, in the case of named/hash interpolations, "find the word". The Squeel syntax places both sides of each comparison in proximity to one another, allowing us to focus on what our code is doing.
-
In the first example, we're starting off with Ruby, switching context to SQL, and then back to Ruby, and while we spend time in SQL-land, we're stuck with SQL syntax, whether or not it's the best way to express what we're trying to do. With Squeel, we're writing Ruby from start to finish. And with Ruby syntax comes flexibility to express the query in the way we see fit.
That last bit is important. We can mix and match predicate methods with operators and take advantage of Ruby's operator precedence or parenthetical grouping to make our intentions more clear, on the first read-through. And if we don't like the way that the existing predications read, we can create our own aliases in a Squeel configure block:
Squeel.configure do |config|
config.alias_predicate :is_less_than, :lt
endPerson.where{salary.is_less_than 50000}.to_sql
# => SELECT "people".* FROM "people" WHERE "people"."salary" < 50000And while we're on the topic of helping you make your code more expressive...
Let's say you want to check if a Person has a name like one of several possibilities.
names = ['Ernie%', 'Joe%', 'Mary%']
Person.where('name LIKE ? OR name LIKE ? OR name LIKE ?', *names)But you're smart, and you know that you might want to check more or less than 3 names, so you make your query flexible:
Person.where((['name LIKE ?'] * names.size).join(' OR '), *names)Yeah... that's readable, all right. How about:
Person.where{name.like_any names}
# => SELECT "people".* FROM "people"
# WHERE (("people"."name" LIKE 'Ernie%' OR "people"."name" LIKE 'Joe%' OR "people"."name" LIKE 'Mary%'))I'm not sure about you, but I much prefer the latter. In short, you can add _any or
_all to any predicate method, and it would do what you expect, when given an array of
possibilities to compare against.
Sifters are like little snippets of conditions that take parameters. Let's say that you have a model called Article, and you often want to query for articles that contain a string in the title or body. So you write a scope:
def self.title_or_body_contains(string)
where{title.matches("%#{string}%") | body.matches("%#{string}%")}
endBut then you want to query for people who wrote an article that matches these conditions, but the scope only works against the model where it was defined. So instead, you write a sifter:
class Article < ActiveRecord::Base
sifter :title_or_body_contains do |string|
title.matches("%#{string}%") | body.matches("%#{string}%")
end
endNow you can write...
Article.where{sift :title_or_body_contains, 'awesome'}
# => SELECT "articles".* FROM "articles"
# WHERE ((
# "articles"."title" LIKE '%awesome%'
# OR "articles"."body" LIKE '%awesome%'
# ))... or ...
Person.joins(:articles).
where{
{articles => sift(:title_or_body_contains, 'awesome')}
}
# => SELECT "people".* FROM "people"
# INNER JOIN "articles" ON "articles"."person_id" = "people"."id"
# WHERE ((
# "articles"."title" LIKE '%awesome%'
# OR "articles"."body" LIKE '%awesome%'
# ))Or, you can just modify your previous scope, changing where to squeel:
def self.title_or_body_contains(string)
squeel{title.matches("%#{string}%") | body.matches("%#{string}%")}
endYou can supply an ActiveRecord::Relation as a value for a predicate in order to use
a subquery. So, for example:
awesome_people = Person.where{awesome == true}
Article.where{author_id.in(awesome_people.select{id})}
# => SELECT "articles".* FROM "articles"
# WHERE "articles"."author_id" IN (SELECT "people"."id" FROM "people" WHERE "people"."awesome" = 't')Squeel adds a couple of enhancements to joins. First, keypaths can be used as shorthand for nested association joins. Second, you can specify join types (inner and outer), and a class in the case of a polymorphic belongs_to relationship.
Person.joins{articles.outer}
# => SELECT "people".* FROM "people"
# LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
Note.joins{notable(Person).outer}
# => SELECT "notes".* FROM "notes"
# LEFT OUTER JOIN "people"
# ON "people"."id" = "notes"."notable_id"
# AND "notes"."notable_type" = 'Person'These can also be used inside keypaths:
Note.joins{notable(Person).articles}
# => SELECT "notes".* FROM "notes"
# INNER JOIN "people" ON "people"."id" = "notes"."notable_id"
# AND "notes"."notable_type" = 'Person'
# INNER JOIN "articles" ON "articles"."person_id" = "people"."id"You can refer to these associations when constructing other parts of your query, and they'll be automatically mapped to the proper table or table alias This is most noticeable when using self-referential associations:
Person.joins{children.parent.children}.
where{
(children.name.like 'Ernie%') |
(children.parent.name.like 'Ernie%') |
(children.parent.children.name.like 'Ernie%')
}
# => SELECT "people".* FROM "people"
# INNER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"
# INNER JOIN "people" "parents_people" ON "parents_people"."id" = "children_people"."parent_id"
# INNER JOIN "people" "children_people_2" ON "children_people_2"."parent_id" = "parents_people"."id"
# WHERE ((("children_people"."name" LIKE 'Ernie%'
# OR "parents_people"."name" LIKE 'Ernie%')
# OR "children_people_2"."name" LIKE 'Ernie%'))Keypaths were used here for clarity, but nested hashes would work just as well.
You can also use a subquery in a join.
Notice:
- Squeel can only accept an ActiveRecord::Relation class of subqueries in a join.
- Use the chain with caution. You should call
asfirst to get a Nodes::As, then callonto get a join node.
subquery = OrderItem.group(:orderable_id).select { [orderable_id, sum(quantity * unit_price).as(amount)] }
Seat.joins { [payment.outer, subquery.as('seat_order_items').on { id == seat_order_items.orderable_id}.outer] }.
select { [seat_order_items.amount, "seats.*"] }
# => SELECT "seat_order_items"."amount", seats.*
# FROM "seats"
# LEFT OUTER JOIN "payments" ON "payments"."id" = "seats"."payment_id"
# LEFT OUTER JOIN (
# SELECT "order_items"."orderable_id",
# sum("order_items"."quantity" * "order_items"."unit_price") AS amount
# FROM "order_items"
# GROUP BY "order_items"."orderable_id"
# ) seat_order_items ON "seats"."id" = "seat_order_items"."orderable_id"Includes works similarly with joins, it uses outer join defaultly. In Rails 4,
you need to use references with includes together.
Person.includes(:articles => {:comments => :person}).references(:all)
# => SELECT "people".* FROM "people"
# LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
# LEFT OUTER JOIN "comments" ON "comments"."article_id" = "articles"."id"
# LEFT OUTER JOIN "people" "people_comments" ON "people_comments"."id" = "comments"."person_id"With a keypath, this would look like:
Person.includes{articles.comments.person}.references(:all)Person.includes(:articles => {:comments => :person})
# => SELECT "people".* FROM "people"
# LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
# LEFT OUTER JOIN "comments" ON "comments"."article_id" = "articles"."id"
# LEFT OUTER JOIN "people" "people_comments" ON "people_comments"."id" = "comments"."person_id"With a keypath, this would look like:
Person.includes{articles.comments.person}You can call SQL functions just like you would call a method in Ruby...
Person.select{coalesce(name, '<no name given>')}
# => SELECT coalesce("people"."name", '<no name given>') FROM "people"...and you can easily give it an alias:
person = Person.select{
coalesce(name, '<no name given>').as(name_with_default)
}.first
person.name_with_default # name or <no name given>, depending on dataWhen you use a stub, symbol, or keypath inside a function call, it'll be interpreted relative to its place inside any nested associations:
Person.joins{articles}.group{articles.title}.having{{articles => {max(id) => id}}}
# => SELECT "people".* FROM "people"
# INNER JOIN "articles" ON "articles"."person_id" = "people"."id"
# GROUP BY "articles"."title"
# HAVING max("articles"."id") = "articles"."id"If you want to use an attribute from a different branch of the hierarchy, use an absolute keypath (~) as done here:
Person.joins{articles}.group{articles.title}.having{{articles => {max(~id) => id}}}
# => SELECT "people".* FROM "people"
# INNER JOIN "articles" ON "articles"."person_id" = "people"."id"
# GROUP BY "articles"."title"
# HAVING max("people"."id") = "articles"."id"You can use the standard mathematical operators (+, -, *, /) inside the Squeel DSL to
specify operators in the resulting SQL, or the op method to specify another
custom operator, such as the standard SQL concatenation operator, ||:
p = Person.select{name.op('||', '-diddly').as(flanderized_name)}.first
p.flanderized_name
# => "Aric Smith-diddly"As you can see, just like functions, these operations can be given aliases.
To select more than one attribute (or calculated attribute) simply put them into an array:
p = Person.select{[ name.op('||', '-diddly').as(flanderized_name),
coalesce(name, '<no name given>').as(name_with_default) ]}.first
p.flanderized_name
# => "Aric Smith-diddly"
p.name_with_default
# => "Aric Smith"Most of the new functionality provided by Squeel is accessed with the new block-style where{}
syntax.
All your existing code that uses plain Active Record where() queries should continue to work the
same after adding Squeel to your project with one exception: symbols as the value side of a
condition (in normal where() clauses).
If you have any where() clauses that use a symbol as the value side
(right-hand side) of a condition, you will need to change the symbol into a
string in order for it to continue to be treated as a value.
Squeel changes the meaning of symbols in the value of a condition to refer to the name of a column instead of simply treating the symbol as a string literal.
For example, this query:
Person.where(:first_name => :last_name)produces this SQL query in plain Active Record:
SELECT people.* FROM people WHERE people.first_name = 'last_name'.but produces this SQL query if you are using Squeel:
SELECT people.* FROM people WHERE people.first_name = people.last_nameNote that this new behavior applies to the plain where()-style expressions in addition to the new
where{} Squeel style.
In order for your existing where() clauses with symbols to continue to behave the same, you
must change the symbols into strings. These scopes, for example:
scope :active, where(:state => :active)
scope :in_state, lambda {|state| where(:state => state) }should be changed to this:
scope :active, where(:state => 'active')
scope :in_state, lambda {|state| where(:state => state.to_s) }For further information, see this post to the Rails list, this commit to the Active Record guides, #67, #75, and #171.
While the Squeel DSL is the preferred way to access advanced query functionality, you can still enable methods on symbols to access Arel predications in a similar manner to MetaWhere:
Squeel.configure do |config|
config.load_core_extensions :symbol
endPerson.joins(:articles => :comments).
where(:articles => {:comments => {:body.matches => 'Hello!'}})
# => SELECT "people".* FROM "people"
# INNER JOIN "articles" ON "articles"."person_id" = "people"."id"
# INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
# WHERE "comments"."body" LIKE 'Hello!'This should help to smooth over the transition to the new DSL.
If you'd like to support the continued development of Squeel, please consider making a donation.
To support the project in other ways:
- Use Squeel in your apps, and let me know if you encounter anything that's broken or missing. A failing spec is awesome. A pull request is even better!
- Spread the word on Twitter, Facebook, and elsewhere if Squeel's been useful to you. The more people who are using the project, the quicker we can find and fix bugs!
Copyright © 2011 Ernie Miller
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent