SQL语法2-白红宇

SQL语法2

阅读量：7305 次

发布时间：2019-06-30

本文共 19249 字，大约阅读时间需要 64 分钟。

SQL SELECT语句用来从数据库表获取数据返回表形式数据的结果。这些结果表被称为结果集。

语法

SELECT语句的基本语法如下：

SELECT column1, column2, columnN FROM table_name;

这里, column1, column2...是要获取其值的表的字段。如果你想获取所有可用字段，那么可以使用下面的语法：

SELECT * FROM table_name;

例子：

考虑CUSTOMERS表具有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

下面是一个例子，这将获取CUSTOMERS表中可用的客户的ID, Name 和 Salary：

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

这将产生以下结果：

+----+----------+----------+| ID | NAME     | SALARY   |+----+----------+----------+|  1 | Ramesh   |  2000.00 ||  2 | Khilan   |  1500.00 ||  3 | kaushik  |  2000.00 ||  4 | Chaitali |  6500.00 ||  5 | Hardik   |  8500.00 ||  6 | Komal    |  4500.00 ||  7 | Muffy    | 10000.00 |+----+----------+----------+

如果你想获取CUSTOMERS表中的所有字段，那么可使用以下查询：

SQL> SELECT * FROM CUSTOMERS;

这将产生以下结果：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

表达式是一个或多个值，运算符和SQL函数计算结果的值的组合。

SQL表达式与公式相似，他们编写查询语言。您也可以使用它们来查询数据库中的特定的数据集。

语法

考虑SELECT语句的基本语法如下：

SELECT column1, column2, columnN FROM table_name WHERE [CONDITION|EXPRESSION];

有不同类型的SQL表达式，其中可提到如下面：

SQL - 布尔表达式：

SQL布尔表达式提取匹配单个值为基础的数据。下面是语法：

SELECT column1, column2, columnN FROM table_name WHERE SINGLE VALUE MATCHTING EXPRESSION;

考虑CUSTOMERS表具有以下记录：

SQL> SELECT * FROM CUSTOMERS;+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+7 rows in set (0.00 sec)

下面是简单的例子，显示SQL布尔表达式的用法：

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;+----+-------+-----+---------+----------+| ID | NAME  | AGE | ADDRESS | SALARY   |+----+-------+-----+---------+----------+|  7 | Muffy |  24 | Indore  | 10000.00 |+----+-------+-----+---------+----------+1 row in set (0.00 sec)

SQL - 数字表达式：

这个表达式用来在任何查询执行任何数学运算。下面是语法：

SELECT numerical_expression as  OPERATION_NAME[FROM table_nameWHERE CONDITION] ;

这里数值表达式被用于数学表达式或任何公式。下面是一个简单的例子，显示SQL数字表达式的用法：

SQL> SELECT (15 + 6) AS ADDITION+----------+| ADDITION |+----------+|       21 |+----------+1 row in set (0.00 sec)

还有像一些内置函数avg(), sum(), count()等，执行了被称为数据计算对表或特定的表列集合体。

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; +---------+| RECORDS |+---------+|       7 |+---------+1 row in set (0.00 sec)

SQL - 日期表达式：

日期表达式返回当前系统日期和时间值：

SQL>  SELECT CURRENT_TIMESTAMP;+---------------------+| Current_Timestamp   |+---------------------+| 2009-11-12 06:40:23 |+---------------------+1 row in set (0.00 sec)

另一个日期表达式如下：

SQL>  SELECT  GETDATE();+-------------------------+| GETDATE                 |+-------------------------+| 2009-10-22 12:07:18.140 |+-------------------------+1 row in set (0.00 sec)

HAVING子句允许您指定过滤器的条件，分组结果会出现在最终结果。

WHERE子句所选列的条件，而由GROUP BY子句条件创建分组的HAVING子句。

语法

下面是HAVING子句在查询中的位置：

SELECTFROMWHEREGROUP BYHAVINGORDER BY

HAVING子句必须遵循GROUP BY子句中的查询，如果使用也必须先于ORDER BY子句。下面是SELECT语句，包括HAVING子句的语法：

SELECT column1, column2FROM table1, table2WHERE [ conditions ]GROUP BY column1, column2HAVING [ conditions ]ORDER BY column1, column2

例子：

考虑CUSTOMERS表具有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

下面是示例，这将显示记录age大于或等于2的数据量：

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARYFROM CUSTOMERSGROUP BY ageHAVING COUNT(age) >= 2;

这将产生以下结果：

