2025年4月 – 但行好事莫问前程

Linux下安装MySQL Router

Posted on 2025年4月24日 by YongJing(敬勇)

Linux下安装MySQL Router
MySQL路由器的二进制发行版可用于多个Linux变体，包括Fedora、Oracle Linux、Red Hat和Ubuntu。

安装选项包括：
.官方MySQL Yum或APT存储库软件包：这些二进制文件是由MySQL发布团队构建的。有关安装这些工具的其他信息，请参阅使用Yum或APT安装它们的快速指南。

.下载MySQL官方软件包：下载地址是https://dev.mysql.com/downloads/router。使用你喜欢的包管理器下载和安装。另外，在MySQL Router 8.0.13版本中，MySQL Router包含在MySQL Server的源代码和单体二进制包中。

.下载源代码并自己编译：源代码是MySQL服务器的一部分，网址是https://dev.mysql.com/downloads/mysql。或者，源代码也可以在GitHub上获得（特别是在router目录中）。有关编译MySQL路由器的信息，请参见从源代码安装MySQL路由器。

在Linux上安装的过程取决于您的Linux发行版。

使用官方的DEB或RPM包安装MySQL Router会在MySQL Router默认运行的主机上创建一个名为mysqlrouter的本地系统用户和组。有关更多信息，请参见系统用户的配置选项。

安装DEB包
在Ubuntu和其他使用Debian软件包方案的系统上，您可以下载并安装.deb软件包，也可以使用APT软件包管理器。

使用APT包管理器
1.请参考MySQL APT库文档安装MySQL APT库。例如:
从这里下载APT配置包。https://dev.mysql.com/downloads/repo/apt/

$> sudo dpkg -i mysql-apt-config_0.8.30-1_all.deb

请选择需要安装的MySQL Server系列，例如MySQL Server 8.0。这个选项还决定了从MySQL存储库中安装的MySQL路由器版本。

2.更新APT存储库：

$> sudo apt-get update

3.安装MySQL路由器。例如:

sudo apt-get install mysql-router-community

手动安装软件包
您也可以下载.deb包并从命令行安装它，类似于

$> sudo dpkg -i package.deb

package.deb是MySQL路由器包的名称；例如：MySQL – Router -community-version-1ubuntu24.04_amd64.deb，其中version表示MySQL路由器的版本号。

安装RPM包
在基于RPM的系统上，您可以下载并安装RPM包，也可以使用Yum包管理器。
.首先，按照MySQL Yum repository文档中的描述安装MySQL Yum repository。例如:从这里下载Yum配置包。https://dev.mysql.com/downloads/repo/yum/

$> sudo rpm -Uvh mysql84-community-release-el7-1.noarch.rpm

.接下来，可选择更改active MySQL Server版本，默认为MySQL 8.4 LTS。例如，将8.4版本修改为8.0，用于MySQL Server （MySQL）和MySQL Router （MySQL -tools的一部分）子仓库：

$> sudo yum-config-manager --disable mysql-8.4-lts-community
$> sudo yum-config-manager --enable  mysql80-community

$> sudo yum-config-manager --disable mysql-tools-8.4-lts-community
$> sudo yum-config-manager --enable  mysql-tools-community

.接下来，安装MySQL Router。例如:

$> sudo yum install mysql-router-community

手动安装RPM包

$> sudo rpm -i package.rpm

package.rpm是MySQL路由器包的名称；例如：mysql-router-community-version-el7.x86_64。其中version是MySQL路由器的版本号。

[root@mysqlcs soft]# rpm -ivh mysql-router-community-8.0.41-1.el7.x86_64.rpm
warning: mysql-router-community-8.0.41-1.el7.x86_64.rpm: Header V4 RSA/SHA256 Signature, key ID a8d3785c: NOKEY
Preparing...                          ################################# [100%]
Updating / installing...
   1:mysql-router-community-8.0.41-1.e################################# [100%]
[root@mysqlcs soft]# id mysqlrouter
uid=987(mysqlrouter) gid=982(mysqlrouter) groups=982(mysqlrouter)

卸载
在Linux上卸载MySQL Router的过程取决于您使用的软件包。

卸载DEB包
要卸载Debian软件包，使用以下命令：

$> sudo dpkg -r mysql-router

该命令不删除配置文件。要同时删除它们和data目录，可以使用：

$> sudo dpkg --purge mysql-router

或者，使用apt-get remove mysql-router或apt-get purge mysql-router。

卸载RPM包
要卸载RPM包，使用以下命令：

$> sudo rpm -e mysql-router-community

类似地，也可以使用yum remove mysql-router-community。

该命令不会删除配置文件。

没有删除的内容
当不清除时，卸载过程不会删除配置文件。在Debian系统上，可能包含如下文件：

/etc/init.d/mysqlrouter
/etc/mysqlrouter/mysqlrouter.conf
/etc/apparmor.d/usr.sbin.mysqlrouter

MySQL Shell for Python来对关系表进行操作

Posted on 2025年4月24日 by YongJing(敬勇)

MySQL Shell for Python来对关系表进行操作
MySQL Shell不仅可以操作JSON文档，还可以操作关系表。在MySQL中，每个关系表都与特定的存储引擎相关联。本节中的例子使用world_x数据库中的InnoDB表。

确认模式
要显示分配给模式变量的值，请输入db。

 MySQL  localhost:33060+  world_x  Py > db

如果schema值不是schema:world_x数据库，则设置db变量如下：

