Tutoriales de acceso a bases de datos DBI en Ruby

Arquitectura de aplicación DBI

DBI es independiente de cualquier base de datos disponible en segundo plano. Independientemente de si usa Oracle, MySQL, Informix, puede usar DBI. El diagrama de arquitectura a continuación ilustra claramente esto.

La arquitectura general de Ruby DBI utiliza dos capas:

• Capa de interfaz de base de datos (DBI). Esta capa es independiente de la base de datos y proporciona una serie de métodos de acceso comunes, el uso de los métodos no depende del tipo de servidor de base de datos.

• Capa de controlador de base de datos (DBD). Esta capa depende de la base de datos y diferentes controladores proporcionan acceso a diferentes motores de bases de datos. MySQL, PostgreSQL, InterBase, Oracle, etc. utilizan diferentes controladores. Cada controlador es responsable de interpretar las solicitudes de la capa DBI y mapearlas a solicitudes adecuadas para el servidor de base de datos del tipo dado.

Instalar

Si desea escribir scripts de Ruby para acceder a la base de datos MySQL, primero debe instalar el módulo Ruby MySQL.

Instalar el paquete de desarrollo de Mysql

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

El sistema Mac OS necesita modificar ~/.bash_profile o ~/Agregar el siguiente código al archivo .profile:

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

O crear un enlace simbólico:

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

Instalar DBI usando RubyGems (recomendado)

RubyGems se creó aproximadamente en2003Año11Mes, desde Ruby 1.9Desde la versión se convirtió en parte de la biblioteca estándar de Ruby. Para más detalles, consulte:RubyGems en Ruby

Instalar dbi y dbd usando gem-mysql：

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

