When updating to 2.3.4 I noticed that touch is
no longer a simple ‘update :updated_at’, but a save!,
which caused some code to break
(e.g. touch`ing in after_save == loop)

Usage

User.first.touch_without_callbacks
User.touch_without_callbacks([User.first.id, User.last.id])

Install
Paste somewhere…

# Provide .touch as it was in 2.3.2, simply update the :updated_at field.
class ActiveRecord::Base
  def touch_without_callbacks
    now = Time.now.utc
    self.class.touch(id, now)
    self.updated_at = now
  end

  def self.touch_without_callbacks(ids, time=Time.now.utc)
    update_all({:updated_at=>time}, :id=>ids)
  end
end

In questo periodo di apprendimento di RubyOnRails, ho imparato ad apprezzare le funzionalità di ActiveRecord, l’ORM di RoR.

Prendendo spunto da questo articolo, ho realizzato lo scheletro di un’applicazione desktop in ruby, che utilizza ActiveRecord come ORM, Sqlite3 come database, FxRuby e WxRuby come esempio di interfaccia grafica.

L’albero delle directory corrisponde ad un progetto di applicazione desktop di NetBeans. Trovo che NetBeans sia un buon IDE per lo sviluppo di applicazioni Ruby e RubyOnRails. Una funzionalità interessante è la possibilità di pacchettizzare l’applicazione in una rubygem, così da rendere semplice la sua pubblicazione.

A questo proposito, ho recentemente scoperto gemcutter, un hosting per le rubygem molto semplice da usare.

Sorgenti

Come per ogni progetto NetBeans, i sorgenti dell’applicazione sono presenti nella directory lib. La logica dell’applicazione è realizzata nel modulo Head.rb.

use_active_record.rb è uno script che dimostra il funzionamento con ActiveRecord.

Potete scaricare il progetto da qui o dal widget di Box.net nella sidebar.

Configurazione

I file di configurazione per l’utilizzo del database sono presenti nella cartella lib/config.

Database

Per il mio esempio ho utilizzato SqLite3. Il database presente nei sorgenti contiene 3 tabelle: users, contents e activities.

La gestione del db avviene, come per RoR, per mezzo delle migrations. Queste sono presenti in lib/db/migrate. Le classi dei modelli si trovano in lib/db/model.  Per avviare le migrations è sufficiente eseguire il comando rake all’interno della cartella lib. Il rakefile presente in quella directory si occuperà del resto.

Gui

Per lo sviluppo dell’interfaccia grafica, ho testato 2 differenti tool di sviluppo: FxRuby e WxRuby. Entrambi sono molto potenti, semplici e facili da configurare. Soprattutto multipiattaforma.

I file relativi ai due esempi sono lib/application_fx.rb per FxRuby e lib/application_wx.rb per WxRuby.

Perhaps you have a web application which not only has a database in which it stores its content but also has one to hold logging data (Exceptions, Log Entries).

This can be a common practice used to keep unrelated data separate and to off load the load created by logging data for purely health monitoring reasons.

If you are using Castle ActiveRecord as your ORM (Object Relational Mapping) layer and are familiar with setting it up for one database you may not be familiar with configuring it to handle more than one database for your objects.

ActiveRecord decides which database to send an object to based on a combination of a Abstract base class which inherits from ActiveRecordBase and a separate configuration section for each of those base classes. Each of those base classes must also be registered with ActiveRecord at application startup just like any Entity you plan on using within the application.

Below are the steps you need to take to properly setup your ASP.net web application to use 2 databases.

1. Create a ActiveRecordBase class for each of the databases you will be using. Each entity which inherits from that base class will be mapped to the corresponding database.

public abstract class ApplicationActiveRecordBase<T> : ActiveRecordBase<T>{}

public abstract class LoggingActiveRecordBase<T> : ActiveRecordBase<T>{}

2. Initialize each of the base classes so that ActiveRecord is aware of the classes

        static ActiveRecordInitializer()

        {

            IConfigurationSource source = ActiveRecordSectionHandler.Instance;

            ActiveRecordStarter.Initialize(

                source,

                typeof(LoggingActiveRecordBase<>),

                typeof(ApplicationActiveRecordBase<>));

        }

3. All entities belonging to a specific database should inherit from the base class associated with that database in the configuration.

    [DataContract]

    [ActiveRecord(Table = "exceptionentry")]

    public class ExceptionEntry : LoggingActiveRecordBase<ExceptionEntry>

    {

4. Add configuration sections to the ActiveRecord configuration for each database specifying the ActiveRecordBase class that will be used to identify the database.

  <activerecord isWeb="true" isDebug="false" threadinfotype="Castle.ActiveRecord.Framework.Scopes.HybridWebThreadScopeInfo, Castle.ActiveRecord">

    <config type="ActiveRecord.BaseClasses.ApplicationActiveRecordBase`1, Data.Core, Version=1.0.0.0, Culture=neutral">

      <add key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider" />

      <add key="hibernate.dialect" value="NHibernate.Dialect.MySQLDialect" />

      <add key="hibernate.connection.driver_class" value="NHibernate.Driver.MySqlDataDriver" />

      <add key="hibernate.connection.connection_string" value="Server=localhost; Database=YOURAPPLICATIONDATABASE; User Id=YOURUSER; Password=YOURPASSWORD" />

    </config>

    <config type="ActiveRecord.BaseClasses.LoggingActiveRecordBase`1, Data.Core, Version=1.0.0.0, Culture=neutral">

      <add key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider" />

      <add key="hibernate.dialect" value="NHibernate.Dialect.MySQLDialect" />

      <add key="hibernate.connection.driver_class" value="NHibernate.Driver.MySqlDataDriver" />

      <add key="hibernate.connection.connection_string" value="Server=localhost; Database=YOURLOGGINGDATABASE; User Id=YOURUSER; Password=YOURPASSWORD" />

    </config>

  </activerecord>  

Where’s the bug?

public virtual void RemoveOfferItems()
{
    for ( int i = 0; i < offerItems.Count; i++ )
    {
        OfferItem offerItem = offerItems[i];
        log.Trace( "offer item: {0}, {1}", offerItem.Id, offerItem.Description );

        offerItems.Remove( offerItem );
        offerItem.Delete();
    }
    Save();
}

But don’t write a test for this…

When I first heard that ColdFusion 9 will have Object Relational Mapping which is otherwise known as ORM baked in, I really did not know what to make of it. While I really did like the idea of portable SQL agnostic DAO code, I dreaded the configuration hell that I encountered with Hibernate and NHibernate. While I did have an okay experiance with the Castle Project’s ActiveRecord implementation of NHibernate, it did not feel very intuitive, at least to me.

Today I spent the better part of the day coding with the new release of ColdFusion and I was blown away with how much it has improved, particularly when used in conjunction with the Eclipse based ColdFusion Builder/Bolt IDE. I particularly love the new ColdFusion(CF) Builder IDE, it looks very polished and has code completion capabilities that felt more like Visual Studio which is a step up from cfeclipse. ColdFusion Builder also has very good integration with ColdFusion servers as it now can start, stop and monitor the ColdFusion servers which is a very big step up. Previously I had to jump between the CF Web Admin/CF Server Monitor and Eclipse/Dreamweaver when I was doing CF development which is very tedious. With this now I can do most of the stuff from within CF Builder which makes life very easy. I tried installing it on my instance of Eclipse that has Flex Builder 3 and it works great. I smell fun times on the horizon when coding apps.

Now back to the main point of this post, Adobe’s implementation of Hibernate which in true CF tradition, is very intuitive and simple. I was seriously having loads of fun playing with it. Here is some of the stuff I did today :

* I will be putting in my 2 cents/commentary on the benefits I see as comments in the code as I believe it is easier to understand that way.

Application.cfc

Books.cfc

Writers.cfc

index.cfm

Sample Output

As you can see above, it is is really easy to retrieve items from the database now with the new ORM framework baked in. The entityLoad(“Writers”) method basically did this :

SELECT a.*, b.* FROM Authors a INNER JOIN Books B ON A.AuthorID = B.AuthorID

Notice that now it is possible to write ColdFusion Components totally based on CFScript which is quite close to ActionScript/JavaScript/ECMAScript. I person love option of writing classes in CFScript but I still think that CFML still has its place. I know I for one prefer to loop though collections using cfloop.

I will blog more about other CF 9 ORM methods and setups in the days to come.

Ever wanted to pull just one random model from the database? Needed complex finders or ugly workarounds? Here’s a tiny extension of ActiveRecord::Base which adds in the ‘missing’ random finders. Try popping that snippet into config/initializers, naming it something useful like supply_random_finders.rb.

Now you’ve got

MyModel.random # pull a random instance of MyModel

on any model extending ActiveRecord::Base, as well as the more verbose

MyModel.find :random

We can use even add conditions to the random search:

MyModel.find :random, :conditions => ["created_at <= ?", 2.weeks.ago]

Of course this incurs the normal performance hit on conditional searches, whereas using MyModel.random allows us to utilize the fact that we know how many models are in the database already. This technique also works alongside named scopes.

Update:

While we’re on the subject of randomness, here’s a nice extension to Time which allows the generation of random dates and times. I came across it in a Danish fork of Faker, and for all I know this may be integrated into the normal Faker by now. But at any rate it seems to provide a nice, clean way to generate random dates. Enjoy!

Outro dia, tive um problema chatíssimo com o ActiveRecord: eu precisava criar um código de autenticidade, que conteria várias matrículas, que conteria várias disciplinas. O problema é o seguinte: Essas matrículas só seriam válidas se, por exemplo, o total de créditos das disciplinas não ultrapassassem um determinado número. Logo, resolvi fazer a validação no modelo de autenticidade, da seguinte forma:

class Autenticidade < ActiveRecord::Base
  MAX_CREDITOS = 40
  has_many :matriculas
  has_many :disciplinas, :through => :matriculas
  validate :credito_alto?

  def credito_alto?
    total = disciplinas.inject(0) { |r, v| r += v.creditos }
    errors.add(:disciplinas, 'créditos acima do permitido') if total > MAX_CREDITOS
  end
end

class Matricula < ActiveRecord::Base
  belongs_to :disciplina
  belongs_to :autenticidade
end

class Disciplina < ActiveRecord::Base
end

Ok, o problema agora é o seguinte: Se eu crio uma autenticidade, com o parâmetro :disciplina_ids => [1, 2], por exemplo, e a autenticidade não é válida, nenhuma nova matrícula é criada – como deveria ser. Agora, se eu atualizo uma autenticidade, com o  autenticidade.update_attributes( :disciplina_ids => [1, 2]), e essa autenticidade não é válida, o ActiveRecord salva as matrículas. Nesse caso, eu tenho uma inconsistência na base de dados feia – e precisava encontrar uma alternativa que não envolvesse muitos hacks, coisa que ainda não encontrei. Mas isso me estimulou a pesquisar o DataMapper.

O DataMapper é um ORM assim como o ActiveRecord – porém com um diferencial que (para alguns) é interessante: Ele só lança os comandos SQL quando você precisa. Nossa autenticidade (fora as validações) ficaria assim:

class Autenticidade
  include DataMapper::Resource

  MAX_CREDITOS = 40
  property :id, Serial
  property :codigo_autenticidade, String
  has n, :matriculas
  has n, :disciplinas, :through => :matriculas
end

Para alguns, é uma vantagem declarar as propriedades no próprio código – dizem que é mais simples de ver o que há nas suas tabelas. Eu, discordo categoricamente disso – o código-fonte não deveria fazer o que a documentação faz (se você não tem um dicionário de dados, é culpa sua, não do ActiveRecord). Mas uma coisa legal é: Se vc fizer, por exemplo: a = Autenticidade.all[0], o DataMapper gera apenas o SQL que você precisaria (nesse caso, SELECT * FROM autenticidades LIMIT 1). Isso funciona, de acordo com a documenação do DataMapper, inclusive para relações:

autenticidades = Autenticidade.all #Não gera nenhum SQL ainda
autenticidades.each do |autenticidade| #Gera um SELECT * FROM autenticidades
  p autenticidade.matriculas #Gera um SELECT para listar TODAS as matrículas de TODAS as autenticidades, apenas na primeira iteração
end

Ok, isso elimina o tal do problema n+1 (No ActiveRecord, isso geraria um SELECT para cada autenticidade). O problema é: isso funciona muito bem, mas no has n, :through, o problema do n+1 existe! E, para piorar, um Autenticidade.all :include => :disciplinas simplesmente não existe, logo eu não tenho como sair desse erro. No fim, a vantagem virou uma desvantagem.

Outra vantagem que eu tinha visto era a possibilidade de criar adaptadores para coisas que não são bases de dados relacionais – imagine, por exemplo, você usando o DataMapper como um ORM para LDAP, MySQL, REST e YAML, tudo ao mesmo tempo – fazer associações com isso seria uma maravilha, falar que seu usuário do MySQL tem uma entrada LDAP, usando as associações do próprio DataMapper. Porém, mais uma vez, as coisas não funcionaram muito bem: has n só funciona quando as bases de dados estão no mesmo adaptador, talvez para otimizar os SQLs com JOINs, etc. Logo, mais uma vantagem que eu vi foi sub-utilizada.

No fim, a única vantagem que o DataMapper me deu foi a possibilidade de fazer isso aqui:

autenticidade = Autenticidade.first
autenticidade.disciplinas << Disciplina.get(:id => 1)
autenticidade.disciplinas << Disciplina.get(:id => 2)
autenticidade.save #Se for falso, NÃO salva as disciplinas

Pois é, eu gostaria mais de ver as vantagens do DataMapper no ActiveRecord do que o inverso…

Rails (2.1, 2.2, 2.3)

The list of great features that was introduced in rails ( since  2.0 was introduced)

Core, Railties …

• ruby 1.9.1
• JRuby 1.3.1
• RailsEngines built in (o)
• Gem menagement (with vendor option)
• RailsMetal (o)
• rack integration (o)
• application template (o)

ActionView

• internationalization (o) & views localization (o) & partial scoping (o)
• nested object forms (o)
• smart partial rendering (o)
• template loading (o)

ActionController

• method arrays for member or collection routes (0)
• resources with specific actions (o)
• simplifying of render (o)
• application.rb -> application_controller.rb
• http digest authntication (o)
• lazy load of sessions

ActiveRecord

• transactional migrations (multi-step)
• database connection pools (o)
• nested transactions (o)
• named scopes (o)
• dynamic scopes (o)
• callbacks with multiple conditions (o)
• hashes for join table conditions (o)
• nested attributess (o)
• default scope (o)
• batch processing (o)
• introduced :having option (o)
• reconenct mysql connections (o)
• dirty tracking (o)
• seed data (o)

ActiveSupport

• time zones (o)
• methods memoization (o)
• delegate with prefix (o)
• enumerable (many?)

Action Mailer

• layouts (o)

A common task when writing your own Rails applications using ActiveRecord is creating your own validations for your models. While it’s perfectly correct to add the validation directly into the model you’re going to need it, sometimes you’d like to reuse the same validation logic in other models and we’re not really going to do a cut-and-paste here are we?

The simplest solution when you’re validating fields (and not the whole model) is to use the validates_each method, as it has some nice features seen in other validations that might interest you as the :if, :unless, :allow_blank and :allow_nil options.

Our custom example validation is to validate that one or more fields are different from one specific field. Imagine that you’re building an invoices application, having the seller to also be the buyer isn’t really what you’re looking for, so that’s why we’re building this validation. Let’s take a look at the validation code:

ActiveRecord::Base.class_eval do

  def self.validates_different( *args )

    options = args.extract_options!
    raise "You must define a :field option to compare to" if options[:field].blank?

    validates_each(*(args << options)) do |record, attribute, value|
      if record.send( options[:field] ) == value
        record.errors.add(
          attribute,
          record.errors.generate_message(
            attribute
            'different',
            :field => record.class.human_attribute_name( options[:field].to_s ) ) )
      end
      true
    end

  end

end

We have inserted a static method inside the ActiveRecord::Base class to be our validation macro, it takes a list of parameters and an options hash at the end, here’s a sample of how it would be used:

class Invoice < ActiveRecord::Base
    validates_different :seller_id, :field => :buyer_id, :allow_blank => true
end

The validation looks just like any other ActiveRecord validation and even uses options well known in them like :allow_blank, keeping the principle of least surprise at bay. It’s also important to notice the use of I18N on the validation message, the “’activerecord.errors.messages” namespace is the ActiveRecord error messages namespace and that’s where you should add your custom validation messages, do not place the messages directly inside your validation or model code. Here’s how the YAML file would look like:

en:
  activerecord:
    errors:
      messages:
        different: “must be different than {{field}}”

And there you go, you have built your own validation macro for your ActiveRecord models and even used the I18N helpers to keep the messages away from your model code.

Το ActiveRecord από την ομάδα του CastleProject είναι βασισμένο στο σχεδιαστικό πρότυπο(ποιός τις σκέφτεται αυτές τις μεταφράσεις αναρωτιέμαι) του active record. Στην ουσία δρα ως ένας μεσάζωντας μεταξύ της εφαρμογής και της βάσης δεδομένων.

There’s early and then there’s insanely early.

• master_slave_adapter – Nice approach to doing master-slave databases in Active Record through a custom adapter that dispatches the database calls.
• Online Viewstate Viewer / Decoder for Asp.Net 2.0 – I didn’t think I’d need this sort of thing any more. I was wrong.
• looksee – Library to examine the method lookup path of ruby objects.

Consider the following model

class Activity
  has_many :tags, :dependent => :destroy
  before_destroy :do_something

  def do_something
    # do something
  end
end

When calling @activity.destroy, the order of execution is

1. Destroy @activity.tags
2. do_something
3. Destroy @activity

Before_destroy is executed after the destroy of it’s association.

Here’s how I managed to get Rails Migrations working with a Maven build process, enabling me to leverage Migrations to maintain the RDBMS schema of a Java application.

Add JRuby and Database dependencies

Add the following dependencies to your pom.xml (adjust for whatever is latest version of jruby and whatever your database is).

  <dependency>
   <groupId>org.jruby</groupId>
   <artifactId>jruby-complete</artifactId>
   <version>1.3.0RC1</version>
  </dependency>
  <dependency>
   <groupId>oracle</groupId>
   <artifactId>jdbc</artifactId>
   <version>11.1.0</version>
  </dependency>

Add a goal to install required Ruby gems

To get Rails migrations running we’ll need the following gems:

• activerecord
• activerecord-jdbc-adapter
• your database specific jdbc adapter

We’ll set up a profile to install these gems if they are missing (based on a approach used by Binil Thomas):

<profiles>
  <profile>
   <id>first.time</id>
   <activation>
    <file>
     <missing>${user.home}/.gem/jruby/1.8/gems/activerecord-2.3.2</missing>
    </file>
   </activation>
   <build>
    <plugins>
     <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>exec-maven-plugin</artifactId>
      <executions>
       <execution>
        <id>install-active-record-gem</id>
        <phase>initialize</phase>
        <goals>
         <goal>java</goal>
        </goals>
        <configuration>
         <mainClass>org.jruby.Main</mainClass>
         <arguments>
          <argument>-S</argument>
          <argument>gem</argument>
          <argument>install</argument>
          <argument>activerecord</argument>
          <argument>activerecord-jdbc-adapter</argument>
          <argument>activerecord-oracle_enhanced-adapter</argument>
          <argument>--no-ri</argument>
          <argument>--no-rdoc</argument>
          <argument>--no-test</argument>
         </arguments>
        </configuration>
       </execution>
      </executions>
     </plugin>
    </plugins>
   </build>
  </profile>
 </profiles>

Replace activerecord-oracle_enhanced-adapter with the name of your chosen database’s jdbc adapter.

Add a goal to run the migration

 <build>
  <plugins>
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <executions>
     <execution>
      <id>run-migrate</id>
      <phase>install</phase>
      <goals>
       <goal>java</goal>
      </goals>
      <configuration>
       <mainClass>org.jruby.Main</mainClass>
       <arguments>
        <argument>-S</argument>
        <argument>rake</argument>
        <argument>-f</argument>
        <argument>${basedir}/Rakefile</argument>
       </arguments>
      </configuration>
     </execution>
    </executions>
   </plugin>
  </plugins>
 </build>

Create a Rakefile

You’ll need a Rakefile to carry out the migration, in my case I wanted to avoid depending on all of Rails so I just used the following:

require 'active_record'
require 'yaml'

RAILS_ROOT = "#{File.dirname(__FILE__)}" unless defined?(RAILS_ROOT)

task :default => :migrate

task :migrate => :environment do
  ActiveRecord::Migrator.migrate('db/migrate', ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
end

task :environment do
  ActiveRecord::Base.establish_connection(YAML::load(File.open("#{RAILS_ROOT}/config/database.yml")))
  ActiveRecord::Base.logger = Logger.new(File.open('database.log', 'a'))
end

Write your migrations

Create your migrations in db/migrate.

Apply database changes

Finally type:

mvn install

to deploy your database changes.

The full POM

<project>
 <modelVersion>4.0.0</modelVersion>
 <groupId>org.example</groupId>
 <artifactId>schema</artifactId>
 <name>Example POM for doing Rails Migrations</name>
 <packaging>pom</packaging>
 <dependencies>
  <dependency>
   <groupId>org.jruby</groupId>
   <artifactId>jruby-complete</artifactId>
   <version>1.3.0RC1</version>
  </dependency>
  <dependency>
   <groupId>oracle</groupId>
   <artifactId>jdbc</artifactId>
   <version>11.2.0</version>
  </dependency>
 </dependencies>
 <build>
  <plugins>
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <executions>
     <execution>
      <id>run-migrate</id>
      <phase>install</phase>
      <goals>
       <goal>java</goal>
      </goals>
      <configuration>
       <mainClass>org.jruby.Main</mainClass>
       <arguments>
        <argument>-S</argument>
        <argument>rake</argument>
        <argument>-f</argument>
        <argument>${basedir}/Rakefile</argument>
       </arguments>
      </configuration>
     </execution>
    </executions>
   </plugin>
  </plugins>
 </build>
 <profiles>
  <profile>
   <id>first.time</id>
   <activation>
    <file>
     <missing>${user.home}/.gem/jruby/1.8/gems/activerecord-2.3.2</missing>
    </file>
   </activation>
   <build>
    <plugins>
     <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>exec-maven-plugin</artifactId>
      <executions>
       <execution>
        <id>install-active-record-gem</id>
        <phase>initialize</phase>
        <goals>
         <goal>java</goal>
        </goals>
        <configuration>
         <mainClass>org.jruby.Main</mainClass>
         <arguments>
          <argument>-S</argument>
          <argument>gem</argument>
          <argument>install</argument>
          <argument>activerecord</argument>
          <argument>activerecord-jdbc-adapter</argument>
          <argument>activerecord-oracle_enhanced-adapter</argument>
          <argument>--no-ri</argument>
          <argument>--no-rdoc</argument>
          <argument>--no-test</argument>
         </arguments>
        </configuration>
       </execution>
      </executions>
     </plugin>
    </plugins>
   </build>
  </profile>
 </profiles>
</project>

Continuing the “RoR interview questions” sequel(part one here) , these are some general Rails concepts and technologies questions. Enjoy .

Why RoR?

0)for fast developing websites
1) DRY
2)convention over configuration
3)scaffolding
4)pure Object oriented concepts
5)less coding
6)easy understanding of coding
7)follows MVC architecture
8)using library and gem files

