数据库 SELECT查询

最新推荐文章于 2024-02-18 21:50:49 发布
最新推荐文章于 2024-02-18 21:50:49 发布
阅读量606 收藏
点赞数
分类专栏： 历史归类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LEI2879223426/article/details/78126885
版权
本文详细介绍了SQL中的SELECT查询语句，包括目标列表达式的各种格式，如通配符、别名和聚集函数的使用。通过实例展示了COUNT、SUM、AVG、MAX和MIN等聚集函数的应用，以及WHERE子句的各种条件表达式，如比较大小、范围、集合匹配、空值查询和多重条件查询。此外，还探讨了ORDER BY子句的排序功能，GROUP BY和HAVING子句的分组筛选，以及嵌套查询的概念和应用场景，包括不相关子查询和相关子查询。最后，提到了集合操作，如UNION，并讨论了基于派生表的查询。
摘要由CSDN通过智能技术生成

SELECT 语句的一般格式：

 

  1. SELECT [ALL|DISTINCT] <目标列表达式>[别名][,<目标列表达式> [别名]] ...
  2.  
  3. FROM <表名/视图名> [别名] [, <表名/视图名> [别名]]... | (<select 语句>) [AS] <别名>
  4. [WHERE <条件表达式>]
  5.  
  6. [GROUP BY <列名1> [HAVING <条件表达式>]]
  7.  
  8. [ORDER BY <列名2> [ASC | DESC]];

执行顺序：

from.....where.....group by......habing.....select........order

1. 目标列表达式的可选格式

 （1） *

 （2）<表名.>*

 （3）COUNT（[DISTINCT|ALL] *） 

 （4） [<表名.>]<属性列名表达式>[,[<表名.>]<属性列名表达式>]...

 Tips： <属性列名表达式> 可以是由属性列、作用于属性列的聚集函数、属性和常量的任意算术运算（+、-、*、/）组成的运算公式。

  eg.  表达式

  1. mysql> SELECT Sname,2016-Sage FROM Student;
  2. +--------+-----------+
  3. | Sname | 2016-Sage |
  4. +--------+-----------+
  5. | Jason | 1995 |
  6. | Taylor | 1995 |
  7. | dsf | 1995 |
  8. +--------+-----------+
  9. 3 rows in set (0.03 sec)

eg. 字符串常量、函数

  1. mysql> SELECT Sname,'Year of Birth:',2016-Sage,LOWER(Sdept) FROM Student; // 小写字母表示系名
  2. +--------+----------------+-----------+--------------+
  3. | Sname | Year of Birth: | 2016-Sage | LOWER(Sdept) |
  4. +--------+----------------+-----------+--------------+
  5. | Jason | Year of Birth: | 1995 | ele |
  6. | Taylor | Year of Birth: | 1995 | ele |
  7. | dsf | Year of Birth: | 1995 | ele |
  8. +--------+----------------+-----------+--------------+
  9. 3 rows in set (0.05 sec)

 

eg. 查询时可以指定别名，这对于算术表达式、常量、函数名的目标列表达尤为有用.

  1. mysql> SELECT Sname NAME,'Year of Birth:' BIRTH,2016-Sage BIRTHDAY,LOWER(Sdept) DEPARTMANT FROM Student;
  2. +--------+----------------+----------+------------+
  3. | NAME | BIRTH | BIRTHDAY | DEPARTMANT | // 指定别名，界面友好性。
  4. +--------+----------------+----------+------------+
  5. | Jason | Year of Birth: | 1995 | ele |
  6. | Taylor | Year of Birth: | 1995 | ele |
  7. | dsf | Year of Birth: | 1995 | ele |
  8. +--------+----------------+----------+------------+
  9. 3 rows in set (0.00 sec)

 

2.聚集函数的一般格式

 

 COUNT（*）                        统计元组的个数

 COUNT（[DISTINCT|ALL] <列名>）    统计一列中值的个数

 SUM（[DISTINCT|ALL] <列名>）      计算一列值的总和（此列必须是数值型）

 AVG（[DISTINCT|ALL] <列名>）      计算一列值的平均值（此列必须是数值型）

 MAX（[DISTINCT|ALL] <列名>）      求一列值中的最大值

 MIN（[DISTINCT|ALL] <列名>）      求一列值中的最小值

 

