Accès à la base de données DBI en Ruby

Architecture de l'application DBI

DBI est indépendant de toute base de données disponible en arrière-plan. Peu importe que vous utilisiez Oracle, MySQL, Informix, vous pouvez utiliser DBI. Le diagramme d'architecture suivant explique cela clairement.

L'architecture générale de Ruby DBI utilise deux couches :

• Couche d'interface de base de données (DBI). Cette couche est indépendante de la base de données et fournit une série de méthodes d'accès publics, l'utilisation des méthodes n'est pas fonction de type de serveur de base de données.

• Couche de pilote de base de données (DBD). Cette couche dépend de la base de données et différentes pilotes fournissent l'accès à différents moteurs de bases de données. MySQL, PostgreSQL, InterBase, Oracle, etc. utilisent des pilotes différents. Chaque pilote est responsable d'interpréter les requêtes provenant de la couche DBI et de les mapper en requêtes adaptées aux serveurs de bases de données de type donné.

Installation

Si vous souhaitez écrire des scripts Ruby pour accéder à la base de données MySQL, vous devez d'abord installer le module Ruby MySQL.

Installer le paquet de développement Mysql

# Ubuntu
sudo apt-get install mysql-client
sudo apt-get install libmysqlclient15-dev
　
# Centos
yum install mysql-devel

Mac OS nécessite la modification de ~/.bash_profile ou ~/Ajoutez le code suivant au fichier .profile :

MYSQL=/usr/local/mysql/bin
export PATH=$PATH:$MYSQL
export DYLD_LIBRARY_PATH=/usr/local/mysql/lib:$DYLD_LIBRARY_PATH

ou utilisez un lien symbolique :

sudo ln　-s　/usr/local/mysql/lib/libmysqlclient.18.dylib　/usr/lib/libmysqlclient.18.dylib

Installer DBI avec RubyGems (recommandé)

RubyGems a été créé environ2003année11mois, à partir de Ruby 1.9devenue une partie intégrante de la bibliothèque standard Ruby. Pour plus de détails, consultez :RubyGems Ruby

Installer dbi et dbd avec gem-mysql :

sudo gem install dbi
sudo gem install mysql
sudo gem install dbd-mysql