(from: http://www.rubyassist.com/rubyonrailsinterviewquestions)

What is agile development? What are the strenghts?

Agile software development refers to a group of software development methodologies based on iterative development, where requirements and solutions evolve through collaboration between self-organizing cross-functional teams

Advantages:

• Customer satisfaction by rapid, continuous delivery of useful software
• Working software is delivered frequently (weeks rather than months)
• Projects are built around motivated individuals, who should be trusted
• Continuous attention to technical excellence and good design
• Simplicity
• Self-organizing teams
• Regular adaptation to changing circumstances

What is MVC? Explain each element.

Name some of the the new features that Rails 2.0, 2.1, 2.3 brings.

Model Questions

What can you define in model?

1. Validations (like validates_presence_of, numeracility_of, format_of etc.)
2. Relationships(like has_one, has_many, HABTM etc.)
3. Callbacks(like before_save, after_save, before_create etc.)
4. Suppose you installed a plugin say validation_group, So you can also define validation_group settings in your model
5. ROR Queries in Sql

(answer from: http://railsbuilder.blogspot.com/2009/04/ruby-on-rails-interview-questions.html)

What is ActiveRecord? What is ORM?

Model relationships

• belongs_to
• has_one
• has_many
• has_many :through

A has_many :through association is often used to set up a many-to-many connection with another model. This association indicates that the declaring model can be matched with zero or more instances of another model by proceeding through a third model

• has_one :through
• has_and_belongs_to_many

What is the difference between has_one and belongs_to?

The distinction is in where you place the foreign key (it goes on the table for the class declaring the belongs_to association), but you should give some thought to the actual meaning of the data as well. The has_one relationship says that one of something is yours – that is, that something points back to you. For example, it makes more sense to say that a supplier owns an account than that an account owns a supplie

Model Validations

What is validates_associated?

Validates whether the associated object or objects are all valid themselves. Works with any kind of association.

Model callbacks

Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic before or after an alteration of the object state. This can be used to make sure that associated and dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes before they‘re validated (by overwriting before_validation)

What is the difference between save and save! ?

Save! performs all validations and callbacks. If any validation returns false, save! throws an error and canceles the save.
Save does not throw any error in the case above, but canceles the save. Also, the validators can be bypassed.

Related objects newly created. When are they saved?

When you assign an object to a has_many association, that object is automatically saved (in order to update its foreign key). If you assign multiple objects in one statement, then they are all saved.

If any of these saves fails due to validation errors, then the assignment statement returns false and the assignment itself is cancelled.

If the parent object (the one declaring the has_many association) is unsaved (that is, new_record? returns true) then the child objects are not saved when they are added. All unsaved members of the association will automatically be saved when the parent is saved.

If you want to assign an object to a has_many association without saving the object, use the collection.build method.

Model relationships? How is “has_and_belongs_to_many” implemented in the database?

A. Polymorphic associations

belongs_to :imageable, :polymorphic => true

has_many :pictures, :as => :imageable

has_many :pictures, :as => :imageable

B. Self joins

What is the difference between delete and destroy?

Delete removes the association, destroy removes also the associated record from the DB.

Controllers

What are the types of routes that can be declared in routes.rb?

What are REST routes?

CRUD rest routes (for map.resources :photos):

What is the difference between photos_url and photos_path?

photos_url # => "http://www.example.com/photos"

photos_path # => "/photos"

What are filters? and how many types of filters are there in ruby?

Filters are methods that are run before, after or “around” a controller action.

Filters are inherited, so if you set a filter on ApplicationController, it will be run on every controller in your application.

Filter can take one of three forms: method reference (symbol), external class, or inline method (proc).

• after_filter
• append_after_filter
• append_around_filter
• append_before_filter
• around_filter
• before_filter
• filter_chain
• prepend_after_filter
• prepend_around_filter
• prepend_before_filter
• skip_after_filter
• skip_before_filter
• skip_filter

What is the flash?

The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request, which is useful for storing error messages etc. It is accessed in much the same way as the session, like a hash.

What is the h function? Against what kinds of attacks can it help?

Helpers

What are helpers? What can you put in a helper?

From where can the methods in a helper be accessed?

View

How are the errors displayed in the view?

error_messages and error_messages_for

Difference between form_for and form_tag

What is a .rjs file? Why do we use request.xhr? in rails

What is REST?

Rails caching strategies

Rails cache sweepers

Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change. They do this by being half-observers, half-filters and implementing callbacks for both roles.

Plugins

What are Rails plugins? Give example (comment) on some plugins you have used.

Rails Middleware

What is Rails Rack?

What is Rails Metal?

there are couple difference between count and length, generally speaking, count does’t load the array so it is faster. However, there are situation count won’t give you an accurate number
here is an example

suppose you have three tables ‘users’, ‘roles’, and the join table ‘roles_users’, and you want to all active users that has role of ‘user’ or ‘admin’
Here is how to get it in rails:

named_scope :active, :joins=> :roles,
     :conditions=>['state=? and roles.name in (?) ', 'active', ['user', 'admin'] ], :group=>'id'

here group is necessary otherwise you will get duplicate users records if users has more than one role.

Here is where length different than count:
say joe is the only user and he has both user and admin roles

User.active.count # returns 2
User.active.length # returns 1

It is easy to figure out why through SQL:
the named_scope translate to

select u.id, u.first_name, u.email
from users u
inner join roles_users ru on ru.user_id = u.id
inner join roles r on r.id = ru.role_id
where u.state = 'active' and r.name in ('user', 'admin')
group by u.id;

the count translates to

select count(*), u.id, u.first_name, u.email
from users u
inner join roles_users ru on ru.user_id = u.id
inner join roles r on r.id = ru.role_id
where u.id = 2 and r.name in ('user', 'admin')
group by u.id;

without group by
+----+------------+--------------------+
| id | first_name | email              |
+----+------------+--------------------+
|  1 | Joe        |    joe@example.com |
|  1 | Joe        |    joe@example.com |
+----+------------+--------------------+
5 rows in set (0.00 sec)

with group by
+----+------------+--------------------+
| id | first_name | email              |
+----+------------+--------------------+
|  1 | Joe        |    joe@example.com |
+----+------------+--------------------+
1 row in set (0.00 sec)

using count and here is why it returns 2
+----------+----+------------+--------------------+
| count(*) | id | first_name | email              |
+----------+----+------------+--------------------+
|        2 |  1 | Joe        |    joe@example.com |
+----------+----+------------+--------------------+
1 row in set (0.00 sec)

the bottom line: don’t use count when using :group

p.s. for more difference between length, size and count, read this blog post: http://rhnh.net/2007/09/26/counting-activerecord-associations-count-size-or-length

Introduction

We all know that in Domain-Driven Design it is good to express our domain with simplicity and “pureness” and for that we usually go for a POxO (Plain Old {fill_with_your_preffered_language} Object) approach. The problem is that the ORM solutions I’ve found for Ruby make us either inherit from some base class or do the mappings directly into our classes. By no means am I saying that they aren’t good, but we are talking about DDD and the idea of having a pure domain layer without distractions is something we should embrace.

My first thought was to write about a full blown example, comparing side by side a common C# / Java implementations to my Ruby implementation but then I realized it would probably have some unnecessary and “boring” information. It’s better to focus on writing about my approach and have some comments here and there to explain how things would be done in other platforms. What I’m going to show here is something that is really common in other languages but not in Ruby I believe, all classes from my domain will be implemented as POROs – Plain Old Ruby Objects, totaly decoupled from any tool that we might use.

There was a talk by Eric Evans called “What I’ve learned about DDD since the book” that has been commented out here and here (slides here). Even though the building blocks of Model-Driven Design mentioned in the book (and the other one mentioned on the talk) are not essential, they are important and will be the subject of this series.

So, to illustrate my ideas I’ll use the common Customer/Order/Product for my examples with some requirements from Jimmy Nilsson – Applying Domain-Driven Design and Patterns:

• List the orders when looking at a specific customer
• Orders have an acceptance status that is changed by the user
• The total value of an order must be lower or equal than one million US$
• A Customer has a credit limit and cannot owe us more than a specified amount of money

Part I – Customer and Products

If you are not familiar with DDD and its building blocks I suggest that have a look at this glossary of DDD terms.

This is our really simple model for this part:

Entities

There’s no big deal here so I’ll just provide some code:

class Customer
  attr_reader :id
  attr_accessor :name
  attr_accessor :credit_limit

  def initialize(name, credit_limit)
    @name = name
    @credit_limit = credit_limit
  end
end

class Product
  attr_reader :id
  attr_accessor :price
  attr_accessor :description

  def initialize(price, description)
    @price = price
    @description = description
  end
end

Repositories

Statically typed languages like Java and C# would have an interface in order to decouple our domain from infrastructure but Ruby doesn’t have interfaces. But still… I believe that we need some kind of contract for the repositories and instead of having a class with empty methods I’ll create in-memory repositories as the pattern definition:

class CustomerRepository
  def self.store(customer)
    customer.instance_variable_set(:@id, next_id) if customer.id.nil?
    customers[customer.id] = customer
  end
  def self.find(id)
    customers[id]
  end
  def self.all
    customers.values
  end
  def self.delete(customer)
    customers.delete(customer.id)
  end  

  private  

  def self.customers
    if !defined?(@@customers)
      @@customers = {}
    else
      @@customers
    end
  end
  def self.next_id
    if !defined?(@@next_id)
      @@next_id = 1
    else
      @@next_id += 1
    end
  end
end

class ProductRepository
  # ... similar code ...
end

Maybe this code could be factored out somewhere but let’s just leave as it is for now.

Right now you might be thinking “This guy is crazy, static methods are evil!!”. Well, I think that it’s not true when it comes to Ruby class methods. Just below I will show you how we can easily add persistence to our domain.

Even if we want to set up a IoC container I don’t think it would be a problem since Ruby classes are objects as well. For example these repositories could be easily injected into a Rails controller instance variable.

Adding persistence

If we use (N)Hibernate, we would probably have the mappings file into a different package / assembly, but in Ruby I think it would be enough to just have persistence related code in another file that redefines the classes.

Mappings

class Customer
  include Clipper::Model

  orm.map(self, "customers") do |customers|
    customers.key(customers.field("id", Clipper::Types::Serial))
    customers.field("name", Clipper::Types::String.new(200))
    customers.field("credit_limit", Clipper::Types::Float(8, 2))
  end
end

class Product
  include Clipper::Model

  orm.map(self, "products") do |products|
    products.key(products.field("id", Clipper::Types::Serial))
    products.field("description", Clipper::Types::String.new(200))
    products.field("price", Clipper::Types::Float(8, 2))
  end
end

Repositories

module ClipperRepository
  def self.included(klass)
    klass.instance_eval do
      include Singleton
      include Clipper::Session::Helper

      def self.orm
        instance.orm
      end
    end
  end
end

class CustomerRepository
  include ClipperRepository

  def self.store(customer)
    orm.save(customer)
  end
  def self.delete(customer)
    orm.delete(customer)
  end
  def self.find(id)
    orm.get(Customer, id)
  end
  def self.all
    orm.all(Customer)
  end
end

class ProductRepository
  # ... similar code  ...
end

Here I’ve used Clipper but for these examples we could probably rewrite it to use DataMapper as well. Unfortunately, with this approach both DataMapper and Clipper will redefine our already defined accessors and that would be a problem if we have some business logic there. For this example this wouldn’t be a problem but I’ve checked with one of Clipper developers and they are willing to have this feature implemented in the library, I’ll have to check if DataMapper folks have something like this in mind as well. I’ve already hacked Clipper in order to have something like Hibernate property access config that defines the strategy for accessing the property value but it still lacks the feature for associations.

Testing

With this approach I believe testing becomes more simple. I’ve created tests for the pure domain and just by including a different file I can test everything hooked up with infrastructure without rewriting the tests. To make things easier, I created two Rake tasks for testing: ‘rake test:domain’ and ‘rake test:infrastructure’. I think they look a bit ugly at the moment but here we go:

namespace :test do
  task :enviroment_domain do |t|
    ENV['DDD_EXAMPLE_HELPER'] = Pathname(__FILE__).dirname + 'tests' + 'domain_helper'
  end

  task :enviroment_infrastructure do |t|
    ENV['DDD_EXAMPLE_HELPER'] = Pathname(__FILE__).dirname + 'tests' + 'infrastructure_helper'
  end

  Rake::TestTask.new(:domain => :enviroment_domain) do |t|
    t.libs << "tests"
    t.test_files = FileList["tests/domain/**/*_test.rb"]
    t.verbose = true
  end

  Rake::TestTask.new(:infrastructure => :enviroment_infrastructure) do |t|
    t.libs << "tests"
    t.test_files = FileList["tests/domain/**/*_test.rb"] + FileList["tests/infrastructure/**/*_test.rb"]
    t.verbose = true
  end
end

Test Case

require ENV['DDD_EXAMPLE_HELPER']

class CustomerRepositoryTest < Test::Unit::TestCase
  # ...
  def test_create
    customer = Customer.new('customer', 1500)
    CustomerRepository.store(customer)
    assert_not_nil(customer.id)
  end
  # ...
end

I believe this approach increases experimentation because we are free to work with our domain without worrying about persistence issues as if we were using Rails ActiveRecord. Rails AR need us to set up DB tables by running migrations in order to use the entities and have access to the properties.

Project Structure

Conclusion

This whole thing might seem weird if you are used to Rails AR, but the fact that we have our domain totaly decoupled from infrastructure issues is important because as technology changes and shifts, and as our domain layer is burdened with complex computer science problems, things will most certainly change.  Keeping the heart of the software decoupled from tools allows those changes to be easier (XP ?).

That’s it! I’d like to thank Michael Brennan and Guilherme Chapiewski for reviewing and contributing with ideas for this post and Sam Smoot for also reviewing and helping me out with Clipper.

I’m figuring out something in my rails app.  I’m figuring out which one’s the worst:

Eager loading 100 rows of data you don’t actually need at the moment

or

10 queries giving 10 result set at once?

Here’s the code to explain it.

@event = Event.find(params[:event_id])

@event_attendees = @event.attendees.paginate(:page => params[:page], :per_page => 10)

In the view, for each attendees, it’s calling a purchase record. Since I’m using will_paginate and setting 10 records per page, for every 10 record of attendees, there’s 10 queries for a purchase record. Here’s the following SQL that will be generated:

SELECT * FROM `attendees` WHERE (`attendees`.event_id = 4)

SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 1) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 2) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 3) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 4) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 5) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 6) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 7) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id =  LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 9) LIMIT 1
SELECT * FROM `purchases` WHERE (purchasable_type = 'Attendee' and purchasable_id = 10) LIMIT 1