DISTINC 短语，指明在计算时要取消指定列中的重复值。默认为ALL，表示不取消重复值。

当聚集函数遇到空值时，除COUNT(*)外，都跳过空值而只处理非空值。 COUNT（*）对元组进行计数时，包含空值所在的元组。

 

注意： WHERE 子句中是不能用聚集函数作为条件表达式的。 聚集函数只能用于 SELECT子句 和 GROUP BY 中的 HAVING 子句。

 

 

 

  1. SELECT COUNT(*) FROM Student;  // 查询学生总人数 
  2. mysql> SELECT COUNT(*) FROM Student;+----------+| COUNT(*) |+----------+| 3 |+----------+1 row in set (0.04 sec)
  1. SELECT COUNT(DISTINCT Sno) FROM SC; // 查询选修了课程的学生人数
  2. mysql> SELECT COUNT(DISTINCT Sno) FROM Sc;+---------------------+| COUNT(DISTINCT Sno) |+---------------------+| 5 |+---------------------+1 row in set (0.00 sec)
  3. //学生每选一门课在SC表中都有一条相应的记录. 一个学生选多门课，SC表会记录多次，COUNT函数必须用DISTINCT短语去掉重复的记录

 

3. WHERE 子句的条件表达式的可选格式

（1） 比较大小

 常见运算符： =（等于），>（大于），<(小于)，>=,<=, !=或<>,!>(不大于)，!<（不小于）.

（2）确定范围

        [NOT] BETWEEN 下限 AND 上限

 eg. 

  查询年龄在20~23岁之间的学生的姓名、系名和年龄

  1. SELECT Sname,Sdept,Sage FROM WHERE Sage BETWEEN 20 AND 24; 

（3）确定集合

   IN 用来查找属性值属于指定集合的元组

   NOT IN  属性不属于任何指定集合的元组

eg.

     查找 CS系，ELE系，IS系 中的学生的姓名、性别

  1. SELECT Sname,Ssex FROM Student WHERE Sdept IN ('CS','ELE',IS);

 （4） 字符匹配

  LIKE 用来进行字符串的匹配。 查找指定的属性列值与<匹配字符串>相匹配的元组

语法格式：

         [NOT] LIKE <'匹配字符串> [ESCAPE <'换码字符'>]

 

  % 代表任意长度（>=0个）的字符串

  _ 下划线代表任意单个字符. eg. a_b 表示以a开头，以b结尾的长度为3的任意字符串.

 

eg.

    查找学号为3120开头的学生的信息

  1. mysql> SELECT * FROM Student WHERE Sno LIKE '3120%';
  2. +--------+--------+------+------+-------+
  3. | Sno | Sname | Ssex | Sage | Sdept |
  4. +--------+--------+------+------+-------+
  5. | 312001 | Jason | fe | 21 | ELE |
  6. | 312028 | Taylor | fe | 21 | ELE |
  7. +--------+--------+------+------+-------+
  8. 2 rows in set (0.00 sec)

  

 

如果用户要查询的字符串本身就含有通配符  % 或  _  ，这时就要用 ESCAPE '<换码字符>' 短语对通配符进行转义了

 

eg.  以 & 作为转义字符。mysql不支持'\'

  1. mysql> select Cno,Cname,Ccredit from Course where Cname LIKE 'DB&_Design' ESCAPE '&';
  2. +-----+-----------+---------+
  3. | Cno | Cname | Ccredit |
  4. +-----+-----------+---------+
  5. | 004 | DB_Design | 6 |
  6. +-----+-----------+---------+
  7. 1 row in set (0.00 sec)

 

 (5) 涉及空值的查询

   IS NULL // 为空  

   IS NOT NULL  // 不为空 

  eg.

  1. mysql> select Sno,Cno from Sc where Grade is not null;
  2. +--------+-----+
  3. | Sno | Cno |
  4. +--------+-----+
  5. | 20123 | 004 |
  6. | 20132 | 001 |
  7. | 312001 | 001 |
  8. | 312028 | 003 |
  9. | 312029 | 006 |
  10. +--------+-----+
  11. 5 rows in set (0.00 sec)

 

