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

Architecture des applications DBI

DBI est indépendant de toute base de données disponible dans le backend. Que vous utilisiez Oracle, MySQL, Informix, vous pouvez utiliser DBI. Le schéma d'architecture ci-dessous l'illustre 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 public pouvant être utilisées quel que soit le 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érents pilotes donnent accès à différents moteurs de base de données. MySQL, PostgreSQL, InterBase, Oracle, etc. utilisent respectivement des pilotes différents. Chaque pilote est chargé d'interpréter les requêtes de la couche DBI et de mapper ces requêtes à celles appropriées pour un type de serveur de base de données donné.

Installation

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

Installez le package de développement Mysql

# Ubuntu
sudo apt-get install mysql-client
sudo apt-get install libmysqlclient15-dev

# Centos
yum install mysql-devel

Le système Mac OS doit modifier le fichier ~/.bash_profile ou ~/.profile, ajoutez le code suivant :

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

ou utilisez une connexion douce :

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

Installer DBI à l'aide de RubyGems (recommandé)

RubyGems a été créé vers novembre 2003 et fait partie de la bibliothèque standard Ruby depuis la version 1.9 de Ruby. Pour plus de détails, consultez : Ruby RubyGems

Utilisez gem pour installer dbi et dbd-mysql :

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

Utilisez le code source pour installer (utilisez cette méthode si la version de Ruby est inférieure à 1.9)

Le module est un DBD et peut être téléchargé depuis http://tmtm.org/downloads/mysql/ruby/.

Téléchargez le dernier package, décompressez-le et entrez dans le répertoire, exécutez la commande suivante pour installer :

% ruby extconf.rb

或者

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

或者

% ruby extconf.rb --with-mysql-config

Puis compilez :

% make

Récupérez et installez Ruby/ DBI

Vous pouvez télécharger et installer le module Ruby DBI à partir du lien ci-dessous :

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

Avant de commencer l'installation, assurez-vous d'avoir un accès root. Maintenant, veuillez suivre les étapes ci-dessous pour installer :

Étape 1

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

Ou téléchargez directement le package zip et décompressez-le.

Étape 2

Entrez dans le répertoire ruby-dbi-master et utilisez le script setup.rb dans le répertoire pour configurer. La commande de configuration la plus couramment utilisée est le paramètre config suivi d'aucun paramètre. Cette commande est configurée pour installer tous les pilotes par défaut.

$ ruby setup.rb config

Plus précisément, vous pouvez utiliser l'option --with pour lister les parties spécifiques que vous souhaitez utiliser. Par exemple, si vous souhaitez uniquement configurer le module DBI principal et le pilote de couche MySQL DBD, entrez la commande suivante :

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

Étape 3

La dernière étape consiste à créer le pilote et à l'installer en utilisant la commande suivante :

$ ruby setup.rb setup
$ ruby setup.rb install

Connexion à la base de données

Supposons que nous utilisons une base de données MySQL Avant de vous connecter à la base de données, veuillez vous assurer :

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

• Vous avez créé la table EMPLOYEE dans TESTDB.

• Cette table contient les champs FIRST_NAME, LAST_NAME, AGE, SEX et REVENU.

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

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

• Vous avez regardé le tutoriel MySQL et compris les opérations de base de MySQL.

  
  

Ce qui suit est un exemple de connexion à la base de données MySQL "TESTDB" :

#!/usr/bin/ruby -w

require "dbi"

begin
     # 连接到 MySQL 服务器
     dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", 
                       "testuser", "test123")
     # 获取服务器版本字符串，并显示
     row = dbh.select_one("SELECT VERSION()")
     puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Lors de l'exécution de ce script, il sera exécuté sous Linux Les résultats suivants sont produits sur la machine.

Server version: 5.0.45

Si la connexion est établie avec une source de données, le handle de base de données (Database Handle) sera renvoyé et enregistré dans dbh pour une utilisation ultérieure, sinon dbh sera be Mis à une valeur nulle, e.err et e::errstr renvoient respectivement le code d'erreur et la chaîne d'erreur.

Enfin, avant de quitter ce programme, assurez-vous de fermer la connexion à la base de données et de libérer les ressources.

Opération INSERT

Lorsque vous souhaitez créer des enregistrements dans une table de base de données, vous devez utiliser l'opération INSERT.

Une fois la connexion à la base de données établie, nous sommes prêts à créer une table ou à créer une insertion dans la table de données en utilisant la méthode do ou la prepare et exécuter enregistrements de méthodes.

Utilisez l'instruction do

Les instructions qui ne renvoient pas de lignes peuvent être effectuées en appelant la méthode de traitement de la base de données do. Cette méthode prend un paramètre de chaîne d'instruction et renvoie le nombre de lignes affectées par l'instruction.

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 )" );

