imported>Cewbot：去除重複的轉換規則: 去除與公共轉換組重複的轉換規則 (1): 存在於轉換組 IT: zh-cn:数据库;zh-tw:資料庫

2026-02-24T09:57:41Z

去除重複的轉換規則: 去除與公共轉換組重複的轉換規則 (1): 存在於轉換組 IT: zh-cn:数据库;zh-tw:資料庫

新页面

{{NoteTA
|G1=IT
|1=zh-tw:資料; zh-cn:数据;
}}
'''[[SQL]]编程语言的语法'''是由ISO/IEC 9075标准中的[[ISO/IEC JTC 1/SC 32|ISO/IEC SC 32]]委员会所定义和维护的。尽管存在标准，不过SQL代码仍然无法在不进行修改的前提下在不同的数据库系统中直接移植。

== 语言元素 ==
[[File:SQL ANATOMY wiki.svg|thumb|400px|图表显示了SQL语言元素组成的一个语句]]

SQL语言分成了几种要素，包括：

* 子句，是语句和查询的组成成分。（在某些情况下，这些都是可选的。）<ref>ANSI/ISO/IEC International Standard (IS). Database Language SQL—Part 2: Foundation (SQL/Foundation). 1999.</ref>
* 表达式，可以产生任何[[变量 (程序设计)|标量]]值，或由[[列 (数据库)|列]]和[[行 (数据库)|行]]的[[数据库表]]
* 谓词，给需要评估的SQL[[三值逻辑|三值逻辑（3VL）]]（true/false/unknown）或[[逻辑代数|布尔]][[真值]]指定条件，并限制语句和查询的效果，或改变程序流程。
* 查询，基于特定条件检索数据。这是''SQL''的一个重要组成部分。
* 语句，可以持久地影响纲要和数据，也可以控制[[数据库事务]]、程序流程、连接、会话或诊断。
** SQL语句也包括[[分號]]（";"）语句终结符。尽管并不是每个平台都必需，但它是作为SQL语法的标准部分定义的。
* [[空白|无意义的空白]]在SQL语句和查询中一般会被忽略，更容易格式化SQL代码便于阅读。

== 运算符 ==

{| class="wikitable"
|-
! 运算子
! 描述
! 例子
|-
| {{code|1= =}}
| 等于
| {{code|1= Author = 'Alcott'}}
|-
| {{code|1= <>}}
| 不等于（许多資料庫管理系统除了支持{{code|1= <>}}以外还支持{{code|1= !=}}）
| {{code|Dept <> 'Sales'}}
|-
| {{code|1= >}}
| 大于
| {{code|Hire_Date > '2012-01-31'}}
|-
| {{code|1= <}}
| 小于
| {{code|Bonus < 50000.00}}
|-
| {{code|1= >=}}
| 大于等于
| {{code|1= Dependents >= 2}}
|-
| {{code|1= <=}}
| 小于等于
| {{code|1= Rate <= 0.05}}
|-
| {{code|1= BETWEEN}}
| 在一个范围内
| {{code|Cost BETWEEN 100.00 AND 500.00}}
|-
| {{code|1= LIKE}}
| 字符模式匹配
| {{code|First_Name LIKE 'Will%'}}
|-
| {{code|1= IN}}
| 等于多个可能的值之一
| {{code|DeptCode IN (101, 103, 209)}}
|-
| {{code|1= IS}} ''或'' {{code|IS NOT}}
| 与空值（数据缺失）比较
| {{code|Address IS NOT NULL}}
|-
| {{code|IS NOT DISTINCT FROM}}
| 等于值或均为空值（数据缺失）
| {{code|Debt IS NOT DISTINCT FROM - Receivables}}
|-
| {{code|1= AS}}
| 用于在查看结果时更改字段名称
| {{code|SELECT employee AS 'department1'}}
|}

有人也提议实现其他运算子，例如{{le|轮廓运算子|skyline operator}}（寻找那些不比任何其他记录“糟糕”的记录）。

=== 条件（CASE）表达式 ===

SQL在[[SQL-92]]标准中引入了<code>CASE/WHEN/THEN/ELSE/END</code>语句。通常情况下所称的“搜索CASE语句”例子如下：

<syntaxhighlight lang="sql">
CASE WHEN n > 0
THEN '正'
WHEN n < 0
THEN '负'
ELSE '零'
END
</syntaxhighlight>

