极客笔记SQL 运算符
每个数据库管理员和用户都使用SQL查询来操作和访问数据库表和视图的数据。
数据的操作和检索是通过使用保留的单词和字符来完成的，这些单词和字符用于执行算术操作、逻辑操作、比较操作、复合操作等。
什么是SQL运算符
SQL保留的单词和字符被称为运算符，在SQL查询中与WHERE子句一起使用。在SQL中，运算符可以是一元运算符或二元运算符。一元运算符只使用一个操作数执行一元操作，而二元运算符使用两个操作数执行二元操作。
一元SQL运算符的语法
Operator SQL_Operand
一元SQL运算符的语法
Operand1 SQL_Operator Operand2
注意：SQL运算符用于根据SQL语句中的特定条件过滤表的数据。
SQL运算符的优先级是什么
SQL运算符的优先级是SQL在同一表达式中评估不同运算符的顺序。结构化查询语言首先评估优先级高的运算符。
在以下表格中，顶部的运算符具有较高的优先级，底部的运算符具有较低的优先级。
| SQL运算符符号 | 运算符 |
|---|---|
** |
指数运算符 |
+, - |
标识运算符，否定运算符 |
*, / |
乘法运算符，除法运算符 |
+, -, || |
加法（加号）运算符，减法（减号）运算符，字符串连接运算符 |
=, !=, <, >, <=, >=, IS NULL, LIKE, BETWEEN, IN |
比较运算符 |
NOT |
逻辑否定运算符 |
&& 或 AND |
连接运算符 |
OR |
包含运算符 |
例如，
UPDATE employee
SET salary = 20 - 3 * 5 WHERE Emp_Id = 5;
在上面的SQL示例中，salary被分配为5，而不是85，因为（乘法）运算符的优先级高于-（减法）运算符，所以它首先与35相乘，然后从20中减去。
运算符类型
SQL运算符分为以下几类：
- SQL算术运算符
- SQL比较运算符
- SQL逻辑运算符
- SQL集合运算符
- SQL位运算符
- SQL一元运算符
让我们讨论每个运算符及其类型。
SQL算术运算符
SQL算术运算符对SQL表的数值数据执行数学运算。这些运算符对数值操作数执行加法、减法、乘法和除法操作。
以下是对SQL数据执行的各种算术运算符：
- SQL加法运算符（+）
- SQL减法运算符（-）
- SQL乘法运算符（+）
- SQL除法运算符（-）
- SQL取模运算符（+）
SQL加法运算符（+）
在SQL中， 加法运算符 对数据库表的数值数据执行加法。在SQL中，我们可以通过指定两个列名作为第一个和第二个操作数来轻松地将同一表的两列的数值相加。我们还可以将数字添加到特定列的现有数字中。
SQL加法运算符的语法：
SELECT operand1 + operand2;
让我们了解下面的例子，它解释了如何在SQL查询中执行加法运算符:
这个例子包含一个 Employee_details 表，它有四列 Emp_Id, Emp_Name, Emp_Salary, 和 Emp_Monthlybonus.
| Emp Id | Emp Name | Emp Salary | Emp Monthlybonus |
|---|---|---|---|
| 101 | Tushar | 25000 | 4000 |
| 102 | Anuj | 30000 | 200 |
- 假设我们想要将 20,000 加到表中每个员工的工资中。那么，我们必须在SQL中编写以下查询：
SELECT Emp_Salary + 20000 as Emp_New_Salary FROM Employee_details;
在这个查询中，我们对给定表的单列执行了SQL加法操作。
- 假设我们想要将上述表的薪水和每月奖金列相加，那么我们需要在SQL中编写以下查询：
SELECT Emp_Salary + Emp_Monthlybonus as Emp_Total_Salary FROM Employee_details;
在这个查询中，我们将以上表格的两列相加在一起。
SQL减法运算符（-）
SQL中的减法运算符对数据库表的数值数据进行减法运算。在SQL中，我们可以通过指定两个列名作为第一和第二操作数来轻松地对同一张表的两个列的数值进行减法运算。我们还可以从特定表列的现有数值中减去数字。
SQL减法运算符的语法：
SELECT operand1 - operand2;
让我们理解下面的例子，它解释了如何在SQL查询中执行减法运算符：
这个例子包含了一个 Employee_details 表，它有四列 Emp_Id，Emp_Name，Emp_Salary和Emp_Monthlybonus。
| Emp Id | Emp Name | Emp Salary | Penalty |
|---|---|---|---|
| 201 | Abhay | 25000 | 200 |
| 202 | Sumit | 30000 | 500 |
- 我们假设我们想要从 员工详情 表中的每个员工的薪资中减去5000。那么，我们必须在SQL中写入以下查询：
SELECT Emp_Salary - 5000 as Emp_New_Salary FROM Employee_details;
在这个查询中，我们对给定表的单列执行了SQL减法运算。
- 如果我们想要从每个员工的薪水中减去罚款，那么我们必须在SQL中编写以下查询:
SELECT Emp_Salary - Penalty as Emp_Total_Salary FROM Employee_details;
SQL乘法运算符（*）
SQL中的乘法运算符对数据库表的数值数据执行乘法运算。在SQL中，我们可以通过将同一表的两列的列名作为第一个和第二个操作数来轻松地将两个列的数值相乘。
SQL乘法运算符的语法：
SELECT operand1 * operand2;
让我们来理解下面的例子，它解释了如何在SQL查询中执行乘法运算符：
该示例包含一个 Employee_details 表，它有四个列 Emp_Id，Emp_Name，Emp_Salary和Emp_Monthlybonus。
| Emp Id | Emp Name | Emp Salary | Penalty |
|---|---|---|---|
| 201 | Abhay | 25000 | 200 |
| 202 | Sumit | 30000 | 500 |
- 假设我们想将 Employee_details 表中的每位员工的薪水加倍。那么，我们必须在SQL中编写以下查询：
SELECT Emp_Salary * 2 as Emp_New_Salary FROM Employee_details;
在这个查询中，我们对给定表的单列执行了SQL乘法操作。
- 如果我们想要将 Emp_Id 列乘以 Emp_Salary 列，其中 Emp_Id 是 202 的雇员，我们需要在SQL中编写以下查询：
SELECT Emp_Id * Emp_Salary as Emp_Id * Emp_Salary FROM Employee_details WHERE Emp_Id = 202;
在此查询中，我们使用WHERE子句将两列的值相乘。
SQL 除法运算符 (/)
SQL中的除法运算符将左侧的操作数除以右侧的操作数。
SQL Division Operator的语法：
SELECT operand1 / operand2;
在SQL中，我们还可以通过将第一个和第二个操作数指定为两个相同表的列名，将一列的数值除以另一列。
我们还可以对SQL表的列中存储的数字执行除法操作。
让我们了解下面的示例，它说明了如何在SQL查询中执行除法运算符：
此示例包含一个 Employee_details 表，其中包含三列 Emp_Id，Emp_Name和Emp_Salary 。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 25000 |
| 202 | Sumit | 30000 |
- 假设我们想将Employee_details表中每个员工的薪水减半。为了进行这个操作，我们需要在SQL中编写以下查询：
SELECT Emp_Salary / 2 as Emp_New_Salary FROM Employee_details;
在此查询中，我们对给定表的单列执行了SQL除法操作。
SQL取余运算符（%）
SQL取余运算符提供了左侧操作数除以右侧操作数后的余数。
SQL取余运算符的语法：
SELECT operand1 % operand2;
让我们理解下面的例子，它解释了如何在SQL查询中执行模运算符：
这个例子包含一个 Division（除法） 表，它有三列 Number（数字），First_operand（第一个操作数），和Second_operand（第二个操作数）。
| Number | First operand | Second operand |
|---|---|---|
| 1 | 56 | 4 |
| 2 | 32 | 8 |
| 3 | 89 | 9 |
| 4 | 18 | 10 |
| 5 | 10 | 5 |
- 如果我们想通过将First_operand列的数字除以Second_operand列的数字来获得余数，那么我们必须在SQL中编写以下查询：
SELECT First_operand % Second_operand as Remainder FROM Employee_details;
SQL比较运算符
SQL中的 比较运算符 用于比较SQL表中的两个不同数据，并检查它们是否相同、大于或小于。SQL比较运算符与SQL查询中的WHERE子句一起使用。
以下是对存储在SQL数据库表中的数据执行的各种比较运算符：
- SQL等于运算符（=）
- SQL不等于运算符（!=）
- SQL大于运算符（>）
- SQL大于等于运算符（>=）
- SQL小于运算符（<）
- SQL小于等于运算符（<=）
SQL等于运算符（=）
此运算符在SQL查询中被广泛使用。SQL中的 等于运算符 仅显示与查询中指定的值匹配的数据。
如果查询中指定的两个操作数的值匹配，此运算符将从数据库表中返回TRUE记录。
让我们来看下面的示例，说明如何执行SQL查询中的等于运算符：
此示例包含一个 Employee_details 表，该表具有三列 Emp_Id，Emp_Name和Emp_Salary。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 30000 |
| 202 | Ankit | 40000 |
| 203 | Bheem | 30000 |
| 204 | Ram | 29000 |
| 205 | Sumit | 30000 |
- 假设我们想要访问那些薪水为30000的 Employee_details 数据表中的所有员工记录。那么，我们必须在SQL数据库中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Salary = 30000;
在这个例子中，我们使用了SQL等于操作符和WHERE子句来获取工资为30000的雇员的记录。
SQL等于不操作符（!=）
SQL中的不等于操作符显示与查询指定值不匹配的数据。
如果查询中指定的两个操作数的值不匹配，则此操作符将从数据库视图和表中返回那些记录或行。
让我们来理解下面的例子，它解释了如何在SQL查询中执行等于不操作符：
这个例子包含了一个 Employee_details 表，它有三个列 Emp_Id，Emp_Name和Emp_Salary。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 45000 |
| 202 | Ankit | 45000 |
| 203 | Bheem | 30000 |
| 204 | Ram | 29000 |
| 205 | Sumit | 29000 |
- 假设我们想要访问员工详细信息表 Employee_details 中薪水不是45000的所有员工的记录。那么，在SQL数据库中，我们必须编写以下查询语句：
SELECT * FROM Employee_details WHERE Emp_Salary != 45000;
在这个例子中，我们使用SQL不等于运算符和WHERE子句来获取那些薪水不为45000的员工记录。
SQL大于运算符 (>)
SQL中的大于运算符只显示那些大于右操作数的值的数据。
让我们来理解下面的例子，它解释了如何在SQL查询中执行大于运算符 ( >)：
这个例子包含一个 Employee_details 表，它有三列 Emp_Id，Emp_Name和Emp_Salary。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 45000 |
| 202 | Ankit | 45000 |
| 203 | Bheem | 30000 |
| 204 | Ram | 29000 |
| 205 | Sumit | 29000 |
- 假设我们想要访问那些员工表中员工ID大于202的员工的所有记录。那么，在SQL数据库中，我们必须编写以下查询语句：
SELECT * FROM Employee_details WHERE Emp_Id > 202;
这里，SQL大于运算符显示了上表中员工ID大于202的记录。
SQL大于等于运算符（>=）
在SQL中，大于等于运算符显示表中大于或等于右操作数的数据。
让我们来看一个下面的例子，解释如何在SQL查询中执行大于等于运算符（>=）：
这个例子包含一个 Employee_details 表，它有三个列 Emp_Id，Emp_Name和Emp_Salary。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 45000 |
| 202 | Ankit | 45000 |
| 203 | Bheem | 30000 |
| 204 | Ram | 29000 |
| 205 | Sumit | 29000 |
- 假设我们想要访问 Employee_details 表中员工ID大于等于202的所有记录。为此，我们需要在SQL数据库中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Id >= 202;
在这里， ‘SQL大于等于运算符’ 与WHERE子句一起显示了表中那些员工的行，其员工ID大于等于202。
SQL Less Than Operator (<)
SQL中的 小于运算符 只显示数据库表中小于右侧操作数值的数据。
此比较运算符检查左侧操作数是否小于右侧操作数。如果条件成立，则SQL中的此运算符显示小于右侧操作数值的数据。
让我们了解下面的示例，以说明如何在SQL查询中执行小于运算符（ <）：
此示例包括一个 Employee_details 表，其中包含三个列 Emp_Id，Emp_Name和Emp_Salary 。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 45000 |
| 202 | Ankit | 45000 |
| 203 | Bheem | 30000 |
| 204 | Ram | 29000 |
| 205 | Sumit | 29000 |
- 假设我们想要访问 Employee_details 表中员工ID小于204的所有记录。为此，我们需要在SQL数据库中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Id < 204;
在这里， SQL less than运算符 与WHERE子句一起显示了上表中雇员ID小于204的记录。
SQL Less Than Equals to 运算符(<=)
SQL中的 Less Than Equals to运算符 显示了表中小于或等于右侧操作数的数据。
此比较运算符检查左侧操作数是否小于或等于右侧操作数。
让我们来看下面的例子，说明如何在SQL查询中执行less than equals to运算符( <=)：
此示例包含一个 Employee_details 表，其中有三列 Emp_Id、Emp_Name和Emp_Salary。
| Emp Id | Emp Name | Emp Salary |
|---|---|---|
| 201 | Abhay | 45000 |
| 202 | Ankit | 45000 |
| 203 | Bheem | 30000 |
| 204 | Ram | 29000 |
| 205 | Sumit | 29000 |
- 假设我们想要访问Employee_details表中员工ID小于等于203的所有记录。为此，我们必须在SQL数据库中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Id <= 203;
在这里，SQL 小于等于操作符 与WHERE子句一起显示表中Employee Id小于等于202的员工的行。
SQL逻辑运算符
SQL中的 逻辑运算符 执行布尔运算，给出两个结果 True和False。 如果两个操作数匹配逻辑条件，则这些运算符提供 True 值。
以下是在SQL数据库表中存储的数据上执行的各种逻辑运算符：
- SQL ALL运算符
- SQL AND运算符
- SQL OR运算符
- SQL BETWEEN运算符
- SQL IN运算符
- SQL NOT运算符
- SQL ANY运算符
- SQL LIKE运算符
SQL ALL运算符
SQL中的ALL运算符将指定的值与SQL数据库中子查询的列的所有值进行比较。
此运算符始终与以下语句一起使用：
- SELECT，
- HAVING，并且
- WHERE。
ALL运算符的语法：
SELECT column_Name1, ...., column_NameN FROM table_Name WHERE column Comparison_operator ALL (SELECT column FROM tablename2)
让我们来理解下面的例子，它说明了如何在SQL查询中执行所有的逻辑运算符：
这个例子包括一个 Employee_details 表，它有三列 Emp_Id、Emp_Name、Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Abhay | 25000 | Gurgaon |
| 202 | Ankit | 45000 | Delhi |
| 203 | Bheem | 30000 | Jaipur |
| 204 | Ram | 29000 | Mumbai |
| 205 | Sumit | 40000 | Kolkata |
- 如果我们想访问表中那些工资比住在Jaipur市的员工工资高的员工的员工ID和员工姓名，那么我们必须在SQL中键入以下查询。
SELECT Emp_Id, Emp_Name FROM Employee_details WHERE Emp_Salary > ALL ( SELECT Emp_Salary FROM Employee_details WHERE Emp_City = Jaipur)
在这里，我们使用了 SQL ALL 运算符 与大于运算符一起使用。
SQL AND 运算符
在 SQL 中，如果由 AND 运算符分隔的所有条件都为真，则会从数据库表中显示记录。AND 运算符也称为合取运算符，并与 WHERE 子句一起使用。
AND 运算符的语法：
SELECT column1, ...., columnN FROM table_Name WHERE condition1 AND condition2 AND condition3 AND ....... AND conditionN;
让我们了解下面的示例，其中解释了如何在SQL查询中执行AND逻辑运算符：
此示例包括一个 Employee_details 表，其中有三列 Emp_Id，Emp_Name，Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Abhay | 25000 | Delhi |
| 202 | Ankit | 45000 | Chandigarh |
| 203 | Bheem | 30000 | Delhi |
| 204 | Ram | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 假设我们想访问”Employee_details”表中工资为25000且所在城市为Delhi的所有员工的记录。为此，我们需要在SQL中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Salary = 25000 OR Emp_City = 'Delhi';
这里，带有WHERE子句的 SQL AND运算符 显示工资为25000且所在城市为Delhi的员工记录。
SQL OR运算符
在SQL中，如果由OR运算符分隔的任何条件为True，则显示表中的记录。它也被称为连词运算符，并与WHERE子句一起使用。
OR运算符的语法：
SELECT column1, ...., columnN FROM table_Name WHERE condition1 OR condition2 OR condition3 OR ....... OR conditionN;
让我们来理解下面的例子，解释了如何在SQL查询中执行OR逻辑运算符：
这个例子包括一个 Employee_details 表，它有三列 Emp_Id, Emp_Name, Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Abhay | 25000 | Delhi |
| 202 | Ankit | 45000 | Chandigarh |
| 203 | Bheem | 30000 | Delhi |
| 204 | Ram | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 如果我们想要访问那些薪水为25000或者所在城市为Delhi的Employee_details表中的所有记录。为此，我们需要在SQL中编写以下查询语句：
SELECT * FROM Employee_details WHERE Emp_Salary = 25000 OR Emp_City = 'Delhi';
在这里， SQL OR运算符 与WHERE子句一起显示工资为25000或城市为Delhi的雇员记录。
SQL BETWEEN运算符
SQL中的 BETWEEN运算符 显示SQL查询中指定范围内的记录。此运算符在数字、字符和日期/时间操作数上操作。
如果给定范围内没有值，则此运算符显示NULL值。
BETWEEN运算符的语法：
SELECT column_Name1, column_Name2 ...., column_NameN FROM table_Name WHERE column_nameBETWEEN value1 and value2;
让我们理解下面的例子，它解释了如何在SQL查询中执行BETWEEN逻辑运算符：
这个例子包含一个 Employee_details 表，它有三个列 Emp_Id, Emp_Name, Emp_Salary, and Emp_City.
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Abhay | 25000 | Delhi |
| 202 | Ankit | 45000 | Chandigarh |
| 203 | Bheem | 30000 | Delhi |
| 204 | Ram | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 假设我们要访问 Employee_details 表中薪资在20000到40000之间的所有员工的信息。为此，我们需要在SQL中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Salary BETWEEN 30000 AND 45000;
在这里，我们使用了 SQL BETWEEN操作符 和Emp_Salary字段。
SQL IN 操作符
SQL中的 IN操作符 允许数据库用户在WHERE子句中指定两个或多个值。这个逻辑操作符最大限度地减少了多个OR条件的要求。
这个操作符使查询更易学习和理解。此操作符将返回与给定列表中任何值匹配的那些行。
IN操作符的语法：
SELECT column_Name1, column_Name2 ...., column_NameN FROM table_Name WHERE column_name IN (list_of_values);
让我们来了解下面的示例，它说明了如何在SQL查询中执行IN逻辑运算符：
此示例包含一个 Employee_details 表，它有三列 Emp_Id, Emp_Name, Emp_Salary和Emp_City.
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Abhay | 25000 | Delhi |
| 202 | Ankit | 45000 | Chandigarh |
| 203 | Bheem | 30000 | Delhi |
| 204 | Ram | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 假设我们想要显示”Employee_details” 表中员工编号为202、204和205的所有员工的信息。为此，我们必须在SQL中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Id IN (202, 204, 205);
在这里，我们使用了 SQL IN 操作符 与 Emp_Id 列。
- 假设，我们想显示 Employee_details 表中那些 员工 Id 不等于 202 和 205 的所有员工的信息。为此，我们需要在 SQL 中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Id NOT IN (202,205);
在这里，我们使用了 SQL NOT IN运算符 和Emp_Id列。
SQL NOT运算符
SQL中的 NOT运算符 显示如果条件评估为假，则从表中显示记录。它总是与WHERE子句一起使用。
NOT运算符的语法：
SELECT column1, column2 ...., columnN FROM table_Name WHERE NOT condition;
让我们来了解下面的例子，它解释了如何在SQL查询中执行NOT逻辑运算符：
这个例子包含了一个 Employee_details 表，它有四列： Emp_Id, Emp_Name, Emp_Salary, 和 Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Abhay | 25000 | Delhi |
| 202 | Ankit | 45000 | Chandigarh |
| 203 | Bheem | 30000 | Delhi |
| 204 | Ram | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 假设我们想显示来自 Employee_details 表中城市不是德里的所有员工的信息。为此，我们必须在SQL中编写以下查询:
SELECT * FROM Employee_details WHERE NOT Emp_City = 'Delhi' ;
在这个例子中，我们使用了 SQL NOT 运算符 与 Emp_City 列。
- 假设我们想展示来自 Employee_details 表中城市不是 Delhi 和 Chandigarh 的员工的所有信息。为此，我们需要在SQL中编写以下查询：
SELECT * FROM Employee_details WHERE NOT Emp_City = 'Delhi' AND NOT Emp_City = 'Chandigarh';
在这个例子中，我们使用了 SQL NOT运算符 与Emp_City列。
SQL ANY运算符
在SQL中， ANY运算符 用于在子查询返回的任何值满足条件时显示记录。
ANY逻辑运算符必须与内部查询中的至少一条记录匹配，并且必须由任何SQL比较运算符前置。
ANY运算符的语法：
SELECT column1, column2 ...., columnN FROM table_Name WHERE column_name comparison_operator ANY ( SELECT column_name FROM table_name WHERE condition(s)) ;
SQL LIKE运算符
LIKE运算符 在SQL中显示与子查询中指定的模式匹配的表中的记录。
百分号（%）符号是与这个逻辑运算符一起使用的通配符。
这个运算符与以下三个语句的WHERE子句一起使用：
- SELECT语句
- UPDATE语句
- DELETE语句
LIKE运算符的语法:
SELECT column_Name1, column_Name2 ...., column_NameN FROM table_Name WHERE column_name LIKE pattern;
让我们来理解下面的例子，它解释了如何在SQL查询中执行LIKE逻辑运算符：
这个例子包括一个 Employee_details 表，它有四列 Emp_Id, Emp_Name, Emp_Salary和Emp_City.
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Chandigarh |
| 203 | Saket | 30000 | Delhi |
| 204 | Abhay | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 如果我们想显示来自 Employee_details 中名字以”s”开头的所有员工的信息。为此，我们必须在SQL中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Name LIKE 's%' ;
在这个例子中，我们使用了SQL的LIKE操作符与 Emp_Name 列一起，因为我们想要访问那些名字以s开头的员工的记录。
- 如果我们想要显示 Employee_details 中那些名字以”y”结尾的所有员工的信息。为此，我们需要在SQL中写下以下查询：
SELECT * FROM Employee_details WHERE Emp_Name LIKE '%y' ;
- 如果我们想要展示名字以”S”开头并以”y”结尾的 Employee_details 中的所有员工的信息。为此，我们需要在SQL中编写以下查询：
SELECT * FROM Employee_details WHERE Emp_Name LIKE 'S%y' ;
SQL集合运算符
SQL中的集合运算符将来自两个或多个SQL数据库表的类似类型的数据组合在一起。它将从两个或多个SQL查询中提取的结果混合到单个结果中。
集合运算符将多个select语句组合成一个查询，并返回一个特定的结果集。
以下是在两个SQL数据库表中存储的类似数据上执行的各种集合运算符：
- SQL联合运算符
- SQL联合所有运算符
- SQL交集运算符
- SQL差集运算符
SQL联合运算符
SQL联合运算符将两个或多个SELECT语句的结果合并并提供单个输出。
每个与UNION运算符一起使用的SELECT语句的数据类型和列数必须相同。此运算符在输出表中不显示重复的记录。
UNION集合运算符的语法：
SELECT column1, column2 ...., columnN FROM table_Name1 [WHERE conditions]
UNION
SELECT column1, column2 ...., columnN FROM table_Name2 [WHERE conditions];
让我们来理解下面的例子，它解释了如何在结构化查询语言中执行Union操作符：
在这个例子中， 我们使用了两个表。 这两个表都有四列 Emp_Id, Emp_Name, Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Delhi |
| 203 | Saket | 30000 | Aligarh |
表格：Employee_details1
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 203 | Saket | 30000 | Aligarh |
| 204 | Saurabh | 40000 | Delhi |
| 205 | Ram | 30000 | Kerala |
| 201 | Sanjay | 25000 | Delhi |
表格：Employee_details2
- 假设我们想要在单个输出中查看来自两个表格的每个员工的员工姓名和员工ID。为此，我们必须在SQL中编写以下查询：
SELECT Emp_ID, Emp_Name FROM Employee_details1
UNION
SELECT Emp_ID, Emp_Name FROM Employee_details2 ;
SQL联合全操作符
SQL联合操作符与UNION操作符相同，唯一的区别是它还会显示相同的记录。
UNION ALL集合运算符的语法：
SELECT column1, column2 ...., columnN FROM table_Name1 [WHERE conditions]
UNION ALL
SELECT column1, column2 ...., columnN FROM table_Name2 [WHERE conditions];
让我们了解下面的例子，它解释了如何在结构化查询语言中执行Union ALL运算符：
在这个例子中， 我们使用了两个表。 这两个表都有四列 Emp_Id, Emp_Name, Emp_Salary 和 Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Delhi |
| 203 | Saket | 30000 | Aligarh |
表格：Employee_details1
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 203 | Saket | 30000 | Aligarh |
| 204 | Saurabh | 40000 | Delhi |
| 205 | Ram | 30000 | Kerala |
| 201 | Sanjay | 25000 | Delhi |
表格：员工详情2
- 如果我们想要在单个输出中查看两个表中每个员工的员工姓名。为此，我们必须在SQL中编写以下查询：
SELECT Emp_Name FROM Employee_details1
UNION ALL
SELECT Emp_Name FROM Employee_details2 ;
SQL交集操作符
SQL交集操作符显示两个或多个SELECT语句的共同记录。每个与INTERSECT操作符一起使用的SELECT语句的数据类型和列数必须相同。
INTERSECT集合操作符的语法：
SELECT column1, column2 ...., columnN FROM table_Name1 [WHERE conditions]
INTERSECT
SELECT column1, column2 ...., columnN FROM table_Name2 [WHERE conditions];
让我们来了解下面的例子，它解释了如何在结构化查询语言中执行INTERSECT运算符：
在这个例子中，我们使用了两个表。这两个表都有四个列，分别是Emp_Id，Emp_Name，Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Delhi |
| 203 | Saket | 30000 | Aligarh |
表格：Employee_details1
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 203 | Saket | 30000 | Aligarh |
| 204 | Saurabh | 40000 | Delhi |
| 205 | Ram | 30000 | Kerala |
| 201 | Sanjay | 25000 | Delhi |
表格：Employee_details2
假设我们想要在一个单一的输出中查看来自两个表格的员工的共同记录。为此，我们必须在SQL中编写以下查询：
SELECT Emp_Name FROM Employee_details1
INTERSECT
SELECT Emp_Name FROM Employee_details2 ;
SQL差集运算符
SQL差集运算符将两个或多个SELECT语句的结果合并，并仅显示来自第一个数据集的结果。
MINUS运算符的语法：
SELECT column1, column2 ...., columnN FROM First_tablename [WHERE conditions]
MINUS
SELECT column1, column2 ...., columnN FROM Second_tablename [WHERE conditions];
让我们来看一下下面的例子，它解释了如何在结构化查询语言中执行INTERSECT操作符：
在这个例子中， 我们使用了两个表。 这两个表都有四列， Emp_Id，Emp_Name，Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Delhi |
| 203 | Saket | 30000 | Aligarh |
表格：Employee_details1
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 203 | Saket | 30000 | Aligarh |
| 204 | Saurabh | 40000 | Delhi |
| 205 | Ram | 30000 | Kerala |
| 201 | Sanjay | 25000 | Delhi |
表格：Employee_details2
假设我们想要在将两个表格合并后的第一个结果集中看到员工的名字。为此，我们必须在SQL中编写以下查询：
SELECT Emp_Name FROM Employee_details1
MINUS
SELECT Emp_Name FROM Employee_details2 ;
SQL一元运算符
SQL中的 一元运算符 对SQL表中的单个数据进行一元运算，这些运算符仅对一个操作数执行操作。
这些类型的运算符可以轻松地对SQL表中的数值数据进行操作。
以下是对存储在SQL表中的数值数据执行的各种一元运算符：
- SQL一元正运算符
- SQL一元负运算符
- SQL一元按位非运算符
SQL一元正运算符
SQL正(+)运算符使SQL表中的数值变为正数。
一元正运算符的语法
SELECT +(column1), +(column2) ...., +(columnN) FROM table_Name [WHERE conditions] ;
让我们理解下面的例子，它解释了如何在SQL表的数据上执行正向一元运算符：
这个例子由一个 Employee_details 表组成，它有四列 Emp_Id, Emp_Name, Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Chandigarh |
| 203 | Saket | 30000 | Delhi |
| 204 | Abhay | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 假设我们想要从Employee_details表中以正数的方式查看每个员工的工资。为此，我们需要在SQL中编写以下查询语句：
SELECT +Emp_Salary Employee_details ;
SQL一元负运算符
SQL负运算符(-)使得SQL表中的数值变为负数。
一元负运算符的语法
SELECT -(column_Name1), -(column_Name2) ...., -(column_NameN) FROM table_Name [WHERE conditions] ;
让我们理解下面的示例，该示例说明如何在SQL表的数据上执行负一元运算符:
这个示例包含一个 Employee_details 表，该表有四列 Emp_Id，Emp_Name，Emp_Salary和Emp_City。
| Emp Id | Emp Name | Emp Salary | Emp City |
|---|---|---|---|
| 201 | Sanjay | 25000 | Delhi |
| 202 | Ajay | 45000 | Chandigarh |
| 203 | Saket | 30000 | Delhi |
| 204 | Abhay | 25000 | Delhi |
| 205 | Sumit | 40000 | Kolkata |
- 假设我们想要从Employee_details表中查看每个员工的工资为负数。为此，我们需要在SQL中编写以下查询语句：
SELECT -Emp_Salary Employee_details ;
- 假设我们想要查看Employee_details表中城市为Kolkatain的雇员的薪水为负值。为此，我们必须在SQL中编写以下查询：
SELECT -Emp_Salary Employee_details WHERE Emp_City = 'Kolkata';
SQL位取反运算符
SQL位取反运算符提供了对单个数值操作数的一补运算。该运算符将数值的每个位取反。如果任何数值的位为001100，则该运算符将这些位取反为110011。
位取反运算符的语法
SELECT ~(column1), ~(column2) ...., ~(columnN) FROM table_Name [WHERE conditions] ;
让我们来理解下面的示例，它解释了如何在SQL表的数据上执行位非（Bitwise NOT）运算符：
该示例包含了一个 学生详细信息（Student_details） 表，该表包括四个列 Roll_No（学号）、Stu_Name（学生姓名）、Stu_Marks（学生成绩）和Stu_City（学生所在城市）。
| Emp Id | Stu Name | Stu Marks | Stu City |
|---|---|---|---|
| 101 | Sanjay | 85 | Delhi |
| 102 | Ajay | 97 | Chandigarh |
| 103 | Saket | 45 | Delhi |
| 104 | Abhay | 68 | Delhi |
| 105 | Sumit | 60 | Kolkata |
如果我们想对 Student_details 表中的marks列执行位取反操作， 我们必须在SQL中编写以下查询语句：
SELECT ~Stu_Marks Employee_details ;
SQL 位运算符
SQL中的位运算符对整数值执行位运算。要了解位运算符的性能，您只需要了解布尔代数的基础知识。
以下是在SQL数据库表中存储的数据上执行的两个重要逻辑运算符：
- 位与运算符（&）
- 位或运算符（|）
位与运算符（&）
位与运算符对给定的整数值执行逻辑与操作。该运算符将一个值的每个位与另一个值的相应位进行比较。
位与运算符的语法
SELECT column1 & column2 & .... & columnN FROM table_Name [WHERE conditions] ;
让我们了解下面的示例，它解释了如何在SQL表的数据上执行位与运算符：
这个例子包含以下表格，它有两列。每一列都包含数值。
当我们在SQL中使用位与运算符时，SQL将两列的值转换为二进制格式，并对转换后的位进行AND运算。
然后，SQL将结果位转换为用户可理解的格式，即十进制格式。
| Column1 | Column2 |
|---|---|
| 1 | 1 |
| 2 | 5 |
| 3 | 4 |
| 4 | 2 |
| 5 | 3 |
- 假设我们想在上面的表格的两列之间执行按位与操作符。为此，我们必须在SQL中编写以下查询：
SELECT Column1 & Column2 From TABLE_AND ;
位或（|）
位或运算符对给定的整数值执行逻辑或运算。该运算符将每个位与另一个值的相应位进行比较。
位或运算符的语法
SELECT column1 | column2 | .... | columnN FROM table_Name [WHERE conditions] ;
让我们了解下面的示例，它解释了如何在SQL表的数据上执行位或运算符：
这个示例包含一个表，其中有两列。每列都保存着数值。
当我们在SQL中使用位或运算符时，SQL会将两列的值转换成二进制格式，然后对二进制位进行位或运算。之后，SQL将结果的二进制位转换成用户可理解的格式，即十进制格式。
| Column1 | Column2 |
|---|---|
| 1 | 1 |
| 2 | 5 |
| 3 | 4 |
| 4 | 2 |
| 5 | 3 |
- 假设我们想在上表的两列之间执行按位或操作符。为此，我们必须在SQL中编写以下查询：
SELECT Column1 | Column2 From TABLE_OR ;