本文共 28675 字，大约阅读时间需要 95 分钟。
目录
常用命令：
1、创建一个新的数据库 <testDB.db> ：$sqlite3 testDB.db
2、一旦数据库被创建，您就可以使用 SQLite 的 .databases 命令来检查它是否在数据库列表中;
3、.dump 命令
3.1、导出完整的数据库在一个文本文件中，如：$sqlite3 testDB.db .dump > testDB.sql
3.2、您可以通过简单的方式从生成的 testDB.sql 恢复，如：$sqlite3 testDB.db < testDB.sql
4、如果想附加一个现有的数据库 testDB.db，则 ATTACH DATABASE 语句将如：ATTACH DATABASE 'testDB.db' as 'TEST';
5、把 'currentDB' 从 testDB.db 中分离出来，如：sqlite> DETACH DATABASE 'currentDB';
6、创建了一个 COMPANY 表，ID 作为主键，NOT NULL 的约束表示在表中创建纪录时这些字段不能为 NULL：
sqlite> CREATE TABLE COMPANY( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), SALARY REAL);
7、 .tables 命令来验证表是否已成功创建，该命令用于列出附加数据库中的所有表：sqlite>.tables
8、.schema 命令得到表的完整信息，如：sqlite>.schema COMPANY
9、 COMPANY 表已存在数据库中，把它从数据库中删除，如：sqlite>DROP TABLE COMPANY;
10、INSERT INTO 语句用于向数据库的某个表中添加新的数据行：
sqlite> INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) ...> VALUES (1, 'Paul', 32, 'California', 20000.00 );
11、select从数据库表中获取数据：SELECT * FROM table_name;
12、有几个内置的函数，比如 avg()、sum()、count()，等等，执行被称为对一个表或一个特定的表列的汇总数据计算。
如：SELECT COUNT(*) AS "RECORDS" FROM COMPANY; SELECT sum(SALARY) AS 'SUM' FROM COMPANY;
13、日期表达式返回当前系统日期和时间值：sqlite>SELECT CURRENT_TIMESTAMP;
14、更新 ID 为 6 的客户地址：sqlite>UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;
15、删除 ID 为 7 的客户：sqlite> DELETE FROM COMPANY WHERE ID = 7;
16、 COMPANY 表中 AGE 以 2 开头的所有记录：sqlite>SELECT * FROM COMPANY WHERE AGE LIKE '2%';
17、显示 COMPANY 表中 AGE 以 2 开头的所有记录：sqlite>SELECT * FROM COMPANY WHERE AGE GLOB '2*';
18、从第三位开始提取 3 个记录：sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;
19、将结果按 SALARY 升序排序：sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;
20、将结果按 NAME 和 SALARY升序排序：sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;
21、将结果按 NAME 降序排序：sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;
22、DELETE TABLE 命令删除所有记录，建议使用 VACUUM 命令清除未使用的空间：sqlite> DELETE FROM COMPANY;
sqlite> VACUUM;
23、创建表时在特定的列名称上使用 AUTOINCREMENT 关键字实现该字段值的自动增加。关键字 AUTOINCREMENT 只能用于整型（INTEGER）字段：CREATE TABLE table_name(column1 INTEGER AUTOINCREMENT,...);
请访问 ，从 Windows 区下载预编译的二进制文件。
您需要下载 sqlite-shell-win32-*.zip 和 sqlite-dll-win32-*.zip 压缩文件。
创建文件夹 C:\>sqlite，并在此文件夹下解压上面两个压缩文件，将得到 sqlite3.def、sqlite3.dll 和 sqlite3.exe 文件。
添加 C:\>sqlite 到 PATH 环境变量，最后在命令提示符下，使用 sqlite3 命令，将显示如下结果。
C:\>sqlite3SQLite version 3.7.15.2 2013-01-09 11:53:05Enter ".help" for instructionsEnter SQL statements terminated with a ";"sqlite>
目前，几乎所有版本的 Linux 操作系统都附带 SQLite。所以，只要使用下面的命令来检查您的机器上是否已经安装了 SQLite。
$sqlite3SQLite version 3.7.15.2 2013-01-09 11:53:05Enter ".help" for instructionsEnter SQL statements terminated with a ";"sqlite>
如果没有看到上面的结果，那么就意味着没有在 Linux 机器上安装 SQLite。因此，让我们按照下面的步骤安装 SQLite：
请访问 ，从源代码区下载 sqlite-autoconf-*.tar.gz。
步骤如下：
$tar xvfz sqlite-autoconf-3071502.tar.gz$cd sqlite-autoconf-3071502$./configure --prefix=/usr/local$make$make install
如需获取可用的点命令的清单，可以在任何时候输入 ".help"。例如：
sqlite>.help
上面的命令会显示各种重要的 SQLite 点命令的列表，如下所示：
| 命令 | 描述 |
|---|---|
| .backup ?DB? FILE | 备份 DB 数据库（默认是 "main"）到 FILE 文件。 |
| .bail ON|OFF | 发生错误后停止。默认为 OFF。 |
| .databases | 列出附加数据库的名称和文件。 |
| .dump ?TABLE? | 以 SQL 文本格式转储数据库。如果指定了 TABLE 表，则只转储匹配 LIKE 模式的 TABLE 表。 |
| .echo ON|OFF | 开启或关闭 echo 命令。 |
| .exit | 退出 SQLite 提示符。 |
| .explain ON|OFF | 开启或关闭适合于 EXPLAIN 的输出模式。如果没有带参数，则为 EXPLAIN on，及开启 EXPLAIN。 |
| .header(s) ON|OFF | 开启或关闭头部显示。 |
| .help | 显示消息。 |
| .import FILE TABLE | 导入来自 FILE 文件的数据到 TABLE 表中。 |
| .indices ?TABLE? | 显示所有索引的名称。如果指定了 TABLE 表，则只显示匹配 LIKE 模式的 TABLE 表的索引。 |
| .load FILE ?ENTRY? | 加载一个扩展库。 |
| .log FILE|off | 开启或关闭日志。FILE 文件可以是 stderr（标准错误）/stdout（标准输出）。 |
| .mode MODE | 设置输出模式，MODE 可以是下列之一：
|
| .nullvalue STRING | 在 NULL 值的地方输出 STRING 字符串。 |
| .output FILENAME | 发送输出到 FILENAME 文件。 |
| .output stdout | 发送输出到屏幕。 |
| .print STRING... | 逐字地输出 STRING 字符串。 |
| .prompt MAIN CONTINUE | 替换标准提示符。 |
| .quit | 退出 SQLite 提示符。 |
| .read FILENAME | 执行 FILENAME 文件中的 SQL。 |
| .schema ?TABLE? | 显示 CREATE 语句。如果指定了 TABLE 表，则只显示匹配 LIKE 模式的 TABLE 表。 |
| .separator STRING | 改变输出模式和 .import 所使用的分隔符。 |
| .show | 显示各种设置的当前值。 |
| .stats ON|OFF | 开启或关闭统计。 |
| .tables ?PATTERN? | 列出匹配 LIKE 模式的表的名称。 |
| .timeout MS | 尝试打开锁定的表 MS 微秒。 |
| .width NUM NUM | 为 "column" 模式设置列宽度。 |
| .timer ON|OFF | 开启或关闭 CPU 定时器测量。 |
确保 sqlite> 提示符与点命令之间没有空格，否则将无法正常工作。
您可以使用下列的点命令来格式化输出为本教程下面所列出的格式：
sqlite>.header onsqlite>.mode columnsqlite>.timer onsqlite>
主表中保存数据库表的关键信息，并把它命名为 sqlite_master。如要查看表概要，可按如下操作：
sqlite>.schema sqlite_master
这将产生如下结果：
CREATE TABLE sqlite_master ( type text, name text, tbl_name text, rootpage integer, sql text);
每个存储在 SQLite 数据库中的值都具有以下存储类之一：
| 存储类 | 描述 |
|---|---|
| NULL | 值是一个 NULL 值。 |
| INTEGER | 值是一个带符号的整数，根据值的大小存储在 1、2、3、4、6 或 8 字节中。 |
| REAL | 值是一个浮点值，存储为 8 字节的 IEEE 浮点数字。 |
| TEXT | 值是一个文本字符串，使用数据库编码（UTF-8、UTF-16BE 或 UTF-16LE）存储。 |
| BLOB | 值是一个 blob 数据，完全根据它的输入存储。 |
SQLite 的存储类稍微比数据类型更普遍。INTEGER 存储类，例如，包含 6 种不同的不同长度的整数数据类型。
SQLite 支持列上的类型 affinity 概念。任何列仍然可以存储任何类型的数据，但列的首选存储类是它的 affinity。在 SQLite3 数据库中，每个表的列分配为以下类型的 affinity 之一：
| Affinity | 描述 |
|---|---|
| TEXT | 该列使用存储类 NULL、TEXT 或 BLOB 存储所有数据。 |
| NUMERIC | 该列可以包含使用所有五个存储类的值。 |
| INTEGER | 与带有 NUMERIC affinity 的列相同，在 CAST 表达式中带有异常。 |
| REAL | 与带有 NUMERIC affinity 的列相似，不同的是，它会强制把整数值转换为浮点表示。 |
| NONE | 带有 affinity NONE 的列，不会优先使用哪个存储类，也不会尝试把数据从一个存储类强制转换为另一个存储类。 |
下表列出了当创建 SQLite3 表时可使用的各种数据类型名称，同时也显示了相应的应用 Affinity：
| 数据类型 | Affinity |
|---|---|
| INTEGER |
| TEXT |
| NONE |
| REAL |
| NUMERIC |
SQLite 没有单独的 Boolean 存储类。相反，布尔值被存储为整数 0（false）和 1（true）。
SQLite 没有一个单独的用于存储日期和/或时间的存储类，但 SQLite 能够把日期和时间存储为 TEXT、REAL 或 INTEGER 值。
| 存储类 | 日期格式 |
|---|---|
| TEXT | 格式为 "YYYY-MM-DD HH:MM:SS.SSS" 的日期。 |
| REAL | 从公元前 4714 年 11 月 24 日格林尼治时间的正午开始算起的天数。 |
| INTEGER | 从 1970-01-01 00:00:00 UTC 算起的秒数。 |
您可以以任何上述格式来存储日期和时间，并且可以使用内置的日期和时间函数来自由转换不同格式。
sqlite3 命令的基本语法如下：
$sqlite3 DatabaseName.db
通常情况下，数据库名称在 RDBMS 内应该是唯一的。
如果您想创建一个新的数据库 <testDB.db>，SQLITE3 语句如下所示：
$sqlite3 testDB.dbSQLite version 3.7.15.2 2013-01-09 11:53:05Enter ".help" for instructionsEnter SQL statements terminated with a ";"sqlite>
上面的命令将在当前目录下创建一个文件 testDB.db。该文件将被 SQLite 引擎用作数据库。如果您已经注意到 sqlite3 命令在成功创建数据库文件之后，将提供一个 sqlite> 提示符。
一旦数据库被创建，您就可以使用 SQLite 的 .databases 命令来检查它是否在数据库列表中，如下所示：
|
|
您可以使用 SQLite .quit 命令退出 sqlite 提示符，如下所示：
|
|
您可以在命令提示符中使用 SQLite .dump 点命令来导出完整的数据库在一个文本文件中，如下所示：
|
|
上面的命令将转换整个 testDB.db 数据库的内容到 SQLite 的语句中，并将其转储到 ASCII 文本文件 testDB.sql 中。您可以通过简单的方式从生成的 testDB.sql 恢复，如下所示：
|
|
假设这样一种情况，当在同一时间有多个数据库可用，您想使用其中的任何一个。SQLite 的 ATTACH DTABASE 语句是用来选择一个特定的数据库，使用该命令后，所有的 SQLite 语句将在附加的数据库下执行。
SQLite 的 ATTACH DATABASE 语句的基本语法如下：
ATTACH DATABASE 'DatabaseName' As 'Alias-Name';
如果想附加一个现有的数据库 testDB.db，则 ATTACH DATABASE 语句将如下所示：
sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';
使用 SQLite .database 命令来显示附加的数据库。
| 1 2 3 4 5 |
|
数据库名称 main 和 temp 被保留用于主数据库和存储临时表及其他临时数据对象的数据库。这两个数据库名称可用于每个数据库连接，且不应该被用于附加，否则将得到一个警告消息，如下所示：
| 1 2 3 4 |
|
SQLite的 DETACH DTABASE 语句是用来把命名数据库从一个数据库连接分离和游离出来，连接是之前使用 ATTACH 语句附加的。如果同一个数据库文件已经被附加上多个别名，DETACH 命令将只断开给定名称的连接，而其余的仍然有效。您无法分离 main 或 temp 数据库。
如果数据库是在内存中或者是临时数据库，则该数据库将被摧毁，且内容将会丢失。
SQLite 的 DETACH DATABASE 'Alias-Name' 语句的基本语法如下：
| 1 |
|
在这里，'Alias-Name' 与您之前使用 ATTACH 语句附加数据库时所用到的别名相同。
假设在前面的章节中您已经创建了一个数据库，并给它附加了 'test' 和 'currentDB'，使用 .database 命令，我们可以看到：
| 1 2 3 4 5 6 |
|
现在，让我们尝试把 'currentDB' 从 testDB.db 中分离出来，如下所示：
| 1 |
|
现在，如果检查当前附加的数据库，您会发现，testDB.db 仍与 'test' 和 'main' 保持连接。
| 1 2 3 4 5 |
|
CREATE TABLE 语句的基本语法如下：
| 1 2 3 4 5 6 7 |
|
CREATE TABLE 是告诉数据库系统创建一个新表的关键字。CREATE TABLE 语句后跟着表的唯一的名称或标识。您也可以选择指定带有 table_name 的database_name。
下面是一个实例，它创建了一个 COMPANY 表，ID 作为主键，NOT NULL 的约束表示在表中创建纪录时这些字段不能为 NULL：
sqlite> CREATE TABLE COMPANY( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), SALARY REAL);
使用 SQLIte 命令中的 .tables 命令来验证表是否已成功创建，该命令用于列出附加数据库中的所有表。
sqlite> .tablesCOMPANY TEST.COMPANY
在这里，可以看到 COMPANY 表出现两次，一个是主数据库的 COMPANY 表，一个是为 testDB.db 创建的 'test' 别名的 test.COMPANY 表。您可以使用 SQLite .schema 命令得到表的完整信息，如下所示：
sqlite>.schema COMPANYCREATE TABLE COMPANY( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), SALARY REAL);
SQLite 的 INSERT INTO 语句用于向数据库的某个表中添加新的数据行。
INSERT INTO 语句有两种基本语法，如下所示：
| 1 2 |
|
在这里，column1, column2,...columnN 是要插入数据的表中的列的名称。
如果要为表中的所有列添加值，您也可以不需要在 SQLite 查询中指定列名称。但要确保值的顺序与列在表中的顺序一致。SQLite 的 INSERT INTO 语法如下：
| 1 |
|
假设您已经在 testDB.db 中创建了 COMPANY表，如下所示：
sqlite> CREATE TABLE COMPANY( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), SALARY REAL);
现在，下面的语句将在 COMPANY 表中创建六个记录：
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)VALUES (1, 'Paul', 32, 'California', 20000.00 );
您也可以使用第二种语法在 COMPANY 表中创建一个记录，如下所示：
INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );
上面的所有语句将在 COMPANY 表中创建下列记录。
sqlite> SELECT * FROM COMPANY;ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.0Run Time: real 0.006 user 0.000000 sys 0.000000
SQLite 的 SELECT 语句用于从 SQLite 数据库表中获取数据，以结果表的形式返回数据。这些结果表也被称为结果集。
SQLite 的 SELECT 语句的基本语法如下：
SELECT column1, column2, columnN FROM table_name;
在这里，column1, column2...是表的字段，他们的值即是您要获取的。如果您想获取所有可用的字段，那么可以使用下面的语法：
SELECT * FROM table_name;
下面是一个实例，使用 SELECT 语句获取并显示所有这些记录。在这里，前三个命令被用来设置正确格式化的输出。
sqlite>.header onsqlite>.mode columnsqlite> SELECT * FROM COMPANY;
有时，由于要显示的列的默认宽度导致 .mode column，这种情况下，输出被截断。此时，您可以使用 .width num, num.... 命令设置显示列的宽度，如下所示：
sqlite>.width 10, 20, 10sqlite>SELECT * FROM COMPANY;
上面的 .width 命令设置第一列的宽度为 10，第二列的宽度为 20，第三列的宽度为 10。因此上述 SELECT 语句将得到以下结果：
ID NAME AGE ADDRESS SALARY---------- -------------------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.0
因为所有的点命令只在 SQLite 提示符中可用，所以当您进行带有 SQLite 的编程时，您要使用下面的带有 sqlite_master 表的 SELECT 语句来列出所有在数据库中创建的表：
sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';
假设在 testDB.db 中已经存在唯一的 COMPANY 表，则将产生以下结果：
tbl_name----------COMPANY
您可以列出关于 COMPANY 表的完整信息，如下所示：
sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';
这些表达式用来执行查询中的任何数学运算。语法如下：
SELECT numerical_expression as OPERATION_NAME[FROM table_name WHERE CONDITION] ;
在这里，numerical_expression 用于数学表达式或任何公式。下面的实例演示了 SQLite 数值表达式的用法：
sqlite> SELECT (15 + 6) AS ADDITIONADDITION = 21
有几个内置的函数，比如 avg()、sum()、count()，等等，执行被称为对一个表或一个特定的表列的汇总数据计算。
sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY;RECORDS = 7sqlite> SELECT sum(SALARY) AS 'SUM' FROM COMPANY; SUM = 260000.0Run Time: real 0.001 user 0.000000 sys 0.000000
日期表达式返回当前系统日期和时间值，这些表达式将被用于各种数据操作。
sqlite> select current_timestamp;current_timestamp = 2018-11-23 03:30:21 /*我们位于东八区，h=h+8*/Run Time: real 0.000 user 0.000000 sys 0.000000
下面的 SELECT 语句列出了 AGE 不为 NULL 的所有记录，结果显示所有的记录，意味着没有一个记录的 AGE 等于 NULL：
|
|
下面的 SELECT 语句列出了 NAME 以 'Ki' 开始的所有记录，'Ki' 之后的字符不做限制：
|
|
下面的 SELECT 语句列出了 NAME 以 'Ki' 开始的所有记录，'Ki' 之后的字符不做限制：
|
|
下面的 SELECT 语句列出了 AGE 的值为 25 或 27 的所有记录：
| 1 2 3 4 5 6 |
|
下面的 SELECT 语句列出了 AGE 的值既不是 25 也不是 27 的所有记录：
| 1 2 3 4 5 6 7 |
|
下面的 SELECT 语句列出了 AGE 的值在 25 与 27 之间的所有记录：
| 1 2 3 4 5 6 |
|
下面的 SELECT 语句使用 SQL 子查询，子查询查找 SALARY > 65000 的带有 AGE 字段的所有记录，后边的 WHERE 子句与 EXISTS 运算符一起使用，列出了外查询中的 AGE 存在于子查询返回的结果中的所有记录：
| 1 2 3 4 5 6 7 8 9 10 11 |
|
下面的 SELECT 语句使用 SQL 子查询，子查询查找 SALARY > 65000 的带有 AGE 字段的所有记录，后边的 WHERE 子句与 > 运算符一起使用，列出了外查询中的 AGE 大于子查询返回的结果中的年龄的所有记录：
| 1 2 3 4 5 |
|
SQLite 的 UPDATE 查询用于修改表中已有的记录。可以使用带有 WHERE 子句的 UPDATE 查询来更新选定行，否则所有的行都会被更新。
带有 WHERE 子句的 UPDATE 查询的基本语法如下：
UPDATE table_nameSET column1 = value1, column2 = value2...., columnN = valueNWHERE [condition];
假设 COMPANY 表有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.0
下面是一个实例，它会更新 ID 为 6 的客户地址：
sqlite> UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;
现在，COMPANY 表有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 Texas 45000.07 James 24 Houston 10000.0
如果您想修改 COMPANY 表中 ADDRESS 和 SALARY 列的所有值，则不需要使用 WHERE 子句，UPDATE 查询如下：
sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;
现在，COMPANY 表有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 Texas 20000.02 Allen 25 Texas 20000.03 Teddy 23 Texas 20000.04 Mark 25 Texas 20000.05 David 27 Texas 20000.06 Kim 22 Texas 20000.07 James 24 Texas 20000.0
SQLite 的 DELETE 查询用于删除表中已有的记录。可以使用带有 WHERE 子句的 DELETE 查询来删除选定行，否则所有的记录都会被删除。
带有 WHERE 子句的 DELETE 查询的基本语法如下：
DELETE FROM table_nameWHERE [condition];
您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。
下面是一个实例，它会删除 ID 为 7 的客户：
sqlite> DELETE FROM COMPANY WHERE ID = 7;
如果您想要从 COMPANY 表中删除所有记录，则不需要使用 WHERE 子句，DELETE 查询如下：
sqlite> DELETE FROM COMPANY;
现在，COMPANY 表中没有任何的记录，因为所有的记录已经通过 DELETE 语句删除。
SQLite 的 LIKE 运算符是用来匹配通配符指定模式的文本值。如果搜索表达式与模式表达式匹配，LIKE 运算符将返回真（true），也就是 1。这里有两个通配符与 LIKE 运算符一起使用：
百分号 （%）
下划线 （_）
百分号（%）代表零个、一个或多个数字或字符。下划线（_）代表一个单一的数字或字符。这些符号可以被组合使用。
% 和 _ 的基本语法如下：
SELECT FROM table_nameWHERE column LIKE 'XXXX%' or SELECT FROM table_nameWHERE column LIKE '%XXXX%' or SELECT FROM table_nameWHERE column LIKE 'XXXX_' or SELECT FROM table_nameWHERE column LIKE '_XXXX' or SELECT FROM table_nameWHERE column LIKE '_XXXX_'
您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。在这里，XXXX 可以是任何数字或字符串值。
下面一些实例演示了 带有 '%' 和 '_' 运算符的 LIKE 子句不同的地方：
| 语句 | 描述 |
|---|---|
| WHERE SALARY LIKE '200%' | 查找以 200 开头的任意值 |
| WHERE SALARY LIKE '%200%' | 查找任意位置包含 200 的任意值 |
| WHERE SALARY LIKE '_00%' | 查找第二位和第三位为 00 的任意值 |
| WHERE SALARY LIKE '2_%_%' | 查找以 2 开头，且长度至少为 3 个字符的任意值 |
| WHERE SALARY LIKE '%2' | 查找以 2 结尾的任意值 |
| WHERE SALARY LIKE '_2%3' | 查找第二位为 2，且以 3 结尾的任意值 |
| WHERE SALARY LIKE '2___3' | 查找长度为 5 位数，且以 2 开头以 3 结尾的任意值 |
下面是一个实例，它显示 COMPANY 表中 AGE 以 2 开头的所有记录：
sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';
下面是一个实例，它显示 COMPANY 表中 ADDRESS 文本里包含一个连字符（-）的所有记录：
sqlite> SELECT * FROM COMPANY WHERE ADDRESS LIKE '%-%';
这将产生以下结果：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------4 Mark 25 Rich-Mond 65000.06 Kim 22 South-Hall 45000.0
SQLite 的 GLOB 运算符是用来匹配通配符指定模式的文本值。如果搜索表达式与模式表达式匹配，GLOB 运算符将返回真（true），也就是 1。与 LIKE 运算符不同的是，GLOB 是大小写敏感的，对于下面的通配符，它遵循 UNIX 的语法。
星号 （*）
问号 （?）
星号（*）代表零个、一个或多个数字或字符。问号（?）代表一个单一的数字或字符。这些符号可以被组合使用。
下面一些实例演示了 带有 '*' 和 '?' 运算符的 GLOB 子句不同的地方：
| 语句 | 描述 |
|---|---|
| WHERE SALARY GLOB '200*' | 查找以 200 开头的任意值 |
| WHERE SALARY GLOB '*200*' | 查找任意位置包含 200 的任意值 |
| WHERE SALARY GLOB '?00*' | 查找第二位和第三位为 00 的任意值 |
| WHERE SALARY GLOB '2??' | 查找以 2 开头，且长度至少为 3 个字符的任意值 |
| WHERE SALARY GLOB '*2' | 查找以 2 结尾的任意值 |
| WHERE SALARY GLOB '?2*3' | 查找第二位为 2，且以 3 结尾的任意值 |
| WHERE SALARY GLOB '2???3' | 查找长度为 5 位数，且以 2 开头以 3 结尾的任意值 |
下面是一个实例，它显示 COMPANY 表中 AGE 以 2 开头的所有记录：
sqlite> SELECT * FROM COMPANY WHERE AGE GLOB '2*';
下面是一个实例，它显示 COMPANY 表中 ADDRESS 文本里包含一个连字符（-）的所有记录：
sqlite> SELECT * FROM COMPANY WHERE ADDRESS GLOB '*-*';
SQLite 的 LIMIT 子句用于限制由 SELECT 语句返回的数据数量。
带有 LIMIT 子句的 SELECT 语句的基本语法如下：
SELECT column1, column2, columnNFROM table_nameLIMIT [no of rows]
下面是 LIMIT 子句与 OFFSET 子句一起使用时的语法：
SELECT column1, column2, columnNFROM table_nameLIMIT [no of rows] OFFSET [row num]
SQLite 引擎将返回从下一行开始直到给定的 OFFSET 为止的所有行，如下面的最后一个实例所示。
它限制了您想要从表中提取的行数：
sqlite> SELECT * FROM COMPANY LIMIT 6;
但是，在某些情况下，可能需要从一个特定的偏移开始提取记录。下面是一个实例，从第三位开始提取 3 个记录：
sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;
这将产生以下结果：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------3 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.0
SQLite 的 ORDER BY 子句是用来基于一个或多个列按升序或降序顺序排列数据。
ORDER BY 子句的基本语法如下：
| 1 2 3 4 |
|
您可以在 ORDER BY 子句中使用多个列。确保您使用的排序列在列清单中。
将结果按 SALARY 升序排序：
sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;
将结果按 NAME 和 SALARY 升序排序：
sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;
会将结果按 NAME 降序排序：
sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;
SQLite 的 GROUP BY 子句用于与 SELECT 语句一起使用，来对相同的数据进行分组。
在 SELECT 语句中，GROUP BY 子句放在 WHERE 子句之后，放在 ORDER BY 子句之前。
下面给出了 GROUP BY 子句的基本语法。GROUP BY 子句必须放在 WHERE 子句中的条件之后，必须放在 ORDER BY 子句之前。
| 1 2 3 4 5 |
|
您可以在 GROUP BY 子句中使用多个列。确保您使用的分组列在列清单中。
假设 COMPANY 表有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.0
如果您想了解每个客户的工资总额，则可使用 GROUP BY 查询，如下所示：
sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;
这将产生以下结果：
NAME SUM(SALARY)---------- -----------Allen 15000.0David 85000.0James 10000.0Kim 45000.0Mark 65000.0Paul 20000.0Teddy 20000.0
现在，让我们使用下面的 INSERT 语句在 COMPANY 表中另外创建三个记录：
INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );
现在，我们的表具有重复名称的记录，如下所示：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.08 Paul 24 Houston 20000.09 James 44 Norway 5000.010 James 45 Texas 5000.0
让我们用同样的 GROUP BY 语句来对所有记录按 NAME 列进行分组，如下所示：
sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;
这将产生以下结果：
NAME SUM(SALARY)---------- -----------Allen 15000David 85000James 20000Kim 45000Mark 65000Paul 40000Teddy 20000
让我们把 ORDER BY 子句与 GROUP BY 子句一起使用，如下所示：
sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;
这将产生以下结果：
NAME SUM(SALARY)---------- -----------Teddy 20000Paul 40000Mark 65000Kim 45000James 20000David 85000Allen 15000
HAVING 子句允许指定条件来过滤将出现在最终结果中的分组结果。
WHERE 子句在所选列上设置条件，而 HAVING 子句则在由 GROUP BY 子句创建的分组上设置条件。
下面是 HAVING 子句在 SELECT 查询中的位置：
|
|
在一个查询中，HAVING 子句必须放在 GROUP BY 子句之后，必须放在 ORDER BY 子句之前。下面是包含 HAVING 子句的 SELECT 语句的语法：
|
|
将显示名称计数小于 2 的所有记录：
sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;
这将产生以下结果：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------2 Allen 25 Texas 150005 David 27 Texas 850006 Kim 22 South-Hall 450004 Mark 25 Rich-Mond 650003 Teddy 23 Norway 20000
下面是一个实例，它将显示名称计数大于 2 的所有记录：
sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;
这将产生以下结果：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------10 James 45 Texas 5000
SQLite 的 DISTINCT 关键字与 SELECT 语句一起使用，来消除所有重复的记录，并只获取唯一一次记录。
有可能出现一种情况，在一个表中有多个重复的记录。当提取这样的记录时，DISTINCT 关键字就显得特别有意义，它只获取唯一一次记录，而不是获取重复记录。
用于消除重复记录的 DISTINCT 关键字的基本语法如下：
| 1 2 3 |
|
假设 COMPANY 表有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.08 Paul 24 Houston 20000.09 James 44 Norway 5000.010 James 45 Texas 5000.0
首先，让我们来看看下面的 SELECT 查询，它将返回重复的工资记录：
sqlite> SELECT name FROM COMPANY;
现在，让我们在上述的 SELECT 查询中使用 DISTINCT 关键字：
sqlite> SELECT DISTINCT name FROM COMPANY;
这将产生以下结果，没有任何重复的条目：
NAME----------PaulAllenTeddyMarkDavidKimJames
事务（Transaction）是一个对数据库执行工作单元。事务（Transaction）是以逻辑顺序完成的工作单位或序列，可以是由用户手动操作完成，也可以是由某种数据库程序自动完成。
事务（Transaction）是指一个或多个更改数据库的扩展。例如，如果您正在创建一个记录或者更新一个记录或者从表中删除一个记录，那么您正在该表上执行事务。重要的是要控制事务以确保数据的完整性和处理数据库错误。
实际上，您可以把许多的 SQLite 查询联合成一组，把所有这些放在一起作为事务的一部分进行执行。
事务（Transaction）具有以下四个标准属性，通常根据首字母缩写为 ACID：
原子性（Atomicity）：确保工作单位内的所有操作都成功完成，否则，事务会在出现故障时终止，之前的操作也会回滚到以前的状态。
一致性（Consistency)：确保数据库在成功提交的事务上正确地改变状态。
隔离性（Isolation）：使事务操作相互独立和透明。
持久性（Durability）：确保已提交事务的结果或效果在系统发生故障的情况下仍然存在。
使用下面的命令来控制事务：
BEGIN TRANSACTION：开始事务处理。
COMMIT：保存更改，或者可以使用 END TRANSACTION 命令。
ROLLBACK：回滚所做的更改。
事务控制命令只与 DML 命令 INSERT、UPDATE 和 DELETE 一起使用。他们不能在创建表或删除表时使用，因为这些操作在数据库中是自动提交的。
事务（Transaction）可以使用 BEGIN TRANSACTION 命令或简单的 BEGIN 命令来启动。此类事务通常会持续执行下去，直到遇到下一个 COMMIT 或 ROLLBACK 命令。不过在数据库关闭或发生错误时，事务处理也会回滚。以下是启动一个事务的简单语法：
|
|
COMMIT 命令是用于把事务调用的更改保存到数据库中的事务命令。
COMMIT 命令把自上次 COMMIT 或 ROLLBACK 命令以来的所有事务保存到数据库。
COMMIT 命令的语法如下：
|
|
ROLLBACK 命令是用于撤消尚未保存到数据库的事务的事务命令。
ROLLBACK 命令只能用于撤销自上次发出 COMMIT 或 ROLLBACK 命令以来的事务。
ROLLBACK 命令的语法如下：
|
|
假设 COMPANY 表有以下记录：
| 1 2 3 4 5 6 7 8 9 |
|
现在，让我们开始一个事务，并从表中删除 age = 25 的记录，最后，我们使用 ROLLBACK 命令撤消所有的更改。
sqlite> BEGIN;sqlite> DELETE FROM COMPANY WHERE AGE = 25;sqlite> ROLLBACK;
检查 COMPANY 表，仍然有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.02 Allen 25 Texas 15000.03 Teddy 23 Norway 20000.04 Mark 25 Rich-Mond 65000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.0
现在，让我们开始另一个事务，从表中删除 age = 25 的记录，最后我们使用 COMMIT 命令提交所有的更改。
sqlite> BEGIN;sqlite> DELETE FROM COMPANY WHERE AGE = 25;sqlite> COMMIT;
检查 COMPANY 表，有以下记录：
ID NAME AGE ADDRESS SALARY---------- ---------- ---------- ---------- ----------1 Paul 32 California 20000.03 Teddy 23 Norway 20000.05 David 27 Texas 85000.06 Kim 22 South-Hall 45000.07 James 24 Houston 10000.0
转载地址：http://rhzwi.baihongyu.com/