mysql-py> \use world_x

显示所有表
要显示world_x数据库中的所有关系表，可以在schema对象上使用get_tables（）方法。

 MySQL  localhost:33060+  world_x  Py > db.get_tables()
[
    ,
    ,
    
]

基本表操作
表的基本操作包括：
db.name.insert():insert（）方法将一条或多条记录插入到指定表中。
db.name.select():select（）方法返回指定表中的部分或全部记录。
db.name.update():update（）方法更新指定表中的记录。
db.name.delete():delete（）方法从指定的表中删除一条或多条记录。

向表中插入记录
可以结合values（）方法使用insert（）方法将记录插入到现有的关系表中。insert（）方法接受单个列或表中的所有列作为参数。使用一个或多个values（）方法指定要插入的值。

插入完整记录
要插入完整的记录，向insert（）方法传递表中的所有列。然后向values（）方法传递每一列的一个值。例如，要向world_x数据库中的city表中添加一条新记录，插入下面的记录并按两次Enter键。

 MySQL  localhost:33060+  world_x  Py > db.city.insert("ID", "Name", "CountryCode", "District", "Info").values(None,  "Olympia", "USA", "Washington", '{"Population": 5000}')
Query OK, 1 item affected (0.0081 sec)

city表有5列：ID、Name、CountryCode、District和Info。每个值必须与它表示的列的数据类型匹配。

插入部分记录
下面的示例将值插入city表的ID、Name和CountryCode列。

 MySQL  localhost:33060+  world_x  Py > db.city.insert("ID", "Name", "CountryCode").values(None, "Little Falls",  "USA").values(None, "Happy Valley", "USA")
Query OK, 2 items affected (0.0055 sec)

Records: 2  Duplicates: 0  Warnings: 0

使用insert（）方法指定列时，值的数量必须与列的数量匹配。在前面的例子中，必须提供三个值来匹配指定的三列。

查询表记录
你可以使用select（）方法从数据库的表中查询并返回记录。X DevAPI提供了与select（）方法一起使用的其他方法，用于过滤和排序返回的记录。

MySQL提供了以下操作符来指定搜索条件：OR (||), AND (&&), XOR, IS, NOT,BETWEEN, IN, LIKE, !=, <>, >, >=, < , <=, &, |, <<, >>, +, -, *, /, ~, 和 %。

查询所有记录
要查询已存在表中的所有记录，只需使用select（）方法，而无需指定搜索条件。下面的示例从world_x数据库中的city表中选择所有记录。

 MySQL  localhost:33060+  world_x  Py > db.city.select()
+----+----------------+-------------+----------+------------------------+
| ID | Name           | CountryCode | District | Info                   |
+----+----------------+-------------+----------+------------------------+
|  2 | Qandahar       | AFG         | Qandahar | {"Population": 237500} |
|  3 | Herat          | AFG         | Herat    | {"Population": 186800} |
|  4 | Mazar-e-Sharif | AFG         | Balkh    | {"Population": 127800} |
...........
| 4078 | Nablus                         | PSE         | Nablus               | {"Population": 100231}  |
| 4079 | Rafah                          | PSE         | Rafah                | {"Population": 92020}   |
| 4089 | Little Falls                   | USA         |                      | NULL                    |
| 4096 | Happy Valley                   | USA         |                      | NULL                    |
| 4103 | San Francisco                  | USA         | California           | {"Population": 830000}  |
| 4124 | Olympia                        | USA         | Washington           | {"Population": 5000}    |
| 4131 | Little Falls                   | USA         |                      | NULL                    |
| 4138 | Happy Valley                   | USA         |                      | NULL                    |
+------+--------------------------------+-------------+----------------------+-------------------------+
4083 rows in set (0.0056 sec)

过滤搜索
要执行一个返回一组表列的查询，可以使用select（）方法，并在方括号中指定要返回的列。这个查询返回city表中的Name和CountryCode列。

 MySQL  localhost:33060+  world_x  Py > db.city.select(["Name", "CountryCode"])
+--------------------------------+-------------+
| Name                           | CountryCode |
+--------------------------------+-------------+
| Qandahar                       | AFG         |
| Herat                          | AFG         |
| Mazar-e-Sharif                 | AFG         |
| Little Falls                   | USA         |
| Happy Valley                   | USA         |
| San Francisco                  | USA         |
.............
| Olympia                        | USA         |
| Little Falls                   | USA         |
| Happy Valley                   | USA         |
+--------------------------------+-------------+
4083 rows in set (0.0019 sec)

要查询返回符合特定搜索条件的行，可以使用where（）方法来包含这些条件。例如，下面的示例返回以字母Z开头的城市的名称和国家代码。

 MySQL  localhost:33060+  world_x  Py > db.city.select(["Name", "CountryCode"]).where("Name like 'Z%'")