De même, vous pouvez exécuter l'instruction SQL INSERT pour créer des enregistrements à insérer dans la table EMPLOYEE.

#!/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"
     dbh.commit
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Utilisez prepare et execute

Vous pouvez utiliser les méthodes prepare et execute de DBI pour exécuter des instructions SQL dans du code Ruby.

Les étapes pour créer un enregistrement sont les suivantes :

• Préparez l'instruction SQL avec l'instruction INSERT. Cela se fera en utilisant la méthode prepare.

• Exécutez une requête SQL pour sélectionner tous les résultats de la base de données. Cela se fera en utilisant la méthode execute.

• Relâchez la poignée de déclaration. Cela se fera à l'aide de l'API finish.

• Si tout se passe bien, validez l'action, sinon vous pouvez rollback pour finaliser la transaction.

Voici la syntaxe d'utilisation de ces deux méthodes :

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

Ces deux méthodes peuvent être utilisées pour transmettre la valeur bind au SQL déclaration. Parfois, la valeur saisie ne peut pas être donnée à l'avance, auquel cas une valeur limitée est utilisée. Utilisez des points d'interrogation (?) à la place de la valeur réelle, qui est transmise via l'APIexecute().

L'exemple suivant crée deux enregistrements dans la table EMPLOYEE :

#!/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
     dbh.commit
     puts "Record has been created"
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Si plusieurs INSERT sont utilisés en même temps, il est préférable de préparer d'abord une instruction, puis de l'exécuter plusieurs fois en boucle. qu'il est beaucoup plus efficace d'appeler do à chaque fois en boucle.

Opération READ

L'opération READ sur n'importe quelle base de données fait référence à l'obtention d'informations utiles à partir de la base de données.

Une fois la connexion à la base de données établie, nous sommes prêts à interroger la base de données. Nous pouvons obtenir les valeurs de la table de la base de données en utilisant la méthode do ou les méthodes prepare et execute.

Les étapes pour obtenir les enregistrements sont les suivantes :

• Préparez la requête SQL en fonction des conditions requises. Cela se fera en utilisant la méthode prepare.

• Exécutez une requête SQL pour sélectionner tous les résultats de la base de données. Cela se fera en utilisant la méthode execute.

• Obtenez les résultats un par un et affichez ces résultats. Cela se fera en utilisant la méthode fetch.

• Relâchez la poignée de déclaration. Cela se fera en utilisant la méthode finish.

L'exemple suivant interroge tous les enregistrements dont le salaire (salaire) dépasse 1 000 dans la table EMPLOYEE.

#!/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 "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
ensure
     # 断开与服务器的连接
     dbh.disconnect if 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

Il existe également de nombreuses façons d'obtenir des enregistrements de la base de données, si vous êtes intéressé, vous pouvez consulter l'Opération Ruby DBI Read .

Opération de mise à jour

L'opération UPDATE sur n'importe quelle base de données fait référence à la mise à jour d'un ou plusieurs enregistrements existants dans la base de données. L'exemple suivant met à jour tous les enregistrements dont le SEX est « M ». Ici, nous ajouterons un an à l'AGE pour tous les hommes. Cela se fera en trois étapes :

• Préparer la requête SQL en fonction des conditions requises. Cela se fera en utilisant la méthode prepare.

• Exécutez une requête SQL pour sélectionner tous les résultats de la base de données. Cela se fera en utilisant la méthode execute.

• Relâchez la poignée de déclaration. Cela se fera en utilisant la méthode finish.

• Si tout se passe bien, validez l'action, sinon vous pouvez rollback pour finaliser la transaction.

#!/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
     dbh.commit
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if 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 tous les enregistrements de EMPLOYEE avec un AGE supérieur à 20. Les étapes de cette opération sont les suivantes :

• Préparer une requête SQL basée sur les conditions requises. Cela se fera en utilisant la méthode prepare.

• Exécutez une requête SQL pour supprimer les enregistrements requis de la base de données. Cela se fera en utilisant la méthode execute.

• Relâchez la poignée de déclaration. Cela se fera en utilisant la méthode finish.

• Si tout se passe bien, validez l'action, sinon vous pouvez rollback pour finaliser la transaction.

#!/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
     dbh.commit
rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Exécuter des transactions

Les transactions sont un mécanisme permettant d'assurer la cohérence des transactions. Une transaction doit avoir les quatre attributs suivants :

• Atomicité : L'atomicité d'une transaction signifie que le programme inclus dans la transaction fonctionne comme la logique de l'unité de base de données , toutes les opérations de modification de données qu'il effectue sont soit effectuées, soit pas du tout effectuées.

• Cohérence : La cohérence d'une transaction signifie que la base de données doit être dans un état cohérent avant et après l'exécution d'une transaction. Une base de données est dite cohérente si son état satisfait à toutes les contraintes d’intégrité.