+----+--------+-----+---------+---------+| ID | NAME   | AGE | ADDRESS | SALARY  |+----+--------+-----+---------+---------+|  2 | Khilan |  25 | Delhi   | 1500.00 |+----+--------+-----+---------+---------+

子查询

子查询或内部查询或嵌套查询在另一个SQL查询的查询和嵌入式WHERE子句中。

子查询用于返回将被用于在主查询作为条件的数据，以进一步限制要检索的数据。

子查询可以在SELECT，INSERT，UPDATE使用，而且随着运算符如DELETE语句 =, <, >, >=, <=, IN, BETWEEN 等.

这里有一些规则，子查询必须遵循：

子查询必须被圆括号括起来。

子查询只能在有一列的SELECT子句中，除非多个列中的子查询，以比较其选定列主查询。

ORDER BY不能在子查询中使用，主查询可以使用ORDER BY。GROUP BY可以用来在子查询中如ORDER BY执行相同的功能。

返回多于一个行子查询只能用于具有多个值运算符，如IN操作。

SELECT列表中不能包含到值计算到任何引用 BLOB, ARRAY, CLOB, 或NCLOB.

子查询不能立即封闭在一组函数。

BETWEEN 操作符不能与子查询使用;然而，操作符BETWEEN可以在子查询中使用。

子查询SELECT语句：

子查询最频繁使用的SELECT语句。其基本语法如下：

SELECT column_name [, column_name ]FROM   table1 [, table2 ]WHERE  column_name OPERATOR            (SELECT column_name [, column_name ]      FROM table1 [, table2 ]      [WHERE])

例子：

考虑CUSTOMERS表具有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

现在，让我们检查下使用子查询SELECT语句：

SQL> SELECT *      FROM CUSTOMERS      WHERE ID IN (SELECT ID                   FROM CUSTOMERS                   WHERE SALARY > 4500) ;

这将产生以下结果：

+----+----------+-----+---------+----------+| ID | NAME     | AGE | ADDRESS | SALARY   |+----+----------+-----+---------+----------+|  4 | Chaitali |  25 | Mumbai  |  6500.00 ||  5 | Hardik   |  27 | Bhopal  |  8500.00 ||  7 | Muffy    |  24 | Indore  | 10000.00 |+----+----------+-----+---------+----------+

子查询的INSERT语句：

子查询，也可以使用INSERT语句。INSERT语句使用从子查询返回的数据插入到另一个表中。在子查询中的所选择的数据可以与任何类型的字符，日期或数字函数进行修改。

其基本语法如下：

INSERT INTO table_name [ (column1 [, column2 ]) ]           SELECT [ *|column1 [, column2 ]           FROM table1 [, table2 ]           [ WHERE VALUE OPERATOR ]

示例:

考虑CUSTOMERS_BKP表的结构相似于CUSTOMERS表。考虑CUSTOMERS_BKP表的结构相似于CUSTOMERS表。

SQL> INSERT INTO CUSTOMERS_BKP     SELECT * FROM CUSTOMERS      WHERE ID IN (SELECT ID                   FROM CUSTOMERS) ;

子查询的UPDATE语句：

子查询可以与UPDATE语句一起使用。单个或多个表中的列可以使用带有UPDATE语句子查询时被更新。

其基本语法如下：

UPDATE tableSET column_name = new_value[ WHERE OPERATOR [ VALUE ]   (SELECT COLUMN_NAME   FROM TABLE_NAME)   [ WHERE) ]

示例:

假设，我们的CUSTOMERS_BKP表是CUSTOMERS表的备份。

下面的例子是在CUSTOMERS表更新0.25倍薪水，其年龄大于或等于27所有的客户：

SQL> UPDATE CUSTOMERS     SET SALARY = SALARY * 0.25     WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP                   WHERE AGE >= 27 );

这将影响到两行，最后CUSTOMERS表将有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  35 | Ahmedabad |   125.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  2125.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

子查询的DELETE语句：

子查询可配合使用像上述的任何其他语句DELETE语句。

其基本语法如下：

DELETE FROM TABLE_NAME[ WHERE OPERATOR [ VALUE ]   (SELECT COLUMN_NAME   FROM TABLE_NAME)   [ WHERE) ]

示例:

假设，我们的CUSTOMERS_BKP表是CUSTOMERS表的备份。

下面的示例将删除CUSTOMERS表记录其年龄大于或等于27所有的客户：

SQL> DELETE FROM CUSTOMERS     WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP                   WHERE AGE > 27 );

这将影响到两行，最后CUSTOMERS表将有以下记录：