+-----------------+-------------+
| Name            | CountryCode |
+-----------------+-------------+
| Zaanstad        | NLD         |
| Zoetermeer      | NLD         |
| Zwolle          | NLD         |
| Zenica          | BIH         |
| Zagazig         | EGY         |
| Zaragoza        | ESP         |
| Zamboanga       | PHL         |
| Zahedan         | IRN         |
| Zanjan          | IRN         |
| Zabol           | IRN         |
| Zama            | JPN         |
| Zhezqazghan     | KAZ         |
| Zhengzhou       | CHN         |
| Zibo            | CHN         |
| Zhangjiakou     | CHN         |
| Zhuzhou         | CHN         |
| Zhangjiang      | CHN         |
| Zigong          | CHN         |
| Zaozhuang       | CHN         |
| Zhenjiang       | CHN         |
| Zhongshan       | CHN         |
| Zunyi           | CHN         |
| Zhaoqing        | CHN         |
| Zhangzhou       | CHN         |
| Zhaodong        | CHN         |
| Zhuhai          | CHN         |
| Zaoyang         | CHN         |
| Zhoushan        | CHN         |
| Zhoukou         | CHN         |
| Zalantun        | CHN         |
| Zhumadian       | CHN         |
| Zixing          | CHN         |
| Zhucheng        | CHN         |
| Zhangjiagang    | CHN         |
| Zagreb          | HRV         |
| Zapopan         | MEX         |
| Zamora          | MEX         |
| Zitácuaro       | MEX         |
| Zacatecas       | MEX         |
| Zinacantepec    | MEX         |
| Zumpango        | MEX         |
| Zinder          | NER         |
| Zaria           | NGA         |
| Zabrze          | POL         |
| Zielona Góra    | POL         |
| Zwickau         | DEU         |
| Ziguinchor      | SEN         |
| Zürich          | CHE         |
| Zanzibar        | TZA         |
| Zonguldak       | TUR         |
| Zaporizzja      | UKR         |
| Zytomyr         | UKR         |
| Zelenograd      | RUS         |
| Zlatoust        | RUS         |
| Zelenodolsk     | RUS         |
| Zeleznodoroznyi | RUS         |
| Zeleznogorsk    | RUS         |
| Zukovski        | RUS         |
| Zeleznogorsk    | RUS         |
+-----------------+-------------+
59 rows in set (0.0050 sec)

可以使用bind（）方法将值与搜索条件分开。例如，不使用“Name = ‘Z%’ ”作为条件，而是使用冒号和以字母开头的名称组成的命名占位符，例如Name。然后在bind（）方法中包含占位符和值，如下所示：

 MySQL  localhost:33060+  world_x  Py > db.city.select(["Name", "CountryCode"]).where("Name like :name").bind("name", "Z%")
+-----------------+-------------+
| Name            | CountryCode |
+-----------------+-------------+
| Zaanstad        | NLD         |
| Zoetermeer      | NLD         |
| Zwolle          | NLD         |
| Zenica          | BIH         |
| Zagazig         | EGY         |
| Zaragoza        | ESP         |
| Zamboanga       | PHL         |
| Zahedan         | IRN         |
| Zanjan          | IRN         |
| Zabol           | IRN         |
| Zama            | JPN         |
| Zhezqazghan     | KAZ         |
| Zhengzhou       | CHN         |
| Zibo            | CHN         |
| Zhangjiakou     | CHN         |
| Zhuzhou         | CHN         |
| Zhangjiang      | CHN         |
| Zigong          | CHN         |
| Zaozhuang       | CHN         |
| Zhenjiang       | CHN         |
| Zhongshan       | CHN         |
| Zunyi           | CHN         |
| Zhaoqing        | CHN         |
| Zhangzhou       | CHN         |
| Zhaodong        | CHN         |
| Zhuhai          | CHN         |
| Zaoyang         | CHN         |
| Zhoushan        | CHN         |
| Zhoukou         | CHN         |
| Zalantun        | CHN         |
| Zhumadian       | CHN         |
| Zixing          | CHN         |
| Zhucheng        | CHN         |
| Zhangjiagang    | CHN         |
| Zagreb          | HRV         |
| Zapopan         | MEX         |
| Zamora          | MEX         |
| Zitácuaro       | MEX         |
| Zacatecas       | MEX         |
| Zinacantepec    | MEX         |
| Zumpango        | MEX         |
| Zinder          | NER         |
| Zaria           | NGA         |
| Zabrze          | POL         |
| Zielona Góra    | POL         |
| Zwickau         | DEU         |
| Ziguinchor      | SEN         |
| Zürich          | CHE         |
| Zanzibar        | TZA         |
| Zonguldak       | TUR         |
| Zaporizzja      | UKR         |
| Zytomyr         | UKR         |
| Zelenograd      | RUS         |
| Zlatoust        | RUS         |
| Zelenodolsk     | RUS         |
| Zeleznodoroznyi | RUS         |
| Zeleznogorsk    | RUS         |
| Zukovski        | RUS         |
| Zeleznogorsk    | RUS         |
+-----------------+-------------+
59 rows in set (0.0042 sec)

在程序中，绑定使您能够在表达式中指定占位符，这些占位符在执行之前被填充值，并且可以根据需要从自动转义中获益。

始终使用绑定来清理输入。使用字符串连接避免在查询中引入值，这会产生无效的输入，在某些情况下，可能会导致安全问题。

要使用AND操作符进行查询，在where（）方法的搜索条件之间添加操作符。

 MySQL  localhost:33060+  world_x  Py > db.city.select(["Name", "CountryCode"]).where("Name like 'Z%' and CountryCode =  'CHN'")