Clearly you can that see the above code creates a n + 1 problem.

So I tried to modified it using eager loading like the following:

@event_attendees = @event.attendees.paginate(:include => :purchase, :page => params[:page], :per_page => 10)

Here’s the following SQL query generated:

SELECT * FROM `attendees` WHERE (`attendees`.event_id = 4)
SELECT `purchases`.* FROM `purchases` WHERE (`purchases`.`purchasable_id` IN (1,2,3,4..100) and `purchases`.`purchasable_type` = 'Attendee')
 # query is shorten for brevity

You can see that it’s using 1 query that fetches 100 rows of data. At first I thought that it will limit the eager loading with my will_paginate per page settings. But clearly for every page that I’m viewing, it’s calling that query hence returning 100 rows of data for each page I’m viewing.

At the moment I’m using the query without eager loading. Simply because I’m concern the app is fetching 100 rows that I don’t need at once. I have no idea how to limit an eager loading association base on will _paginate per_page. Or probably I could eager load once and keep in cache. Or does rails does that automatically?

Will investigate though. Oh well, back to work!

Here’s a little gotcha for you which caught me out by surprise, obvious when you think about it, but irritating if you miss it: the ruby String comparison operator does case-sensitive comparisons.

# Good:
['C', 'b', 'A', 'D'].sort #=> ['A', 'b', 'C', 'D']