(6) 多重条件查询

 

   AND 和 OR 用来连接多个查询条件.  AND 的优先级高于 OR，用括号可以改变优先级

 

  1. mysql> SELECT Sname FROM Student WHERE Sdept='ELE' AND Sage<22;
  2. +--------+
  3. | Sname |
  4. +--------+
  5. | Jason |
  6. | Taylor |
  7. | dsf |
  8. +--------+
  9. 3 rows in set (0.00 sec)

 

 

 

4. ORDER BY 子句 ： 对查询结果按照一个或多个属性列的升序（ASC）或降序（DESC）排列，默认升序.

 

  1. mysql> SELECT * FROM Student ORDER BY Sage DESC; // DESC降序
  2. +--------+--------+------+------+-------+
  3. | Sno | Sname | Ssex | Sage | Sdept |
  4. +--------+--------+------+------+-------+
  5. | 31223 | dsf | ma | 23 | IS |
  6. | 312028 | Taylor | fe | 21 | ELE |
  7. | 312001 | Jason | fe | 19 | CS |
  8. +--------+--------+------+------+-------+
  9. 3 rows in set (0.00 sec)

 

5. GROUP BY 子句 ： 将查询结果按某一列或多列的值分组，属性值相等的为一组。 对查询结果进行分组是为了细化聚集函数的作用对象，分组后，聚集函数将作用于每一个分组,即每一组都有一个函数值。

 

  1. mysql> SELECT Cno,COUNT(Sno) FROM Sc GROUP BY Cno; // 按照属性 Cno 进行分组，再对每一个分组计算 Sno的个数
  2. +-----+------------+
  3. | Cno | COUNT(Sno) |
  4. +-----+------------+
  5. | 001 | 2 |
  6. | 003 | 1 |
  7. | 004 | 1 |
  8. | 006 | 1 |
  9. +-----+------------+

 

 

如果分组后还要求按一定的条件对这些分组进行筛选，最终只输出满足条件的组，则使用 HAVING 短语指定筛选条件。

 

  1. mysql> select * from Sc;
  2. +--------+------+-------+
  3. | Sno | Cno | Grade |
  4. +--------+------+-------+
  5. | 20123 | 004 | 96 |
  6. | 20132 | 001 | 88 |
  7. | 312001 | 001 | 98 |
  8. | 312028 | 003 | 99 |
  9. | 312028 | 004 | 100 |
  10. | 312028 | 006 | 100 |
  11. | 312028 | 009 | 100 |
  12. | 312028 | 010] | 100 |
  13. | 312029 | 006 | 100 |
  14. +--------+------+-------+
  15. 9 rows in set (0.00 sec)
  16. mysql> SELECT Sno FROM Sc GROUP BY Sno HAVING COUNT(*) > 3; // 先用 GROUP BY 子句按 Sno 进行分组，再用聚集函数对每一个分组计数，HAVING短语给出选择组的条件，满足条件(元组个数>3)的组才会被选出来。
  17. +--------+
  18. | Sno |
  19. +--------+
  20. | 312028 |
  21. +--------+
  22. 1 row in set (0.00 sec)

 

注意： WHERE 子句与 HAVING 短语的区别在于 作用对象不同，WHERE 子句作用于 基本表或者视图，从中选择满足条件的元组。

     HAVING 短语作用于分组，从中选出满足条件的组。

 