+--------------+-------------+
| Name         | CountryCode |
+--------------+-------------+
| Zhengzhou    | CHN         |
| Zibo         | CHN         |
| Zhangjiakou  | CHN         |
| Zhuzhou      | CHN         |
| Zhangjiang   | CHN         |
| Zigong       | CHN         |
| Zaozhuang    | CHN         |
| Zhenjiang    | CHN         |
| Zhongshan    | CHN         |
| Zunyi        | CHN         |
| Zhaoqing     | CHN         |
| Zhangzhou    | CHN         |
| Zhaodong     | CHN         |
| Zhuhai       | CHN         |
| Zaoyang      | CHN         |
| Zhoushan     | CHN         |
| Zhoukou      | CHN         |
| Zalantun     | CHN         |
| Zhumadian    | CHN         |
| Zixing       | CHN         |
| Zhucheng     | CHN         |
| Zhangjiagang | CHN         |
+--------------+-------------+
22 rows in set (0.0044 sec)

要指定多个条件运算符，可以将搜索条件放在括号中以更改运算符的优先级。下面的例子演示了AND和OR操作符的位置。

 MySQL  localhost:33060+  world_x  Py > db.city.select(["Name", "CountryCode"]).where("Name like 'Z%' and (CountryCode = 'CHN'  or CountryCode = 'RUS')")
+-----------------+-------------+
| Name            | CountryCode |
+-----------------+-------------+
| Zhengzhou       | CHN         |
| Zibo            | CHN         |
| Zhangjiakou     | CHN         |
| Zhuzhou         | CHN         |
| Zhangjiang      | CHN         |
| Zigong          | CHN         |
| Zaozhuang       | CHN         |
| Zhenjiang       | CHN         |
| Zhongshan       | CHN         |
| Zunyi           | CHN         |
| Zhaoqing        | CHN         |
| Zhangzhou       | CHN         |
| Zhaodong        | CHN         |
| Zhuhai          | CHN         |
| Zaoyang         | CHN         |
| Zhoushan        | CHN         |
| Zhoukou         | CHN         |
| Zalantun        | CHN         |
| Zhumadian       | CHN         |
| Zixing          | CHN         |
| Zhucheng        | CHN         |
| Zhangjiagang    | CHN         |
| Zelenograd      | RUS         |
| Zlatoust        | RUS         |
| Zelenodolsk     | RUS         |
| Zeleznodoroznyi | RUS         |
| Zeleznogorsk    | RUS         |
| Zukovski        | RUS         |
| Zeleznogorsk    | RUS         |
+-----------------+-------------+
29 rows in set (0.0042 sec)

限制、排序和偏移结果
可以应用limit（）、order_by（）和offset（）方法来管理select（）方法返回的记录的数量和顺序。

要指定结果集中包含的记录数，可以在limit（）方法后面添加一个值给select（）方法。例如，下面的查询返回country表中的前5条记录。

 MySQL  localhost:33060+  world_x  Py > db.country.select(["Code", "Name"]).limit(5)
+------+-------------+
| Code | Name        |
+------+-------------+
| ABW  | Aruba       |
| AFG  | Afghanistan |
| AGO  | Angola      |
| AIA  | Anguilla    |
| ALB  | Albania     |
+------+-------------+
5 rows in set (0.0029 sec)

要指定结果的顺序，请将order_by（）方法添加到select（）方法后面。向order_by（）方法传递一个列表，其中包含一个或多个用于排序的列，还可以根据需要传递降序（desc）或升序（asc）属性。升序是默认的排序类型。

例如，下面的查询按Name列对所有记录进行排序，然后按降序返回前三条记录。

 MySQL  localhost:33060+  world_x  Py > db.country.select(["Code", "Name"]).order_by(["Name desc"]).limit(3)
+------+------------+
| Code | Name       |
+------+------------+
| ZWE  | Zimbabwe   |
| ZMB  | Zambia     |
| YUG  | Yugoslavia |
+------+------------+
3 rows in set (0.0017 sec)

默认情况下，limit（）方法从表中的第一条记录开始。可以使用offset（）方法修改起始记录。例如，要忽略第一条记录并返回符合条件的后三条记录，可以向offset（）方法传递一个值1。

 MySQL  localhost:33060+  world_x  Py > db.country.select(["Code", "Name"]).order_by(["Name desc"]).limit(3).offset(1)
+------+------------+
| Code | Name       |
+------+------------+
| ZMB  | Zambia     |
| YUG  | Yugoslavia |
| YEM  | Yemen      |
+------+------------+
3 rows in set (0.0015 sec)

更新表记录
可以使用update（）方法修改表中的一条或多条记录。update（）方法的工作原理是过滤一个查询，只包含需要更新的记录，然后对这些记录应用指定的操作。

要替换city表中的城市名，向set（）方法传递新的城市名。然后，向where（）方法传递要定位和替换的城市名。下面的例子将北京这个城市替换为北京。

 MySQL  localhost:33060+  world_x  Py > db.city.update().set("Name", "Beijing").where("Name = 'Peking'")
Query OK, 1 items affected (0.0093 sec)

Rows matched: 1  Changed: 1  Warnings: 0

使用select（）方法验证更改。

 MySQL  localhost:33060+  world_x  Py > db.city.select(["ID", "Name", "CountryCode", "District", "Info"]).where("Name =  'Beijing'")
+------+---------+-------------+----------+-------------------------+
| ID   | Name    | CountryCode | District | Info                    |
+------+---------+-------------+----------+-------------------------+
| 1891 | Beijing | CHN         | Peking   | {"Population": 7472000} |
+------+---------+-------------+----------+-------------------------+
1 row in set (0.0072 sec)

删除表记录
你可以使用delete（）方法从数据库的一张表中删除部分或全部记录。X DevAPI提供了额外的方法与delete（）方法一起使用，用于过滤和排序要删除的记录。