• Isolement : L'isolement des transactions signifie que les transactions simultanées sont isolées les unes des autres, c'est-à-dire que les opérations au sein d'une transaction et les données exploitées doivent être bloquées afin qu'il ne puisse pas être vu par d'autres transactions tentant de le modifier.

• Durabilité : La durabilité d'une transaction signifie garantir que les mises à jour des transactions validées ne peuvent pas être perdues en cas de panne du système ou du support. Autrement dit, une fois qu'une transaction est validée, ses modifications apportées aux données de la base de données doivent être permanentes et résister à toute défaillance du système de base de données. La durabilité est assurée grâce à la sauvegarde et à la restauration de la base de données.

DBI propose deux méthodes d'exécution des transactions. L'une est la méthode commit ou rollback, qui est utilisée pour valider ou annuler la transaction. Il existe également la méthode transaction, qui peut être utilisée pour mettre en œuvre des transactions. Ensuite, nous présenterons ces deux méthodes simples d'implémentation des transactions :

Méthode I

La première méthode utilise la méthode commit et rollback de DBI pour explicitement valider ou annuler la transaction :

   dbh['AutoCommit'] = false # 设置自动提交为 false.
   begin
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'John'")
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'Zara'")
     dbh.commit
   rescue
     puts "transaction failed"
     dbh.rollback
   end
   dbh['AutoCommit'] = true

Méthode II

La deuxième méthode utilise la méthode transaction. Cette méthode est relativement simple car elle nécessite un bloc de code contenant les instructions qui composent la transaction. La méthode transaction exécute le bloc, puis appelle automatiquement commit ou rollback selon que le bloc est exécuté avec succès :

   dbh['AutoCommit'] = false # 设置自动提交为 false
   dbh.transaction do |dbh|
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'John'")
     dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 
             WHERE FIRST_NAME = 'Zara'")
   end
   dbh['AutoCommit'] = true

opération COMMIT

Commit est une opération qui identifie que les modifications apportées à la base de données ont été effectuées. Après cette opération, toutes les modifications sont irréversibles.

Ce qui suit est un exemple simple d'appel de la méthode commit.

     dbh.commit

Opération ROLLBACK

Si vous n'êtes pas satisfait d'une ou plusieurs modifications et que vous souhaitez annuler complètement ces modifications, utilisez la méthode rollback.

Ce qui suit est un exemple simple d'appel de la méthode rollback.

     dbh.rollback

Déconnectez la base de données

Pour vous déconnecter de la base de données, veuillez utiliser l'API de déconnexion.

    dbh.disconnect

Si l'utilisateur ferme la connexion à la base de données via la méthode de déconnexion, DBI annulera toutes les transactions en cours. Cependant, sans s'appuyer sur les détails de l'implémentation DBI, votre application peut très bien appeler explicitement commit ou rollback.

Gestion des erreurs

Il existe de nombreuses sources d'erreurs différentes. Par exemple, il y a une erreur de syntaxe lors de l'exécution d'une instruction SQL, ou la connexion échoue, ou la méthode fetch est appelée sur un handle d'instruction annulé ou terminé.

Si une méthode DBI échoue, DBI lèvera une exception. Les méthodes DBI peuvent lever n'importe quel type d'exception, mais les deux classes d'exceptions les plus importantes sont DBI::InterfaceError et DBI::DatabaseError.

Les objets d'exception de ces classes ont trois attributs : err, errstr et state Le sous-tableau représente le numéro d'erreur, un descriptif. La chaîne d'erreur et un code d'erreur standard. Les attributs sont détaillés comme suit :

• err : renvoie la représentation entière de l'erreur survenue, ou nil si le DBD ne le fait pas le soutenir. Par exemple, Oracle DBD renvoie la partie numérique du message d'erreur ORA-XXXX.

• errstr : Renvoie une représentation sous forme de chaîne de l'erreur qui s'est produite.

• state : Renvoie le code SQLSTATE de l'erreur survenue. SQLSTATE est une chaîne de cinq caractères. La plupart des DBD ne le prennent pas en charge, donc nul n'est renvoyé.

Dans l'exemple ci-dessus, vous avez vu le code suivant :

rescue DBI::DatabaseError => e
     puts "An error occurred"
     puts "Error code:    #{e.err}"
     puts "Error message: #{e.errstr}"
     dbh.rollback
ensure
     # 断开与服务器的连接
     dbh.disconnect if dbh
end

Afin d'obtenir des informations de débogage sur ce que le script exécute lors de son exécution, vous pouvez activer tracé. Pour ce faire, vous devez d'abord télécharger le module dbi/trace puis appeler la méthode trace qui contrôle le mode trace et la destination de sortie : La valeur du mode