# Bad (what <=> gives you out the box):
['C', 'b', 'A', 'D'].sort #=> ['A', 'C', 'D', 'b']

For a nice efficient implementation of a AR model comparitor use the String#casecmp method for a case-insensitive comparison:

class MyObject
  def <=>(other)
    self.my_attribute.casecmp(other.my_attribute)
  end
end

OK, so you’ve decided that it’s a good idea for you to override one of the fundamental methods on one of your ActiveRecord models. But in doing so, you have discovered that all of a sudden your callbacks have stopped working.

The reason for this is when your class is loaded, ActiveRecord::Callbacks have already hooked in the callback methods around the relevant methods using alias_method_chain meaning that the once named destroy method is now called destroy_without_callbacks.

So, to actually override the destroy method, use the following code:

def destroy_without_callbacks
  unless new_record?
    # do your code here
  end
  freeze
end

Note that the implementations will differ for other methods e.g. create, so you should check the ActiveRecord base class to see what should be in there.

Source: http://mattpayne.ca/blog/post/named-scope

class Region < ActiveRecord::Base
  belongs_to :country
end

class Country < ActiveRecord::Base
  has_many :regions
end

class Region < ActiveRecord::Base
  #other code
  def self.ordered
    find(:all,  rder => "name ASC")
  end