使用条件删除记录
下面的例子将搜索条件传递给delete（）方法。所有符合条件的记录都将从city表中删除。在这个例子中，只有一条记录符合条件。
MySQL localhost:33060+ world_x Py > db.city.delete().where(“Name = ‘Olympia'”)
Query OK, 1 item affected (0.0146 sec)

删除第一条记录
要删除city表中的第一条记录，可以使用limit（）方法将值设为1。
MySQL localhost:33060+ world_x Py > db.city.delete().limit(1)
Query OK, 1 item affected (0.0043 sec)

删除表中的所有记录
可以删除表中的所有记录。为此，可以使用delete（）方法，但不指定搜索条件。
MySQL localhost:33060+ world_x Py > db.city.delete()
Query OK, 4080 item affected (0.0043 sec)

表中的文档
在MySQL中，表可以包含传统的关系型数据、JSON值，或者两者都包含。你可以把传统数据和JSON文档结合起来，把文档存储在原生JSON数据类型的列中。

本示例使用world_x数据库中的city表。

插入记录
要向表的列中插入一个文档，只需按正确的顺序向values（）方法传递一个格式良好的JSON文档。在下面的示例中，文档作为要插入Info列的最终值被传递。
MySQL localhost:33060+ world_x Py > db.city.insert().values(None, “San Francisco”, “USA”, “California”, ‘{“Population”:830000}’)
Query OK, 1 item affected (0.0093 sec)

查询记录
你可以使用搜索条件进行查询，计算表达式中的文档值。

MySQL localhost:33060+ world_x Py > db.city.select([“ID”, “Name”, “CountryCode”, “District”, “Info”]).\
-> where(“CountryCode = :country and Info->’$.Population’ > 1000000”).\
-> bind(‘country’, ‘USA’)
->
+——+————–+————-+————–+————————-+
| ID | Name | CountryCode | District | Info |
+——+————–+————-+————–+————————-+
| 3793 | New York | USA | New York | {“Population”: 8008278} |
| 3794 | Los Angeles | USA | California | {“Population”: 3694820} |
| 3795 | Chicago | USA | Illinois | {“Population”: 2896016} |
| 3796 | Houston | USA | Texas | {“Population”: 1953631} |
| 3797 | Philadelphia | USA | Pennsylvania | {“Population”: 1517550} |
| 3798 | Phoenix | USA | Arizona | {“Population”: 1321045} |
| 3799 | San Diego | USA | California | {“Population”: 1223400} |
| 3800 | Dallas | USA | Texas | {“Population”: 1188580} |
| 3801 | San Antonio | USA | Texas | {“Population”: 1144646} |
+——+————–+————-+————–+————————-+
9 rows in set (0.0077 sec)
MySQL localhost:33060+ world_x Py >

MySQL Shell for Python来对文档与集合进行操作

Posted on 2025年4月1日 by YongJing(敬勇)

MySQL Shell for Python来对文档与集合进行操作

启动MySQL Shell
安装并启动MySQL server后，将MySQL Shell连接到server实例。默认情况下，MySQL Shell使用X协议连接。
在运行server实例的系统上，打开一个终端窗口，并使用以下命令启动MySQL Shell：

[root@mysqlcs ~]# mysqlsh root@localhost/world_x --py
Please provide the password for 'root@localhost': ******
Save password for 'root@localhost'? [Y]es/[N]o/Ne[v]er (default No): N
MySQL Shell 8.0.41

Copyright (c) 2016, 2025, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its affiliates.
Other names may be trademarks of their respective owners.

Type '\help' or '\?' for help; '\quit' to exit.
Creating a session to 'root@localhost/world_x'
Fetching schema names for auto-completion... Press ^C to stop.
Your MySQL connection id is 84 (X protocol)
Server version: 5.7.26-log Source distribution
Default schema `world_x` accessible through db.
 MySQL  localhost:33060+  world_x  Py >

创建、列出和删除集合
在MySQL Shell中，你可以创建新的集合，获取模式中已存在集合的列表，或者从模式中删除已存在的集合。集合名称区分大小写，每个集合名称必须唯一。

确认模式
要显示分配给模式变量的值，请输入db。

 MySQL  localhost:33060+  world_x  Py > db

如果schema值不是schema:world_x，则设置db变量如下：

 MySQL  localhost:33060+  world_x  Py >\use world_x

创建集合
要在现有模式中创建新集合，可以使用create_collection（）方法。下面的示例在world_x数据库中创建一个名为flags的集合。

 MySQL  localhost:33060+  world_x  Py > db.create_collection("flags");

显示集合
要显示world_x数据库中的所有集合，可以在schema对象上使用get_collections（）方法。服务器返回的集合出现在括号中。

 MySQL  localhost:33060+  world_x  Py > db.get_collections()
[
    
]

删除集合
要从数据库中删除现有集合，可以在session对象上调用drop_collection（）方法。例如，要从world_x数据库中删除flags集合，输入：

 MySQL  localhost:33060+  world_x  Py > db.drop_collection("flags");

添加文档
使用MySQL Shell，可以使用add（）方法将一个文档或一个列表文档插入到现有的集合中。本节中的所有示例都使用flags集合。
将下面的文档插入countryinfo集合。按两次Enter键插入文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.add(
                                     -> {
                                     ->   "GNP": .6,
                                     ->   "IndepYear": 1967,
                                     ->   "Name": "Sealand",
                                     ->   "_id": "SEA",
                                     ->   "demographics": {
                                     ->      "LifeExpectancy": 79,
                                     ->      "Population": 27
                                     ->   },
                                     ->   "geography": {
                                     ->      "Continent": "Europe",
                                     ->      "Region": "British Islands",
                                     ->      "SurfaceArea": 193
                                     ->   },
                                     ->   "government": {
                                     ->      "GovernmentForm": "Monarchy",
                                     ->      "HeadOfState": "Michael Bates"
                                     ->   }
                                     ->  }
                                     -> )
                                     ->
Query OK, 1 item affected (0.0106 sec)

该方法返回操作的状态。

每个文档都需要一个名为_id的标识符字段。_id字段的值必须在同一个集合中的所有文档中唯一。如果传递给add（）方法的文档不包含_id字段，MySQL Shell会自动在文档中插入一个字段，并设置该字段的值为生成的UUID （universal unique identifier，通用唯一标识符）。

查找文档
可以使用find（）方法从数据库中的集合中查询并返回文档。MySQL Shell为find（）方法提供了额外的方法来过滤和排序返回的文档。MySQL提供了以下操作符来指定搜索条件：OR (||), AND (&&), XOR, IS, NOT,BETWEEN, IN, LIKE, !=, <>, >, >=, < , <=, &, |, <<, >>, +, -, *, /, ~, 和 %.

查找集合中的所有文档
要返回集合中的所有文档，可以使用find（）方法，但不指定搜索条件。例如，下面的操作返回countryinfo集合中的所有文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.find()
{
    "GNP": 828,
    "_id": "ABW",
    "Name": "Aruba",
    "IndepYear": 1972,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 103000,
        "LifeExpectancy": 78.4000015258789
    }
}
{
    "GNP": 0.6,
    "_id": "SEA",
    "Name": "Sealand",
    "IndepYear": 1967,
    "geography": {
        "Region": "British Islands",
        "Continent": "Europe",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Michael Bates",
        "GovernmentForm": "Monarchy"
    },
    "demographics": {
        "Population": 27,
        "LifeExpectancy": 79
    }
}
2 documents in set (0.0019 sec)