require "dbi/trace"
..............

trace(mode, destination)

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

contient quelques méthodes pour créer des handles. Ces méthodes sont appelées via des blocs de code. L'avantage d'utiliser des blocs de code avec des méthodes est qu'ils fournissent un handle vers le bloc de code en tant que paramètre, qui est automatiquement effacé à la fin du bloc. Vous trouverez ci-dessous quelques exemples pour vous aider à comprendre ce concept.

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

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

• dbh.execute : Cette méthode est similaire à dbh.prepare, mais dbh.execute ne nécessite pas d'appeler la méthode d'exécution dans le bloc. Les handles d’instructions sont automatiquement exécutés.

Instance 1

DBI.connect peut avoir un bloc de code, transmettez-lui le handle de la base de données, et il se brisera automatiquement à la fin de le bloc Poignée d'ouverture.

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

Exemple 2

dbh.prepare peut prendre un bloc de code, lui transmettre un handle d'instruction et finish sera automatiquement appelé à la fin du bloc.

dbh.prepare("SHOW DATABASES") do |sth|
       sth.execute
       puts "Databases: " + sth.fetch_all.join(", ")
end

Exemple 3

dbh.execute peut prendre un bloc de code, lui transmettre un handle d'instruction et finish sera automatiquement appelé à la fin du bloc. La méthode

dbh.execute("SHOW DATABASES") do |sth|
   puts "Databases: " + sth.fetch_all.join(", ")
end

DBI transaction peut également avoir un bloc de code, qui a été expliqué dans le chapitre ci-dessus.

Fonctions et propriétés spécifiques au pilote

DBI permet au pilote de base de données de fournir des fonctions supplémentaires spécifiques à la base de données, qui peuvent être utilisées par l'utilisateur via la méthode func de n'importe quel objet Handle. est appelé.

Utilisez les méthodes []= ou [] pour définir ou obtenir des propriétés spécifiques au pilote.

DBD::Mysql implémente les fonctions spécifiques au pilote suivantes :

Numéro de série	Fonction et description
1	序号 函数 & 描述 1 dbh.func(:createdb, db_name) 创建一个新的数据库。 2 dbh.func(:dropdb, db_name) 删除一个数据库。 3 dbh.func(:reload) 执行重新加载操作。 4 dbh.func(:shutdown) 关闭服务器。 5 dbh.func(:insert_id) => Fixnum 返回该连接的最近 AUTO_INCREMENT 值。 6 dbh.func(:client_info) => String 根据版本返回 MySQL 客户端信息。 7 dbh.func(:client_version) => Fixnum 根据版本返回客户端信息。这与 :client_info 类似，但是它会返回一个 fixnum，而不是返回字符串。 8 dbh.func(:host_info) => String 返回主机信息。 9 dbh.func(:proto_info) => Fixnum 返回用于通信的协议。 10 dbh.func(:server_info) => String 根据版本返回 MySQL 服务器端信息。 11 dbh.func(:stat) => Stringb> 返回数据库的当前状态。 12 dbh.func(:thread_id) => Fixnum 返回当前线程的 ID。 dbh.func(:createdb, db_name) Créez une nouvelle base de données.
2	dbh.func(:dropdb, db_name) Supprimer une base de données.
3	dbh.func(:reload) Effectuez l'opération de rechargement.
4	<🎜>dbh.func(:shutdown)<🎜> Arrêtez le serveur.
5	<🎜>dbh.func(:insert_id) => Fixnum<🎜> Renvoie la valeur AUTO_INCREMENT la plus récente pour la connexion.
6	<🎜>dbh.func(:client_info) => String<🎜> Renvoyer les informations du client MySQL selon la version .
7	<🎜>dbh.func(:client_version) => Fixnum <🎜> Renvoyer les informations du client en fonction de la version. Ceci est similaire à :client_info, mais il renvoie un fixnum au lieu d'une chaîne.
8	<🎜>dbh.func(:host_info) => String<🎜> Renvoie les informations sur l'hôte.
9	<🎜>dbh.func(:proto_info) => Fixnum<🎜> Renvoie le protocole utilisé pour la communication.
10	<🎜>dbh.func(:server_info) => String <🎜> Renvoyer les informations côté serveur MySQL en fonction à la version.
11	<🎜>dbh.func(:stat) => Stringb> Renvoie l'état actuel de la base de données. <🎜>
12	<🎜>dbh.func(:thread_id) => Fixnum<🎜> Renvoie le fil de discussion actuel IDENTIFIANT.

<🎜>Instance<🎜>

#!/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 "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

<🎜>Cela produira les résultats suivants :<🎜>

5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 \
Opens: 324  Flush tables: 1  Open tables: 64  \
Queries per second avg: 2.860

<🎜>