MySQL Ruby 教程

MySQL Ruby 教程

这是针对 MySQL 数据库的 Ruby 编程教程。 它涵盖了使用 Ruby 进行 MySQL 编程的基础。 它使用mysql模块。 这些示例是在 Ubuntu Linux 上创建和测试的。

如果您需要重新了解 Ruby 语言，可以在上找到完整的Ruby 教程。

MySQL & Ruby

_MySQL是领先的开源数据库管理系统。 它是一个多用户，多线程的数据库管理系统。 MySQL 在网络上特别流行。 它是由 Linux，Apache，MySQL 和 PHP 组成的非常流行的LAMP平台的一部分。 目前，MySQL 由 *** 拥有。 MySQL 数据库在最重要的 OS 平台上可用。Ruby_ 是一种动态的，反射性的，通用的面向对象的编程语言。 最近，它在 Web 编程中变得非常流行，这主要归功于 Ruby on Rails 框架的成功。

mysql 模块

mysql模块是 MySQL 服务器的 Ruby 接口。 它为 Ruby 程序提供的功能与 MySQL C API 为 C 程序提供的功能相同。

$ sudo gem1.9 install mysql

在这里，我们为 MySQL 数据库安装 Ruby 模块。

开始之前

我们将创建一个新的数据库用户和一个新的数据库。 为此，我们使用mysql客户端程序。

我们使用 root 帐户连接到 MySQL 服务器。 我们用SHOW DATABASES语句显示所有可用的数据库。

mysql> CREATE DATABASE mydb;Query OK, 1 row affected (0.02 sec)

我们创建一个新的mydb数据库。 在整个教程中，我们将使用此数据库。

mysql> CREATE USER user12@localhost IDENTIFIED BY '34klq*';Query OK, 0 rows affected (0.00 sec)mysql> USE mydb;Database changedmysql> GRANT ALL ON mydb.* to user12@localhost;Query OK, 0 rows affected (0.00 sec)mysql> quit;Bye

我们创建一个新的数据库用户。 我们授予该用户mydb数据库所有表的所有特权。

MySQL 服务器版本

在第一个示例中，我们将获取 MySQL 数据库的版本。

#!/usr/bin/rubyrequire '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.errorensure    con.close if conend

在此脚本中，我们获取服务器版本。 我们用两种不同的方式来做。

require 'mysql'

我们导入mysql模块。 该模块具有用于 MySQL 数据库的类和方法。

con = Mysql.new 'localhost', 'user12', '34klq*'

我们创建连接对象。 参数包括主机名，用户名和密码。 在我们的情况下，主机名是 localhost，例如 我们的电脑。

puts con.get_server_info

我们创建的 Mysql 对象具有get_server_info方法。 它返回安装的 MySQL 服务器的版本。

rs = con.query 'SELECT VERSION()'puts rs.fetch_row    

获取版本的另一种方法是执行SELECT VERSION() SQL 语句。 我们获取数据。 由于只检索一条记录，因此我们称为fetch_row方法。

rescue Mysql::Error => e    puts e.errno    puts e.error

我们检查错误。 这很重要，因为使用数据库容易出错。

ensure    con.close if conend

最后，我们释放资源。

$ ./version.rb5.5.95.5.9

输出可能类似于上面。

列出数据库

MySQL Ruby 模块具有list_dbs方法，该方法返回可用的数据库。

#!/usr/bin/rubyrequire 'mysql'begin    con = Mysql.new 'localhost', 'user12', '34klq*'    con.list_dbs.each do |db|        puts db    endrescue Mysql::Error => e    puts e.errno    puts e.errorensure    con.close if conend

在此脚本中，我们在 MySQL 服务器上打印所有可用的数据库。

con.list_dbs.each do |db|    puts dbend

list_dbs方法返回可用数据库名称的数组。 使用数组的 each 方法，我们将数组的每个项目打印到控制台。

$ ./listdb.rbinformation_schemamydbtestworld

在我的系统上，我创建了上述数据库。

创建并填充表

我们创建一个表，并用一些数据填充它。

#!/usr/bin/rubyrequire '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.errorensure    con.close if conend

我们创建一个 Writers 表，并向其中添加五个作者。

con.query("CREATE TABLE IF NOT EXISTS \        Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))")

要执行 SQL 语句，我们使用query方法。 该 SQL 语句创建一个称为 Writers 的新数据库表。 它有两列。 ID 和名称。

con.query("INSERT INTO Writers(Name) VALUES('Jack London')")con.query("INSERT INTO Writers(Name) VALUES('Honore de Balzac')")...

我们使用INSERT语句在表中插入作者。 在这里，我们添加两行。

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 表中选择所有数据。

检索数据

现在我们已经将一些数据插入数据库中，我们可以将其取回。

#!/usr/bin/rubyrequire "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")    endrescue Mysql::Error => e    puts e.errno    puts e.errorensure    con.close if conend

在此示例中，我们从 Writers 表中检索所有数据。