该方法生成的结果除了包含集合中的所有文档外，还包含操作信息。

过滤搜索
你可以在find（）方法中包含搜索条件。组成搜索条件的表达式的语法与传统MySQL相同。所有表达式必须用引号括起来。
这里的所有示例都使用world_x数据库中的flags集合。为简洁起见，有些示例不显示输出。
一个简单的搜索条件由_id字段和文档的唯一标识符组成。下面的例子返回一个与标识符字符串匹配的文档：

 MySQL  localhost:33060+  world_x  Py > db.flags.find("_id = 'SEA'")
{
    "GNP": 0.6,
    "_id": "SEA",
    "Name": "Sealand",
    "IndepYear": 1967,
    "geography": {
        "Region": "British Islands",
        "Continent": "Europe",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Michael Bates",
        "GovernmentForm": "Monarchy"
    },
    "demographics": {
        "Population": 27,
        "LifeExpectancy": 79
    }
}
1 document in set (0.0010 sec)

下面的示例搜索GNP高于5000亿美元的所有国家。国家信息收集以百万为单位衡量国民生产总值。

 MySQL  localhost:33060+  world_x  Py > db.flags.find("GNP > 500000")
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
1 document in set (0.0013 sec)

下面查询中的Population字段嵌入到人口统计对象中。要访问嵌入式字段，使用人口统计数据和人口之间的句号来识别关系。文档名和字段名区分大小写。

 MySQL  localhost:33060+  world_x  Py > db.flags.find("GNP > 500000 and demographics.Population > 100000000")
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
1 document in set (0.0013 sec)

下列表达式中的算术运算符用于查询人均国民生产总值高于30000美元的国家。搜索条件可以包括算术运算符和大多数MySQL函数。

 MySQL  localhost:33060+  world_x  Py > db.flags.find("GNP*1000000/demographics.Population > 30000")
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
1 document in set (0.0012 sec)

可以使用bind（）方法将值与搜索条件分开。例如，与其指定硬编码的国家名作为条件，不如用冒号和以字母开头的名称（如country）组成的命名占位符。然后在bind（）方法中包含占位符和值，如下所示：

 MySQL  localhost:33060+  world_x  Py > db.flags.find("Name = :country").bind("country", "Aruba")
{
    "GNP": 828,
    "_id": "ABW",
    "Name": "Aruba",
    "IndepYear": 1972,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 103000,
        "LifeExpectancy": 78.4000015258789
    }
}
1 document in set (0.0014 sec)

指定返回列
可以返回文档的特定字段，而不是返回所有字段。下面的示例返回countryinfo集合中匹配搜索条件的所有文档的GNP和Name字段。使用fields（）方法传递要返回的字段列表

 MySQL  localhost:33060+  world_x  Py > db.flags.find("GNP > 5000000").fields(["GNP", "Name"])
{
    "GNP": 800000000,
    "Name": "Hunan"
}
1 document in set (0.0014 sec)

此外，您可以使用描述要返回的文档的表达式来更改返回的文档——添加、重命名、嵌套甚至计算新的字段值。例如，使用下面的表达式更改字段的名称，使其仅返回两个文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.find().fields(mysqlx.expr('{"Name": upper(Name), "GNPPerCapita":  GNP*1000000/demographics.Population}')).limit(2)
{
    "Name": "ARUBA",
    "GNPPerCapita": 8038.834951456311
}
{
    "Name": "HUNAN",
    "GNPPerCapita": 99626.400996264
}
2 documents in set (0.0012 sec)