+----+----------+-----+---------+----------+| ID | NAME     | AGE | ADDRESS | SALARY   |+----+----------+-----+---------+----------+|  2 | Khilan   |  25 | Delhi   |  1500.00 ||  3 | kaushik  |  23 | Kota    |  2000.00 ||  4 | Chaitali |  25 | Mumbai  |  6500.00 ||  6 | Komal    |  22 | MP      |  4500.00 ||  7 | Muffy    |  24 | Indore  | 10000.00 |+----+----------+-----+---------+----------+

JOIN链接

SQL Join联接子句用于在两个或更多在数据库中的表的记录组合。JOIN是通过使用从两个表字段共通的值组合连接起来。

考虑下面的两个表中，(a)CUSTOMERS表如下：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

(b)另一个表的命令如下：

+-----+---------------------+-------------+--------+|OID  | DATE                | CUSTOMER_ID | AMOUNT |+-----+---------------------+-------------+--------+| 102 | 2009-10-08 00:00:00 |           3 |   3000 || 100 | 2009-10-08 00:00:00 |           3 |   1500 || 101 | 2009-11-20 00:00:00 |           2 |   1560 || 103 | 2008-05-20 00:00:00 |           4 |   2060 |+-----+---------------------+-------------+--------+

现在，让我们在SELECT语句中联接这两个表如下：

SQL> SELECT ID, NAME, AGE, AMOUNT        FROM CUSTOMERS, ORDERS        WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

这将产生以下结果:

+----+----------+-----+--------+| ID | NAME     | AGE | AMOUNT |+----+----------+-----+--------+|  3 | kaushik  |  23 |   3000 ||  3 | kaushik  |  23 |   1500 ||  2 | Khilan   |  25 |   1560 ||  4 | Chaitali |  25 |   2060 |+----+----------+-----+--------+

在这里，值得注意的是，在WHERE子句中加Join。几家运算符可以用来连接表，如=, <, >, <>, <=, >=, !=, BETWEEN, LIKE, 和 NOT; 他们都可以被用来连接表。然而，最常见的运算符是等于符号。

SQL Join 类型:

在SQL连接有不同类型可用：

返回记录当两个表有匹配。

返回左表中所有的行，即使右表中没有匹配。

返回右表中所有的行，即使有在左表中没有匹配。

返回表中匹配的所有行。

是用来连接表本身，如果表有两张表，暂时改名至少在一个表中的SQL语句。

返回来自两个或更多个联接的表的记录的集合的笛卡尔乘积。

ORDER BY子句

SQL ORDER BY子句用于按升序或降序排序数据在一列或多列的基础上。一些数据库默认排序查询结果按升序排列。

语法

ORDER BY子句的基本语法如下：

SELECT column-list FROM table_name [WHERE condition] [ORDER BY column1, column2, .. columnN][ASC | DESC];

您可以在ORDER BY子句使用多列。确保任何列使用排序，column应该是在column-list中。

例子：

考虑CUSTOMERS表具有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

下面是一个例子，将结果通过NAME和SALARY升序排序：

SQL> SELECT * FROM CUSTOMERS     ORDER BY NAME, SALARY;

这将产生以下结果：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 ||  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |+----+----------+-----+-----------+----------+

下面是一个例子，这将结果通过NAME降序排序：

SQL> SELECT * FROM CUSTOMERS     ORDER BY NAME DESC;

这将产生以下结果：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 |

group by

SQL GROUP BY子句用于协同SELECT语句用来安排相同的数据分组。

GROUP BY子句在SELECT语句的WHERE子句之后并ORDER BY子句之前。

语法

GROUP BY子句的基本语法如下。GROUP BY子句中必须遵循WHERE子句中的条件，如果使用必须先于ORDER BY子句。

SELECT column1, column2FROM table_nameWHERE [ conditions ]GROUP BY column1, column2ORDER BY column1, column2

例子：

考虑到CUSTOMERS表具有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

如果你想知道每个客户的薪水的总额，使用GROUP BY查询如下所示：

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS     GROUP BY NAME;

这将产生以下结果：

+----------+-------------+| NAME     | SUM(SALARY) |+----------+-------------+| Chaitali |     6500.00 || Hardik   |     8500.00 || kaushik  |     2000.00 || Khilan   |     1500.00 || Komal    |     4500.00 || Muffy    |    10000.00 || Ramesh   |     2000.00 |+----------+-------------+

现在，让我们有如下表，客户表中有以下重名记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Ramesh   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | kaushik  |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

现在如果你想知道的薪水对每个客户的总金额，使用GROUP BY查询将如下：

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS     GROUP BY NAME;

