MySQL Ruby 教程 · ZetCode 中文系列教程

# MySQL Ruby 教程 > 原文： [http://zetcode.com/db/mysqlrubytutorial/](http://zetcode.com/db/mysqlrubytutorial/) 这是针对 MySQL 数据库的 Ruby 编程教程。它涵盖了使用 Ruby 进行 MySQL 编程的基础。它使用`mysql`模块。这些示例是在 Ubuntu Linux 上创建和测试的。在 ZetCode 上有一个类似的 [MySQL C API 教程](/tutorials/mysqlcapitutorial/)， [MySQL Visual Basic 教程](/db/mysqlvb/)或 [MySQL Python 教程](/db/mysqlpython/)。您也可以考虑查看 [MySQL 教程](/databases/mysqltutorial/)。 ## MySQL & Ruby MySQL 是领先的开源数据库管理系统。它是一个多用户，多线程的数据库管理系统。 MySQL 在网络上特别流行。它是由 Linux，Apache，MySQL 和 PHP 组成的非常流行的LAMP平台的一部分。目前，MySQL 由 Oracle 拥有。 MySQL 数据库在最重要的 OS 平台上可用。Ruby 是一种动态的，反射性的，通用的面向对象的编程语言。最近，它在 Web 编程中变得非常流行，这主要归功于 Ruby on Rails 框架的成功。 ## mysql 模块 `mysql`模块是 MySQL 服务器的 Ruby 接口。它为 Ruby 程序提供的功能与 MySQL C API 为 C 程序提供的功能相同。 ```ruby $ sudo gem1.9 install mysql ``` 在这里，我们为 MySQL 数据库安装 Ruby 模块。 ## 开始之前我们将创建一个新的数据库用户和一个新的数据库。为此，我们使用`mysql`客户端程序。 ```ruby $ mysql -u root -p Enter password: Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 30 Server version: 5.0.67-0ubuntu6 (Ubuntu) Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql> SHOW DATABASES; +--------------------+ | Database | +--------------------+ | information_schema | | mysql | +--------------------+ 2 rows in set (0.00 sec) ``` 我们使用 root 帐户连接到 MySQL 服务器。我们用`SHOW DATABASES`语句显示所有可用的数据库。 ```ruby mysql> CREATE DATABASE mydb; Query OK, 1 row affected (0.02 sec) ``` 我们创建一个新的`mydb`数据库。在整个教程中，我们将使用此数据库。 ```ruby mysql> CREATE USER user12@localhost IDENTIFIED BY '34klq*'; Query OK, 0 rows affected (0.00 sec) mysql> USE mydb; Database changed mysql> GRANT ALL ON mydb.* to user12@localhost; Query OK, 0 rows affected (0.00 sec) mysql> quit; Bye ``` 我们创建一个新的数据库用户。我们授予该用户`mydb`数据库所有表的所有特权。 ## MySQL 服务器版本在第一个示例中，我们将获取 MySQL 数据库的版本。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*' puts con.get_server_info rs = con.query 'SELECT VERSION()' puts rs.fetch_row rescue Mysql::Error => e puts e.errno puts e.error ensure con.close if con end ``` 在此脚本中，我们获取服务器版本。我们用两种不同的方式来做。 ```ruby require 'mysql' ``` 我们导入`mysql`模块。该模块具有用于 MySQL 数据库的类和方法。 ```ruby con = Mysql.new 'localhost', 'user12', '34klq*' ``` 我们创建连接对象。参数包括主机名，用户名和密码。在我们的情况下，主机名是`localhost`，例如我们的电脑。 ```ruby puts con.get_server_info ``` 我们创建的 Mysql 对象具有`get_server_info`方法。它返回安装的 MySQL 服务器的版本。 ```ruby rs = con.query 'SELECT VERSION()' puts rs.fetch_row ``` 获取版本的另一种方法是执行`SELECT VERSION()` SQL 语句。我们获取数据。由于只检索一条记录，因此我们称为`fetch_row`方法。 ```ruby rescue Mysql::Error => e puts e.errno puts e.error ``` 我们检查错误。这很重要，因为使用数据库容易出错。 ```ruby ensure con.close if con end ``` 最后，我们释放资源。 ```ruby $ ./version.rb 5.5.9 5.5.9 ``` 输出可能类似于上面。 ## 列出数据库 MySQL Ruby 模块具有`list_dbs`方法，该方法返回可用的数据库。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*' con.list_dbs.each do |db| puts db end rescue Mysql::Error => e puts e.errno puts e.error ensure con.close if con end ``` 在此脚本中，我们在 MySQL 服务器上打印所有可用的数据库。 ```ruby con.list_dbs.each do |db| puts db end ``` `list_dbs`方法返回可用数据库名称的数组。使用数组的`each`方法，我们将数组的每个项目打印到控制台。 ```ruby $ ./listdb.rb information_schema mydb test world ``` 在我的系统上，我创建了上述数据库。 ## 创建并填充表我们创建一个表，并用一些数据填充它。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' con.query("CREATE TABLE IF NOT EXISTS \ Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))") con.query("INSERT INTO Writers(Name) VALUES('Jack London')") con.query("INSERT INTO Writers(Name) VALUES('Honore de Balzac')") con.query("INSERT INTO Writers(Name) VALUES('Lion Feuchtwanger')") con.query("INSERT INTO Writers(Name) VALUES('Emile Zola')") con.query("INSERT INTO Writers(Name) VALUES('Truman Capote')") rescue Mysql::Error => e puts e.errno puts e.error ensure con.close if con end ``` 我们创建一个`Writers`表，并向其中添加五个作者。 ```ruby con.query("CREATE TABLE IF NOT EXISTS \ Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))") ``` 要执行 SQL 语句，我们使用`query`方法。该 SQL 语句创建一个称为`Writers`的新数据库表。它有两列。 ID 和名称。 ```ruby con.query("INSERT INTO Writers(Name) VALUES('Jack London')") con.query("INSERT INTO Writers(Name) VALUES('Honore de Balzac')") ... ``` 我们使用`INSERT`语句在表中插入作者。在这里，我们添加两行。 ```ruby mysql> SELECT * FROM Writers; +----+-------------------+ | Id | Name | +----+-------------------+ | 1 | Jack London | | 2 | Honore de Balzac | | 3 | Lion Feuchtwanger | | 4 | Emile Zola | | 5 | Truman Capote | +----+-------------------+ 5 rows in set (0.00 sec) ``` 执行脚本后，我们使用`mysql`客户端工具从`Writers`表中选择所有数据。 ## 检索数据现在我们已经将一些数据插入数据库中，我们可以将其取回。 ```ruby #!/usr/bin/ruby require "mysql" begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query("SELECT * FROM Writers") n_rows = rs.num_rows puts "There are #{n_rows} rows in the result set" n_rows.times do puts rs.fetch_row.join("\s") end rescue Mysql::Error => e puts e.errno puts e.error ensure con.close if con end ``` 在此示例中，我们从 Writers 表中检索所有数据。 ```ruby con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' ``` 构造器的最后一个参数是我们要连接的数据库名称。 ```ruby rs = con.query("SELECT * FROM Writers") ``` 该 SQL 语句从`Writers`表中选择所有数据。 ```ruby n_rows = rs.num_rows ``` 我们使用结果集对象的`num_rows`方法获得结果集中的行数。 ```ruby n_rows.times do puts rs.fetch_row.join("\s") end ``` 在这里，我们使用`fetch_row`方法获取每一行。它返回一行作为字段数组。默认情况下，打印时这些字段用换行分隔。使用`join`方法，我们将每一行打印在一行上。字段由一个空格分隔。 ```ruby $ ./retrieve1.rb There are 5 rows in the result set 1 Jack London 2 Honore de Balzac 3 Lion Feuchtwanger 4 Emile Zola 5 Truman Capote ``` 接下来，我们介绍另一种从表中检索数据的方法。 ```ruby #!/usr/bin/ruby require "mysql" begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query("SELECT * FROM Writers") rs.each do |row| puts row.join("\s") end rescue Mysql::Error => e puts e.errno puts e.error ensure con.close if con end ``` 我们从`Writers`表中打印所有数据。这次我们使用结果集的每种方法遍历数据。 ```ruby rs.each do |row| puts row.join("\s") end ``` 我们使用每种方法遍历结果集。 ```ruby $ ./retrieve2.rb 1 Jack London 2 Honore de Balzac 3 Lion Feuchtwanger 4 Emile Zola 5 Truman Capote ``` 这是示例的输出。我们可以以 Ruby 哈希的形式遍历数据。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)" puts "We have #{rs.num_rows} row(s)" rs.each_hash do |row| puts row['Id'] + " " + row['Name'] end rescue Mysql::Error => e puts e ensure con.close if con end ``` 在示例中，我们使用`each_hash`迭代器。可以通过列名称检索结果集中的记录。 ```ruby rs.each_hash do |row| puts row['Id'] + " " + row['Name'] end ``` 我们使用`each_hash`方法查看结果集。返回的每一行都是一个 Ruby 哈希；键值对的集合。键是列名。 ```ruby $ ./retrieve3.rb We have 3 row(s) 1 Jack London 2 Honore de Balzac 3 Lion Feuchtwanger ``` 示例的输出。 ## 多个语句 MySQL 支持多条语句执行。必须通过特殊选项启用它。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' con.set_server_option Mysql::OPTION_MULTI_STATEMENTS_ON rs = con.query "SELECT Name FROM Writers WHERE Id=1; SELECT Name FROM Writers WHERE Id=2; SELECT Name FROM Writers WHERE Id=3" puts rs.fetch_row while con.next_result rs = con.store_result puts rs.fetch_row end rescue Mysql::Error => e puts e.errno puts e.error ensure con.close if con end ``` 在此示例中，我们在一个查询中具有三个`SELECT`语句。 ```ruby con.set_server_option Mysql::OPTION_MULTI_STATEMENTS_ON ``` 首先，我们需要使用`Mysql::OPTION_MULTI_STATEMENTS_ON`启用多条语句处理。 ```ruby rs = con.query "SELECT Name FROM Writers WHERE Id=1; SELECT Name FROM Writers WHERE Id=2; SELECT Name FROM Writers WHERE Id=3" ``` 在这里，我们定义了三个`SELECT`语句。它们之间用分号分隔。 ```ruby puts rs.fetch_row ``` 查询方法返回第一个结果集。我们从该结果集中获取一行。 ```ruby while con.next_result rs = con.store_result puts rs.fetch_row end ``` 我们将获得其他结果集，直到没有更多要处理的语句为止。 ```ruby $ ./multiplest.rb Jack London Honore de Balzac Lion Feuchtwanger ``` 运行示例。 ## 元数据元数据是有关数据库中数据的信息。 MySQL 系统中的元数据包含有关存储数据的表和列的信息。受 SQL 语句影响的行数是元数据。结果集中返回的行数和列数也属于元数据。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)" puts "We have #{con.field_count} fields" puts "We have #{rs.num_rows} row(s)" puts rs.fetch_row.join("\s") rescue Mysql::Error => e puts e ensure con.close if con end ``` 在此脚本中，我们从 SQL 查询中找出行数和列数。 ```ruby rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)" ``` 该 SQL 语句返回三行。每行有两列。 ```ruby puts "We have #{con.field_count} fields" puts "We have #{rs.num_rows} row(s)" ``` 这两行返回结果集中的列数和行数。请注意，此处的字段是列的同义词。返回的数据是元数据。 ```ruby puts rs.fetch_row.join("\s") ``` 在这里，我们从结果集中返回一行。这是存储在我们数据库表中的原始数据。对于`INSERT`，`DELETE`和`UPDATE`语句，有一种称为`rows_affected`的方法。此方法返回受这三个语句影响的行数。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' con.query "DELETE FROM Writers WHERE Id IN (1, 2, 3)" puts "The query has affected #{con.affected_rows} rows" rescue Mysql::Error => e puts e ensure con.close if con end ``` 在我们的示例中，我们从`Writers`表中删除了前三行。 ```ruby con.query "DELETE FROM Writers WHERE Id IN (1, 2, 3)" ``` 一个 SQL 语句，该语句删除`Writers`表的前三行。 ```ruby puts "The query has affected #{con.affected_rows} rows" ``` 在这里，我们得到受上述 SQL 语句影响的行数。该数字属于元数据。 ```ruby $ ./affected.rb The query has affected 3 rows mysql> SELECT * FROM Writers; +----+---------------+ | Id | Name | +----+---------------+ | 4 | Emile Zola | | 5 | Truman Capote | +----+---------------+ 2 rows in set (0.00 sec) ``` 我们执行受影响的`.rb`脚本，并检查`Writers`表中的更改。三行已被删除。在下一个示例中，我们将检查有关字段的元数据。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query "SELECT * FROM Writers WHERE Id=1" field = rs.fetch_field_direct 1 puts "Table name: #{field.table}" puts "Field name: #{field.name}" puts "Field length: #{field.length}" puts "Field type: #{field.type}" rescue Mysql::Error => e puts e ensure con.close if con end ``` 我们从数据库中获得一条记录。我们得到字段的表名，列名，长度和类型。 ```ruby rs = con.query "SELECT * FROM Writers WHERE Id=1" ``` 该查询返回一行。它有两列。 ```ruby field = rs.fetch_field_direct 1 ``` 使用`fetch_field_direct`方法，我们得到了一条特定的记录。更准确地说，记录来自第一行第二列的交集。 ```ruby puts "Table name: #{field.table}" puts "Field name: #{field.name}" puts "Field length: #{field.length}" puts "Field type: #{field.type}" ``` 我们使用字段对象的属性读取器获取元数据。 ```ruby $ ./metadata.rb Table name: Writers Field name: Name Field length: 25 Field type: 253 ``` 这是示例的输出。在与元数据有关的最后一个示例中，我们将打印表中的所有行及其列名。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query "SELECT * FROM Writers" fields = rs.fetch_fields puts "%3s %s" % [fields[0].name, fields[1].name] rs.each_hash do |row| puts "%3s %s" % [row['Id'], row['Name']] end rescue Mysql::Error => e puts e ensure con.close if con end ``` 我们将`Writers`表的内容打印到控制台。现在，我们也包括列的名称。 ```ruby fields = rs.fetch_fields puts "%3s %s" % [fields[0].name, fields[1].name] ``` 第一步，我们获取列名。它们使用标准的 Ruby 字符串格式化函数进行打印。 ```ruby rs.each_hash do |row| puts "%3s %s" % [row['Id'], row['Name']] end ``` 现在，将获取数据并将其打印到控制台。我们也进行一些格式化。 ```ruby $ ./columnheaders.rb Id Name 1 Jack London 2 Honore de Balzac 3 Lion Feuchtwanger 4 Emile Zola 5 Truman Capote ``` 脚本的输出。 ## 预备语句现在，我们将以预备语句来关注自己。在编写预备语句时，我们使用占位符，而不是直接将值写入语句中。预准备的语句可提高安全性和性能。 ```ruby #!/usr/bin/ruby require 'mysql' name = "Stefan Zweig" begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' pst = con.prepare "INSERT INTO Writers(Name) VALUES(?)" pst.execute name rescue Mysql::Error => e puts e ensure con.close if con pst.close if pst end ``` 在上面的示例中，我们将新行插入`Writers`表。我们使用预备语句。 ```ruby pst = con.prepare "INSERT INTO Writers(Name) VALUES(?)" ``` `prepare`方法用于创建预备语句。 `?`字符是一个占位符。稍后，我们将一个值绑定到该占位符。 ```ruby pst.execute name ``` 我们将名称变量中的值绑定到占位符，并执行预备语句。 ```ruby pst.close if pst ``` 预备语句已关闭。 ```ruby mysql> SELECT * FROM Writers; +----+-------------------+ | Id | Name | +----+-------------------+ | 1 | Jack London | | 2 | Honore de Balzac | | 3 | Lion Feuchtwanger | | 4 | Emile Zola | | 5 | Truman Capote | | 6 | Stefan Zweig | +----+-------------------+ 6 rows in set (0.00 sec) ``` 脚本成功运行后，我们在`Writers`表中看到一个新作者。 ## 写图像有些人喜欢将其图像放入数据库中，有些人则希望将其保留在文件系统中以供其应用使用。当我们处理大量图像时，会出现技术难题。图像是二进制数据。 MySQL 数据库具有一种特殊的数据类型来存储称为`BLOB`（二进制大对象）的二进制数据。 ```ruby mysql> CREATE TABLE Images(Id INT PRIMARY KEY AUTO_INCREMENT, Data MEDIUMBLOB); Query OK, 0 rows affected (0.06 sec) ``` 对于此示例，我们创建一个名为`Images`的新表。 ```ruby #!/usr/bin/ruby require 'mysql' begin fin = File.open("woman.jpg" , "rb") img = fin.read rescue SystemCallError => e puts e ensure fin.close if fin end begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' pst = con.prepare("INSERT INTO Images SET Data='%s'" % img.unpack('H*')) pst.execute rescue Mysql::Error => e puts e ensure con.close if con pst.close if pst end ``` 在上面的脚本中，我们读取 JPG 图像并将其插入到`Images`表中。 ```ruby fin = File.open("woman.jpg" , "rb") img = fin.read ``` 我们打开并阅读图像。 `read`方法以字符串形式返回数据。 ```ruby pst = con.prepare("INSERT INTO Images SET Data='%s'" % img.unpack('H*')) ``` 将该字符串数据放入预备语句中。在这样做之前，使用 Ruby 字符串对象的`unpack`方法对其进行解码。解码是必需的，因为图像对象具有许多无法正常处理的特殊字符。 ## 读取图像在前面的示例中，我们已将图像插入数据库表中。现在，我们将从表中读取图像。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' rs = con.query "SELECT Data FROM Images LIMIT 1" f = File.new "woman2.jpg", "wb" f.write rs.fetch_row.pack 'H*' rescue Mysql::Error, SystemCallError => e puts e ensure con.close if con f.close if f end ``` 我们从图片表中读取了一张图片。 ```ruby rs = con.query "SELECT Data FROM Images LIMIT 1" ``` 我们从表中选择一条记录。 ```ruby f = File.new "woman2.jpg", "wb" ``` 我们创建一个可写的二进制文件。 ```ruby f.write rs.fetch_row.pack 'H*' ``` 我们从先前的 SQL 语句中获取数据并将其写入文件。 `fetch_row`方法返回一个数组对象。在将数据写入文件之前，使用数组的`pack`方法将其放回原始格式。对于解码和反转这两种操作，我们使用相同的指令`'H*'`。它代表十六进制字符串。现在我们在当前目录中应该有一个名为`woman2.jpg`的映像。我们可以检查它是否与我们插入表中的图像相同。 ## 事务支持 `transaction`是针对一个或多个数据库中数据的数据库操作的基本单位。事务中所有 SQL 语句的影响可以全部提交给数据库，也可以全部回滚。默认情况下，MySQL 在自动提交模式下运行。在这种模式下，对表的所有更改将立即生效。为了防止这种情况，我们必须关闭自动提交模式。禁用自动提交后，对事务感知表的更改不会立即永久更改。要存储更改，我们必须调用`COMMIT`语句或`ROLLBACK`还原它们。 Ruby MySQL 为这些 SQL 语句`commit`和`rollback`提供了便捷的方法。 MySQL 数据库具有不同类型的存储引擎。最常见的是 MyISAM 和 InnoDB 引擎。在数据安全性和数据库速度之间需要权衡。 MyISAM 表的处理速度更快，并且不支持事务。 `commit`和`rollback`方法未实现。他们什么都不做。另一方面，InnoDB 表可以更安全地防止数据丢失。他们支持事务。它们处理较慢。 ```ruby mysql> SELECT TABLE_NAME, ENGINE FROM information_schema.TABLES -> where TABLE_SCHEMA = 'mydb' AND TABLE_NAME='Writers'; +------------+--------+ | TABLE_NAME | ENGINE | +------------+--------+ | Writers | InnoDB | +------------+--------+ 1 row in set (0.00 sec) ``` `Writers`表的引擎是 InnoDB，它支持事务。 ```ruby #!/usr/bin/ruby require 'mysql' begin con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb' con.autocommit false pst = con.prepare "UPDATE Writers SET Name = ? WHERE Id = ?" pst.execute "Leo Tolstoy", "1" pst.execute "Boris Pasternak", "2" pst.execute "Leonid Leonov" con.commit rescue Mysql::Error => e puts e con.rollback ensure pst.close if pst con.close if con end ``` 在此脚本中，我们尝试更新三行。 ```ruby con.autocommit false ``` 自动提交模式被禁用。 ```ruby pst = con.prepare "UPDATE Writers SET Name = ? WHERE Id = ?" pst.execute "Leo Tolstoy", "1" pst.execute "Boris Pasternak", "2" pst.execute "Leonid Leonov" ``` 我们执行三个`UPDATE`语句。最后一个不正确。第二个参数丢失。 ```ruby con.commit ``` 如果一切正常，则更改将提交到表中。 ```ruby rescue Mysql::Error => e puts e con.rollback ``` 如果发生错误，则会回滚更改。 ```ruby $ ./update.rb execute: param_count(2) != number of argument(1) mysql> SELECT * FROM Writers; +----+-------------------+ | Id | Name | +----+-------------------+ | 1 | Jack London | | 2 | Honore de Balzac | | 3 | Lion Feuchtwanger | | 4 | Emile Zola | | 5 | Truman Capote | | 6 | Stefan Zweig | +----+-------------------+ 6 rows in set (0.00 sec) ``` 运行脚本会出现错误。但是，该事务已回滚，并且前两行未更改。 [Tweet](https://twitter.com/share) 这是 MySQL Ruby 教程。您可能也对 [PostgreSQL Ruby 教程](/db/postgresqlruby/)， [SQLite Ruby 教程](/db/sqliteruby/)或 [MongoDB Ruby 教程](/db/mongodbruby/)感兴趣。