限制、排序和跳过结果
可以应用limit（）、sort（）和skip（）方法来管理find（）方法返回的文档数量和顺序。

要指定结果集中包含的文档数量，可以在limit（）方法的find（）方法后面添加一个值。下面的查询返回flags集合中的前2个文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.find().limit(2)
{
    "GNP": 828,
    "_id": "ABW",
    "Name": "Aruba",
    "IndepYear": 1972,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 103000,
        "LifeExpectancy": 78.4000015258789
    }
}
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
2 documents in set (0.0028 sec)

要指定结果的顺序，可将sort（）方法添加到find（）方法后面。向sort（）方法传递一个列表，其中包含一个或多个用于排序的字段，还可以根据需要传递descending （desc）或ascending （asc）属性。升序是默认的排序类型。

例如，下面的查询按indeyear字段对所有文档进行排序，然后按降序返回前2个文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.find().sort(["IndepYear desc"]).limit(2)
{
    "GNP": 828,
    "_id": "ABW",
    "Name": "Aruba",
    "IndepYear": 1972,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 103000,
        "LifeExpectancy": 78.4000015258789
    }
}
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
2 documents in set (0.0016 sec)

默认情况下，limit（）方法从集合中的第一个文档开始。可以使用skip（）方法来修改开始的文档。例如，要忽略第一个文档并返回匹配条件的后面8个文档，就向skip（）方法传递一个值1。

 MySQL  localhost:33060+  world_x  Py > db.flags.find().sort(["IndepYear desc"]).limit(3).skip(1)
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
{
    "GNP": 0.6,
    "_id": "SEA",
    "Name": "Sealand",
    "IndepYear": 1967,
    "geography": {
        "Region": "British Islands",
        "Continent": "Europe",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Michael Bates",
        "GovernmentForm": "Monarchy"
    },
    "demographics": {
        "Population": 27,
        "LifeExpectancy": 79
    }
}
2 documents in set (0.0013 sec)

修改文档
可以使用modify（）方法更新集合中的一个或多个文档。X DevAPI为modify（）方法提供了额外的方法：
.设置和取消设置文档中的字段。
.追加、插入和删除数组
.绑定、限制和排序要修改的文档。

设置和不设置字段
modify（）方法的工作原理是过滤一个集合，只包含需要修改的文档，然后对这些文档应用指定的操作。

在下面的示例中，modify（）方法使用搜索条件来标识要更改的文档，然后set（）方法替换嵌套的人口统计对象中的两个值。

 MySQL  localhost:33060+  world_x  Py > db.flags.modify("_id = 'SEA'").set("demographics", {"LifeExpectancy": 78,  "Population": 28})
Query OK, 1 item affected (0.0202 sec)

Rows matched: 1  Changed: 1  Warnings: 0

在修改文档之后，使用find（）方法来验证更改。

 MySQL  localhost:33060+  world_x  Py > db.flags.find("_id = 'SEA'")
{
    "GNP": 0.6,
    "_id": "SEA",
    "Name": "Sealand",
    "IndepYear": 1967,
    "geography": {
        "Region": "British Islands",
        "Continent": "Europe",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Michael Bates",
        "GovernmentForm": "Monarchy"
    },
    "demographics": {
        "Population": 28,
        "LifeExpectancy": 78
    }
}
1 document in set (0.0010 sec)

要从文档中删除内容，可以使用modify（）和unset（）方法。例如，下面的查询从匹配搜索条件的文档中删除GNP。

 MySQL  localhost:33060+  world_x  Py > db.flags.modify("Name = 'Sealand'").unset("GNP")
Query OK, 1 item affected (0.0051 sec)

Rows matched: 1  Changed: 1  Warnings: 0

使用find（）方法验证更改。

 MySQL  localhost:33060+  world_x  Py > db.flags.find("Name = 'Sealand'")
{
    "_id": "SEA",
    "Name": "Sealand",
    "IndepYear": 1967,
    "geography": {
        "Region": "British Islands",
        "Continent": "Europe",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Michael Bates",
        "GovernmentForm": "Monarchy"
    },
    "demographics": {
        "Population": 28,
        "LifeExpectancy": 78
    }
}
1 document in set (0.0012 sec)

追加、插入和删除数组
要向数组字段添加元素，或者插入、删除数组中的元素，可以使用array_append（）、array_insert（）或array_delete（）方法。下面的例子修改了flags集合，以支持跟踪国际机场。
第一个例子使用modify（）和set（）方法在所有文档中创建一个新的Airports字段。在没有指定搜索条件的情况下修改文档时要小心。这个操作将修改集合中的所有文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.modify("True").set("Airports", [])
Query OK, 3 items affected (0.0226 sec)

Rows matched: 3  Changed: 3  Warnings: 0

添加了Airports字段后，下一个示例使用array_append（）方法将一个新机场添加到一个文档中。美元。下例中的Airports表示当前文档的 Airports字段。

 MySQL  localhost:33060+  world_x  Py > db.flags.modify("Name = 'Hunan'").array_append("$.Airports", "TY")
Query OK, 1 item affected (0.0067 sec)

Rows matched: 1  Changed: 1  Warnings: 0