eg. 查询平均成绩大于等于90分的学生学号和平均成绩，

 SELECT Sno,AVG(Grade) FROM Sc GROUP BY Sno HAVING AVG(Grade)>=90;

   // 先按学号进行分组，得出每一个学生课程组，再计算平均值，根据 HAVING 条件，输出平均分>=90分的分组.

  1. mysql> SELECT Sno,AVG(Grade) FROM Sc GROUP BY Sno HAVING AVG(Grade)>=90;
  2. +--------+------------+
  3. | Sno | AVG(Grade) |
  4. +--------+------------+
  5. | 20123 | 96.0000 |
  6. | 312001 | 98.0000 |
  7. | 312028 | 99.8000 |
  8. | 312029 | 100.0000 |
  9. +--------+------------+

 

 

6. 嵌套查询

 

   在 SQL 语言中， 一个 SELECT-FROM-WHERE 语句成为一个查询块。 将一个查询块嵌套在另一个查询块的 WHERE 子句或 HAVING短语的条件中 的查询称为嵌套查询（nested query）。

   

   

  1.  select Sname from Student where Sno IN  // 外层查询或父查询
  2.                      (select Sno from Sc where Cno='006'); // 内层查询或子查询

 

  SQL 允许多层嵌套查询，即一个子查询中还可以嵌套其他子查询。 

注意：  子查询的 SELECT 语句中不能使用 ORDER BY 子句， ORDER BY 子句只能对最终查询结果排序。

 

 嵌套查询使用户可以用多个简单的查询构成复杂的查询，从而增强SQL的查询能力。  以层层嵌套的方式来构造程序正是 SQL 中 “结构化” 的含义所在。

 

(1)带有 IN 谓词的子查询

   在嵌套查询中，子查询的结果往往是 元组的集合，所以 IN 在嵌套查询中最经常使用。

eg.

  1. mysql> SELECT Sno,Sname,Sdept FROM Student WHERE Sdept IN (SELECT Sdept FROM Student WHERE Sname='huangxin'); // 与 huangxin 在同一个系的学生信息
  2. +--------+---------------+-------+
  3. | Sno | Sname | Sdept |
  4. +--------+---------------+-------+
  5. | 312019 | Linus Travlds | Linux |
  6. | 312022 | huangxin | Linux |
  7. +--------+---------------+-------+
  8. 2 rows in set (0.00 sec)

 

 这种 子查询的条件不依赖于父查询，称为 不相关子查询。（ 执行过程： 由里向外处理，即先执行子查询，子查询的结果用于建立父查询的查找条件）.

  如果子查询的查询条件依赖于父查询，这类子查询称为 相关子查询. 整个查询语句称为 相关嵌套查询（correlated nested query）.

   

(1)带有 比较运算符的 子查询

       指的是 父查询与子查询之间用 比较运算符进行连接。当用户能确切知道内层查询返回的是单个值时，可以用（>< >= <= !=或<> ）等比较运算符。

   

   eg. 

   相关子查询， 子查询的 查询条件 x.Sno 依赖于父查询传进来的元组 x，是与父查询相关的，

           > 用于连接父查询 、子查询 

  1. mysql> SELECT Sno,Cno FROM Sc x WHERE Grade > (SELECT AVG(Grade) FROM Sc y WHERE y.Sno = x.Sno); // x,y 是表的别名
  2. +--------+-----+
  3. | Sno | Cno |
  4. +--------+-----+
  5. | 312028 | 004 |
  6. | 312028 | 006 |
  7. | 312028 | 009 |
  8. +--------+-----+
  9. 3 rows in set (0.00 sec)

 

(3)带有 ANY(SOME) 或 ALL 谓词的子查询   

    子查询返回单值时，可以用比较运算符，但返回 多个值时 要用ANY、ALL来进行连接。  而是用ANY/ALL 时，必须同时使用 比较运算符。

     

 

 

 

eg.  查询 ELE 系 中任意一个年龄小于ELE系学生的信息 

  1. mysql> SELECT Sname,Sage,Sdept FROM Student WHERE Sage<ANY(SELECT Sage FROM Student WHERE Sdept='ELE') AND Sdept != 'ELE';
  2. +-------+------+-------+
  3. | Sname | Sage | Sdept |
  4. +-------+------+-------+
  5. | Jason | 19 | CS |
  6. +-------+------+-------+
  7. 1 row in set (0.00 sec)