这将产生以下结果：

+---------+-------------+| NAME    | SUM(SALARY) |+---------+-------------+| Hardik  |     8500.00 || kaushik |     8500.00 || Komal   |     4500.00 || Muffy   |    10000.00 || Ramesh  |     3500.00 |+---------+-------------+

视图

视图无非是存储在数据库中的相关名称的SQL语句。视图实际上是一个表中的预定义的SQL查询形式的组合物。

视图可以包含一个表中的所有行或从表中选择部分行。视图可以从一个或多个表取决于书面SQL查询来创建。

视图是一种虚拟表，让用户做到以下几点：

用户或用户类别的找到天然或直观的结构数据的方式。

限制访问的数据，使得用户可以看到，（有时）修改确实需要或不需要更多。

汇总可从表中的数据生成各种报告。

创建视图：

使用CREATE VIEW语句创建数据库视图。视图可以从一个单一的表，多个表或另一视图中创建。

要创建视图，用户必须根据具体的实施有相应的系统权限。

CREATE VIEW基本的语法如下：

CREATE VIEW view_name ASSELECT column1, column2.....FROM table_nameWHERE [condition];

可以包括在正常使用的SQL SELECT查询类似的方式，在SELECT语句中的多个表。

例子：

考虑CUSTOMERS表具有以下记录：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

现在，下面的例子创建客户表的视图。这个视图将用于从CUSTOMERS表读取客户姓名和年龄：

SQL > CREATE VIEW CUSTOMERS_VIEW ASSELECT name, ageFROM  CUSTOMERS;

现在，你可以查询CUSTOMERS_VIEW类似的方式来查询实际的表。下面是一个例子：

SQL > SELECT * FROM CUSTOMERS_VIEW;

这将产生以下结果:

+----------+-----+| name     | age |+----------+-----+| Ramesh   |  32 || Khilan   |  25 || kaushik  |  23 || Chaitali |  25 || Hardik   |  27 || Komal    |  22 || Muffy    |  24 |+----------+-----+

WITH CHECK OPTION：

WITH CHECK OPTION是CREATE VIEW语句选项。WITH CHECK OPTION的目的是为了确保所有更新和插入满足视图定义的条件。

如果它没有满足条件，在UPDATE或INSERT返回一个错误。

以下是创建CUSTOMERS_VIEW 视图例子使用WITH CHECK OPTION：

CREATE VIEW CUSTOMERS_VIEW ASSELECT name, ageFROM  CUSTOMERSWHERE age IS NOT NULLWITH CHECK OPTION;

在这种情况下，WITH CHECK OPTION拒绝任何NULL值条目在视图的AGE列，因为该视图由数据定义的不能在AGE栏中有NULL值。

更新视图：

视图在一定条件下可以更新：

SELECT子句不包含关键字DISTINCT。

SELECT子句不包含汇总函数。

SELECT子句不包含集合函数。

SELECT子句不能包含集合运算符。

SELECT子句不能包含一个ORDER BY子句。

FROM子句中不能包含多个表。

WHERE子句不能包含子查询。

查询不包含GROUP BY或HAVING。

计算列无法更新。

从基表中的所有NOT NULL列必须包含在视图是为了使用INSERT查询功能。

所以，如果一个视图满足所有上述规则，那么就可以更新视图。下面是一个例子，更新Ramesh的年龄：

SQL > UPDATE CUSTOMERS_VIEW      SET AGE = 35      WHERE name='Ramesh';

这最终将更新基础表CUSTOMERS，并同样在视图中反映。现在，试着查询基础表，SELECT语句将产生如下结果：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  6 | Komal    |  22 | MP        |  4500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

将行插入视图：

数据行可以插入的视图。适用于UPDATE命令规则同样也适用于INSERT命令。

在这里，我们也不能插入行到CUSTOMERS_VIEW，因为我们还没有包括在该视图中的所有NOT NULL列，否则，你可以插入数据行到视图，以其插入一个表中类似的方式。

在视图中删除行：

可以从视图中删除数据行。适用于UPDATE和INSERT命令的规则同样也适用于DELETE命令。

下面是一个例子删除其 AGE= 22 的记录

SQL > DELETE FROM CUSTOMERS_VIEW      WHERE age = 22;

这将最终从基表CUSTOMERS删除一行，并同样在视图本身也会有反映。现在，试着查询基础表，SELECT语句将产生如下结果：