end

class Region < ActiveRecord::Base
  named_scope  rdered,  rder => "name ASC"
  #other code
end

class Region < ActiveRecord::Base
  belongs_to :country
  named_scope  rdered,  rder => "name ASC"
  named_scope :by_country, lambda { |c| { :conditions => ["country_id = ?", c.id] } }
  named_scope :containing, lambda { |s| { :conditions => ["name like ?", "%#{s}%"] } }
end

class Runner
 c = Country.find_by_name("Canada")
 regions = Region.by_country(c).containing("A").ordered
 puts "Provinces in Canada containing the letter A in ascending order: #{regions.inspect}"
end

class Region < ActiveRecord::Base
  belongs_to :country
  named_scope  rdered,  rder => "name ASC"
  named_scope :by_country, lambda { |c| { :conditions => ["country_id = ?", c.id] } }
  named_scope :containing, lambda { |s| { :conditions => ["name like ?", "%#{s}%"] } }
  named_scope :simple, :select => "id, name"
end

Before getting down to business, I want to present the topics I’m willing to go through here:

1. Finding a nice way to decouple our domain from infrastructure – The discussion will be about forgetting Rails ActiveRecord in order to achieve persistence ignorance.
2. Porting DDDSample to Ruby and Rails – I haven’t seen any movement towards that yet so we could get some people together and make this happen.
3. Finding a way to make usage of a Domain Specific Language in DDDSample.