也可以用聚集函数实现：

  1. mysql> SELECT Sname,Sage,Sdept FROM Student WHERE Sage < (SELECT MAX(Sage) FROM Student WHERE Sdept='ELE') AND Sdept != 'ELE';
  2. +-------+------+-------+
  3. | Sname | Sage | Sdept |
  4. +-------+------+-------+
  5. | Jason | 19 | CS |
  6. +-------+------+-------+
  7. 1 row in set (0.00 sec)

 

 小结： 使用聚集函数实现子查询通常比 直接用 ANY/ALL 查询效率要高！

  1.      =ANY 等价于 IN 
  2.      <ANY 等价于 <MAX 
  3.      !=ALL 等价于 NOT IN
  4.       <ALL 等价于 <MIN

 

 

(4) 带有 EXISTS 的子查询

     这种子查询不返回任何数据，只产生 逻辑真值‘true’ 或逻辑假值 ‘false’.

  

  eg. 相关子查询，子查询依赖于父查询的 Student.Sno 进行条件判断，若成功，则 WHERE子句 返回 '真'，对“父”的每一个元组，重复完成这一过程。

  1. mysql> SELECT Sname FROM Student WHERE EXISTS (SELECT * FROM Sc WHERE Sno=Student.Sno AND Cno='004');
  2. +--------+ // WHERE 返回真值后，外层查询从元组中提取 Sname 列
  3. | Sname |
  4. +--------+
  5. | Taylor |
  6. +--------+
  7. 1 row in set (0.00 sec)

 

NOT EXIST ： 内层查询结果为空时，则外层的 WHERE 子句返回真值。

 

  1. mysql> SELECT Sname FROM Student WHERE NOT EXISTS (SELECT * FROM Sc WHERE Sno=Student.Sno AND Cno='004');
  2. +---------------+
  3. | Sname |
  4. +---------------+
  5. | dsf |
  6. | huangxin |
  7. | Jason |
  8. | Linus Travlds |
  9. +---------------+
  10. 4 rows in set (0.00 sec)

 

 

7. 集合查询

   SELECT 语句查询的结果是元组的集合，所以多个SELECT 语句的结果可以进行 集合操作。

主要包括：  UNION并操作、  INTERSECT交操作、 EXCEPT差操作

   

 注意: 参加集合操作的各查询结果的列数必须相同，对应的数据类型也必须相同。

 

（1） UINON 会自动去掉重复元组, 如果要保留重复元组则使用 UNION ALL 操作符。

 

  1. mysql> select * from Student where Sdept='CS' UNION select * from Student where Sage <=19;
  2. +--------+-------+------+------+-------+
  3. | Sno | Sname | Ssex | Sage | Sdept |
  4. +--------+-------+------+------+-------+
  5. | 312001 | Jason | fe | 19 | CS |
  6. +--------+-------+------+------+-------+
  7. 1 row in set (0.13 sec)

MySQL 不支持集合的 INTERSECT 、EXCEPT 操作。

 

可以用 WHERE 的 条件句实现：

 

  1. mysql> select * from Student where Sage <= 22 AND Sdept='CS'; // 年龄小于22并且是CS系

 

 

8. 基于派生表的查询

 

     子查询出现在 FROM 子句中， 这时子查询生成的临时派生表（derived table）成为主查询的查询对象。

 

  eg.   mysql 不能指定派生表的属性列，子查询SELECT后面的列名为其默认属性。 可以在子查询指定别名

  1. mysql> SELECT Sname FROM Student,(SELECT Sno FROM Sc WHERE Cno='001') AS Sc1 WHERE Student.Sno=Sc1.Sno;
  2. // 派生表，
  3. +-------+
  4. | Sname |
  5. +-------+
  6. | Jason |
  7. +-------+
  8. 1 row in set (0.00 sec)

   AS 关键字可以省略，但是必须为 派生关系指定一个别名。

 

  1. mysql> SELECT Sname FROM Student,(SELECT Sno www FROM Sc WHERE Cno='001') Sc1 WHERE Student.Sno=Sc1.www;
  2. +-------+
  3. | Sname |
  4. +-------+
  5. | Jason |
  6. +-------+
  7. 1 row in set (0.04 sec)

 