con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'

构造函数的最后一个参数是我们要连接的数据库名称。

rs = con.query("SELECT * FROM Writers")

该 SQL 语句从Writers表中选择所有数据。

n_rows = rs.num_rows

我们使用结果集对象的num_rows方法获得结果集中的行数。

n_rows.times do    puts rs.fetch_row.join("\s")end

在这里，我们使用fetch_row方法获取每一行。 它返回一行作为字段数组。 默认情况下，打印时这些字段用换行分隔。 使用join方法，我们将每一行打印在一行上。 字段由一个空格分隔。

$ ./retrieve1.rbThere are 5 rows in the result set1 Jack London2 Honore de Balzac3 Lion Feuchtwanger4 Emile Zola5 Truman Capote

接下来，我们介绍另一种从表中检索数据的方法。

#!/usr/bin/rubyrequire "mysql"begin    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'    rs = con.query("SELECT * FROM Writers")    rs.each do |row|        puts row.join("\s")    endrescue Mysql::Error => e    puts e.errno    puts e.errorensure    con.close if conend

我们从Writers表中打印所有数据。 这次我们使用结果集的每种方法遍历数据。

rs.each do |row|    puts row.join("\s")end

我们使用每种方法遍历结果集。

$ ./retrieve2.rb1 Jack London2 Honore de Balzac3 Lion Feuchtwanger4 Emile Zola5 Truman Capote

这是示例的输出。

我们可以以 Ruby 哈希的形式遍历数据。

#!/usr/bin/rubyrequire '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 conend

在示例中，我们使用each_hash迭代器。 可以通过列名称检索结果集中的记录。

rs.each_hash do |row|    puts row['Id'] + " " + row['Name']end     

我们使用each_hash方法查看结果集。 返回的每一行都是一个 Ruby 哈希； 键值对的集合。 键是列名。

$ ./retrieve3.rbWe have 3 row(s)1 Jack London2 Honore de Balzac3 Lion Feuchtwanger

示例的输出。

多个语句

MySQL 支持多条语句执行。 必须通过特殊选项启用它。

#!/usr/bin/rubyrequire '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.errorensure    con.close if conend

在此示例中，我们在一个查询中具有三个SELECT语句。

con.set_server_option Mysql::OPTION_MULTI_STATEMENTS_ON

首先，我们需要使用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"

在这里，我们定义了三个SELECT语句。 它们之间用分号分隔。

puts rs.fetch_row 

查询方法返回第一个结果集。 我们从该结果集中获取一行。

while con.next_result    rs = con.store_result        puts rs.fetch_rowend   

我们将获得其他结果集，直到没有更多要处理的语句为止。

$ ./multiplest.rbJack LondonHonore de BalzacLion Feuchtwanger

运行示例。

元数据

元数据是有关数据库中数据的信息。 MySQL 系统中的元数据包含有关存储数据的表和列的信息。 受 SQL 语句影响的行数是元数据。 结果集中返回的行数和列数也属于元数据。

#!/usr/bin/rubyrequire '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 conend

在此脚本中，我们从 SQL 查询中找出行数和列数。

rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)"

该 SQL 语句返回三行。 每行有两列。

puts "We have #{con.field_count} fields"puts "We have #{rs.num_rows} row(s)"

这两行返回结果集中的列数和行数。 请注意，此处的字段是列的同义词。 返回的数据是元数据。

puts rs.fetch_row.join("\s")

在这里，我们从结果集中返回一行。 这是存储在我们数据库表中的原始数据。

对于INSERT，DELETE和UPDATE语句，有一种称为rows_affected的方法。 此方法返回受这三个语句影响的行数。

#!/usr/bin/rubyrequire '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 conend

在我们的示例中，我们从Writers表中删除了前三行。

con.query "DELETE FROM Writers WHERE Id IN (1, 2, 3)"

一个 SQL 语句，该语句删除Writers表的前三行。

puts "The query has affected #{con.affected_rows} rows"

在这里，我们得到受上述 SQL 语句影响的行数。 该数字属于元数据。

$ ./affected.rbThe query has affected 3 rowsmysql> SELECT * FROM Writers;+----+---------------+| Id | Name          |+----+---------------+|  4 | Emile Zola    ||  5 | Truman Capote |+----+---------------+2 rows in set (0.00 sec)

我们执行受影响的.rb 脚本，并检查Writers表中的更改。 三行已被删除。

在下一个示例中，我们将检查有关字段的元数据。

#!/usr/bin/rubyrequire '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 eensure    con.close if conend

我们从数据库中获得一条记录。 我们得到字段的表名，列名，长度和类型。

rs = con.query "SELECT * FROM Writers WHERE Id=1"

该查询返回一行。 它有两列。

field = rs.fetch_field_direct 1

使用fetch_field_direct方法，我们得到了一条特定的记录。 更准确地说，记录来自第一行第二列的交集。