Instalar usando código fuente (versión de Ruby menor1.9utilizando este método）

Este módulo es un DBD y se puede obtener desde http://tmtm.org/downloads/mysql/ruby/ Descargar e instalar.

Descomprimir el paquete más reciente después de la descarga, ingresar al directorio y ejecutar los siguientes comandos para instalar:

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

Luego compila:

make

Obtener e instalar Ruby/DBI

Puede descargar e instalar el módulo Ruby DBI desde los siguientes enlaces:

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

Asegúrese de que tiene permisos de root antes de comenzar la instalación. Ahora, siga los siguientes pasos para instalar:

Pasos 1

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

o descomprimir directamente el paquete zip.

Pasos 2

ingresar al directorio ruby-dbi-masteren el directorio, utilice setup.rb para configurar. El comando más utilizado es config sin parámetros adicionales después del parámetro de configuración. Este comando se configura por defecto para instalar todos los controladores.

ruby setup.rb config

Más específicamente, puede usar --El parámetro with se utiliza para listar las partes específicas que desea usar. Por ejemplo, si solo desea configurar el módulo DBI principal y el nivel de controlador DBD de MySQL, ingrese el siguiente comando:

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

Pasos 3

El último paso es establecer el controlador, utilice el siguiente comando para instalar:

ruby setup.rb setup
ruby setup.rb install

Conexión de base de datos

Supongamos que estamos utilizando una base de datos MySQL, asegúrese de lo siguiente antes de conectar a la base de datos:

• Ya ha creado una base de datos TESTDB.

• Ya ha creado la tabla EMPLOYEE en TESTDB.

• La tabla tiene los campos FIRST_NAME, LAST_NAME, AGE, SEX y INCOME.

• Configurar el ID de usuario "testuser" y la contraseña "test123para acceder a TESTDB

• El módulo DBI de Ruby se ha instalado correctamente en su máquina.

• Ya ha visto el tutorial de MySQL y comprende las operaciones básicas.

A continuación, se muestra un ejemplo de conexión a la base de datos MySQL "TESTDB":

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# Conectar al servidor MySQL
　　　　　dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　　　　　　"testuser", "test123)
　　　　　# Obtener la cadena de versión del servidor y mostrarla
　　　　　row = dbh.select_one("SELECT VERSION()")
　　　　　puts "Versión del servidor: "　+　row[0]
rescue DBI::DatabaseError => e
　　　　　puts "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

Al ejecutar este script, se producirán los siguientes resultados en una máquina Linux.

Server version:　5.0.45

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

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

INSERT 操作

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

一旦建立了数据库连接，我们就可以准备使用 do 方法或 prepare y 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

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# Conectar al servidor 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 "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

Usar prepare y execute

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

创建记录的步骤如下：

• 准备带有 INSERT 语句的 SQL 语句。这将通过使用 prepare Método para completar.

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

• Libere el manejador de sentencias. Esto se logra utilizando finish API 来完成。

• Si todo va bien, entonces Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. Esta operación, de lo contrario, puede A continuación se muestra una llamada Completar la transacción.

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

Ejemplo en línea

sth = dbh.prepare(statement)
sth.execute
　　　... 0 o más operaciones SQL ...
sth.finish

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

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

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# Conectar al servidor 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 "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

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

READ 操作

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

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

获取记录的步骤如下：

• Preparar una consulta SQL basada en las condiciones necesarias. Esto se logra utilizando prepare Método para completar.

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

• 逐一获取结果，并输出这些结果。这将通过使用 fetch Método para completar.

• Libere el manejador de sentencias. Esto se logra utilizando finish Método para completar.

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

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# Conectar al servidor 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 "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

Esto producirá el siguiente resultado:

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

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

Update 操作

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

• Preparar una consulta SQL basada en las condiciones necesarias. Esto se logra utilizando prepare Método para completar.

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

• Libere el manejador de sentencias. Esto se logra utilizando finish Método para completar.

• Si todo va bien, entonces Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. Esta operación, de lo contrario, puede A continuación se muestra una llamada Completar la transacción.

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# Conectar al servidor 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 "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

Operación DELETE

Cuando desee eliminar registros de la base de datos, necesitará usar la operación DELETE. El siguiente ejemplo elimina registros de EMPLOYEE con AGE superior a 20 registros. Los pasos de esta operación son los siguientes:

• Preparar una consulta SQL basada en las condiciones necesarias. Esto se logra utilizando prepare Método para completar.

• Ejecutar una consulta SQL, eliminar los registros necesarios de la base de datos. Esto se logra utilizando execute Método para completar.

• Libere el manejador de sentencias. Esto se logra utilizando finish Método para completar.

• Si todo va bien, entonces Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. Esta operación, de lo contrario, puede A continuación se muestra una llamada Completar la transacción.

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require "dbi"
　
begin
　　　　　# Conectar al servidor 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 "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

Ejecutar transacción

Una transacción es un mecanismo que asegura la consistencia de las transacciones. Una transacción debe tener las siguientes cuatro propiedades:

• Atomicidad (Atomicity):La atomicidad de la transacción se refiere a que el programa contenido en la transacción es la unidad de trabajo lógica de la base de datos, y las operaciones de modificación de datos que realiza deben ejecutarse completamente o no ejecutarse en absoluto.

• Consistencia (Consistency):La consistencia de la transacción significa que la base de datos debe estar en un estado consistente antes y después de la ejecución de la transacción. Si el estado de la base de datos satisface todas las restricciones de integridad, se dice que la base de datos es consistente.

• Aislación (Isolation):La aislación de la transacción se refiere a que las transacciones concurrentes están aisladas entre sí, es decir, las operaciones internas de una transacción y los datos en los que se están operando deben bloquearse, no deben ser vistos por otras transacciones que intentan modificar.

• Persistencia (Durability):La persistencia de la transacción significa que cuando ocurre un fallo en el sistema o el medio, se asegura de que las actualizaciones de las transacciones comprometidas no se pierdan. Es decir, una vez que se compromete una transacción, los cambios en los datos de la base de datos deben ser permanentes, capaces de soportar cualquier fallo del sistema de base de datos. La persistencia se garantiza mediante respaldos y restauraciones de bases de datos.

DBI proporciona dos métodos para ejecutar transacciones. Uno es Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. o A continuación se muestra una llamada Método, utilizado para comprometer o revertir la transacción. También hay otro transaction Método, que se puede utilizar para implementar transacciones. A continuación, presentaremos estos dos métodos simples para implementar transacciones:

Método I

El primer método utiliza DBI Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. y A continuación se muestra una llamada Método para explicitar el compromiso o cancelación de la transacción:

Ejemplo en línea

dbh['AutoCommit'] = false # Establecer el commit automático en 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 "transacción fallida"
　　　　　dbh.rollback
　　　end
　　　WHERE FIRST_NAME = 'Zara'

Método II

El segundo método utiliza transaction Método. Este método es relativamente simple, ya que requiere un bloque de código que contiene las sentencias que constituyen la transacción.transaction Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. o A continuación se muestra una llamadabloque de ejecución de método, luego según si el bloque se ejecuta con éxito o no, se llama automáticamente

Ejemplo en línea

：
　　　dbh['AutoCommit'] = false # Establecer autoCommit en 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

Operación COMMIT

método. Commit es una operación que identifica que los cambios en la base de datos se han completado, después de esta operación, todos los cambios no se pueden deshacer. rollback

commit

dbh.commit

operación ROLLBACK A continuación se muestra una llamada Si no está satisfecho con algunos o varios cambios, desea restaurar completamente estos cambios, utilice

método. A continuación se muestra una llamada rollback

dbh.rollback

Un ejemplo simple de método.

Desconectar base de datos

Para desconectar la conexión de base de datos, utilice la API disconnect.

dbh.disconnect

Si el usuario cierra la conexión de base de datos a través del método disconnect, DBI rolled back todas las transacciones no completadas. Sin embargo, no es necesario depender de los detalles de implementación de DBI, su aplicación puede llamar explícitamente a commit o rollback.

Manejo de errores

Hay muchos orígenes diferentes de errores. Por ejemplo, errores de sintaxis en la ejecución de una sentencia SQL, fallo en la conexión, o llamada al método fetch a un manejador de sentencia cancelado o completado. DBI::InterfaceError y DBI::DatabaseError.

Estos objetos Exception de la clase tienen err、errstr y state Tres atributos, que representan respectivamente el número de error, una cadena descriptiva del error y un código de error estándar. La descripción específica de los atributos es la siguiente:

• err：Devuelve la representación numérica del error ocurrido, si el DBD no lo soporta se devuelve nil. Por ejemplo, el DBD de Oracle devuelve ORA-XXXX Parte numérica del mensaje de error.

• errstr：Devuelve la representación de cadena del error ocurrido.

• state：Devuelve el código SQLSTATE del error ocurrido. SQLSTATE es una cadena de cinco caracteres. La mayoría de los DBD no lo soportan, por lo que se devuelve nil.

En los ejemplos anteriores ya ha visto el siguiente código:

rescue DBI::DatabaseError => e
　　　　　puts "Se produjo un error"
　　　　　puts "Código de error:         #{e.err}"
　　　　　puts "Mensaje de error: #{e.errstr}"
　　　　　dbh.rollback
ensure
　　　　　#　Desconectar la conexión con el servidor
　　　　　dbh.disconnect if dbh
end

Para obtener información de depuración sobre el contenido de ejecución del script, puede activar el seguimiento. Para esto, debe descargar primero dbi/El módulo trace, luego llame al modo de seguimiento de control y la ubicación de destino de salida. trace método：

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

El valor de mode puede ser 0(off)、1、2 o 3El valor de destination debe ser un objeto IO. Los valores predeterminados son 2 y STDERR.

método de código del bloque

hay varios métodos para crear manejadores. Estos métodos se llaman a través de bloques de código. La ventaja de usar bloques de código con métodos es que proporcionan un manejador como parámetro al bloque de código, que se borra automáticamente cuando el bloque termina. A continuación se presentan algunos ejemplos que ayudan a entender este concepto.

• DBI.connect ：Este método genera un manejador de base de datos, se recomienda llamar a disconnect al final del bloque. disconnect para desconectar la base de datos.

• dbh.prepare ：Este método genera un manejador de instrucciones, se recomienda llamar a finish al final del bloque. finishEn el bloque, debe llamar a execute método para ejecutar instrucciones.

• dbh.execute ：Este método es similar a dbh.prepare, pero dbh.execute no necesita llamar al método execute dentro del bloque. El manejador de sentencias se ejecutará automáticamente.

ejemplo 1

DBI.connect puede tener un bloque de código, al que se le pasa un manejador de base de datos y se cierra automáticamente el manejador al final del bloque.

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost",　
　　　　　　　　　　　　　　　　　　"testuser", "test123do　|dbh|

ejemplo 2

dbh.prepare puede tener un bloque de código, al que se le pasa un manejador de sentencias y se llama automáticamente a finish al final del bloque.

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

ejemplo 3

dbh.execute puede tener un bloque de código, al que se le pasa un manejador de sentencias y se llama automáticamente a finish al final del bloque.

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

DBI transaction Los métodos también pueden tener un bloque de código, lo cual se ha explicado en el capítulo anterior.

funciones y propiedades de controladores específicos

DBI permite que los programas de control de bases de datos proporcionen funciones específicas de bases de datos adicionales, que los usuarios pueden llamar a través de cualquier objeto Handle func método para llamar.

Usar []= o [] El método puede configurar o obtener las propiedades específicas del driver de programa.

DBD::Mysql implementa las funciones específicas del siguiente driver de programa:

Ejemplo en línea

#!/usr/bin/ruby
　
require "dbi"
begin
　　　# Conectar al servidor 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 "Se produjo un error"
　　　puts "Código de error:         #{e.err}"
　　　puts "Mensaje de error: #{e.errstr}"
ensure
　　　dbh.disconnect if dbh
end

Esto producirá el siguiente resultado:

5.0.45
50045
Localhost a través de socket UNIX
10
5.0.45
150621
Tiempo de actividad:　384981　　Hilos:　1　　Preguntas:　1101078　　Consultas lentas:　4　\
Aperturas:　324　　Tablas vaciadas:　1　　Tablas abiertas:　64　　\
Promedio de consultas por segundo:　2.860