Installer en utilisant le code source (version Ruby inférieure1.9Utilisez cette méthode (）

Ce module est un DBD, il peut être téléchargé depuis http://tmtm.org/downloads/mysql/ruby/ Télécharger et installer.

Téléchargez le dernier paquet après le téléchargement, décompressez-le dans le répertoire et exécutez les commandes suivantes pour l'installer :

ruby extconf.rb
　
ou
　
ruby extconf.rb　--with-mysql-dir=/usr/local/mysql
　
ou
　
ruby extconf.rb　--with-mysql-config

Puis compilez :

make

Obtenir et installer Ruby/DBI

Vous pouvez télécharger et installer le module Ruby DBI à partir des liens suivants :

https://github.com/erikh/ruby-dbi

Assurez-vous d'avoir les privilèges root avant de commencer l'installation. Voici les étapes d'installation :

Étape 1

git clone https://github.com/erikh/ruby-dbi.git

ou décompressez directement le zip.

Étape 2

Accédez au répertoire ruby-dbi-masterdans le répertoire setup.rb Le script de configuration. La commande la plus courante est config sans aucun paramètre après le paramètre config. Cette commande configure par défaut l'installation de tous les pilotes.

ruby setup.rb config

Plus spécifiquement, vous pouvez utiliser --L'option with est utilisée pour lister les parties spécifiques que vous souhaitez utiliser. Par exemple, si vous ne souhaitez configurer que le module principal DBI et le pilote DBD MySQL, entrez la commande suivante :

ruby setup.rb config　--with=dbi,dbd_mysql

Étape 3

La dernière étape consiste à créer le pilote, installez-le avec la commande suivante :

ruby setup.rb setup
ruby setup.rb install

Connexion à la base de données

Supposons que nous utilisions la base de données MySQL, assurez-vous de :

• Vous avez déjà créé une base de données TESTDB.

• Vous avez déjà créé la table EMPLOYEE dans TESTDB.

• La table contient les champs FIRST_NAME, LAST_NAME, AGE, SEX et INCOME.

• Définir l'ID utilisateur "testuser" et le mot de passe "test123" pour accéder à TESTDB

• Le module DBI Ruby a été installé correctement sur votre machine.

• Vous avez déjà vu le tutoriel MySQL et compris les opérations de base MySQL.

Voici un exemple de connexion à la base de données MySQL "TESTDB":

Exemple en ligne

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# 连接到 MySQL 服务器
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　# Obtenir la chaîne de version du serveur et l'afficher
　　　　　row = dbh.select_one("SELECT VERSION()")
　　　　　puts "Version du serveur: "　+　row[0]
rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

Lorsque ce script est exécuté, les résultats suivants seront générés sur un ordinateur Linux.

Server version:　5.0.45

如果建立连接时带有数据源，则返回数据库句柄（Database Handle），并保存到 dbh 中以便后续使用，否则 dbh 将被设置为 nil 值，e.err et e::errstr 分别返回错误代码和错误字符串。

最后，在退出这段程序之前，请确保关闭数据库连接，释放资源。

INSERT 操作

当您想要在数据库表中创建记录时，需要用到 INSERT 操作。

一旦建立了数据库连接，我们就可以准备使用 do 方法或 prepare et execute 方法创建表或创建插入数据表中的记录。

使用 do 语句

不返回行的语句可通过调用 do 数据库处理方法。该方法带有一个语句字符串参数，并返回该语句所影响的行数。

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")
dbh.do("CREATE TABLE EMPLOYEE (
　　　　　FIRST_NAME CHAR(20) NOT NULL,
　　　　　LAST_NAME CHAR(20),
　　　　　AGE INT,　　
　　　　　SEX CHAR(1),
　　　　　INCOME FLOAT )");

同样地，您可以执行 SQL INSERT 语句来创建记录插入 EMPLOYEE 表中。

Exemple en ligne

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# 连接到 MySQL 服务器
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　dbh.do("INSERT INTO EMPLOYEE(FIRST_NAME,
　　　　　　　　　　　　　　　　　　　LAST_NAME,　
　　　　　　　　　　　　　　　　　　　AGE,　
　　　　　　　　　SEX,　
　　　　　　　　　INCOME)
　　　　　　　　　　VALUES ('Mac', 'Mohan',　20, 'M',　2000)")
　　　　　puts "Record has been created"
　　　　　commit
rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

Utilisez prepare et execute

您可以使用 DBI 的 prepare et execute 方法来执行 Ruby 代码中的 SQL 语句。

创建记录的步骤如下：

• 准备带有 INSERT 语句的 SQL 语句。这将通过使用 prepare Méthode pour le faire.

• 执行 SQL 查询，从数据库中选择所有结果。这将通过使用 execute Méthode pour le faire.

• Libérer le gestionnaire de requête. Cela se fait en utilisant finish API 来完成。

• Si tout se passe bien, alors Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. Cette opération, sinon vous pouvez Voici un appel Terminer la transaction.

下面是使用这两种方法的语法：

Exemple en ligne

sth = dbh.prepare(statement)
sth.execute
　　　... zero or more SQL operations ...
sth.finish

这两种方法可用于传 bind 值给 SQL 语句。有时候被输入的值可能未事先给出，在这种情况下，则会用到绑定值。使用问号（?")代替实际值，实际值通过 execute() API 来传递。

下面的示例在 EMPLOYEE 表中创建了两个记录：

Exemple en ligne

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# 连接到 MySQL 服务器
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　sth = dbh.prepare("INSERT INTO EMPLOYEE(FIRST_NAME,
　　　　　　　　　　　　　　　　　　　LAST_NAME,　
　　　　　　　　　　　　　　　　　　　AGE,　
　　　　　　　　　SEX,　
　　　　　　　　　INCOME)
　　　　　　　　　　　　　　　　　　　VALUES (?, ?, ?, ?, ?)" )
　　　　　sth.execute('John', 'Poul',　25, 'M',　2300)
　　　　　sth.execute('Zara', 'Ali',　17, 'F',　1000)
　　　　　sth.finish
　　　　　commit
　　　　　puts "Record has been created"
rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

如果同时使用多个 INSERT，那么先准备一个语句，然后在一个循环中多次执行它要比通过循环每次调用 do 有效率得多。

READ 操作

对任何数据库的 READ 操作是指从数据库中获取有用的信息。

一旦建立了数据库连接，我们就可以准备查询数据库。我们可以使用 do 方法或 prepare et execute 方法从数据库表中获取值。

获取记录的步骤如下：

• Préparer une requête SQL basée sur les conditions nécessaires. Cela se fait en utilisant prepare Méthode pour le faire.

• 执行 SQL 查询，从数据库中选择所有结果。这将通过使用 execute Méthode pour le faire.

• 逐一获取结果，并输出这些结果。这将通过使用 fetch Méthode pour le faire.

• Libérer le gestionnaire de requête. Cela se fait en utilisant finish Méthode pour le faire.

下面的示例从 EMPLOYEE 表中查询所有工资(salary)超过 1000 的记录。

Exemple en ligne

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# 连接到 MySQL 服务器
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　sth = dbh.prepare("SELECT　*　FROM EMPLOYEE　
　　　　　　　　　　　　　　　　　　　　　　　　WHERE INCOME > ?")
　　　　　sth.execute(1000)
　
　　　　　sth.fetch do |row|
　　　　　　　　printf "First Name: %s, Last Name : %s\n", row[0], row[1]
　　　　　　　　printf "Age: %d, Sex : %s\n", row[2], row[3]
　　　　　　　　printf "Salary :%d \n\n", row[4]
　　　　　end
　　　　　sth.finish
rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

Cela produira le résultat suivant :

First Name: Mac, Last Name : Mohan
Age:　20, Sex : M
Salary :2000
First Name: John, Last Name : Poul
Age:　25, Sex : M
Salary :2300

还有很多从数据库获取记录的方法，如果您感兴趣，可以查看 Opérations de lecture DBI Ruby.

Update 操作

对任何数据库的 UPDATE 操作是指更新数据库中一个或多个已有的记录。下面的示例更新 SEX 为 'M' 的所有记录。在这里，我们将把所有男性的 AGE 增加一岁。这将分为三步：

• Préparer une requête SQL basée sur les conditions nécessaires. Cela se fait en utilisant prepare Méthode pour le faire.

• 执行 SQL 查询，从数据库中选择所有结果。这将通过使用 execute Méthode pour le faire.

• Libérer le gestionnaire de requête. Cela se fait en utilisant finish Méthode pour le faire.

• Si tout se passe bien, alors Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. Cette opération, sinon vous pouvez Voici un appel Terminer la transaction.

Exemple en ligne

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# 连接到 MySQL 服务器
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE")　+　1
　　　　　　　　　　　　　　　　　　　　　　　　WHERE SEX = ?")
　　　　　sth.execute('M')
　　　　　sth.finish
　　　　　commit
rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

Opération DELETE

Lorsque vous souhaitez supprimer des enregistrements de la base de données, vous devez utiliser l'opération DELETE. L'exemple suivant supprime les enregistrements de EMPLOYEE où AGE est supérieur à 20 des enregistrements. Les étapes de cette opération sont les suivantes :

• Préparer une requête SQL basée sur les conditions nécessaires. Cela se fait en utilisant prepare Méthode pour le faire.

• Exécuter une requête SQL, supprimer les enregistrements nécessaires de la base de données. Cela se fait en utilisant execute Méthode pour le faire.

• Libérer le gestionnaire de requête. Cela se fait en utilisant finish Méthode pour le faire.

• Si tout se passe bien, alors Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. Cette opération, sinon vous pouvez Voici un appel Terminer la transaction.

Exemple en ligne

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# 连接到 MySQL 服务器
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　sth = dbh.prepare("DELETE FROM EMPLOYEE　
　　　　　　　　　　　　　　　　　　　　　　　　WHERE AGE > ?")
　　　　　sth.execute(20)
　　　　　sth.finish
　　　　　commit
rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

Exécuter une transaction

Une transaction est un mécanisme garantissant l'uniformité des transactions. Une transaction doit avoir les quatre propriétés suivantes :

• Atomisme (Atomicité) :L'atomisme des transactions signifie que le programme contenu dans une transaction est l'unité de travail logique de la base de données, et les opérations de modification des données qu'il effectue doivent être soit entièrement exécutées, soit pas exécutées du tout.

• Uniformité (Consistency) :L'uniformité des transactions signifie que la base de données doit être dans un état uniforme avant et après l'exécution d'une transaction. Si l'état de la base de données satisfait toutes les contraintes d'intégrité, on dit que la base de données est uniforme.

• Isolement (Isolation) :L'isolement des transactions signifie que les transactions concurrentes sont isolées, c'est-à-dire que les opérations internes d'une transaction et les données en cours d'opération doivent être bloquées, afin qu'elles ne soient pas vues par d'autres transactions tentant de les modifier.

• Pérennité (Durabilité) :La pérennité des transactions signifie que lorsque le système ou le support subit une panne, les mises à jour des transactions déjà soumises ne peuvent pas être perdues. C'est-à-dire qu'une fois une transaction soumise, les modifications apportées aux données de la base de données doivent être permanentes et résister à tout dysfonctionnement du système de base de données. La pérennité est assurée par les sauvegardes et les restaurations de la base de données.

DBI fournit deux méthodes pour exécuter des transactions. L'une est Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. ou Voici un appel Méthode, utilisée pour soumettre ou annuler une transaction. Il y a aussi une autre transaction Méthode, utilisable pour réaliser des transactions. Nous allons maintenant présenter ces deux méthodes simples pour réaliser des transactions :

Méthode I

La première méthode utilise DBI Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. et Voici un appel Méthode pour soumettre ou annuler explicitement une transaction :

Exemple en ligne

dbh['AutoCommit'] = false # Mettre le commit automatique à false.
　　　begin
　　　　　WHERE FIRST_NAME = 'John'")+1　
　　　　　　　　　　　　　dbh.transaction do |dbh|
　　　　　WHERE FIRST_NAME = 'John'")+1　
　　　　　　　　　　　　　dbh.do("UPDATE EMPLOYEE SET AGE = AGE
　　　　　commit
　　　rescue
　　　　　puts "transaction failed"
　　　　　dbh.rollback
　　　end
　　　WHERE FIRST_NAME = 'Zara'")

Méthode II

La deuxième méthode utilise transaction Méthode. Cette méthode est relativement simple, car elle nécessite un bloc de code contenant des instructions de transaction.transaction 方法执行块，然后根据块是否执行成功，自动调用 Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. ou Voici un appelBlocs d'exécution de méthode, puis appeler automatiquement en fonction de la réussite ou de l'échec du bloc.

Exemple en ligne

:
　　　dbh['AutoCommit'] = false # Mettre le commit automatique à false
　　　　　WHERE FIRST_NAME = 'John'")+1　
　　　　　　　　　　　　　dbh.transaction do |dbh|
　　　　　WHERE FIRST_NAME = 'John'")+1　
　　　　　　　　　　　　　dbh.do("UPDATE EMPLOYEE SET AGE = AGE
　　　end
　　　WHERE FIRST_NAME = 'Zara'")

dbh['AutoCommit'] = true

Opération COMMIT

méthode. Commit est une opération qui indique que les modifications de la base de données sont terminées, après laquelle toutes les modifications ne peuvent pas être annulées. rollback

commit

dbh.commit

l'opération ROLLBACK Voici un appel Si vous n'êtes pas satisfait d'un ou plusieurs changements, et que vous souhaitez complètement restaurer ces changements, utilisez

méthode. Voici un appel rollback

dbh.rollback

Un exemple simple de méthode.

Déconnexion de la base de données

Pour rompre la connexion à la base de données, utilisez l'API disconnect.

dbh.disconnect

Si l'utilisateur ferme la connexion à la base de données via la méthode disconnect, DBI rollback toutes les transactions non terminées. Cependant, sans dépendre des détails d'implémentation de DBI, votre application peut bien appeler explicitement commit ou rollback.

Gérer les erreurs

Il y a de nombreuses sources d'erreurs. Par exemple, une erreur de syntaxe lors de l'exécution d'une instruction SQL, une échec de connexion, ou l'appel de la méthode fetch sur un handle de requête annulé ou terminé. DBI::InterfaceError et DBI::DatabaseError.

Les objets Exception de ces classes ont err,errstr et state Il y a trois attributs, qui représentent respectivement le numéro d'erreur, une chaîne descriptive de l'erreur et un code d'erreur standard. Les détails des attributs sont les suivants :

• err :Retournez la représentation en nombre de l'erreur survenue, ou nil si le DBD ne le supporte pas. nil. Par exemple, Oracle DBD retourne ORA-XXXX Partie numérique du message d'erreur.

• errstr :Retournez la représentation en chaîne de l'erreur survenue.

• state :Retournez le code SQLSTATE de l'erreur survenue. SQLSTATE est une chaîne de cinq caractères. La plupart des DBD ne le supportent pas, donc nil est retourné.

Dans les exemples précédents, vous avez déjà vu le code suivant: }}

rescue DBI::DatabaseError => e
　　　　　puts "Une erreur s'est produite"
　　　　　puts "Code d'erreur : #{e.err}"
　　　　　puts "Message d'erreur : #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　# Déconnecter de la connexion au serveur
　　　　　dbh.disconnect si dbh
end

Pour obtenir des informations de débogage sur le contenu de l'exécution du script, vous pouvez activer le débogage. Pour cela, vous devez d'abord télécharger dbi/Le module trace, puis appeler le mode de contrôle de trace et la destination des outputs. trace Méthode :

require "dbi/trace"
..............
　
trace(mode, destination)

La valeur de mode peut être 0(off),1,2 ou 3, la valeur de destination doit être un objet IO. Les valeurs par défaut sont 2 et STDERR.

Le bloc de code de la méthode

Il y a plusieurs méthodes pour créer des handles. Ces méthodes appellent des blocs de code. L'un des avantages des blocs de code avec des méthodes est qu'ils fournissent un handle en tant que paramètre au bloc de code, qui est automatiquement supprimé lorsque le bloc se termine. Voici quelques exemples pour mieux comprendre ce concept.

• DBI.connect :Cette méthode génère un handle de base de données, il est recommandé de l'appeler à la fin du bloc. disconnect Pour se déconnecter de la base de données.

• dbh.prepare :Cette méthode génère un handle de requête, il est recommandé de l'appeler à la fin du bloc. finish. À l'intérieur du bloc, vous devez appeler execute Cette méthode permet d'exécuter une instruction.

• dbh.execute :Cette méthode est similaire à dbh.prepare, mais dbh.execute n'a pas besoin d'appeler la méthode execute à l'intérieur du bloc. Le handle de requête s'exécute automatiquement.

Exemple 1

DBI.connect Un bloc de code peut être inclus, en passant un handle à la base de données, et il se déconnecte automatiquement du handle à la fin du bloc.

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　"testuser", "test123") do |dbh|

Exemple 2

dbh.prepare Un bloc de code peut être inclus, en passant un handle à la requête, et il appelle automatiquement finish à la fin du bloc.

dbh.prepare("SHOW Bases de données") do |sth|
　　　　　　　sth.execute
　　　　　　　puts "Bases de données: "　+　sth.fetch_all.join(",")
end

Exemple 3

dbh.execute Un bloc de code peut être inclus, en passant un handle à la requête, et il appelle automatiquement finish à la fin du bloc.

dbh.execute("SHOW Bases de données") do |sth|
　　　puts "Bases de données: "　+　sth.fetch_all.join(",")
end

DBI transaction Les méthodes peuvent également inclure un bloc de code, ce qui a été expliqué dans le chapitre précédent.

Fonctions et attributs spécifiques au pilote

DBI permet aux pilotes de bases de données de fournir des fonctions spécifiques à la base de données supplémentaires, qui peuvent être appelées par l'utilisateur via n'importe quel objet Handle func méthodes pour appeler.

Utilisez []= ou [] Les méthodes peuvent définir ou obtenir les propriétés spécifiques du pilote.

DBD::Mysql implémente les fonctions spécifiques du pilote suivant :

Exemple en ligne

#!/usr/bin/ruby
　
require "dbi"
begin
　　　# 连接到 MySQL 服务器
　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)　
　　　puts dbh.func(:client_info)
　　　puts dbh.func(:client_version)
　　　puts dbh.func(:host_info)
　　　puts dbh.func(:proto_info)
　　　puts dbh.func(:server_info)
　　　puts dbh.func(:thread_id)
　　　puts dbh.func(:stat)
rescue DBI::DatabaseError => e
　　　puts "Une erreur s'est produite"
　　　puts "Code d'erreur : #{e.err}"
　　　puts "Message d'erreur : #{e.errstr}"
ensure
　　　dbh.disconnect si dbh
end

Cela produira le résultat suivant :

5.0.45
50045
Localhost via socket UNIX
10
5.0.45
150621
Uptime :　384981　　Threads :　1　　Questions :　1101078　　Requêtes lentes :　4　\
Ouvrages :　324　　Tables vidées :　1　　Tables ouvertes :　64　　\
Requêtes par seconde en moyenne :　2.860