Vous le savez probablement déjà, il est possible, avec Active Record, de faire vos conditions proprement de deux manières différentes :
Model.find(:all, :conditions => ['champ = ?', valeur])
Model.find(:all, :conditions => {:champ => valeur})

Le second est plus propre. Cependant à première vue, il n’est pas possible d’y faire des conditions autres que le égal (=).
Du coup dès que votre condition devient un chouilla complexe, il deviendrait nécessaire d’utiliser les crochets. C’est dommage.

Heureusement, il des conditions autres que le = sont gerées avec les hashes.
Petit exemple de requête
Model.find(:all, :conditions=>{
:title => "Title",          # title='Title'
:published_at => (Date.now-30 .. Date.now),  # published_at BETWEEN xxx AND xxx
:rating => [ 4, 5, 6 ],          # rating IN ( 4, 5, 6 )
:content => /(a|b|c)/          # REGEXP '(a|b|c)'
)

Cela permet déjà de faire quelques requêtes supplémentaires. Cependant dès que l’on va vouloir faire des choses comme des LIKE, des !=, des >= ou des <=, nous allons, de toute façon, devoir passer par des tableaux.

If you’ve already been using Active Record. And as you’re reading this blog and this article, I suppose you have, even though you may not know you have, you know how it is powerful.
In case your memory fails you, active record is the list of methods used to access databases in Ruby on Rails.
It is compatible with MySQL, SQLite and PostgreSQL (and if you wish to add your own adaptor, you can quite easily).
But Rails is a framework for web applications. And God knows the web isn’t the only face of computer programming.
So we’ll see how easy it is to use Active Record without Rails (or without all rails as activerecord is a part of it).
First of all, you need to install the library. If you already Rails installed on your server, you’re ready to go. Otherwise, do the following :

gem install activerecord

It’ll get the latest stable version of the library and install it on your computer.

Now, let’s start having fun with some code lines :)

Create a new document named (for example) main.rb.

First, you need to call the rubygems and activerecord libraries.

require 'rubygems'
require 'active_record'

With those lines at the top of your document, you now have access to all the methods provided by Active Record.

So let’s use them.

ActiveRecord::Base.establish_connection(
    :adapter => 'mysql',
    :host => 'localhost',
    :user => 'root',
    :password => 'root',
    :database => 'test'
)

This will instantiate the library.
<em>However, it'll not connect you to the database. You're getting connected only when you do the first query</em>

We now need to create a model.
I invite you not to create it in the same document. So create a document named "user.rb" in the same directory as your main.rb.
Put in that new document :
[code lang="ruby"]class User > ActiveRecord::Base
end

And in your main.rb, call it.

require 'user'

You now have access, in your main.rb, to the object User, which is a child of ActiveRecord::Base and grants it all the usual methods available to Ruby on Rails models. However, you're not in a rails application.
So let's get all our users.

p User.find(:all)

Based on the fact that the table "users" exists in your database "test", this will print in your console the hash of all your users.

You can now do anything you want using ActiveRecord in your Ruby console or offline user interfaces applications.

But wait it's not over. Until now, we've defined all our configuration datas directly in the program. And that's very bad. So we need to add an external database.yml document.

adapter: mysql
host: localhost
username: root
password: root
database: refcrawler_dev

And to load that external document in ours to get it's values.

require 'yaml'
dbconfig = YAML::load(File.open('config/database.yml'))
ActiveRecord::Base.establish_connection(dbconfig)

Si vous avez déjà utilisé Active Record. Et vu que vous lisez ce blog et cet article, je suppose que c’est le cas, même si vous n’en savez peut-être rien.

Dans le cas ou votre mémoire vous jouerai des tours, voici un petit rappel. Active Record est une librairie utilisée dans Ruby on Rails et permettant aux applications de manipuler de manière aisée les bases de données.

C’est compatible avec MySQL, SQLite et PostgreSQL (il est cependant tout à fait possible de développer son propre adaptateur).

Mais Rails est un framework pour applications web. Et le web ne se résume pas au développement web.

Du coup nous allons voir comment implémenter et utiliser Active Record dans votre application console.

Tout d’abord, vous devez installer la librairie. Si vous avez déjà installé Rails sur votre machine, vous êtes prêt à démarrer. Dans le cas contraire, tapez la commande suivante en console :

gem install activerecord

Cela téléchargera la dernière version stable de la librairie et l’installera sur la machine.

Maintenant commençons à nous amuser un peu en développant :)

Créez un nouveau document que vous appellerez (par exemple) main.rb

Tout d’abord, vous devez appeller les librairies rubygems et activerecord.

require 'rubygems'
require 'active_record'

Avec ces lignes en haut de votre document, vous avez maintenant accès à toutes les méthodes fournies par Active Record.

Du coup, autant les utiliser.

ActiveRecord::Base.establish_connection(
    :adapter => 'mysql',
    :host => 'localhost',
    :user => 'root',
    :password => 'root',
    :database => 'test'
)

Ceci initialisera la librairie.

Cependant, cela ne vous connectera pas à la base de données. Vous ne le serez que lorsque vous ferez votre première requête.

Maintenant, créons un modèle.

Je vous invite à ne pas le créer dans le document, pour des raisons de propreté de l’application. Créons donc un document nommé « user.rb » dans le même répertoire que votre main.rb.

Placez le code suivant dans votre nouveau document :

class User < ActiveRecord::Base
end

Et dans votre main.rb, appellez le :

require 'user'

Vous avez maintenant accès, dans votre main.rb, à l’objet User, qui hérite de ActiveRecord::Base et vous fournit donc toutes les méthodes habituellement utilisées dans les modèles Ruby on Rails. Vous n’êtes cependant pas dans une application Rails.

Du coup récupérons tous nos utilisateurs.

p User.find(:all)

Si votre table « users » existe dans la base de données « test », ceci affichera dans votre console un bump du hash de tous vos utilisateurs.

Vous pouvez donc maintenant faire tout ce que vous faites habituellement dans vos modèles Ruby on Rails. En passant par les associations entre modèles, en passant par les validations. Et même les migrations (ceci fera cependant l’objet d’un second article).

Mais attendez ce n’est pas tout. Jusqu’à maintenant, nous avons défini nos paramètres de configuration directement dans l’application. Et c’est très très mal. Du coup nous allons ajouter un document database.yml externe :

adapter: mysql
host: localhost
username: root
password: root
database: refcrawler_dev

Et pour charger ces paramètres de connexion dans notre document :

require 'yaml'
dbconfig = YAML::load(File.open('config/database.yml'))
ActiveRecord::Base.establish_connection(dbconfig)
 
Fork me on GitHub