知识即信仰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据库复习笔记——SELECT 大全
Coohx
09-17 2797
SELECT 语句的一般格式： SELECT [ALL|DISTINCT] [别名][, [别名]] ... FROM [别名] [, [别名]]... | (select 语句>) [AS] [WHERE ] [GROUP BY 1> [HAVING ]] [ORDER BY 2> [ASC | DESC]]; 1. 目标列表达式的可选格式
数据库SELECT语句
旭日的博客
01-12 1615
这样，MySQL可以快速有效地决定哪些词匹配（哪些行包含它们），哪些词不匹配，它们匹配的频率，等等。当SQL看到上述WHERE子句时，它理解为由供应商1002制造的任何价格为10美元（含）以上的产品，或者由供应商1003制造的任何产品，而不管其价格如何。这是一个重要的区别，WHERE排除的行不包括在分组中。在使用OUTER JOIN语法时，必须使用RIGHT或LEFT关键字指定包括其所有行的表（RIGHT指出的是OUTER JOIN右边的表，而LEFT指出的是OUTER JOIN左边的表）。
SQL-SELECT-检索数据（一）
04-15 3773
1. 检索数据SELECT 从一个或者多个表中检索信息-- 检索单个列 SELECT prod_name FROM products;-- 检索多个列 SELECT prod_id, prod_name, prod_price FROM products;-- 检索所有的列 SELECT * FROM products;-- 检索不同的值 SELECT DISTINCT vend_id FROM p
MySQL之select查询
最新发布
huaz_md的博客
02-18 2318
结构化查询语言(Structured Query Language)，在关系型数据库上执行数据操作、数据检索以及数据维护的标准语言。使用SQL语句，程序员和数据库管理员可以完成如下的任务。改变数据库的结构更改系统的安全设置增加用户对数据库或表的许可权限（root和普通用户的权限）在数据库中检索需要的信息对数据库的信息进行更新别名。
数据库基础——4.select语句
m0_52096593的博客
05-27 7458
这篇文章我们来讲一下select语句，这是数据库中最最重要的一个关键字。
数据库select 查询
12-14
查询一个特定的学号的学生信息 首先引入一个知识，模糊查询（某种程度上有点类似于正则表达式）。 [not ]like '' [escape ''] 匹配串中可以有通配符’%’，’’,’%’表示任意长度的任意字符，‘’表示任意的单个...
数据库select查询
12-17
数据库处理的经典查询处理 select查询语句 全面描述
MySQL数据库SELECT查询表达式解析
09-09
MySQL数据库的SELECT查询是SQL语言中最基础且最重要的部分，它用于从数据表中检索所需的信息。在本篇文章中，我们将深入探讨SELECT查询表达式的各个方面。 首先，`select_expr`是SELECT语句的核心部分，用于定义...
数据库SQL SELECT查询的工作原理
09-09
数据库SQL SELECT查询是Web开发中不可或缺的部分，理解其工作原理对于优化数据库性能至关重要。下面将详细解释SELECT查询在数据库中的执行流程。 首先，应用程序通过连接到数据库服务器来发送SELECT语句。这一过程...
数据库select操作
yugongbaocc的博客
03-19 1448
这个表是永久存储在服务器硬盘的，当输入命令后，客户端会把命令包装成网络请求，发给服务器，服务器收到命令请求，会操作硬盘，从硬盘中读取数据，把数据包装成响应，这个响应就是查询的结果。下面例子中，孟德英语小于70，画横线的条件不成立，但是因为和or是或的关系，他chinese大于80条件成立，所以孟德也会打印。而select * from 表名，查询的临时结果表，不是在硬盘上，而是在内存中，随着进行了输出后，数据也就被释放了。如果不指定多个列，只有指定一个列，如果结果相同，彼此之间的顺序都是不可预期的。
数据库 select 篇
叶子的博客
07-23 219
关于SELECT 一些基础语法 三范式 1NF:是指数据库表的每一列都是不可分割的基本数据项，同一列中不能有多个值， 即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性，就可能 需要定义一个新的实体，新的实体由重复的属性构成，新实体与原实体之间为一对多关系。 在第一范式（1NF）中表的每一行只包含一个实例的信息。 2NF：是在第一范式（1NF）的基础上建立起来的，即满足第二范式...
【MySQL入门】-- 数据库简单的SELECT语句详解
不知名菜鸡
06-15 1802
注意：一般情况下，不要使用通配符 “*” ，使用它虽然可以节省输入查询字段的时间，但是获取不需要的字段会降低查询效率。通配符“*” 是当不知道所需要的字段名时，可以通过它查。生产环境中，不推荐使用 select * 查询。默认情况下，查询会返回全部行，包括重复。SELECT语句中使用关键字DISTINCT去除重复行。注意：MySQL的SQL语句是不区分大小写的，SELECT和select是相同的。
数据库的检索（select）
有道无术，术尚可求，有术无道，止于术。
01-01 788
今天我们学习一下数据库检索语句，由于经常用到，有需求的小伙伴欢迎来查看哦！ 一、简单的查询  --获取所以列 select * from T_table --获取部分列 select id, title from T_table 效果展示：  在...之间：Between.. and..  相当于大于等于80  and 小于等于100 select id from T_tabl...
数据库入门：select部分用法
Believer_YU的博客
07-14 8670
sql语言一些简单的查询操作
数据库查询语言---select
hjikhjj的博客
02-12 931
select基本查询语句 where与having区别 group by order by
数据库基础，select命令
weixin_45575912的博客
03-15 1936
数据库基础 1.DBMS数据库管理系统 ​ 数据库管理系统(Database Management System)是一种操纵和管理数据库的大型软件，用于建立、使用和维护数据库，简称 DBMS。它对数据库进行统一的管理和控制，以保证数据库的安全性和完整性。用户通过 DBMS访问数据库中的数据，数据库管理员也通过 dbms 进行数据库的维护工作。它可使多个应用程序和用户用不同的方法在同时或不同时刻去建立，修改和询问数据库。大部分 DBMS 提供数据定义语言 DDL （Data Definition Langu
mysql-sql-select
Kincym的博客
05-10 789
and与or的优化级 and优先级高于or。 ： 比如查询薪水大于1800，并且部门编号为20或30的员工 select * from emp where sal>1800 and deptno=20 or deptno = 30; 上输出的结果不是我们预期的结果，首先SQL语句过滤了 sal > 1800 and deptno = 20，然后再将deptno = 30的员工合并过来，所
数据库02.select
隐身的六娃
04-24 234
SQL语句是由简单的英语单词构成的。这些单词称为关键字，每个SQL语句都是由一个或多个关键字构成的。 最经常用的应该就是SQL语句就是select语句。 他的用途是从一个或多个表中检索信息。 初始语法 SELECT prod_name FROM table_name 可以从 table_name 的表中检索一个名为prod_name的列。 PS： 没有排序语句的话，这里的数据是无序的，可能是添加...
数据库select语句详解
热门推荐
weixin_44454512的博客
10-29 1万+
SELECT 1.基本语法 select * from 表名 查询这张表所有内容。 select 列名 from 表名 查询这张表某一列所有内容。 select 列名1，列名2…from 表名 查询这张表的列1，列2，等多列。 select distinct 列名 from 表名 查询这一列去掉重复内容后的内容。 select 表达式 from 表名 查询表达式，下面会详细讲。 select 列名（表达式）as 别名 from 表名 给某一列或表达式取别名。 2.例子 如下这张表emp： 1）检索单个
数据库查询语句select
04-29
select语句用于从数据库中选择数据。其基本语法如下： ``` SELECT column1, column2, ... FROM table_name WHERE condition; ``` 其中，column1, column2, ... 表示要选择的列，用逗号隔开；table_name 表示要查询...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值