puts "Table name: #{field.table}"puts "Field name: #{field.name}"puts "Field length: #{field.length}"puts "Field type: #{field.type}"

我们使用字段对象的属性读取器获取元数据。

$ ./metadata.rbTable name: WritersField name: NameField length: 25Field type: 253

这是示例的输出。

在与元数据有关的最后一个示例中，我们将打印表中的所有行及其列名。

#!/usr/bin/rubyrequire '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']]    endrescue Mysql::Error => e    puts eensure    con.close if conend

我们将Writers表的内容打印到控制台。 现在，我们也包括列的名称。

fields = rs.fetch_fields    puts "%3s %s" % [fields[0].name, fields[1].name]

第一步，我们获取列名。 它们使用标准的 Ruby 字符串格式化功能进行打印。

rs.each_hash do |row|    puts "%3s %s" % [row['Id'], row['Name']]end

现在，将获取数据并将其打印到控制台。 我们也进行一些格式化。

$ ./columnheaders.rb Id Name  1 Jack London  2 Honore de Balzac  3 Lion Feuchtwanger  4 Emile Zola  5 Truman Capote

脚本的输出。

预备语句

现在，我们将以预备语句来关注自己。 在编写预备语句时，我们使用占位符，而不是直接将值写入语句中。 预准备的语句可提高安全性和性能。

#!/usr/bin/rubyrequire 'mysql'name = "Stefan Zweig"begin    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'        pst = con.prepare "INSERT INTO Writers(Name) VALUES(?)"    pst.execute namerescue Mysql::Error => e    puts e    ensure    con.close if con    pst.close if pstend

在上面的示例中，我们将新行插入Writers表。 我们使用预备语句。

pst = con.prepare "INSERT INTO Writers(Name) VALUES(?)"

prepare方法用于创建预备语句。 ?字符是一个占位符。 稍后，我们将一个值绑定到该占位符。

pst.execute name

我们将名称变量中的值绑定到占位符，并执行预备语句。

pst.close if pst

预备语句已关闭。

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（二进制大对象）的二进制数据。

mysql> CREATE TABLE Images(Id INT PRIMARY KEY AUTO_INCREMENT, Data MEDIUMBLOB);Query OK, 0 rows affected (0.06 sec)

对于此示例，我们创建一个名为Images的新表。

#!/usr/bin/rubyrequire 'mysql'begin    fin = File.open("woman.jpg" , "rb")    img = fin.readrescue SystemCallError => e          puts eensure    fin.close if fin endbegin    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 eensure    con.close if con    pst.close if pstend

在上面的脚本中，我们读取 JPG 图像并将其插入到Images表中。

fin = File.open("woman.jpg" , "rb")img = fin.read

我们打开并阅读图像。 read方法以字符串形式返回数据。

pst = con.prepare("INSERT INTO Images SET Data='%s'" % img.unpack('H*'))

将该字符串数据放入预备语句中。 在这样做之前，使用 Ruby 字符串对象的unpack方法对其进行解码。 解码是必需的，因为图像对象具有许多无法正常处理的特殊字符。

读取图像

在前面的示例中，我们已将图像插入数据库表中。 现在，我们将从表中读取图像。

#!/usr/bin/rubyrequire '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 eensure    con.close if con    f.close if fend

我们从图片表中读取了一张图片。

rs = con.query "SELECT Data FROM Images LIMIT 1" 

我们从表中选择一条记录。

f = File.new "woman2.jpg", "wb"

我们创建一个可写的二进制文件。

f.write rs.fetch_row.pack 'H*'

我们从先前的 SQL 语句中获取数据并将其写入文件。 fetch_row方法返回一个数组对象。 在将数据写入文件之前，使用数组的pack方法将其放回原始格式。 对于解码和反转这两种操作，我们使用相同的指令'H*'。 它代表十六进制字符串。

现在我们在当前目录中应该有一个名为woman2.jpg的映像。 我们可以检查它是否与我们插入表中的图像相同。

事务支持

transaction是针对一个或多个数据库中数据的数据库操作的基本单位。 事务中所有 SQL 语句的影响可以全部提交给数据库，也可以全部回滚。

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，它支持事务。

在此脚本中，我们尝试更新三行。

自动提交模式被禁用。

pst = con.prepare "UPDATE Writers SET Name = ? WHERE Id = ?"pst.execute "Leo Tolstoy", "1"pst.execute "Boris Pasternak", "2"pst.execute "Leonid Leonov"

我们执行三个UPDATE语句。 最后一个不正确。 第二个参数丢失。

如果一切正常，则更改将提交到表中。

rescue Mysql::Error => e    puts e    con.rollback

如果发生错误，则会回滚更改。

$ ./update.rbexecute: 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)

运行脚本会出现错误。 但是，该事务已回滚，并且前两行未更改。

您可能也对 MySQL Python 教程， MySQL Visual Basic 教程或 MySQL PHP 教程，MySQL Java 教程，MySQL Ruby 教程，MySQL C# 教程感兴趣。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。