MySQL基础 增删改查,函数,JDBC,DAO模式,三层架构开发。
MySQL基础 增删改查,函数,JDBC,DAO模式,三层架构开发。
第一章
数据库设计
简述数据库完整性及相关作用？
数据库的数据完整性==数据的一致性与准确性
如何保证数据完整性？实施约束
1.实体完整性约束
主键约束 标识列 唯一约束
2.引用完整性约束
外键约束
3.自定义完整性约束
约束方法：规则，存储过程，触发器
4,域完整性约束
约束方法：限制数据类型，检查约束，外键约束，默认值，非空约束
软件项目实施过程：
【瀑布模型】–》项目风险需求分析调研
【售前】–》设计阶段Ui设计
【美工】–》产品原型设计
【产品经理】–》数据库设计，技术路线选型）—》开发阶段—》测试阶段—》产品实施阶段—》产品发布上线
【java软件开发】–》测试阶段
【测试工程师】–》产品实施阶段
【软解实施工程师】–》产品发布上线
【敏捷式开发】
中心思想：持续集成，持续部署
互联网公司 软件公司
设计数据库的步骤：
1，收集信息（meeting）
2.标识实体
3.标识实体所拥有的属性
4.标识实体与实体之间的关系
5.构建E-R图（实体关系图）
6.Meeting 开会讨论
7.将E-R图转换为数据库模型图-（工具：Navicate data Model）
8.Meeting开会讨论
9.使用数据库三大范式 规范化数据库设计
10.依照与数据库模型图建库建表
UML统一建模语言 实现图形构建 E-R图
画图的目的：更好的方便团队的协作：
数据库三大范式：
- 第一范式（1NF）：每张表中的每个字段都应该只有一个单一值，即每个字段不能有多个值或重复值。
- 第二范式（2NF）：每张表都应该有一个主键（Primary Key），并且所有非主键字段都应该完全依赖于主键。如果一个表中存在部分依赖的情况，需要将其拆分成多张表来消除冗余。
- 第三范式（3NF）：每个非主键字段都应该互相独立，即没有任何一个非主键字段能够通过其他非主键字段推导出来。如果存在传递依赖的情况，需要将其拆分成多张表来消除冗余。
遵循这些范式可以使数据库的设计更加规范和合理，减少数据冗余、依赖和异常，提高数据质量和可维护性。
总结：数据库的范式其实是五大范式，第五范式成为完美范式；
注意：有时候为了满足特定业务场景的需求，我们可能会违反数据库的范式只满足第二范式；
世界上没有完美的软件程序
也没有完美的软件架构；
第二章
第二章 初始MySql
数据库分类：（编程语言：T-Sql 标准的结构化查询语言）
关系型数据库
T-Sql 语言的组成 ：
DQL（Database Query Language是一种用于从关系型数据库中检索数据的语言。在 SQL 中，SELECT 语句是最基本和常见的 DQL 命令，它指定了要查询哪些列、从哪个表中查询、如何过滤数据以及如何排序结果集等。以下是 SELECT 语句的基本语法：
SELECT column1, column2, ... FROM table_name WHERE condition ORDER BY column1 DESC;
其中：
column1, column2, ...指定要查询的列名。table_name指定要从中检索数据的表名。WHERE condition是一个可选的子句，用于过滤数据，并且只返回符合条件的行。ORDER BY column1 DESC是一个可选的子句，用于按照某个列进行排序，并且可以选择升序或降序排序。
除了 SELECT 语句之外，还有其他的 DQL 命令，例如：
- JOIN：用于将多个表中的数据联合在一起查询。
- GROUP BY 和 HAVING：用于对查询结果进行分组和聚合操作。
- UNION：用于将两个或多个 SELECT 语句的结果组合成一个结果集。
这些命令可以根据实际情况和需求进行灵活组合，以检索所需的数据。
**DCL（Data Control Language）**是一种用于管理数据库对象访问权限和安全性的语言。DCL 包括以下几个命令：
- GRANT：将访问权限授予用户或角色。例如，可以使用 GRANT 命令将 SELECT 权限授权给某个用户。
- REVOKE：撤销用户或角色的访问权限。例如，可以使用 REVOKE 命令撤销某个用户的 SELECT 权限。
- DENY：拒绝用户或角色的访问权限。与 REVOKE 不同的是，DENY 是显式拒绝权限，意味着该用户或角色不能再以任何方式获得被拒绝的权限，而 REVOKE 只是撤销权限，这些权限可能会在以后重新授予。
- AUDIT：用于审计数据库活动，例如记录哪些用户进行了哪些操作。例如，可以使用 AUDIT 命令来启用对 DML 操作的审计。
这些命令都涉及到数据库对象的权限和安全性设置，可以帮助管理员更好地管理和保护数据库。
**DDL（Data Definition Language）**数据定义语言 是一种用于创建、修改和删除数据库对象的语言。DDL 命令可以用于创建表、视图、索引、存储过程等各种数据库对象，并且可以修改这些对象的结构和属性。
以下是几个常见的 DDL 命令：
- CREATE：用于创建数据库对象，如表、视图、索引、存储过程等。
- ALTER：用于修改数据库对象的结构和属性，如修改表的列、添加索引等。
- DROP：用于删除数据库对象，如删除表、视图、索引、存储过程等。需要注意的是，DROP 命令是不可逆的，删除后无法恢复。
- TRUNCATE：用于删除表中的所有数据，但保留表的结构和属性。
除了上述命令之外，还有其他的 DDL 命令，例如 RENAME、COMMENT 等等，可以根据实际情况和需求进行灵活使用。
DDL 命令是数据库管理员和开发人员必备的工具之一，它们能够帮助管理数据库对象的结构和属性，以满足不同的业务需求。
**TCL（Transaction Control Language）**是一种用于管理数据库事务的语言。TCL 包括以下三个主要命令：
- COMMIT：提交事务，并将所有已执行的 SQL 语句永久保存到数据库中。
- ROLLBACK**：回滚事务，即撤销所有已执行的 SQL 语句，并恢复到事务开始前的状态。**
- SAVEPOINT：在事务中创建一个保存点，以便可以在之后通过 ROLLBACK 到达保存点。
TCL 命令可以帮助开发人员确保数据库操作是原子性、一致性、隔离性和持久性（ACID），从而保证数据的完整性和可靠性。通常情况下，在进行修改操作时需要使用事务来确保数据的正确性和安全性，避免出现意外错误导致数据不一致或丢失。
Oracle 甲骨文公司产品 8i 9i 10g 11g 11gr2 12c 亿级 收费
MS SQLSercer 2000 2005 2008 【数据库性能可以与ORacie数据库相媲美？】千万级 收费
MySql 开源（开放源代码，免费）数据库 DB2 IBM 百万级
Office access 十万级数据
Google SQLITE 文件型数据库 MB
非关系型数据库 NoSql : Not only Sql; 内存型数据库 17年流行
Redis
MongoDB
数据库是由两部分组成：1.客户端 2.服务器端
查看本机所有的数据库
可以使用以下 SQL 语句查看本机上所有的数据库：
SHOW DATABASES;
执行此命令后，会返回一个包含所有数据库名称的列表。
需要注意的是，根据用户权限的不同，可能只能看到某些特定的数据库。如果没有足够的权限，则无法查看所有数据库。在这种情况下，需要联系数据库管理员以获取更高的访问权限。
切换数据库
可以使用以下命令来切换数据库：
USE database_name;
其中，database_name 是要切换到的数据库的名称。
例如，如果要切换到名为 example 的数据库，可以执行以下 SQL 语句：
USE example;
执行此命令后，所有后续的 SQL 查询和命令都将在选定的数据库中执行。需要注意的是，如果尝试使用不存在的数据库名称，则会报错。
查看当前数据库中所有的表;
可以使用以下 SQL 语句查看当前数据库中所有的表：
SHOW TABLES;
执行此命令后，会返回当前数据库中所有表的名称列表。
需要注意的是，根据用户权限的不同，可能只能看到某些特定的表。如果没有足够的权限，则无法查看所有表。在这种情况下，需要联系数据库管理员以获取更高的访问权限。
新建数据库
在 MySQL 中，可以使用以下 SQL 语句来创建新的数据库：
CREATE DATABASE database_name;
其中，database_name 是要创建的新数据库的名称。
例如，如果要创建名为 example 的数据库，可以执行以下 SQL 语句：
CREATE DATABASE example;
需要注意的是，根据用户权限的不同，可能无法创建新的数据库。如果没有足够的权限，则无法创建新的数据库或者需要联系数据库管理员以获取更高的访问权限。
删除数据库
在 MySQL 中，可以使用以下 SQL 语句删除数据库：
DROP DATABASE database_name;
其中，database_name 是要删除的数据库名称。
例如，如果要删除名为 example 的数据库，可以执行以下 SQL 语句：
DROP DATABASE example;
需要注意的是，删除数据库会彻底清除该数据库中的所有数据和表结构，因此在执行此操作之前应该非常小心。在删除数据库之前，应该备份重要的数据以防止数据丢失。
查看表结构
可以使用以下 SQL 语句查看表的结构：
DESCRIBE table_name;
其中，table_name 是要查看结构的表名称。
例如，如果要查看名为 employees 的表的结构，可以执行以下 SQL 语句：
DESCRIBE employees;
执行此命令后，会返回表的列名、数据类型、键信息等所有结构信息。
除了 DESCRIBE 命令外，还可以使用 SHOW CREATE TABLE 命令来查看更详细的表结构信息。例如，以下 SQL 语句将显示名为 employees 的表的完整创建语句和其他详细信息：
SHOW CREATE TABLE employees;
以上命令将输出包含表结构和创建语句的信息，并且可以给出更多关于索引、键、外键等其他信息。
连接MYSql数据库方式：
1.DOS命令窗口
在 Windows 操作系统中，可以使用命令行窗口（也称为 DOS 窗口）连接到 MySQL 数据库。以下是连接到 MySQL 的步骤：
-
打开命令行窗口：在 Windows 中，可以按下 Windows 按钮 + R 键，在运行对话框中输入
cmd并按下 Enter 键来打开命令行窗口。 -
进入 MySQL 安装目录：通过
cd命令进入到 MySQL 的安装目录。例如，如果 MySQL 安装在C:\Program Files\MySQL\MySQL Server 8.0\bin目录下，则可以使用以下命令进入该目录：cd C:\Program Files\MySQL\MySQL Server 8.0\bin -
使用以下命令连接到 MySQL：
mysql -u username -p其中，
username是 MySQL 用户名。执行此命令后，系统将提示您输入密码。输入密码并按下 Enter 键即可连接到 MySQL。
需要注意的是，如果 MySQL 服务器没有在本地运行，则需要指定 MySQL 服务器的主机名或 IP 地址，并且可能还需要指定端口号和其他参数。例如，以下命令将连接到远程 MySQL 服务器 example.com，用户名为 root，并指定端口号为 3306：
mysql -h example.com -P 3306 -u root -p
执行此命令后，系统将提示您输入密码。输入密码并按下 Enter 键即可连接到远程 MySQL 服务器。
2.MYsql自带的连接工具
MySQL 自带的连接工具是 MySQL 命令行客户端，也称为 MySQL shell。MySQL shell 是一个交互式命令行工具，可以在终端中使用 SQL 命令来管理 MySQL 数据库。MySQL shell 可以在 Windows、Linux 和 macOS 等操作系统上运行，并且支持各种 MySQL 版本。
要使用 MySQL shell 连接到 MySQL 数据库，请按照以下步骤：
-
打开终端：在 Windows 操作系统中，可以按下
Windows键 +R键，在运行对话框中输入cmd并按下Enter键来打开命令行窗口。在 Linux 或 macOS 中，可以打开终端应用程序。 -
输入以下命令将 MySQL shell 与 MySQL 数据库连接起来：
mysql -u username -p其中，
username是 MySQL 用户名。 -
系统将提示您输入密码。输入密码并按下
Enter键即可连接到 MySQL 数据库。如果密码正确，则会显示 MySQL shell 提示符（mysql>）。 -
**输入 SQL 命令或 MySQL shell 命令以管理数据库。**例如，可以使用
SHOW DATABASES;命令查看所有可用的数据库。
需要注意的是，通过 MySQL shell 连接到 MySQL 数据库时，可以执行任何具有适当权限的 SQL 命令。因此，需要小心处理并确保授权用户具有必要的访问权限。
3.第三方连接工具（Navicate，SQLYog）；
除了 MySQL 自带的命令行客户端之外，还有很多第三方连接工具可以用来连接和管理 MySQL 数据库，例如 Navicat、SQLyog、HeidiSQL 等。这些工具提供了直观的图形用户界面，使得用户可以更轻松地管理数据库，而无需使用 SQL 命令或其他编程语言。
以下是使用 Navicat 或 SQLyog 连接到 MySQL 数据库的步骤：
- 下载并安装连接工具： 首先需要下载并安装 Navicat 或 SQLyog，然后启动应用程序。
- 创建新连接：在 Navicat 或 SQLyog 中，单击 “New Connection” 或类似按钮来创建新连接。在弹出的对话框中，输入 MySQL 数据库的主机名、端口号、用户名和密码等信息。
- 测试连接： 输入完连接信息后，请单击 “Test Connection” 或类似按钮来测试连接是否成功。如果连接成功，则会显示一条消息或指示灯变为绿色。
- 打开数据库：在连接成功后，可以单击 “Open Database” 或类似按钮来打开 MySQL 数据库。此时，将显示可用的数据库列表。
- 管理数据库：现在可以使用导航栏或菜单栏中的选项，例如创建新表、修改表结构、插入数据、执行查询等。
需要注意的是，不同的连接工具可能会略有不同的界面和功能，但是基本的连接和管理 MySQL 数据库的步骤是类似的。
T-Sql脚本语言–解释型语言
T-SQL（Transact-SQL）是一种解释型脚本语言，用于在 Microsoft SQL Server 和 Azure SQL 数据库等 Microsoft 数据库管理系统中执行数据库查询、插入数据、更新和删除数据、创建和修改表、视图、存储过程以及其他数据库对象。T-SQL 由 Microsoft 开发并扩展了标准的 SQL 语言，提供了更多的功能和语法，例如控制流语句、变量声明、函数、触发器等。
与编译型语言不同，解释型语言不需要预先将源代码转换为可执行文件，并且可以直接在运行时进行解释和执行。T-SQL 脚本通常由 SQL Server 服务进程解释和执行，而不是通过编译生成可执行文件。这使得 T-SQL 脚本更加灵活和易于调试，但同时也可能导致性能问题和安全风险，因此需要小心处理。
JavaScript 是另一种常见的解释型语言，通常用于客户端脚本开发、Web 应用程序、服务器端应用程序等。与 T-SQL 不同，JavaScript 在广泛的应用程序和平台上都有使用，也具有不同的语法、功能和用途。
java 编译型语言
Java 是一种编译型语言，使用 Java 编译器将源代码编译成字节码文件（.class 文件），然后在 Java 虚拟机（JVM）上运行。与解释型语言不同，编译型语言需要在运行之前将源代码转换为可执行文件。
Java 编译器可以在任何支持 Java 开发环境的计算机上编译 Java 代码。编译器将源代码转换为字节码，该字节码独立于具体的硬件和操作系统，并且可以在任何支持 JVM 的平台上运行。这种跨平台性使得 Java 成为一种广泛应用的编程语言，尤其适合开发 Web 应用程序、企业级应用程序、移动应用程序等。
另外，Java 还提供了一些工具，例如反编译器、JAR 打包工具、调试器等，使开发人员可以更轻松地开发和调试 Java 代码。通过优化编译器和 JIT（Just-In-Time）编译器，Java 运行时环境可以在运行时将字节码转换为本地机器代码，以增加执行效率。
需要注意的是，虽然 Java 是编译型语言，但是在开发过程中也存在一些解释型语言的特性。例如，Java 可以通过反射或动态代理等机制，在运行时动态生成代码或修改类结构。此外，Java 也支持动态语言和脚本语言的特性，例如 lambda 表达式、方法引用、脚本引擎等。
.frm
.frm 是 MySQL 数据库中表格定义文件的后缀名，用于存储表格的结构和元数据信息。在 MySQL 中，每个表格都有一个对应的 .frm 文件，该文件包含了表格的列定义、键定义、默认值、注释等所有表格结构相关的信息。
.frm 文件通常位于数据库目录下的与表格名称相同的文件夹中，例如 mydatabase/mytable.frm。这些文件是 MySQL 数据库重要的组成部分，因为它们描述了数据库中表格的基本结构和约束信息。
当 MySQL 服务器启动时，它会扫描所有数据库的目录，并加载所有 .frm 文件以重建表格定义。如果 .frm 文件损坏或丢失，将无法访问相关表格，因此务必注意备份和保护这些文件。
需要注意的是，在特定情况下，如使用 InnoDB 存储引擎，.frm 文件可能并不是必需的，并且表格定义信息可能也存在于其他文件（如共享表空间文件）中。
.myd 数据文件
.myd 是 MySQL 数据库中 MyISAM 存储引擎使用的数据文件的后缀名，用于存储表格中实际的数据。在 MySQL 中，每个 MyISAM 表格都有一个对应的 .myd 文件，该文件包含了表格中所有行的数据。
.myd 文件通常位于数据库目录下与表格名称相同的文件夹中，例如 mydatabase/mytable.myd。这些文件是 MySQL 数据库重要的组成部分，因为它们包含了表格中的实际数据。如果 .myd 文件丢失或损坏，则可能会导致数据丢失或表格不可访问。
需要注意的是，.myd 文件仅适用于 MyISAM 存储引擎，而对于其他存储引擎（如 InnoDB），则可能使用不同的数据文件格式和结构。例如，InnoDB 存储引擎使用多个文件来存储表格数据和元数据信息，包括 .ibd、.frm、.ib_logfile* 等文件。因此，在备份和维护 MySQL 数据库时，需要理解所使用的存储引擎的特性和文件结构，以确保数据的完整性和安全性。
.myi 索引文件
.myi 是 MySQL 数据库中 MyISAM 存储引擎使用的索引文件的后缀名，用于存储表格的索引信息。在 MySQL 中，每个 MyISAM 表格都有一个对应的 .myi 文件，该文件包含了表格中每个索引的数据结构和元数据信息。
.myi 文件通常位于数据库目录下与表格名称相同的文件夹中，例如 mydatabase/mytable.myi。这些文件是 MySQL 数据库重要的组成部分，因为它们包含了表格的索引信息。如果 .myi 文件丢失或损坏，则可能会导致无法正确访问表格索引，从而影响查询效率和数据完整性。
需要注意的是，.myi 文件仅适用于 MyISAM 存储引擎，而对于其他存储引擎（如 InnoDB），则可能使用不同的索引文件格式和结构。例如，InnoDB 存储引擎使用 .ibd 文件来存储索引信息和表格数据。因此，在备份和维护 MySQL 数据库时，需要理解所使用的存储引擎的特性和文件结构，以确保数据的完整性和安全性。
第三章：高级查询
C（create）U (update) R (reader) D (delete) 操作
查询操作是最复杂的
*如何提升海量数据的检索效率；（没有最好的只有当前环境下）
1.优化Sql语句
SQL 语句优化是一种使数据库查询更快且更有效的技术。以下是一些优化 SQL 语句的方法：
- 缩小查询范围：可以使用 WHERE 子句或其他过滤条件来缩小查询的范围，以减少需要扫描的数据行数。
- 使用索引：索引可以提高查询性能，因为它们允许数据库直接定位到特定的数据行，而无需扫描整个表格。可以根据查询类型和表格结构选择合适的索引，并确保索引列的数据类型匹配查询条件。
- 避免使用 SELECT *：只查询需要的列，而不是整个表格，可以减少查询所需的 I/O 和内存消耗。
- 避免在查询中使用函数：嵌套函数、聚合函数等会导致数据库执行额外的计算工作。如果可能，可以将计算移到应用程序中进行。
- 避免重复查询：可以使用 JOIN、子查询或临时表格来避免执行多次查询。
- 合并查询：可以考虑将多个查询合并成单个查询，以减少数据库的负载和网络延迟。
- 使用 UNION ALL 替代 UNION：除非需要去重，否则使用 UNION ALL 可以比 UNION 更快，因为它不需要执行排序操作。
- 使用 LIMIT 条件：如果只需要查询前几行数据，则可以使用 LIMIT 条件来限制结果集的大小，以减少数据库资源的消耗。
- 缓存查询结果：对于经常执行的查询，可以考虑使用缓存来保存结果，以避免重复执行查询。
需要注意的是，优化 SQL 语句是一项艰巨的任务，需要理解表格结构、索引类型和查询逻辑等方面的知识。在进行 SQL 优化之前，应仔细分析查询性能和数据库瓶颈，并评估不同的优化方法的效果和影响。
2.为表增加索引（Mysql,全文索引,SqlServer 具体索引，非具体索引）
为表增加索引是提高数据库查询性能的一种常用方法，不同类型的索引适用于不同类型的查询和数据结构。以下是针对 MySQL 和 SQL Server 数据库的具体索引和非具体索引的介绍：
MySQL 索引：
- B-Tree 索引：这是 MySQL 最常用的索引类型，可以应用于 WHERE 子句中的任意列。使用 CREATE INDEX 语句可以为指定列创建 B-Tree 索引。
- 全文索引：这种索引用于在文本列中进行全文搜索，支持关键字搜索、短语搜索、布尔搜索等功能。使用 ALTER TABLE 语句可以为指定列创建全文索引。
SQL Server 索引：
- 聚簇索引：这是 SQL Server 中最常用的索引类型，用于按照物理顺序排序和存储表格行。每个表格只能有一个聚簇索引，通常应该选择主键作为聚簇索引。
- 非聚簇索引：这种索引与聚簇索引不同，它们存储在单独的数据结构中，可在多个列上创建，并且支持多个索引的组合使用。CREATE INDEX 语句可用于为指定列或列集创建非聚簇索引。
- 全文索引：与 MySQL 的全文索引类似，在 SQL Server 中也可以为文本列创建全文索引，以支持高效的文本搜索操作。
尽管具体索引各不相同，但它们都能够加速查询并提高数据库性能。需要注意的是，对于大型或复杂的表格，应该仔细考虑使用哪种类型的索引，并且每个索引都会增加写入操作的成本，因此应该权衡索引对读取和写入操作的影响。
3.修改Mysql数据库表的参数配置（Myisam存储引擎）
MySQL 中 MyISAM 存储引擎的参数配置可以通过 ALTER TABLE 语句进行修改。以下是一些常用的 MyISAM 参数及其修改方法：
- 自增长字段起始值：使用 AUTO_INCREMENT 属性可以为表格中的自增长字段指定起始值。例如，如果要将表格中的自增长 ID 字段的起始值设置为 1000，则可以使用以下 ALTER TABLE 语句：
ALTER TABLE table_name AUTO_INCREMENT=1000;
- 数据文件大小限制：使用 MAX_ROWS 和 AVG_ROW_LENGTH 属性可以限制表格数据文件的大小。例如，如果要将表格数据文件大小限制为 10 MB，则可以使用以下 ALTER TABLE 语句：
ALTER TABLE table_name MAX_ROWS=10000000 AVG_ROW_LENGTH=100;
- 索引缓存大小：使用 key_buffer_size 参数可以指定 MyISAM 存储引擎使用的索引缓存大小，以提高查询性能。例如，如果要将索引缓存大小设置为 256 MB，则可以在 MySQL 配置文件中添加以下行：
key_buffer_size=256M
需要注意的是，修改 MyISAM 参数的效果取决于表格结构、数据分布和查询模式等因素。应该谨慎调整参数，并且在修改之前备份数据以避免意外数据丢失。
4.数据库分流（分库，分表–拆分原则）
数据库分流是一种将大型数据库拆分为多个较小的数据库或表格，以提高查询性能、降低负载和加强容错能力的技术。以下是常用的数据库分流方法和拆分原则：
- 分库：将不同的数据存储在不同的数据库中，可以通过不同的连接字符串或分布式事务来访问这些数据库。通常，分库的原则是将相互独立、业务无关、访问频率低的数据分离出去，以减少主数据库的负载。例如，可以将用户信息、商品信息、日志信息等分别存储在不同的数据库中。
- 分表：将一个大型表格拆分成多个较小的表格，每个表格包含部分数据行。通常，分表的原则是根据数据访问模式、数据量和表格结构等因素进行划分。例如，可以按照时间范围、地理位置、用户 ID 等因素对数据行进行分割。分表可以减少单个表格的读写压力，并且可以并行处理查询请求。
- 水平拆分和垂直拆分：水平拆分是按照数据行进行拆分（例如按照用户 ID 或时间进行拆分），而垂直拆分是按照列进行拆分（例如将经常使用的列放到一个表格中，其他列放到其他表格中）。根据数据特性和查询模式的不同，可以选择水平拆分、垂直拆分或两者结合进行数据库分流。
需要注意的是，数据库分流是一项复杂的任务，需要仔细评估数据库的负载和性能瓶颈，并且需要修改应用程序代码以适应新的数据库架构。在进行分流之前，应该制定详细的计划和测试方案，并对分流后的性能和可用性进行监控和优化。
5.缓存技术
缓存技术是一种通过将数据或计算结果存储在高速、易于访问的内存中，以提高应用程序性能和响应速度的技术。以下是常用的缓存技术：
- 本地缓存：本地缓存是指在应用程序进程内部使用内存缓存数据或结果，以避免从外部系统（如数据库、文件系统）读取数据。本地缓存可以减少网络延迟和 I/O 操作，并提高应用程序的性能和响应速度。
- 分布式缓存：分布式缓存是指将缓存数据存储在多个节点上，以增加可扩展性和容错能力。分布式缓存通常使用一致性哈希等算法来分配数据到不同的节点中，并使用副本机制来提高数据可靠性和可用性。
- 前端缓存：前端缓存是指将静态资源（如图片、CSS、JS 文件）存储在浏览器或 CDN 中，以避免重复下载和浪费网络带宽。前端缓存可以减少页面加载时间和服务器负载，并提高用户体验。
- 数据库缓存：数据库缓存是指将热点数据或查询结果存储在内存中，以避免频繁地从磁盘读取数据。数据库缓存通常使用内置缓存或第三方缓存插件来实现，例如 MySQL 的 Query Cache、Redis 等。
- 对象缓存：对象缓存是指将应用程序中的对象存储在内存中，以避免反复创建和销毁对象。对象缓存通常用于高并发的 Web 应用程序中，并且可以通过连接池和对象池等技术进一步优化性能。
需要注意的是，缓存技术虽然可以提高应用程序性能和响应速度，但也会增加系统复杂度和数据一致性问题。在设计和使用缓存时，应该考虑缓存的生命周期、大小、更新策略、过期机制和失效处理等方面的问题，并进行监控和调优以确保系统的可靠性和稳定性。
6.适应非关系型数据库 (特点：内存行数据库)
非关系型数据库是一种不同于传统关系型数据库的数据存储方式，常见的非关系型数据库包括内存行数据库、文档数据库、列式数据库等。适应非关系型数据库需要考虑以下几个方面：
- 数据模型和查询语言不同：非关系型数据库通常使用键值对、文档或列族等数据模型，而不是传统的表格和行列。此外，它们也可能使用不同的查询语言和 API。因此，要想适应非关系型数据库，需要了解其数据模型和查询语言，并学习如何使用相应的 API 和工具。
- 大量的内存操作：内存行数据库通常将所有数据都存储在内存中，以提高读写速度和响应时间。因此，在使用内存行数据库时，需要考虑内存使用状况、缓存策略、数据持久化等问题，并针对大量的内存操作进行优化。
- 水平扩展和分布式存储：非关系型数据库通常支持水平扩展和分布式存储，可以通过增加节点或分片来扩展系统容量和性能。因此，在设计和使用非关系型数据库时，需要考虑数据分布和负载均衡等问题，并选择合适的分片和复制策略。
- 数据一致性和可靠性：非关系型数据库通常使用异步复制和数据冗余等机制来保证数据的一致性和可靠性。因此，在使用非关系型数据库时，需要考虑数据同步的延迟、备份和恢复等问题，并进行监控和备份以确保数据的可靠性。
需要注意的是，非关系型数据库虽然具有高性能、可扩展性和灵活性等优势，但也存在容易出错、难以维护和缺乏标准化等问题。在选择和使用非关系型数据库时，应该了解其特点和限制，并根据实际需求权衡其利弊，以确保系统的稳定性和可靠性。
修改表的名称
可以使用 ALTER TABLE 命令来修改表的名称。以下是 ALTER TABLE 命令的语法：
ALTER TABLE table_name RENAME TO new_table_name;
其中，table_name 是要修改的表的名称，new_table_name 是新的表名称。
例如，如果要将表 employees 的名称更改为 staffs，可以执行以下 SQL 语句：
ALTER TABLE employees RENAME TO staffs;
需要注意的是，修改表名可能会影响依赖于该表的其他对象，如触发器、存储过程等，因此在修改表名之前应该先检查所有相关对象并进行必要的修改。
添加字段
- 确定要添加字段的表格：使用 ALTER TABLE 语句时，需要指定要修改的表格名称。
- 确定要添加的字段名称和数据类型：根据业务需求确定新字段的名称和数据类型。常见的数据类型包括整数、浮点数、字符型、日期型等。
- 添加字段到表格中：使用 ALTER TABLE ADD COLUMN 语句将新字段添加到表格中。例如，以下语句将在 customers 表格中添加一个新字段 email：
ALTER TABLE customers ADD COLUMN email VARCHAR(255);
需要注意的是，在添加字段之前应该备份数据以防止意外数据丢失，并且应该考虑新字段对应用程序和数据库查询的影响。如果表格中已经存在大量数据，添加新字段可能会导致性能下降和增加存储空间需求。因此，应该谨慎考虑添加新字段的必要性，并进行测试和优化以确保系统的稳定性和可靠性。
修改字段
在关系型数据库中，修改字段可以通过 ALTER TABLE 语句实现。以下是修改字段的一般步骤：
- 确定要修改字段的表格：使用 ALTER TABLE 语句时，需要指定要修改的表格名称。
- 确定要修改的字段名称和数据类型：根据业务需求确定要修改的字段名称和数据类型。常见的修改包括更改数据类型、长度、默认值等。
- 修改字段属性：使用 ALTER TABLE MODIFY COLUMN 语句修改字段属性。例如，以下语句将 customers 表格中的 email 字段名称改为 contact_email，并将数据类型修改为 TEXT：
ALTER TABLE customers MODIFY COLUMN email TEXT, CHANGE COLUMN email contact_email;
需要注意的是，在修改字段之前应该备份数据以防止意外数据丢失，并且应该考虑新字段对应用程序和数据库查询的影响。如果有大量数据需要修改，可能会导致性能下降和增加存储空间需求。因此，应该谨慎考虑修改字段的必要性，并进行测试和优化以确保系统的稳定性和可靠性。
删除字段
在关系型数据库中，删除字段可以通过 ALTER TABLE 语句实现。以下是删除字段的一般步骤：
- 确定要删除字段的表格：使用 ALTER TABLE 语句时，需要指定要修改的表格名称。
- 确定要删除的字段名称：根据业务需求确定要删除的字段名称。
- 删除字段：使用 ALTER TABLE DROP COLUMN 语句将字段从表格中删除。例如，以下语句将 customers 表格中的 email 字段删除：
ALTER TABLE customers DROP COLUMN email;
需要注意的是，在删除字段之前应该备份数据以防止意外数据丢失，并且应该考虑是否会影响到应用程序和数据库查询。如果字段包含大量数据，可能会导致性能下降和增加存储空间需求。因此，应该谨慎考虑删除字段的必要性，并进行测试和优化以确保系统的稳定性和可靠性。
添加主键
在关系型数据库中，添加主键可以通过 ALTER TABLE 语句实现。以下是添加主键的一般步骤：
- 确定要添加主键的表格：使用 ALTER TABLE 语句时，需要指定要修改的表格名称。
- 确定要作为主键的字段：根据业务需求确定要作为主键的字段，通常是一个唯一标识符或者一个组合键。
- 添加主键到表格中：使用 ALTER TABLE ADD PRIMARY KEY 语句将主键添加到表格中。例如，以下语句将在 customers 表格中添加一个由 customer_id 组成的主键：
ALTER TABLE customers ADD PRIMARY KEY (customer_id);
需要注意的是，主键必须满足以下条件：不能为空、唯一且不可更改。如果表格已经存在数据，添加主键可能会导致失败或错误，因此应该先清理重复或空值的数据。如果已经有主键，则需要先删除原来的主键再添加新的。因此，在添加主键之前应该进行备份和谨慎考虑其对应用程序和数据库查询的影响，以确保系统的稳定性和可靠性。
给表增加外键
在关系型数据库中，给表增加外键可以通过 ALTER TABLE 语句实现。以下是增加外键的一般步骤：
- 确定要添加外键的表格：使用 ALTER TABLE 语句时，需要指定要修改的表格名称。
- 确定要添加外键的字段及其对应的参考表格和字段：根据业务需求确定要添加外键的字段，以及它对应的参考表格和字段。
- 添加外键到表格中：使用 ALTER TABLE ADD FOREIGN KEY 语句将外键添加到表格中。例如，以下语句将在 orders 表格中添加一个外键，将 customer_id 字段与 customers 表格中的 customer_id 字段关联起来：
ALTER TABLE orders ADD CONSTRAINT fk_orders_customers
FOREIGN KEY (customer_id)
REFERENCES customers(customer_id);
需要注意的是，在添加外键之前应该确保参考表格中的对应字段已经存在主键或唯一键，并且该字段类型和大小与要添加外键的字段相同。如果表格中有大量数据，添加外键可能会导致性能下降和增加存储空间需求。因此，应该谨慎考虑添加外键的必要性，并进行测试和优化以确保系统的稳定性和可靠性。
1.插入单行数据
在关系型数据库中，插入单行数据可以通过 INSERT INTO 语句实现。以下是插入单行数据的一般步骤：
- 确定要插入数据的表格：使用 INSERT INTO 语句时，需要指定要插入数据的表格名称。
- 确定要插入的字段和对应的值：根据业务需求确定要插入的字段和它们对应的值。如果没有指定某些字段，则默认为NULL或使用默认值。
- 插入数据到表格中：使用 INSERT INTO VALUES 语句将数据插入到表格中。例如，以下语句将在 customers 表格中插入一行数据：
INSERT INTO customers (customer_name, customer_email, customer_phone)
VALUES ('John Smith', '[email protected]', '123-456-7890');
需要注意的是，插入数据的顺序应该与字段列表中的顺序相同，并且每个字段的值应该与其数据类型相匹配。如果插入重复的数据，可能会导致唯一性约束出错。因此，在插入数据之前应该谨慎检查要插入的数据是否符合表格约束，以确保系统的稳定性和可靠性。
批量插入
在关系型数据库中，批量插入数据可以通过 INSERT INTO 语句的 VALUES 子句或者 SELECT 子句实现。以下是批量插入数据的一般步骤：
- 确定要插入数据的表格：使用 INSERT INTO 语句时，需要指定要插入数据的表格名称。
- 确定要插入的字段和对应的值：根据业务需求确定要插入的字段和它们对应的值。如果没有指定某些字段，则默认为NULL或使用默认值。
- 使用 VALUES 子句进行批量插入：使用 VALUES 子句插入多行数据。例如，以下语句将在 customers 表格中插入两行数据：
INSERT INTO customers (customer_name, customer_email, customer_phone)
VALUES
('John Smith', '[email protected]', '123-456-7890'),
('Jane Doe', '[email protected]', '234-567-8901');
- 使用 SELECT 子句进行批量插入：使用 SELECT 子句从其他表格或查询结果集中选择数据并插入到目标表格中。例如，以下语句将从 orders 表格中选择前100条记录的 customer_id 、order_date 和 order_total 字段值，并将它们插入到 customers_report 表格中：
INSERT INTO customers_report (customer_id, report_date, report_total)
SELECT customer_id, CURDATE(), SUM(order_total)
FROM orders
GROUP BY customer_id
LIMIT 100;
需要注意的是，在批量插入数据之前应该谨慎检查要插入的数据是否符合表格约束，以确保系统的稳定性和可靠性。如果插入重复的数据，可能会导致唯一性约束出错。同时，如果插入大量数据，可能会对数据库的性能产生影响，因此应该进行测试和优化以最大程度地提高插入效率。
2.批量插入（复制粘贴到新表）
在关系型数据库中，可以使用 INSERT INTO 语句的 SELECT 子句来将一个表格的数据复制到另一个表格中。以下是将一个表格的数据复制到另一个表格中的一般步骤：
- 创建新表格：如果需要将数据复制到一个新的表格中，需要先创建一个新表格并定义好其结构。
- 确定要复制数据的原表格：使用 SELECT 子句时，需要指定要从哪个表格中选择数据。
- 确定要插入数据的目标表格：使用 INSERT INTO 语句时，需要指定要将数据插入到哪个表格中。
- 复制数据：使用 INSERT INTO SELECT 语句将数据从原表格中选择出来，并插入到目标表格中。例如，以下语句将从 customers 表格中选择所有数据，并将其插入到 customers_backup 表格中：
INSERT INTO customers_backup
SELECT * FROM customers;
需要注意的是，在复制数据之前应该检查目标表格是否具有与原表格相同的结构和约束条件。如果存在不匹配的情况，可能会导致失败或错误。同时，如果复制大量数据，可能会对数据库的性能产生影响，因此应该进行测试和优化以最大程度地提高效率。
更新
在关系型数据库中，更新数据可以通过 UPDATE 语句实现。以下是更新数据的一般步骤：
- 确定要更新数据的表格：使用 UPDATE 语句时，需要指定要更新数据的表格名称。
- 确定要更新数据的行和对应的字段值：根据业务需求确定要更新哪些行以及它们对应的字段值。
- 使用 WHERE 子句过滤数据行：如果不想更新所有行，可以使用 WHERE 子句来选择要更新的行。例如，以下语句将更新 customers 表格中 customer_id 为 100 的行的 email 字段：
UPDATE customers SET email = '[email protected]'
WHERE customer_id = 100;
删除表
在关系型数据库中，可以使用 DROP TABLE 语句删除表格。以下是删除表格的一般步骤：
- 确定要删除的表格：使用 DROP TABLE 语句时，需要指定要删除的表格名称。
- 确认删除操作：在执行 DROP TABLE 语句之前，应该先确认是否确实要删除这个表格以及其中的所有数据。删除表格会删除表格定义、索引、约束等元数据和数据，同时可能会影响其他与其相关的表格和查询。
- 执行 DROP TABLE 语句：执行 DROP TABLE 语句将表格及其所有数据从数据库中删除。例如，以下语句将删除名为 customers 的表格：
DROP TABLE customers;
需要注意的是，删除表格是不可逆的操作，因此应该谨慎考虑并备份相关数据和元数据。如果表格中有被其他表格引用的外键，需要先删除这些外键才能删除表格。同时，如果表格占用了大量存储空间，删除表格可能需要较长时间，并且可能会对数据库性能产生影响。
注释
/*
1，删除一张表中所有的数据，请输入用truncate table 性能比较好
-
标识列是否会自动归零；
*/
/------------------------查询--------------------/
select * from tb_stident;
select sid,agen from tb_student;
select sid as `学生编号`,sname `学生姓名` form tb_student;
select st.sid,st.sname,st.age from tb_student as st;
#常量列
select sid,sname.'三好学生' form tb_student;
#union ,union ALL
select * from tb_student where sid=25;
union（必须要求一模一样要不然无法合并查询结果）
select * from tb_student where sid=26;
select sname * from tb_student where sid=25;
union All
select sname * from tb_student where sid=26;
distinct去重名
insert into tb_student values(null,‘葫芦2娃’,12,2)
select distinct sname from tb_student where sname=‘葫芦2娃’;
在关系型数据库中，可以使用 SELECT 语句中的 DISTINCT 关键字来去重。如果一个列包含重复的值，DISTINCT 关键字可以返回唯一的值列表。
例如，在 customers 表格中，如果要获取所有不同的 customer_name 值，可以使用以下语句：
SELECT DISTINCT customer_name FROM customers;
这将返回一个包含所有不同 customer_name 值的列表。
UNION
操作符用于连接两个或多个 SELECT 语句的结果集，并去除重复的行。例如：
SELECT customer_id, customer_name, customer_email FROM customers
UNION
SELECT supplier_id, supplier_name, supplier_email FROM suppliers;
这将返回一个包含 customers 表格和 suppliers 表格中不重复行的结果集，其中每个行由 customer_id、customer_name 和 customer_email 三个字段组成。
UNION ALL 操作符
也用于连接两个或多个 SELECT 语句的结果集，但是不去重重复的行。例如：
SELECT customer_id, customer_name, customer_email FROM customers
UNION ALL
SELECT supplier_id, supplier_name, supplier_email FROM suppliers;
这将返回一个包含 customers 表格和 suppliers 表格中所有行的结果集，其中可能包含重复的行。
分组
在关系型数据库中，可以使用 GROUP BY 语句对查询结果按照一个或多个列进行分组。GROUP BY 常与聚合函数（如 COUNT、SUM、AVG 等）一起使用，用于计算每个分组的统计信息。
以下是使用 GROUP BY 进行分组的示例，假设有一个 orders 表格，其中包含 customer_id、order_date 和 order_total 三个字段：
SELECT customer_id, YEAR(order_date) AS year, SUM(order_total) AS total
FROM orders
GROUP BY customer_id, YEAR(order_date);
这将返回一个根据 customer_id 和 order_date 年份进行分组的结果集，以及每个分组的总订单金额。使用 GROUP BY 子句时，查询中选择的列必须要么在 GROUP BY 子句中指定，要么使用聚合函数进行计算。
需要注意的是，在使用 GROUP BY 进行分组时应该谨慎处理 NULL 值和空值，因为它们可能会影响分组的结果。同时，由于 GROUP BY 操作需要对所有数据进行排序和比较以确定分组，因此当数据量很大时，可能会对查询性能产生影响。
/where having 区别？/
在关系型数据库中，WHERE 和 HAVING 都是用于限制 SELECT 语句中返回的结果集的子句，但它们的使用场景和作用范围不同。
WHERE 子句用于在查询之前筛选行。它可以根据指定的条件选择要返回的行，并将其他行排除在外。
例如：
SELECT customer_id, customer_name
FROM customers
WHERE customer_age > 18;
这将返回一个只包含年龄大于18岁的客户信息的结果集。
HAVING 子句在 GROUP BY 子句之后对分组进行筛选。它可以根据指定的条件选择分组，并将其他分组排除在外。
例如：
SELECT customer_id, YEAR(order_date) AS year, SUM(order_total) AS total
FROM orders
GROUP BY customer_id, YEAR(order_date)
HAVING total > 1000;
这将返回一个根据 customer_id 和 order_date 年份进行分组的结果集，以及每个分组的总订单金额，但仅返回总金额大于1000的分组。
需要注意的是，HAVING 子句只能用于聚合函数组成的表达式，而且必须放在 GROUP BY 子句之后。如果没有使用 GROUP BY 子句，则 WHERE 子句和 HAVING 子句的作用相同。同时，在使用 HAVING 进行分组筛选时应该谨慎处理 NULL 值和空值，因为它们可能会影响分组的结果。
排序
在关系型数据库中，可以使用 ORDER BY 子句对 SELECT 语句的结果集进行排序。ORDER BY 子句可以按照一个或多个列的值升序或降序排列结果集。
以下是使用 ORDER BY 进行排序的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 customer_age 三个字段：
SELECT customer_id, customer_name, customer_age
FROM customers
ORDER BY customer_age DESC; -- 按照年龄降序排序
这将返回一个按照客户年龄降序排列的结果集。如果需要按照多个列排序，则可以在 ORDER BY 子句中指定多个列，例如：
SELECT customer_id, customer_name, customer_age
FROM customers
ORDER BY customer_age DESC, customer_name ASC; -- 先按照年龄降序，再按照名称升序排序
需要注意的是，ORDER BY 子句可能会影响查询性能，因为它需要对所有数据进行排序和比较以确定顺序。同时，在使用 ORDER BY 进行排序时应该处理 NULL 值和空值，因为它们可能会影响排序结果。
LIMIT
在关系型数据库中，可以使用 LIMIT 子句限制 SELECT 语句返回的结果集中的行数。LIMIT 子句一般用于分页查询，例如每次只返回前几条或者跳过前几条记录。
以下是使用 LIMIT 进行分页查询的示例，假设有一个 products 表格，其中包含 product_id、product_name 和 product_price 三个字段：
SELECT product_id, product_name, product_price
FROM products
ORDER BY product_price DESC
LIMIT 10; -- 返回价格最高的前10个产品
**select * from tb_student limit 2;**
**select * from tb_student order by sid desc limit 2;（最后两名）**
**select * from tb_student limit 2,2;(从第一个二开始截取，第二个2是获取两个）**
这将返回一个包含前10个价格最高的产品信息的结果集。
1.聚合函数
在关系型数据库中，聚合函数用于对表格中的数据进行统计和计算。常见的聚合函数包括 COUNT、SUM、AVG、MIN 和 MAX 等。
以下是使用聚合函数进行统计的示例，假设有一个 orders 表格，其中包含 customer_id、order_date 和 order_total 三个字段：
SELECT COUNT(*) AS count
FROM orders
WHERE customer_id = 100; -- 统计客户 100 的订单数
SELECT YEAR(order_date) AS year, SUM(order_total) AS total
FROM orders
GROUP BY YEAR(order_date); -- 按照年份统计总订单金额
SELECT AVG(order_total) AS average, MIN(order_total) AS min, MAX(order_total) AS max
FROM orders; -- 计算总订单金额的平均值、最小值和最大值
需要注意的是，在使用聚合函数进行统计时应该处理 NULL 值和空值，因为它们可能会影响统计结果。同时，在使用 GROUP BY 进行分组统计时应该谨慎处理 NULL 值和空值，因为它们可能会导致分组不准确或者出现错误。
2.系统函数
以下是几个常见的系统函数示例：
- 字符串处理函数
- CONCAT：用于连接两个或多个字符串。
- LENGTH：用于返回指定字符串的长度。
- UPPER 和 LOWER：分别用于将字符串转换为大写和小写。
- SUBSTR 或 SUBSTRING：用于截取指定字符串的子串。
- REPLACE：用于将字符串中的一个子串替换为另一个字符串。
例如：
SELECT CONCAT(first_name, ' ', last_name) AS full_name
FROM customers;
SELECT customer_id, LENGTH(email) AS email_length
FROM customers;
SELECT UPPER(customer_name) AS upper_name
FROM customers;
SELECT SUBSTR(address, 1, 10) AS short_address
FROM customers;
SELECT REPLACE(notes, 'important', 'urgent') AS updated_notes
FROM orders;
- 日期处理函数
- YEAR、MONTH、DAY：分别用于返回日期的年份、月份和日期。
- DATE_FORMAT：用于将日期格式化为指定的字符串形式。
- NOW：用于返回当前系统时间。
- DATEDIFF：用于计算两个日期之间的天数差异。
例如：
SELECT order_id, YEAR(order_date) AS order_year
FROM orders;
SELECT customer_id, DATE_FORMAT(birth_date, '%Y-%m-%d') AS formatted_birthdate
FROM customers;
SELECT NOW() AS current_time;
SELECT DATEDIFF('2023-04-01', '2023-03-01') AS days_diff;
需要注意的是，在使用系统函数时应该处理 NULL 值和空值，因为它们可能会影响函数的行为和结果。同时，在使用日期处理函数时应该考虑不同数据库系统的日期格式和语法差异。
3.自动逸函数
可能是指自增函数**（Auto-increment Function)** ，它是一种在关系型数据库中用于生成唯一标识符的函数。自增函数可以为表格中某个列定义一个递增的数值序列，每插入一行数据时都将自动为该列分配一个新的、唯一的值。
以下是使用自增函数创建自增列的示例，假设有一个 customers 表格，其中需要为 customer_id 列创建自增列：
CREATE TABLE customers (
customer_id INT AUTO_INCREMENT PRIMARY KEY,
customer_name VARCHAR(50),
customer_age INT
);
这将创建一个名为 customers 的表格，其中包含一个名为 customer_id 的自增列作为主键。
当向表格中插入新行时，可以省略 customer_id 列并让系统自动生成：
INSERT INTO customers (customer_name, customer_age) VALUES ('Alice', 25);
此时，系统将自动为 customer_id 分配一个新的唯一值。
#字符串函数
select contcat(sname,`-`,`三好学生`) from tb_student;
selct insert(`我是易建联`,3,2,'我是林书豪')替换文字
select lower('helloworld');转换小写
select upper('helloworld');转换大写
select substring('hello',4,2)字符串截取
select substring（sname，1，2） from tb_student; 截取
select concat(substring（sname，1，2）,'---','王覅') from tb_student;
select new();当前时间年月日分秒
select curdate();当前日期年月日
select curttme();当前分秒
select week((now()));获取当前时间在多少周
select year(new());当前年份
select hour();获取当前小时
select minute(now());获取当前分钟
select datadiff(now(),`2021-1-1`);相差多少天
select adddate(now（），5)在当前时间增加多少天
select ceil（3.4）；
select floor(3.7);
select rand();生成随机数
in 在。。。范围
在关系型数据库中，可以使用 IN 子句来筛选包含在一组固定值列表中的行。IN 子句通常用于在 WHERE 子句中指定一个范围或者多个值。
以下是使用 IN 子句进行筛选的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 customer_age 三个字段：
SELECT customer_id, customer_name
FROM customers
WHERE customer_age IN (18, 21, 25); -- 筛选年龄为 18、21 或 25 岁的客户
SELECT customer_id, customer_name
FROM customers
WHERE customer_name IN ('Alice', 'Bob', 'Charlie'); -- 筛选名字为 Alice、Bob 或 Charlie 的客户
需要注意的是，在使用 IN 子句时应该谨慎处理 NULL 值和空值，因为它们可能会影响筛选结果。同时，当需要判断某个列的值是否属于一个范围集合时，可能会使用 BETWEEN AND 子句，例如：
SELECT customer_id, customer_name
FROM customers
WHERE customer_age BETWEEN 18 AND 30; -- 筛选年龄在 18 到 30 岁之间的客户
需要注意的是，BETWEEN AND 子句包括起始和结束值，即上面的例子中会包含年龄为 18 和 30 岁的客户。
between…and 在。。。范围
在关系型数据库中，BETWEEN AND 子句用于在指定的范围内筛选数据。BETWEEN AND 子句通常用于在 WHERE 子句中指定一个范围。
以下是使用 BETWEEN AND 子句进行筛选的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 customer_age 三个字段：
SELECT customer_id, customer_name
FROM customers
WHERE customer_age BETWEEN 18 AND 30; -- 筛选年龄在 18 到 30 岁之间的客户
需要注意的是，BETWEEN AND 子句包括起始值和结束值，即上面的例子中会包含年龄为 18 和 30 岁的客户。同时，如果想要排除边界值，则可以使用 NOT BETWEEN AND 子句。
SELECT customer_id, customer_name
FROM customers
WHERE customer_age NOT BETWEEN 18 AND 30; -- 筛选年龄不在 18 到 30 岁之间的客户
需要注意的是，在使用 BETWEEN AND 子句时应该谨慎处理 NULL 值和空值，因为它们可能会影响筛选结果。同时，当需要判断某个列的值是否属于一个范围集合时，也可以使用 IN 子句。
表连接：
1.内连接 inner join
2.外连接
2.1.左外连接 left [outer] join
2.2.右外连接 right [outer] join
3.交叉式连接（实现迪米特算法）full join(mysql不支持)
内连接
在关系型数据库中，INNER JOIN（内连接）是一种将两个或多个表格中的数据进行联接的方法，返回包含匹配行的结果集。INNER JOIN 只返回同时在两个表格中存在的记录，即只有满足联接条件的行才会出现在结果集中。
以下是使用 INNER JOIN 进行联接的示例，假设有两个表格：orders 和 customers，其中 orders 包含 order_id、customer_id 和 order_total 三个字段，customers 包含 customer_id、customer_name 和 customer_age 三个字段：
SELECT orders.order_id, customers.customer_name, orders.order_total
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id;
这将返回一个包含订单号、客户名称和订单金额的结果集，其中只包含既有对应订单又有对应客户信息的记录。
需要注意的是，在使用 INNER JOIN 进行联接时，应该明确指定联接条件（ON 子句），否则联接将无法成功。同时，在使用 INNER JOIN 时应该谨慎处理 NULL 值和空值，因为它们可能会影响联接结果。
左外连接(拿右边的比较没有的话不连接)
在关系型数据库中，**外连接（Outer Join）**是一种将两个或多个表格中的数据进行联接的方法。与 INNER JOIN 不同的是，外连接可以返回不满足联接条件的记录，并且可以指定左外连接和右外连接。
以下是使用外连接进行联接的示例，假设有两个表格：orders 和 customers，其中 orders 包含 order_id、customer_id 和 order_total 三个字段，customers 包含 customer_id、customer_name 和 customer_age 三个字段：
-- 左外连接(拿右边的比较没有的话不连接)
SELECT orders.order_id, customers.customer_name, orders.order_total
FROM orders
LEFT JOIN customers ON orders.customer_id = customers.customer_id;
-- 右外连接(拿左边的比较没有的话不连接)
SELECT orders.order_id, customers.customer_name, orders.order_total
FROM orders
RIGHT JOIN customers ON orders.customer_id = customers.customer_id;
左外连接将会返回左表格（orders）中所有记录以及右表格（customers）中满足联接条件的记录，如果某些记录在右表格中不存在，则返回 NULL 值。右外连接则相反，返回右表格中所有记录以及左表格中满足联接条件的记录。
需要注意的是，在使用外连接进行联接时应该明确指定联接条件（ON 子句），否则联接将无法成功。同时，在使用外连接时应该谨慎处理 NULL 值和空值，因为它们可能会影响联接结果。
交叉式连接（Cross Join）
也称为笛卡尔积，是一种将两个表格中的每一行都与另一个表格中的每一行进行组合的联接方式。交叉连接不需要指定任何联接条件，它将返回两个表格中所有记录的组合。
以下是使用交叉连接进行联接的示例，假设有两个表格：orders 和 customers，其中 orders 包含 order_id 和 order_total 两个字段，customers 包含 customer_id、customer_name 和 customer_age 三个字段：
SELECT *
FROM orders
CROSS JOIN customers;
这将返回一个包含所有订单和客户信息的结果集，其中每个订单都与每个客户进行了组合。
需要注意的是，在使用交叉连接进行联接时应该谨慎处理因数据量过大而导致的性能问题。通常情况下，都会在交叉连接后进行 WHERE 子句的筛选操作，以缩小结果集大小。
第四章
创建临时表
在关系型数据库中，临时表是一种存储临时数据的表格，通常在查询中使用。临时表与普通表格的区别在于其具有较短的生命周期，并且在使用后会自动销毁。
以下是创建和查询临时表的示例：
-- 创建临时表
CREATE TEMPORARY TABLE temp_orders (
order_id INT PRIMARY KEY,
customer_id INT,
order_total DECIMAL(10,2)
);
-- 向临时表插入数据
INSERT INTO temp_orders (order_id, customer_id, order_total)
VALUES
(1, 100, 50.00),
(2, 101, 100.00),
(3, 102, 150.00);
-- 查询临时表
SELECT * FROM temp_orders;
这将创建一个名为 temp_orders 的临时表，并向其中插入了三个订单记录。在查询完临时表后，它将被自动销毁。
需要注意的是，在使用临时表时应该谨慎处理因数据量过大而导致的性能问题。同时，在不再需要使用临时表时应该及时销毁它，避免占用过多的内存空间。
第五章
在关系型数据库中，事务是一组数据库操作，这些操作作为一个整体被视为单个逻辑工作单位，并且只有在该组操作全部完成后才能提交到数据库中。ACID 是指一组事务处理的标准，包括原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability），是保证事务处理正确性和完整性的基本要求。
- 原子性（Atomicity）：指一个事务中的所有操作要么全部完成，要么全部不完成，如果任何一个操作失败，则整个事务都将被回滚到操作之前的状态。
- 一致性（Consistency）：指在一个事务执行完成后，数据库必须处于一致的状态，即数据库中的所有数据都必须遵循规则，以保证数据的正确性。
- 隔离性（Isolation）：指数据库系统需要提供一定的隔离机制，以确保多个并发的事务可以同时执行而不会相互影响。隔离级别包括读未提交、读已提交、可重复读和串行化。
- 持久性（Durability）：指当一个事务成功完成后，它所做的修改必须永久地保存在数据库中，即使系统出现故障或异常情况也不能丢失。
需要注意的是，在使用事务时应该遵循 ACID 原则，以确保事务的正确性和完整性。同时，在处理大量数据时应该优化事务的使用方式，避免因事务操作过于频繁而导致性能下降。
数据库存储过程–类似java中的方法.
注意:默认情况下mYsql为自动提交事务 每条sql语句在MYsql执行默认就是一个事务；
事务涉及的语法：
第一步 开启事务关键字begin 或 start transaction
第二步 commit 提交 rollback回滚（撤销）
----------> 存储过程
---------->自定义函数
while loop
repeate
二：视图
在关系型数据库中，视图（View）是一种虚拟表格，其内容基于查询语句生成。视图通常使用 SELECT 语句从一个或多个表格中选择特定的列和行，并以逻辑方式组合它们，然后将结果保存为一个虚拟的表格供使用。
以下是创建和使用视图的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 customer_age 三个字段：
-- 创建视图
CREATE VIEW view_customers AS
SELECT customer_id, customer_name
FROM customers
WHERE customer_age > 18;
-- 查询视图
SELECT * FROM view_customers;
这将创建一个名为 view_customers 的视图，其内容基于 customers 表格中年龄大于 18 岁的客户信息。在查询时，可以像查询普通表格一样使用 SELECT 语句来检索视图数据。
三：索引
作用：提升数据检索速度：
注意：索引不能乱用
普通索引
也称作B-Tree索引，是一种常见的索引类型。它基于二叉搜索树（B-Tree）数据结构实现，能够大幅提高查询效率。普通索引一般在单个列上创建，并对该列进行排序和分组。
以下是为表格添加普通索引的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 customer_age 三个字段：
-- 在 customer_age 列上创建普通索引
CREATE INDEX idx_customer_age ON customers (customer_age);
-- 查询数据时使用索引
SELECT customer_id, customer_name
FROM customers
WHERE customer_age > 18;
在这个示例中，我们为 customers 表格中的 customer_age 列创建了一个名为 idx_customer_age 的普通索引。在查询时，数据库系统将会使用该索引来加速 WHERE 子句中对 customer_age 列的筛选操作，从而提高查询效率。
需要注意的是，在创建普通索引时应该谨慎选择列名，避免过多或不必要的索引导致性能下降。同时，在处理大量数据时应该优化索引的使用方式，以获得更好的查询效率。
唯一索引
唯一索引（Unique Index） 是一种保证数据表格中某一列或多列的值唯一的索引。唯一索引可以用于加速数据查询，并确保每个记录都具有唯一标识符。
以下是为表格添加唯一索引的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 email 三个字段：
-- 在 email 列上创建唯一索引
CREATE UNIQUE INDEX idx_email ON customers (email);
-- 查询数据时使用索引
SELECT customer_id, customer_name
FROM customers
WHERE email = '[email protected]';
在这个示例中，我们为 customers 表格中的 email 列创建了一个名为 idx_email 的唯一索引。在查询时，如果 WHERE 子句中指定了 email 值，数据库系统将会使用该索引来加速查询过程。
需要注意的是，在创建唯一索引时应该谨慎选择列名，避免过多或不必要的索引导致性能下降。同时，唯一索引会对插入和更新操作的性能产生影响，因为在执行这些操作时需要检查索引是否违反唯一性约束。
主键索引
是一种用于标识数据表格中每个记录唯一标识符的索引。主键索引通常用于加速数据查询和确保数据完整性。
以下是为表格添加主键索引的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name 和 email 三个字段：
-- 在 customer_id 列上创建主键索引
ALTER TABLE customers ADD PRIMARY KEY (customer_id);
-- 查询数据时使用索引
SELECT customer_name, email
FROM customers
WHERE customer_id = 1;
在这个示例中，我们为 customers 表格中的 customer_id 列创建了一个主键索引。在查询时，如果 WHERE 子句中指定了 customer_id 值，数据库系统将会使用该索引来加速查询过程。
需要注意的是，在创建主键索引时应该谨慎选择列名，并确保其值在表格中具有唯一性。同时，主键索引还可以通过外键约束来保证数据表格之间的引用完整性。
复合索引
也称为联合索引（Concatenated Index），是一种基于多个列值的组合来创建的索引类型。它可以提高特定查询的检索速度，同时减少查询所需的存储空间。
以下是为表格添加复合索引的示例，假设有一个 customers 表格，其中包含 customer_id、customer_name、city 和 country 四个字段：
-- 在 city 和 country 列上创建复合索引
CREATE INDEX idx_city_country ON customers (city, country);
-- 查询数据时使用索引
SELECT customer_id, customer_name
FROM customers
WHERE city = 'New York' AND country = 'USA';
在这个示例中，我们为 customers 表格中的 city 和 country 列创建了一个名为 idx_city_country 的复合索引。在查询时，如果 WHERE 子句中指定了 city 和 country 值，数据库系统将会使用该索引来加速查询过程。
需要注意的是，在创建复合索引时应该谨慎选择列名，并确保选择的列是常用于 WHERE 子句的筛选条件。同时，复合索引的效率也取决于索引列的顺序，因此应该根据具体查询的需要来确定复合索引的列顺序。
全文索引
是一种用于在文本数据中进行关键词搜索的索引技术。它可以快速地找到包含特定关键词或短语的记录，并按相关性排序。
以下是为表格添加全文索引的示例，假设有一个 articles 表格，其中包含 article_id、title 和 content 三个字段：
-- 在 title 和 content 列上创建全文索引
CREATE FULLTEXT INDEX idx_article_content ON articles (title, content);
-- 查询数据时使用全文索引
SELECT article_id, title
FROM articles
WHERE MATCH(title, content) AGAINST('database' IN NATURAL LANGUAGE MODE);
在这个示例中，我们为 articles 表格中的 title 和 content 列创建了一个名为 idx_article_content 的全文索引，并使用 MATCH AGAINST 语句来进行全文搜索。在查询时，如果 WHERE 子句中指定了关键词 ‘database’，数据库系统将会使用该索引来加速查询过程。
需要注意的是，在创建全文索引时应该谨慎选择列名，并确保选择的列中包含常用的关键词和短语。同时，在处理大量数据时应该优化全文索引的使用方式，以获得更好的搜索效率。
空间索引（Spatial Index）
是一种用于加速空间数据查询的索引类型。它基于空间数据结构，如 R 树（R-Tree）、**四叉树（Quadtree）**等，可以快速地找到包含特定空间对象的记录，并按距离排序。
以下是为表格添加空间索引的示例，假设有一个 locations 表格，其中包含 location_id、location_name 和坐标信息 location_point 三个字段：
-- 在 location_point 列上创建空间索引
CREATE SPATIAL INDEX idx_locations_point ON locations (location_point);
-- 查询离指定坐标最近的5个位置
SELECT location_id, location_name
FROM locations
ORDER BY ST_DISTANCE(location_point, POINT(120.12345, 30.6789))
LIMIT 5;
在这个示例中，我们为 locations 表格中的 location_point 列创建了一个名为 idx_locations_point 的空间索引，并使用 ST_DISTANCE 函数对 location_point 列和指定坐标点之间的距离进行排序。在查询时，如果使用 ORDER BY 子句来指定距离排序，数据库系统将会使用该索引来加速查询过程。
需要注意的是，在创建空间索引时应该谨慎选择列名，并确保选择的列包含空间对象的坐标信息。同时，空间索引还支持多种空间查询操作，如相交查询（ST_INTERSECTS）、包含查询（ST_CONTAINS）等，应根据具体查询需要选择合适的查询操作。
第七章
-----------------------JDBC---------------------- （java数据库连接技术）
jdbc：java database connection
JDBC操作步骤；
**JDBC（Java Database Connectivity）**是 Java 语言中用于与关系型数据库交互的一种标准 API。通常，JDBC 操作可以分为以下步骤：
- 加载数据库驱动程序：在使用 JDBC 连接数据库之前，需要先加载相应的数据库驱动程序。例如，如果要连接 MySQL 数据库，则需要加载 com.mysql.jdbc.Driver 驱动程序。
- 建立数据库连接：使用 DriverManager.getConnection() 方法来建立数据库连接。该方法需要指定数据库 URL、用户名和密码等连接参数。
- 创建 Statement 对象：使用 Connection.createStatement() 方法来创建一个 Statement 对象，用于执行 SQL 查询和更新操作。
- 执行 SQL 语句：使用 Statement.executeXXX() 方法来执行 SQL 查询和更新操作，其中 XXX 可以是任意一种支持的 SQL 语句类型，如 executeQuery()、executeUpdate() 等。
- 处理查询结果：如果执行的是查询操作，则可以使用 ResultSet 对象来处理查询结果。ResultSet 提供了访问查询结果集合中数据行和列的一系列方法，如 getInt()、getString() 等。
- 关闭连接和资源：在完成 JDBC 操作后，需要显式地关闭数据库连接和相关资源，以释放占用的系统资源。使用 Connection.close() 和 Statement.close() 方法来关闭连接和 Statement 对象。
以下是一个简单的 JDBC 操作示例，用于从 MySQL 数据库中检索数据：
import java.sql.*;
public class JdbcExample {
public static void main(String[] args) throws SQLException {
String url = "jdbc:mysql://localhost:3306/mydatabase";
String user = "root";
String password = "password";
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
// 加载 MySQL 数据库驱动程序
Class.forName("com.mysql.jdbc.Driver");
// 建立数据库连接
connection = DriverManager.getConnection(url, user, password);
// 创建 Statement 对象
statement = connection.createStatement();
// 执行 SQL 查询操作
resultSet = statement.executeQuery("SELECT * FROM customers WHERE age > 18");
// 处理查询结果
while (resultSet.next()) {
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
System.out.println("Name: " + name + ", Age: " + age);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
// 关闭连接和资源
if (resultSet != null) {
resultSet.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
}
}
}
}
需要注意的是，在实际应用中，JDBC 操作还需要考虑事务管理、异常处理、连接池等方面的问题。同时，在执行大量数据操作时，还需要优化 JDBC 操作的方式，以提高性能和可靠性。
通过JDBC连接数据库的方式：
1.基于纯java驱动连接数据库（推荐第一种）
是使用 JDBC API 连接数据库的标准方法。这种方式可以通过在 Java 程序中加载数据库驱动程序，并使用 DriverManager.getConnection() 方法建立与数据库的连接。
以下是一个基于纯 Java 驱动程序连接 MySQL 数据库的示例：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JdbcExample {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
// 加载 MySQL 数据库驱动程序
Class.forName("com.mysql.jdbc.Driver");
// 获取数据库连接
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "******";
conn = DriverManager.getConnection(url, user, password);
// 创建 SQL 语句并执行查询
String sql = "SELECT * FROM users";
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
// 处理查询结果集
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println("User info - ID: " + id + ", Name: " + name + ", Age: " + age);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭数据库连接
try {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
在这个示例中，我们使用 Class.forName() 方法加载 MySQL 驱动程序，通过 DriverManager.getConnection() 方法获取与数据库的连接，创建 Statement 对象并执行查询操作，最后通过 ResultSet 对象处理查询结果集。
需要注意的是，在实际应用中，为了提高 JDBC 操作的性能和可靠性，还需要考虑连接池、事务管理、异常处理等方面的问题。同时，还应该根据具体应用场景优化 SQL 查询语句，以提高查询效率。
2.基于ODBC数据源的方式连接数据库；（JDBC-ODBC桥连接）(不推荐)；
基于 ODBC 数据源连接数据库的方式，可以使用 JDBC-ODBC 桥（JDBC-ODBC Bridge）来实现。这种方式需要先在操作系统中配置好 ODBC 数据源，然后使用 JDBC-ODBC 桥连接该数据源。
以下是一个基于 ODBC 数据源连接 MySQL 数据库的示例：
import java.sql.*;
public class JdbcExample {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
// 加载 JDBC-ODBC 驱动程序
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// 获取 ODBC 数据源连接
String dataSourceName = "test_dsn";
String user = "root";
String password = "******";
conn = DriverManager.getConnection("jdbc:odbc:" + dataSourceName, user, password);
// 创建 SQL 语句并执行查询
String sql = "SELECT * FROM users";
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
// 处理查询结果集
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println("User info - ID: " + id + ", Name: " + name + ", Age: " + age);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭数据库连接
try {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
在这个示例中，我们使用 Class.forName() 方法加载 JDBC-ODBC 驱动程序，通过 DriverManager.getConnection() 方法获取 ODBC 数据源连接，创建 Statement 对象并执行查询操作，最后通过 ResultSet 对象处理查询结果集。
需要注意的是，JDBC-ODBC 桥连接方式已经不推荐使用，并且在 Java 8 中已经被移除。其主要原因是该连接方式存在诸多安全和性能问题，容易受到网络攻击和 SQL 注入等风险。建议使用基于纯 Java 驱动程序连接数据库的方式来代替。
预编译语句
优势：
1.执行效率比较高
2.防止sql注入攻击
1.JDBC支持事务
2.关于存储构成调用
**预编译语句（Prepared Statement）**是一种用于执行 SQL 查询和更新操作的 JDBC 接口。与普通的 Statement 不同，预编译语句可以将 SQL 查询或更新操作预先编译成二进制格式，并缓存到数据库中，以便多次执行。
以下是一个使用预编译语句执行查询操作的示例：
java复制代码import java.sql.*;
public class JdbcExample {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
// 加载 MySQL 数据库驱动程序
Class.forName("com.mysql.jdbc.Driver");
// 获取数据库连接
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "******";
conn = DriverManager.getConnection(url, user, password);
// 创建预编译 SQL 语句并执行查询
String sql = "SELECT * FROM users WHERE age > ?";
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, 18); // 绑定参数
rs = pstmt.executeQuery();
// 处理查询结果集
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println("User info - ID: " + id + ", Name: " + name + ", Age: " + age);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭数据库连接
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
if (conn != null) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
在这个示例中，我们使用 PreparedStatement 接口创建预编译 SQL 语句，并使用 setXXX() 方法绑定参数。在执行查询时，JDBC 驱动程序会将预编译 SQL 语句发送给数据库，数据库会将该语句编译成二进制格式并缓存起来，以便于多次执行。
需要注意的是，在实际应用中，预编译语句比普通语句效率更高，尤其是在重复执行相同类型的语句时。同时，还可以通过使用批处理操作来 further 提高预编译语句的性能和可靠性。
封装SmartJDBC
作用：为产品研发提供更高效的数据库访问的组件：
SmartJDBC 是一个封装了 JDBC API 的 Java 类库，可以简化 JDBC 操作，并提供更加易用和灵活的数据库访问方式。它对预编译语句、事务管理、连接池等方面进行了封装，提供了丰富的 API 接口，以便于开发人员快速开发出高效、可靠的数据库应用程序。
以下是一个使用 SmartJDBC 进行数据库操作的示例：
import cn.smartx.beans.User;
import cn.smartx.database.SmartDataSource;
import cn.smartx.database.SmartJdbc;
import cn.smartx.enums.SqlType;
import java.util.List;
public class JdbcExample {
public static void main(String[] args) {
// 获取数据源连接
SmartDataSource dataSource = new SmartDataSource("jdbc:mysql://localhost:3306/test", "root", "******");
// 初始化 SmartJdbc 对象
SmartJdbc jdbc = new SmartJdbc(dataSource);
// 查询用户信息
String sql = "SELECT * FROM users WHERE age > ?";
List<User> users = jdbc.queryForList(User.class, SqlType.SELECT, sql, 18);
// 输出用户信息
for (User u : users) {
System.out.println("User info - ID: " + u.getId() + ", Name: " + u.getName() + ", Age: " + u.getAge());
}
// 关闭数据源连接
dataSource.destroy();
}
}
在这个示例中，我们使用 SmartJDBC 封装的 API 完成了查询用户信息的操作。首先，我们通过 SmartDataSource 获取到数据库连接，然后初始化 SmartJdbc 对象。接下来，使用 SmartJdbc.queryForList() 方法执行 SQL 查询操作，并将查询结果封装为 User 类型的对象列表。
需要注意的是，SmartJDBC 还提供了许多其他的 API 接口，如更新操作、批处理、事务管理等。在实际应用中，我们可以根据具体的需求来选择合适的 API 接口，以便于快速开发出高效、可靠的数据库应用程序。
第八章
DAO模式
DAO模式是非常流行的数据访问方式：
DAO（Data Access Object）模式是一种 JavaEE 设计模式，用于封装对数据库的访问，将业务逻辑和数据访问分离，以提高代码的可维护性、可测试性和重用性。DAO 模式通常包括 DAO 接口、DAO 实现类和实体类三个部分。
下面是一个简单的使用 DAO 模式操作 User 实体类的示例：
首先定义一个 User 类，表示数据库中 users 表的一个记录：
public class User {
private int id;
private String name;
private int age;
// getters and setters
// ...
}
然后定义一个 UserDao 接口，表示对 users 表进行 CRUD 操作的接口：
public interface UserDao {
public void addUser(User user);
public void updateUser(User user);
public void deleteUser(int userId);
public User getUserById(int userId);
public List<User> getUsers();
}
最后，实现 UserDao 接口的具体实现类如下所示：
public class UserDaoImpl implements UserDao {
private Connection conn;
public UserDaoImpl(Connection conn) {
this.conn = conn;
}
@Override
public void addUser(User user) {
PreparedStatement pstmt = null;
try {
String sql = "INSERT INTO users (name, age) VALUES (?, ?)";
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, user.getName());
pstmt.setInt(2, user.getAge());
pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeStatement(pstmt);
}
}
@Override
public void updateUser(User user) {
PreparedStatement pstmt = null;
try {
String sql = "UPDATE users SET name=?, age=? WHERE id=?";
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, user.getName());
pstmt.setInt(2, user.getAge());
pstmt.setInt(3, user.getId());
pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeStatement(pstmt);
}
}
@Override
public void deleteUser(int userId) {
PreparedStatement pstmt = null;
try {
String sql = "DELETE FROM users WHERE id=?";
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, userId);
pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeStatement(pstmt);
}
}
@Override
public User getUserById(int userId) {
PreparedStatement pstmt = null;
ResultSet rs = null;
User user = null;
try {
String sql = "SELECT * FROM users WHERE id=?";
pstmt = conn.prepareStatement(sql);
pstmt.setInt(1, userId);
rs = pstmt.executeQuery();
if (rs.next()) {
user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
user.setAge(rs.getInt("age"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeResultSet(rs);
closeStatement(pstmt);
}
return user;
}
@Override
public List<User> getUsers() {
Statement stmt = null;
ResultSet rs = null;
List<User> userList = new ArrayList<>();
try {
String sql = "SELECT * FROM users";
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
User user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
user.setAge(rs.getInt("age"));
userList.add(user);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
closeResultSet(rs);
closeStatement(stmt);
}
return userList;
}
private void closeResultSet(ResultSet rs) {
try {
if (rs != null) {
rs.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
private void closeStatement(Statement stmt) {
try {
if (stmt != null) {
stmt.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
在 UserDaoImpl 类中，我们使用 JDBC API 实现了 UserDao 接口中定义的方法。需要注意的是，为了提高代码的可维护性和可测试性，我们使用 PreparedStatement 和 Statement 对象执行 SQL 语句，并在 finally 块中关闭资源。同时，为了方便开
DAO（Data Access Object）模式通常包括以下三个组成部分：
- DAO 接口（DAO Interface）：定义了对数据库进行 CRUD（Create、Retrieve、Update、Delete）操作的方法，是业务逻辑和数据访问之间的一个接口。
- DAO 实现类（DAO Implementation Class）：实现了 DAO 接口中定义的方法，使用 JDBC API 访问数据库并执行相应的 SQL 语句。DAO 实现类隐藏了底层的数据访问逻辑，提供了更加简洁和易于维护的代码。
- 实体类（Entity Class）：表示数据库中的一条记录，通常由一个 Java 类来封装。实体类中的属性与数据库表中的列一一对应，可以通过 getter 和 setter 方法来访问这些属性。
DAO 模式的主要目的是将业务逻辑和数据访问分离，以提高代码的可维护性、可测试性和重用性。在 DAO 模式中，业务逻辑层只需要调用 DAO 接口中的方法，而无需关心具体的数据访问实现方式。这种松耦合的设计使得系统更加灵活和易于扩展。
DAO:data access object 数据访问对象（实现数据的增删改查操作）
软件架构问题：代码设计遵循高内聚，低耦合
三层架构开发
三层架构是一种常见的软件开发架构模式，将整个应用程序分为三个主要的逻辑层，分别是表示层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data Access Layer）。每一层都有其独立的功能和职责，并通过接口来相互协作。
下面是三层架构的各个层次的描述：
- 表示层（Presentation Layer）：表示层是应用程序与用户之间的界面层，负责接收来自用户的请求，并将响应结果展示给用户。表示层通常包括了 Web 页面、客户端和其他形式的 UI 界面。
- 业务逻辑层（Business Logic Layer）：业务逻辑层处理业务逻辑，实现业务规则并协调不同的数据操作。在这一层中，通常会涉及到流程控制、事务管理、验证、计算等等。业务逻辑层对外暴露服务接口，供上层调用。
- **数据访问层（Data Access Layer）：**数据访问层负责与数据库进行交互，实现数据的持久化存储。数据访问层通常包含了 DAO（Data Access Object）等组件，提供了一些常见的数据库操作方法，如增删改查、连接池管理等。
三层架构的优点在于：
- 易于维护：每个逻辑层都有其独立的职责，可以分别进行模块化开发和测试，减少了代码耦合度，提高了代码可维护性和可测试性。
- 易于扩展：由于每个逻辑层都有清晰的职责划分，因此在需要增加新功能或调整现有功能时，可以针对特定的逻辑层进行扩展或修改，不会影响其他逻辑层。
- 安全可靠：数据访问层提供了统一的数据操作接口，可以对数据库进行统一管理和安全控制，保证了系统的稳定性和安全性。
但是三层架构也存在一些缺点，如增加了代码量、增加了开发成本等。此外，在应用程序的规模较小或者业务逻辑相对简单的情况下，采用三层架构可能过于复杂。需要根据具体的应用场景和需求来选择是否采用三层架构。
【Notice】:不要违反三层架构开发的原则