+----+----------+-----+-----------+----------+| ID | NAME     | AGE | ADDRESS   | SALARY   |+----+----------+-----+-----------+----------+|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 ||  2 | Khilan   |  25 | Delhi     |  1500.00 ||  3 | kaushik  |  23 | Kota      |  2000.00 ||  4 | Chaitali |  25 | Mumbai    |  6500.00 ||  5 | Hardik   |  27 | Bhopal    |  8500.00 ||  7 | Muffy    |  24 | Indore    | 10000.00 |+----+----------+-----+-----------+----------+

删除视图：

很显然，在这里有一个视图，需要一种方法来删除这个视图如果它不再需要。语法很简单，如下所示：

DROP VIEW view_name;

下面是一个例子是删除CUSTOMERS客户表的视图：

DROP VIEW CUSTOMERS_VIEW;

索引

索引是数据库的搜索引擎使用，以加快数据检索特定的查找表。简单地说，索引是一个指向表中的数据。数据库中的索引非常类似于在一本书的索引。

例如，如果你想引用一本书的所有页面以讨论某个话题，首先参考索引，其中列出了所有的主题字母顺序，然后被转介到一个或多个特定的页码。

索引有助于加快SELECT和WHERE子句查询，但它会减慢数据输入，使用UPDATE和INSERT语句。索引可创建或删除，但对数据不会有影响。

创建索引包括CREATE INDEX语句，它允许重命名索引，指定表和其中一个或多个列索引，并指示索引是否为升序或降序排序。

索引是唯一的，类似于UNIQUE约束，索引防止在列的列或组合在其上有一个索引重复条目。

CREATE INDEX命令：

CREATE INDEX的基本语法如下：

CREATE INDEX index_name ON table_name;

单列索引：

单列索引是一个基于只有创建表列。其基本语法如下：

CREATE INDEX index_nameON table_name (column_name);

唯一索引：

唯一索引不仅用于性能，而且要求数据的完整性。唯一索引不允许有任何重复值插入到表中。其基本语法如下：

CREATE UNIQUE INDEX index_nameon table_name (column_name);

组合索引：

组合索引在表上的两个或多个列的索引。其基本语法如下：

CREATE INDEX index_nameon table_name (column1, column2);

是否要创建一个单列索引或复合索引，考虑到列，您可以使用非常频繁的查询的WHERE子句作为过滤条件。

应该有只有一个使用列，单列指数应的选择。如果有频繁使用WHERE子句作为过滤器中的两个或多个列，组合索引将是最好的选择。

隐式索引：

隐式索引是自动由数据库服务器创建对象时创建的索引。索引是主键约束和唯一性约束自动创建。

DROP INDEX命令：

索引可以使用SQL DROP命令删除。应当谨慎删除索引时导致的性能可能会减慢或改善。

其基本语法如下：

DROP INDEX index_name;

您可以查看篇章查看索引的实际例子。

什么时候避免使用索引？

尽管索引的目的在于提高数据库的性能，以下几种情况应该避免使用。以下准则显示，当使用索引应该重新考虑：

索引不应该用在小型表上。

有频繁的，大批量更新或插入操作的表。

索引不应该用于对包含大量NULL值的列。

列经常操纵不应该被索引。

转载于:https://blog.51cto.com/yongguang/1686295

你可能感兴趣的文章

博客园首页新随笔联系订阅管理随笔 - 175 文章 - 2 评论 - 1146 Silverlight实用窍门系列：6.Silverlight弹出窗口以及DataGrid分页【附带实例源码】...

查看>>

EF(Linq)框架使用过程中的小技巧汇总

查看>>

Python3-list

查看>>

poj 3225 间隙(横截面和填充操作)

查看>>

strcpy函数的实现【转】

查看>>

在分布式事务（MSDTC）中使用OLE DB数据库连接访问数据

查看>>

对pgpoo-II的pool_process_context的 proc_id 的理解

查看>>

查询在一张表不在另外一张表的记录

查看>>

C语言中strcpy(char *strDest, const char *strScr)字符串复制库函数的理解与分析

[LeetCode] Graph Valid Tree 图验证树

查看>>

html在线编辑器汇总

查看>>

Windows Phone Developer Tools for Mango

查看>>

ylbtech-dbs:ylbtech-5,RI(报销发票系统)

查看>>

PLSQL Developer 不能连接 oracle 11g 64位的解决办法

查看>>

Angular 4.0 使用第三方类库

查看>>

如何制作prezi swf格式字体(prezi 中文字体)

查看>>

适合于IE6 SP1的无边框网页－－仍然需要改进，但对于基本应用应该可用了

查看>>

数据分析：互联网金融数据分析应用

查看>>