And that’s it! I still need to learn a bit more on the last topic but I hope that when we get to it I’m already confortable with its concepts and ideas.

Coming up

• A comparisson between a common “C# / Java + (N)Hibernate” implementation of some Model Driven Design building blocks used in DDD and my one.

I started to think about the relation of DDD and Ruby /Rails when I was thinking about the subject of my final paper for university. First I wanted to write about DDD only, it is subject that doesn’t seem to have much attention among the people that I know. But after reading an Eric Evans (author of the blue book) interview for InfoQ – Domain-Driven Design Quickly book, I realized that DDD + Ruby + Rails was something that I should give a try. For the same reasons I agree with him in the way that Ruby can be a nice platform for doing DDD:

InfoQ: Technology platforms (Java, .NET, Ruby, others) are continually evolving. How does Domain Driven Design fit in?

EVANS: [...] DDD is not specific to a technology platform, but some platforms give more expressive ways of creating business logic, and some platforms have less distracting clutter.
[...]  Then you have the new-comers like Ruby. Ruby has a very expressive syntax, and at this basic level it should be a very good language for DDD (although I haven’t heard of much actual use of it in those sorts of applications yet). Rails has generated a lot of excitement because it finally seems to make creation of Web UIs as easy as UIs were back in the early 1990s, before the Web. Right now, this capability has mostly been applied to building some of the vast number of Web applications which don’t have much domain richness behind them, since even these have been painfully difficult in the past. But my hope is that, as the UI implementation part of the problem is reduced, that people will see this as an opportunity to focus more of their attention on the domain. If Ruby usage ever starts going in that direction, I think it could provide an excellent platform for DDD. (A few infrastructure pieces would probably have to be filled in.)
More out on the cutting-edge are the efforts in the area of domain-specific languages (DSLs), which I have long believed could be the next big step for DDD. To date, we still don’t have a tool that really gives us what we need. But people are experimenting more than ever in this area, and that makes me hopeful.
Right now, as far as I can tell, most people attempting to apply DDD are working in Java or .Net, with a few in Smalltalk. So it is the positive trend in the Java world that is having the immediate effect.

