30 November 2011

Export to Excel in Rails 3 without a Gem

Export to Excel in Rails 3 without a Gem

Creating Demo project

 rails new xcel_demo –d mysql

Creating a User model

rails g scaffold User name:string email:string content:string

Add a MIME type in \config\initializers\mime_type.rb

Mime::Type.register 'application/vnd.ms-excel', :xls

Add a xls format output to the method in the Controller

  def index
    @users = User.all

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @users }

Creating the view for the XLS

Now create a view to render the xls file. Here as we have modified the index method we will create a view index.xls.erb for the same in the views for Users
<h1>Listing users</h1>


<% @users.each do |user| %>
    <td><%= user.name %></td>
    <td><%= user.city %></td>
    <td><%= user.gender %></td>
    <td><%= user.phone %></td>
    <td><%= user.address %></td>
<% end %>

<br />
The text in the <th> tags are the headers and <td> tags are the data for the specified columns

Adding the link to export excel on the Index page

 <%= link_to 'Export XLS', url_for(:format => 'xls') %>
This will allow the data on index page to be exported in Excel Format.

29 September 2011

Squeel: Replacement for metawhere Gem in Rails 3.1

Getting started

In your Gemfile:
gem "squeel"  # Last officially released gem
# gem "squeel", :git => "git://github.com/ernie/squeel.git" # Track git repo
In an initializer:
Squeel.configure do |config|
  # To load hash extensions (to allow for AND (&), OR (|), and NOT (-) against
  # hashes of conditions)
  config.load_core_extensions :hash

  # To load symbol extensions (for a subset of the old MetaWhere functionality,
  # via ARel predicate methods on Symbols: :name.matches, etc)
  # config.load_core_extensions :symbol

  # To load both hash and symbol extensions
  # config.load_core_extensions :hash, :symbol

The Squeel Query DSL

Squeel enhances the normal ActiveRecord 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:
  1. Assign the variable locally before the DSL block, and access it as you would normally.
  2. 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.
  3. 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 ActiveRecord, 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:
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:
This 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.
!=not_eq!= (1.9 only), ^ (1.8)
NOT LIKEdoes_not_match!~ (1.9 only)not_like
NOT INnot_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 ActiveRecord. 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 ActiveRecord, we'd do something like:
  '(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.
  1. 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.
  2. 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.

Predicate aliases

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

Person.where{salary.is_less_than 50000}.to_sql
# => SELECT "people".* FROM "people"  WHERE "people"."salary" < 50000
And while we're on the topic of helping you make your code more expressive...

Compound conditions

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}%")}
But 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}%")
Now 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 ...
         {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}%")}


You 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}
# => 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.
=> SELECT "people".* FROM "people"
   LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
=> 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:
=> 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:
         (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 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)
person.name_with_default # name or <no name given>, depending on data
When 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"

SQL Operators

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
=> "Aric Smith-diddly" 
As you can see, just like functions, these operations can be given aliases.

Legacy compatibility

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

Person.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