SQL按照<code>WHEN</code>条件在源代码中出现的顺序进行判断。如果源代码中没有指定<code>ELSE</code>表达式，SQL默认为<code>ELSE NULL</code>。SQL标准中还有一种“简单CASE语句”，类似C语言的switch：

<syntaxhighlight lang="sql">
CASE n WHEN 1
THEN 'one'
WHEN 2
THEN 'two'
ELSE 'I cannot count that high'
END
</syntaxhighlight>

该语法是隐式相等条件。通常情况下，遇到[[空值 (SQL)|与空值比较]]的情况会发出警告。

对于[[Oracle数据库]]的SQL语法，还可以用<code>DECODE</code>函数简化：

<syntaxhighlight lang="oracle11">
SELECT DECODE(n, 1, 'one',
2, 'two',
'i cannot count that high')
FROM some_table;
</syntaxhighlight>

最后一个值是可选的，若无指定，默认为<code>NULL</code>。另外，与“简单CASE”不同的是，Oracle的<code>DECODE</code>会认为两个<code>NULL</code>之间相等。<ref>{{cite web |url=http://docs.oracle.com/cd/B19306_01/server.102/b14200/functions040.htm |title=DECODE |publisher=Docs.oracle.com |accessdate=2013-06-14 |archive-date=2013-06-28 |archive-url=https://web.archive.org/web/20130628025818/http://docs.oracle.com/cd/B19306_01/server.102/b14200/functions040.htm |dead-url=no }}</ref>

== 查询 ==

SQL中最常见的操作是查询，它是通过陈述性<code>[[查询 (SQL)|SELECT]]</code>语句执行的。<code>SELECT</code>从一个或多个[[数据库表|表]]或表达式中检索数据。标准的<code>SELECT</code>不会对数据库有持久影响。<code>SELECT</code>的一些非标准的实现可以有持久影响，如一些数据库中有<code>SELECT INTO</code>语法。<ref name="ms-sql-select-into">{{cite book | chapter = Transact-SQL Reference | title = SQL Server Language Reference | series = SQL Server 2005 Books Online | publisher = Microsoft | date = 2007-09-15 | url = http://msdn.microsoft.com/en-us/library/ms188029.aspx | accessdate = 2007-06-17 | archive-date = 2008-04-30 | archive-url = https://web.archive.org/web/20080430104929/http://msdn.microsoft.com/en-us/library/ms188029.aspx | dead-url = no }}</ref>

查询允许用户描述所需的数据，将{{le|查询计划|query plan|计划}}、{{le|查询优化器|query optimizer|优化}}以及执行用以产生它选取的结果的物理操作交给[[数据库|数据库管理系统（DBMS）]]负责。

查询包含一系列含有最终结果的字段, 紧跟<code>SELECT</code>关键词。星号（"<code>*</code>"）也可以用来指定查询应当返回查询表所有字段。<code>SELECT</code>是最复杂的SQL语句，可选的关键词和子句包括：

* <code>[[From (SQL)|FROM]]</code>子句指定了选择的数据表。<code>FROM</code>子句也可以包含<code>[[连接 (SQL)|JOIN]]</code> 二层子句来为数据表的连接设置规则。
* <code>[[Where (SQL)|WHERE]]</code>子句后接一个比较谓词以限制返回的行。<code>WHERE</code>子句仅保留返回结果里使得比较谓词的值为True的行。
* <code>[[Group by (SQL)|GROUP BY]]</code>子句用于将若干含有相同值的行合并。 <code>GROUP BY</code>通常与SQL聚合函数连用，或者用于清除数据重复的行。<code>GROUP BY</code>子句要用在<code>WHERE</code>子句之后。
* <code>[[Having (SQL)|HAVING]]</code>子句后接一个谓词来过滤从<code>GROUP BY</code>子句中获得的结果，由于其作用于<code>GROUP BY</code>子句之上，所以聚合函数也可以放到其谓词中。
* <code>[[Order by (SQL)|ORDER BY]]</code>子句指明将哪个字段用作排序关键字，以及排序顺序(升序/降序)，如果无此子句，那么返回结果的顺序不能保证有序。

下面是一个返回昂贵的书籍列表的<code>SELECT</code>查询的例子。查询会从 ''Book'' 表中检索所有 ''price'' 的值大于 100.00 的行。结果按 ''title'' 升序排列。''选择列表''中的星号（*）表明''Book''表中所有字段都包含在结果集中。

<syntaxhighlight lang="sql">
SELECT *
FROM Book
WHERE price > 100.00
ORDER BY title;
</syntaxhighlight>

下面的例子演示了通过返回与每本书相关联的书籍和作者来多表查询、分组和聚集。

<syntaxhighlight lang="sql">
SELECT Book.title AS Title,
count(*) AS Authors
FROM Book
JOIN Book_author
ON Book.isbn = Book_author.isbn
GROUP BY Book.title;
</syntaxhighlight>

输出可能类似于下面的例子：

Title Authors
---------------------- -------
SQL Examples and Guide 4
The Joy of SQL 1
An Introduction to SQL 2
Pitfalls of SQL 1

在''isbn''是两个表中唯一通用的列名，且名为''title''的列仅存在于''Books''表中的前提下，上述查询可以用以下形式重写：

<syntaxhighlight lang="sql">
SELECT title,
count(*) AS Authors
FROM Book
NATURAL JOIN Book_author
GROUP BY title;
</syntaxhighlight>

然而，许多厂商或者不支持这种方法，或者需要某些列命名约定来实现自然联接。

SQL包含有用于计算存储值的值的运算符和函数。SQL允许在''选择列表''中使用表达式来投影数据，如下例所示，它返回成本超过100.00的书籍列表，另外一列''sales_tax''包含以''price''的6％计算的销售税数据。

<syntaxhighlight lang="sql">
SELECT isbn,
title,
price,
price * 0.06 AS sales_tax
FROM Book
WHERE price > 100.00
ORDER BY title;
</syntaxhighlight>

=== 子查询 ===

查询可以嵌套，以便一个查询的结果可以通过关系运算符或聚合函数在另一个查询中使用。嵌套查询也称为''子查询''。虽然连接和其他表操作在许多情况下提供了计算上优越（即更快）的替代方案，但是子查询的使用引入了在执行中会很有用或很必要的等级。在下例中，聚合函数<code>AVG</code>接收子查询的结果作为输入：

<syntaxhighlight lang="sql">
SELECT isbn,
title,
price
FROM Book
WHERE price < (SELECT AVG(price) FROM Book)
ORDER BY title;
</syntaxhighlight>

子查询可以使用外部查询的值，在这种情况下，它被称为{{le|相关子查询|correlated subquery}}。

自1999年以来，SQL标准允许称为{{le|公共表表达式|common table expression}}的命名子查询（在IBM DB2版本2中实现之后命名和设计; Oracle把它叫做{{le|子查询部分|subquery factoring}}）。CTE还可以通过自身引用来[[递归]]；{{le|SQL中的分层和递归查询|Hierarchical and recursive queries in SQL|得到的机制}}允许树或图遍历，以及更一般的[[不动点]]计算。

=== 派生表 ===

''派生表''是在FROM子句中引用SQL子查询的用法。基本上，派生表是可以从中选择或连接到的子查询。派生表功能允许用户将子查询引用为表。派生表也称为''内联视图''或''子选择''。

在下例中，SQL语句涉及从初始“Book”表到派生表“sales”的连接。此派生表使用ISBN捕获关联的图书销售信息以加入“Book”表。因此，派生表提供的结果集包含附加列（销售的商品数量和销售图书的公司）：

<syntaxhighlight lang="sql">
SELECT b.isbn, b.title, b.price, sales.items_sold, sales.company_nm
FROM Book b
JOIN (SELECT SUM(Items_Sold) Items_Sold, Company_Nm, ISBN
FROM Book_Sales
GROUP BY Company_Nm, ISBN) sales
ON sales.isbn = b.isbn
</syntaxhighlight>

=== 空值与三值逻辑 ===
{{main|Null (SQL)|三值逻辑}}

SQL中引入了[[空值 (SQL)|空值]]的概念，用来处理关系模型中缺少信息的情况。<code>NULL</code>一词表示空白值，是SQL中的保留词。如果Null进行比较，例如在WHERE子句中使用“=”判断相等，那么会返回未知值，而SELECT语句只会返回WHERE子句条件为真（TRUE）的结果，不会返回条件为假（FALSE）或未知的结果。

“真”、“假”以及与空值直接比较时所得到的“未知”共同组成了SQL的[[三值逻辑|three-valued logic]]。SQL所用的真值表与Kleene和Lukasiewicz三值逻辑的共同部分对应 (它们对内涵的定义不同，然而SQL没有定义这样的操作)。<ref name="Klein">{{cite journal|title=Null Values in Relational Databases and Sure Information Answers|isbn=3540365966|url=https://link.springer.com/chapter/10.1007/3-540-36596-6_7|date=2001-01-07|publisher=Springer, Berlin, Heidelberg|doi=10.1007/3-540-36596-6_7|language=en|pages=119–138|accessdate=2018-04-02|author=Klein Hans-Joachim|archive-date=2018-06-05|archive-url=https://web.archive.org/web/20180605042114/https://link.springer.com/chapter/10.1007%2F3-540-36596-6_7|dead-url=no}}</ref>

{| border="0"
|-
| valign="top" |
{| class="wikitable"
|-
! colspan=2 rowspan=2 | p AND q
! colspan=3 | p
|-
! style="width: 5em;" | 真
! style="width: 5em;" | 假
! style="width: 5em;" | 未知
|-
! rowspan=3 style="width: 1.2em;" | q || style="width: 5em;" | 真
| {{yes|真}}
| {{no|假}}
| {{Unk|未知}}
|-
! style="width: 5em;" | 假
| {{no|假}}
| {{no|假}}
| {{no|假}}
|-
! style="width: 5em;" | 未知
| {{Unk|未知}}
| {{no|假}}
| {{Unk|未知}}
|}
| valign="top" |
{| class="wikitable"
|-
! colspan=2 rowspan=2 | p OR q
! colspan=3 | p
|-
! style="width: 5em;" | 真
! style="width: 5em;" | 假
! style="width: 5em;" | 未知
|-
! rowspan=3 style="width: 1.2em;" | q || style="width: 5em;" | 真
| {{yes|真}}
| {{yes|真}}
| {{yes|真}}
|-
! style="width: 5em;" | 假
| {{yes|真}}
| {{no|假}}
| {{Unk|未知}}
|-
! style="width: 5em;" | 未知
| {{yes|真}}
| {{Unk|未知}}
| {{Unk|未知}}
|}
|}

{| border="0"
|-
| valign="top" |
{| class="wikitable"
|-
! colspan=2 rowspan=2 | p = q
! colspan=3 | p
|-
! style="width: 5em;" | 真
! style="width: 5em;" | 假
! style="width: 5em;" | 未知
|-
! rowspan=3 style="width: 1.2em;" | q || style="width: 5em;" | 真
| {{yes|真}}
| {{no|假}}
| {{Unk|未知}}
|-
! style="width: 5em;" | 假
| {{no|假}}
| {{yes|真}}
| {{Unk|未知}}
|-
! style="width: 5em;" | 未知
| {{Unk|未知}}
| {{Unk|未知}}
| {{Unk|未知}}
|}
| valign="top" |
{| class="wikitable"
|-
! style="width: 5em;" | q
! style="width: 5em;" | NOT q
|-
! 真
| {{no|假}}
|-
! 假
| {{yes|真}}
|-
! 未知
| {{Unk|未知}}
|}
|}

然而，由于在直接比较之外的处理，在SQL中对Null的语义解释存在争议。如上表所示，SQL中的两个NULL之间的直接等式比较（例如<code>NULL = NULL</code>）返回真值“未知”。这符合Null不具有值（并不是任何数据域的成员）的解释，而是缺失信息的占位符或“标记”。但是，在<code>UNION</code>和<code>INTERSECT</code>操作符的SQL规范中，两个空值不相等的原则在实际上标识了null。<ref name="Meyden"/> 因此，与涉及NULL的显式比较（例如上述<code>WHERE</code>子句中的那些）的操作不同，SQL中的这些集合运算可能产生表示不确定信息的结果。在Codd的1979年提案中（该提案基本被SQL92采纳），这种语义上的不一致被合理化了，他认为在集合操作中删除重复的操作发生在 "比检索操作求值中的相等验证更低的细节层次上"。<ref name="Klein"/> 然而，计算机科学教授Ron van der Meyden认为“SQL标准的不一致意味着不可能将任何直观的逻辑语义归结为SQL中的null处理。”<ref name="Meyden">Ron van der Meyden, "[http://books.google.com/books?id=gF0b85IuqQwC&pg=PA344 Logical approaches to incomplete information: a survey] {{Wayback|url=http://books.google.com/books?id=gF0b85IuqQwC&pg=PA344 |date=20140702081315 }}" in Chomicki, Jan; Saake, Gunter (Eds.) ''Logics for Databases and Information Systems'', Kluwer Academic Publishers ISBN 978-0-7923-8129-7, p. 344; [http://www.cse.unsw.edu.au/~meyden/research/indef-review.ps PS preprint] {{Wayback|url=http://www.cse.unsw.edu.au/~meyden/research/indef-review.ps |date=20160304035410 }} (note: page numbering differs in preprint from the published version)</ref>

另外，由于直接与空值比较会返回未知，因此SQL又提供了两个用于测试空值的语句：<code>IS NULL</code>和<code>IS NOT NULL</code>，前者用于判断是否为空，后者相反<ref name="SQL2003-Part2-Sec87">{{ cite book | last =ISO/IEC | title =ISO/IEC 9075-2:2003, "SQL/Foundation" | publisher =ISO/IEC | nopp =true }}</ref>。 SQL不明确支持[[全称量化]]，必须将其定义为否定[[存在量化]]。<ref>M. Negri, G. Pelagatti, L. Sbattella (1989) ''[http://portal.acm.org/citation.cfm?id=63224.68822&coll=GUIDE&dl=GUIDE Semantics and problems of universal quantification in SQL]{{Dead link}}''.</ref><ref>Fratarcangeli, Claudio (1991). ''Technique for universal quantification in SQL''. Retrieved from [http://portal.acm.org/citation.cfm?id=126482.126484&coll=GUIDE&dl=GUIDE&CFID=5934371&CFTOKEN=55309005 ACM.org.]</ref><ref name="kawash">Kawash, Jalal (2004) ''Complex quantification in Structured Query Language (SQL): a tutorial using relational calculus'' - Journal of Computers in Mathematics and Science Teaching ISSN 0731-9258 Volume 23, Issue 2, 2004 AACE Norfolk, Virginia. Retrieved from [http://www.thefreelibrary.com/Complex+quantification+in+Structured+Query+Language+(SQL):+a+tutorial...-a0119901477 Thefreelibrary.com] {{Wayback|url=http://www.thefreelibrary.com/Complex+quantification+in+Structured+Query+Language+(SQL):+a+tutorial...-a0119901477 |date=20101204092844 }}.</ref> 还有“<行值表达式> IS DISTINCT FROM <行值表达式>”插入比较运算符，除非两个操作数相等或两者都为NULL，否则返回TRUE。同样，<code>IS NOT DISTINCT FROM</code>定义为“NOT (<行值表达式> IS DISTINCT FROM <行值表达式>)”。[[SQL:1999]]还引入了<code>BOOLEAN</code>类型变量，根据标准也可以是未知值。实践中一些数据库系统（例如[[PostgreSQL]]）会把 implement the BOOLEAN Unknown as a BOOLEAN NULL.

== 数据操作 ==

[[資料操縱語言]]（DML）是SQL用于添加、更新和删除数据的子集：
* <code>[[插入 (SQL)|INSERT]]</code>添加行（正式名称为[[多元组|元组]]）到一个现有的表，例如：

<syntaxhighlight lang="sql">
INSERT INTO example
(field1, field2, field3)
VALUES
('test', 'N', NULL);
</syntaxhighlight>

* <code>[[Update|UPDATE]]</code>修改现有的表中一些行，例如：

<syntaxhighlight lang="sql">
UPDATE example
SET field1 = 'updated value'
WHERE field2 = 'N';
</syntaxhighlight>

* <code>[[删除 (SQL)|DELETE]]</code>从表中删除现有的行，如：

<syntaxhighlight lang="sql">
DELETE FROM example
WHERE field2 = 'N';
</syntaxhighlight>

* <code>[[Merge (SQL)|MERGE]]</code>用来合并多个表的数据。它结合了<code>INSERT</code>和<code>UPDATE</code>元素。它是在SQL:2003标准中定义的；在那之前，一些数据库也以不同的语法提供了相似的功能，又是叫做“{{le|upsert|upsert}}”。

<syntaxhighlight lang="sql">
MERGE INTO table_name USING table_reference ON (condition)
WHEN MATCHED THEN
UPDATE SET column1 = value1 [, column2 = value2 ...]
WHEN NOT MATCHED THEN
INSERT (column1 [, column2 ...]) VALUES (value1 [, value2 ...])
</syntaxhighlight>

== 事务控制 ==

如果数据库系统支持事务，那么可用以下语句：

* <code>START TRANSACTION</code>（或<code>BEGIN WORK</code>、<code>BEGIN TRANSACTION</code>，取决于具体数据库系统的规定）表示[[数据库事务]]开始。
* <code>SAVE TRANSACTION</code>（或<code>SAVEPOINT</code>）命令会记录事务本身的状态，即保存点。

<syntaxhighlight lang="sql">
CREATE TABLE tbl_1(id int);
INSERT INTO tbl_1(id) VALUES(1);
INSERT INTO tbl_1(id) VALUES(2);
COMMIT;
UPDATE tbl_1 SET id=200 WHERE id=1;
SAVEPOINT id_1upd;
UPDATE tbl_1 SET id=1000 WHERE id=2;
ROLLBACK to id_1upd;
SELECT id from tbl_1;
</syntaxhighlight>

* <code>[[Commit (SQL)|COMMIT]]</code>会令事务过程中进行数据修改正式生效。
* <code>[[Rollback (SQL)|ROLLBACK]]</code>会放弃上次<code>COMMIT</code>或<code>ROLLBACK</code>之后的修改，使数据恢复到前一状态。不过一旦<code>COMMIT</code>语句结束，事务所产生的修改将无法回退。

<code>COMMIT</code>和<code>ROLLBACK</code>会中止当前事务并释放锁。在没有<code>START TRANSACTION</code>或类似语句的情况下，SQL的语义与实现有关的。

下面例子展示了把一个账户的金额转移到另一个账户上面的过程。只要表示减少和增加的两个UPDATE语句中有一个失败，整个事务就会回退，更改也不会保存到数据库中。

<syntaxhighlight lang="sql">
START TRANSACTION;
UPDATE Account SET amount=amount-200 WHERE account_number=1234;
UPDATE Account SET amount=amount+200 WHERE account_number=2345;

IF ERRORS=0 COMMIT;
IF ERRORS<>0 ROLLBACK;
</syntaxhighlight>

== 数据定义 ==

[[資料定義語言]]（DDL）管理表和索引结构。DDL的最基本是<code>CREATE</code>、<code>ALTER</code>、<code>RENAME</code>、<code>DROP</code>和<code>TRUNCATE</code>语句：

* <code>[[資料定義語言#CREATE|CREATE]]</code>在数据库中创建一个对象（例如一张表），举例来说：

<syntaxhighlight lang="sql">
CREATE TABLE example(
column1 INTEGER,
column2 VARCHAR(50),
column3 DATE NOT NULL,
PRIMARY KEY (column1, column2)
);
</syntaxhighlight>

* <code>[[資料定義語言#ALTER|ALTER]]</code>以不同方式修改现有对象的结构，例如向现有的表或约束添加字段：

<syntaxhighlight lang="sql">
ALTER TABLE example ADD column4 NUMBER(3) NOT NULL;
</syntaxhighlight>

* <code>[[Truncate|TRUNCATE]]</code>以一种非常快速的方式删除表中的所有数据，删除表内的数据而不是表本身。这通常意味着后续的COMMIT操作, 即，它不能被回滚（与DELETE不同，数据不会为之后回滚而写入日志）。

<syntaxhighlight lang="sql">
TRUNCATE TABLE example;
</syntaxhighlight>

* <code>[[資料定義語言#DROP|DROP]]</code>删除数据库中的对象，通常无法挽回的，即，它不能被回滚，如：

<syntaxhighlight lang="sql">
DROP TABLE example;
</syntaxhighlight>

== 数据类型 ==

一张表中的每个字段都要定义该字段的类型。ANSI SQL包括下列数据类型：<ref name="SQL1992">{{cite journal | url = http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt | title = Information Technology: Database Language SQL | publisher = CMU | journal = | access-date = 2017-10-28 | archive-date = 2006-06-21 | archive-url = https://web.archive.org/web/20060621035823/http://www.contrib.andrew.cmu.edu/%7Eshadow/sql/sql1992.txt | dead-url = yes }} (proposed revised text of DIS 9075).</ref><ref>[[C. J. Date]] with [[Hugh Darwen]]: ''A Guide to the SQL standard : a users guide to the standard database language SQL, 4th ed.'', Addison Wesley, USA 1997, {{ISBN|978-0-201-96426-4}}</ref>

=== 字符串 ===

* <code>CHARACTER(<var>n</var>)</code>或<code>CHAR(<var>n</var>)</code>：宽度为<var>n</var>的定长字符串。如果内容长度不足，则以空格填充；
* <code>CHARACTER VARYING(<var>n</var>)</code>或<code>VARCHAR(<var>n</var>)</code>：最长为<var>n</var>个字符的可变宽度字符串；
* <code>NATIONAL CHARACTER(<var>n</var>)</code>或<code>NCHAR(<var>n</var>)</code>：支持国际字符集的固定宽度字符串；
* <code>NATIONAL CHARACTER VARYING(<var>n</var>)</code>或<code>NVARCHAR(<var>n</var>)</code>：可变宽度的<code>NCHAR</code>字符串；

=== Bit类型 ===
Bit是一种存储0或1的整数类型，一个Bit值需要一个字节。

* <code>BIT(<var>n</var>)</code>：<var>n</var>比特Bit类型
* <code>BIT VARYING(<var>n</var>)</code>：最大长度为<var>n</var>的Bit类型

=== 数值 ===

* 整数：包括<code>SMALLINT</code>、<code>INTEGER</code>和<code>BIGINT</code>，可表示的数据范围从小到大。
* 小数：包括<code>FLOAT</code>, <code>REAL</code>和<code>DOUBLE PRECISION</code>，可表示的数据范围从小到大。
* 定点数：包括<code>NUMERIC(长度, 精度)</code> or <code>DECIMAL(长度, 精度)</code>。

定点数类型包含两个要素：长度、精度。长度表示数字的最大个数，包括小数点左面和右面的数字。精度是非负整数，精度为零意味着数值只能是整数。以123.45为例，它的长度为5，精度为2。

SQL提供了除去小数部分、只保留整数部分的函数，叫做<code>TRUNC</code>（Informix、DB2、PostgreSQL、Oracle和MySQL）或<code>ROUND</code>（Informix、SQLite、Sybase、Oracle、PostgreSQL和Microsoft SQL Server）<ref name="Jones 127">Arie Jones, Ryan K. Stephens, Ronald R. Plew, Alex Kriegel, Robert F. Garrett (2005), ''SQL Functions Programmer's Reference''. Wiley, 127 pages.</ref>

=== 日期与时间 ===

* <code>DATE</code>：日期值（例如 <code>2011-05-03</code>）
* <code>TIME</code>：时间值（例如 <code>15:51:36</code>）。时间值的粒度通常是100纳秒。
* <code>TIME WITH TIME ZONE</code>或<code>TIMETZ</code>：与<code>TIME</code>相同，但包含时区信息。
* <code>TIMESTAMP</code>：[[时间戳]]，同时包含日期和时间（例如 <code>2011-05-03 15:51:36</code>）。
* <code>TIMESTAMP WITH TIME ZONE</code>或<code>TIMESTAMPTZ</code>：与<code>TIMESTAMP</code>相同，但包含时区信息。
* <code>INTERVAL</code>
SQL提供了多个在日期时间类型和字符串类型之间互相转换的函数，例如<code>TO_DATE</code>、<code>TO_TIME</code>、<code>TO_TIMESTAMP</code>等。可以通过<code>NOW</code>函数来获取数据库服务器的时间。

== 数据控制 ==

[[資料控制語言]] (Data Control Language, DCL) 授权的用户访问和操作的数据。
它的两个主要的语句是：

* <code>GRANT</code> 授权的一个或多个用户执行在一个对象上的一个操作或者一组操作。
* <code>REVOKE</code> 消除了授权，其可以是默认的授权。
例如:

<syntaxhighlight lang="sql">
GRANT SELECT, UPDATE
ON example
TO some_user, another_user;

REVOKE SELECT, UPDATE
ON example
FROM some_user, another_user;
</syntaxhighlight>

== 参考文献 ==
{{Reflist|30em}}

{{-}}
{{SQL}}
{{查询语言}}
{{Database}}
{{ISO standards}}

[[Category:SQL]]
[[Category:程序设计语言语法]]

SQL语法 - 版本历史

imported>Cewbot：​去除重複的轉換規則: 去除與公共轉換組重複的轉換規則 (1): 存在於轉換組 IT: zh-cn:数据库;zh-tw:資料庫

imported>Cewbot：去除重複的轉換規則: 去除與公共轉換組重複的轉換規則 (1): 存在於轉換組 IT: zh-cn:数据库;zh-tw:資料庫