So… The book dates from Dec 08, 2006. Has anyone seen a movement toward this direction? I googled about it and I didn’t find anyone talking about a succesful experimentation with the two of them (I’ll add more to that in a minute). Maybe I’m using the wrong keywords or maybe there’s really nothing about. The fact is that there are lots and lots of references and examples of how it works in the context of .NET and Java (and I think some in PHP) but I couldn’t find anything related to Ruby (and Rails).

All that made me come up with the subject for my final paper which will probably be called “Applying Domain-Driven Design with Ruby and Rails” and this blog came as a support for my thoughts.

What (maybe) stop us from doing “DDD on Ruby / Rails”?

After some research I’ve organized a few links about the discussion:

• Discussion on Yahoo Groups
• Domain-driven Ruby on Rails??
• Domain-Driven or Database-Driven?
• Active Record and DDD

They maybe sum up the reasons that people might think we are not able to create an DDD-ish application in Ruby / Rails.

Most of the arguments that I found are that Rails was created for data-centric applications that involves only CRUD. If that is true, it ends up beeing one of the 95% of the applications that won’t benefit from applying DDD. The other main argument probably is that in Rails the domain model entities are implemented using Active Record pattern and that might “break” DDD since it violates the Single Responsibility Principle (and maybe Liskov substition principle as discussed here) and we are bound to the underlaying persistence (which can be  considered as a distraction).

But… It is a fact that Rails is a highly productive framework. So, what if we could bring the two worlds together? Instead of not fighting our framework, what if we were able to “quickly” build more complex applications with the combination DDD + Ruby + Rails? It will probably be not so easy but I’m willing to give it a try.

I’ve done some experimentation in that way and I will be posting about it on the next days so that we can discuss it. For now, I can say that I believe that I found a good way to decouple our domain from infrastructure. I’ve managed to model my domain objects as POROs (plain old ruby objects) taking advantage of Ruby’s open classes and modules mixins.

My plan is to make an attempt to rewrite the DDDSample application writen in Java (I’ll just have to check if someone has a problem with that)

Got something to add? Please leave a comment!

Maybe you think I’m crazy to start this discussion or maybe you are pretty sure the we can’t put DDD and Ruby / Rails together, but feel free to drop by and express your opinion. The main purpose of this blog is to concentrate discussion about the topics.

Today needs to be about writing code.