使用db.flags.find(“Name = ‘Hunan'”)查看更改

 MySQL  localhost:33060+  world_x  Py > db.flags.find("Name = 'Hunan'")
{
    "GNP": 800000000,
    "_id": "CN",
    "Name": "Hunan",
    "Airports": [
        "TY"
    ],
    "IndepYear": 1971,
    "geography": {
        "Region": "Caribbean",
        "Continent": "North America",
        "SurfaceArea": 193
    },
    "government": {
        "HeadOfState": "Beatrix",
        "GovernmentForm": "Nonmetropolitan Territory of The Netherlands"
    },
    "demographics": {
        "Population": 8030000000,
        "LifeExpectancy": 85
    }
}
1 document in set (0.0011 sec)

要在数组的不同位置插入元素，可以使用array_insert（）方法在路径表达式中指定要插入的索引。在这个例子中，索引是0，即数组的第一个元素。

 MySQL  localhost:33060+  world_x  Py > db.flags.modify("Name = 'Hunan'").array_insert("$.Airports[0]", "HH")
Query OK, 1 item affected (0.0068 sec)

Rows matched: 1  Changed: 1  Warnings: 0

要从数组中删除元素，必须向array_delete（）方法传递要删除元素的索引。

 MySQL  localhost:33060+  world_x  Py > db.flags.modify("Name = 'Hunan'").array_delete("$.Airports[1]")
Query OK, 1 item affected (0.0062 sec)

Rows matched: 1  Changed: 1  Warnings: 0

删除文档
可以使用remove（）方法从数据库集合中删除部分或全部文档。X DevAPI为remove（）方法提供了额外的方法，用于过滤和排序要删除的文档。

使用条件删除文档
下面的例子向remove（）方法传递了一个搜索条件。所有符合条件的文档都将从flags集合中删除。在这个例子中，有一个文档符合条件。

 MySQL  localhost:33060+  world_x  Py > db.flags.remove("_id = 'SEA'")
Query OK, 1 item affected (0.0057 sec)

删除第一个文档
要删除flags集合中的第一个文档，可使用limit（）方法，将值设为1。

 MySQL  localhost:33060+  world_x  Py > db.flags.remove("True").limit(1)
Query OK, 1 item affected (0.0047 sec)

按顺序删除最后一个文档
下面的示例按国家名称删除flags集合中的最后一个文档。

 MySQL  localhost:33060+  world_x  Py > db.flags.remove("True").sort(["Name desc"]).limit(1)
Query OK, 1 item affected (0.0086 sec)

删除集合中的所有文档
可以删除集合中的所有文档。为此，使用remove（”True”）方法，而不指定搜索条件。

MySQL Shell对关系表中的文档进行操作

Posted on 2025年4月1日 by YongJing(敬勇)

MySQL Shell对关系表中的文档进行操作
在MySQL中，表可以包含传统的关系型数据、JSON值，或者两者都包含。你可以把传统数据和JSON文档结合起来，把文档存储在原生JSON数据类型的列中。

这里使用world_x数据库中的city表进行演示。

city表描述
city表有五个列（或字段）。

mysql> use world_x
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> desc city;
+-------------+----------+------+-----+---------+----------------+
| Field       | Type     | Null | Key | Default | Extra          |
+-------------+----------+------+-----+---------+----------------+
| ID          | int(11)  | NO   | PRI | NULL    | auto_increment |
| Name        | char(35) | NO   |     |         |                |
| CountryCode | char(3)  | NO   |     |         |                |
| District    | char(20) | NO   |     |         |                |
| Info        | json     | YES  |     | NULL    |                |
+-------------+----------+------+-----+---------+----------------+
5 rows in set (0.01 sec)

插入记录
要向表的列中插入一个文档，只需按正确的顺序向values（）方法传递一个格式良好的JSON文档。在下面的示例中，文档作为要插入Info列的最终值被传递。

 MySQL  localhost:33060+  world_x  JS > db.city.insert().values(null, "San Francisco", "USA", "California",  '{"Population":830000}')
Query OK, 1 item affected (0.0104 sec)

查询记录
你可以使用搜索条件进行查询，计算表达式中的文档值。

 MySQL  localhost:33060+  world_x  JS > db.city.select(["ID", "Name", "CountryCode", "District", "Info"]).where("CountryCode =  :country and Info->'$.Population' > 1000000").bind('country', 'USA')
+------+--------------+-------------+--------------+-------------------------+
| ID   | Name         | CountryCode | District     | Info                    |
+------+--------------+-------------+--------------+-------------------------+
| 3793 | New York     | USA         | New York     | {"Population": 8008278} |
| 3794 | Los Angeles  | USA         | California   | {"Population": 3694820} |
| 3795 | Chicago      | USA         | Illinois     | {"Population": 2896016} |
| 3796 | Houston      | USA         | Texas        | {"Population": 1953631} |
| 3797 | Philadelphia | USA         | Pennsylvania | {"Population": 1517550} |
| 3798 | Phoenix      | USA         | Arizona      | {"Population": 1321045} |
| 3799 | San Diego    | USA         | California   | {"Population": 1223400} |
| 3800 | Dallas       | USA         | Texas        | {"Population": 1188580} |
| 3801 | San Antonio  | USA         | Texas        | {"Population": 1144646} |
+------+--------------+-------------+--------------+-------------------------+
9 rows in set (0.0078 sec)

删除记录
可以使用搜索条件进行删除，计算表达式中的文档值。

 MySQL  localhost:33060+  world_x  JS > db.city.delete().where("CountryCode = :country and Info->'$.Population'  =1830000").bind('country', 'CN')
Query OK, 1 item affected (0.0115 sec)