SELECT
, INSERT
, UPDATE
, DELETE
SELECT
句法SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT] [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS] [HIGH_PRIORITY] [DISTINCT | DISTINCTROW | ALL] select_expression,... [INTO {OUTFILE | DUMPFILE} 'file_name' export_options] [FROM table_references [WHERE where_definition] [GROUP BY {unsigned_integer | col_name | formula} [ASC | DESC], ...] [HAVING where_definition] [ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] ,...] [LIMIT [offset,] rows | rows OFFSET offset] [PROCEDURE procedure_name(argument_list)] [FOR UPDATE | LOCK IN SHARE MODE]]
SELECT
用于检索从一个或多个表中选取出的行。select_expression
表示你希望检索的列。 SELECT
也可以被用于检索没有引用任何表的计算列。例如:
mysql> SELECT 1 + 1; -> 2
所有使用的关键词必须严格以上面所显示的次序被给出。举例来说,一个 HAVING
子句必须出现在 GROUP BY
子句后,在 ORDER BY
字句之前。
SELECT
表达式可以使用 AS
指定一个别名。别名可以当作表达式的列名,用于 ORDER BY
或 HAVING
子句中。例如: mysql> SELECT CONCAT(last_name,', ',first_name) AS full_name FROM mytable ORDER BY full_name;
WHERE
子句中使用一个列别名是不允许的,因为,当 WHERE
子句被执行时,列值可能还没有被计算确定。
FROM table_references
子句表示从哪个表中检索记录行。如果你命名超过超过一个表,并执行一个 join。对于 join 句法的信息。对于每个引用的表,你可以顺便指定一个别名。 table_name [[AS] alias] [[USE INDEX (key_list)] | [IGNORE INDEX (key_list)] | FORCE INDEX (key_list)]]到 MySQL 3.23.12 时,当 MySQL 在从一个表中检索信息时,你可以提示它选择了哪一个索引。如果
EXPLAIN
显示 MySQL 使用了可能的索引列表中错误的索引,这个特性将是很有用的。通过指定 USE INDEX (key_list)
,你可以告诉 MySQL 使用可能的索引中最合适的一个索引在表中查找记录行。可选的二选一句法 IGNORE INDEX (key_list)
可被用于告诉 MySQL 不使用特定的索引。 在 MySQL 4.0.9 中,你也可以使用 FORCE INDEX
。这个有点像 USE INDEX (key_list)
,但是有了这个附加物,一个表的扫描被采用时,将会有非常大的开销。换句法说,如果没有方法使用给定的索引在表中寻找记录行,这时表扫描才会被使用。 USE/IGNORE/FORCE KEY
分别是 USE/IGNORE/FORCE INDEX
的同义词。
tbl_name
(在当前的数据库中) 引用一张表,或以 dbname.tbl_name
明确地指定其个数据。你要以以 col_name
、tbl_name.col_name
或 db_name.tbl_name.col_name
引用一个列。 你不需要在一个 SELECT
语句中引用的列前指定 tbl_name
或 db_name.tbl_name
前缀,除非引用列存在二义性。对于有歧义的列引用需要更加显式的列引用格式。
tbl_name [AS] alias_name
给以别名: mysql> SELECT t1.name, t2.salary FROM employee AS t1, info AS t2 -> WHERE t1.name = t2.name; mysql> SELECT t1.name, t2.salary FROM employee t1, info t2 -> WHERE t1.name = t2.name;
ORDER BY
和 GROUP BY
子句中使用列名、列的别名或列的位置来引用。列的位置从 1 开始: mysql> SELECT college, region, seed FROM tournament -> ORDER BY region, seed; mysql> SELECT college, region AS r, seed AS s FROM tournament -> ORDER BY r, s; mysql> SELECT college, region, seed FROM tournament -> ORDER BY 2, 3;为了以倒序排序,可以在 ORDER BY 子句中用于排序的列名后添加一个
DESC
(递减 descending)关键词。缺省为升序排序;这也可以通过使用 ASC
关键词明确指定。
WHERE
子句中可以使用 MySQL 支持的任何函数。
HAVING
子句可以引用任何列或在 select_expression
中命名的别名。它在最后被执行,仅仅就在项目被送到客户端之前,不进行任何优化。所以不要对应该放在 WHERE
子句中的项目使用 HAVING
。举例来说,不要写成这样: mysql> SELECT col_name FROM tbl_name HAVING col_name > 0;用这个代替:
mysql> SELECT col_name FROM tbl_name WHERE col_name > 0;在 MySQL 3.22.5 或以后的版本中,你也可以这下面的形式书写一个查询:
mysql> SELECT user,MAX(salary) FROM users -> GROUP BY user HAVING MAX(salary)>10;在较早的 MySQL 版本中,你可能需要用下面的代替了:
mysql> SELECT user,MAX(salary) AS sum FROM users -> group by user HAVING sum>10;
DISTINCT
、DISTINCTROW
和 ALL
选项指定重复的记录行是否被返回。缺省为 (ALL
),返回所有匹配的记录行。DISTINCT
和 DISTINCTROW
是同义词,它指定结果集重复的记录行被排除。
SQL_
开头、STRAIGHT_JOIN
和 HIGH_PRIORITY
的选项是 MySQL 对 ANSI SQL 的扩展。
HIGH_PRIORITY
将给 SELECT
语句比更新一个表有更高的优先级。你只应该对非常快的或需要立即返回的查询使用它。 如果一个表已被读锁定,甚至是有一个更新语句正在等待表的释放,一个 SELECT HIGH_PRIORITY
查询也将会执行。
SQL_BIG_RESULT
可以与 GROUP BY
或 DISTINCT
一同使用,以告诉优化器结果集将有许多记录行。在这种情况下,如果需要,MySQL 将直接使用基于磁盘的临时表。同样的,在这种情况下,MySQL 更愿意以 GROUP BY
上的一个键进行排序而不是建立一个临时表。
SQL_BUFFER_RESULT
将强制把结果放入一个临时表。这将有助于 MySQL 尽早地释放表和有助于将大的结果集传送到客户端。
SQL_SMALL_RESULT
, 一个 MySQL 特有的选项,可以与 GROUP BY
或 DISTINCT
一同使用,以告诉优化器结果集将会很小。在这种情况下,MySQL 将使用快速的临时表存储结果表,而不是使用排序。在 MySQL 3.23 中,这通常是不需要的。
SQL_CALC_FOUND_ROWS
(版本 4.0.0 和更新的) 告诉 MySQL 计算在不考虑 LIMIT
子句时结果集中将有多少行记录。然后使用 SELECT FOUND_ROWS()
可以检索到记录行的数目。 请注意,在早于 4.1.0 的版本中,LIMIT 0
是不工作的,它将被优化为立即返回(结果集的记录数为 0)。
QUERY_CACHE_TYPE=2
(DEMAND
),SQL_CACHE
告诉 MySQL 将存储查询结果放入查询高速缓存内。
SQL_NO_CACHE
告诉 MySQL 不允许将查询结果存储到查询缓存内。
GROUP BY
,输出记录将会依照 GROUP BY
列进行排序,就好像你对所有 GROUP BY
中的所有字段使用了 ORDER BY
。MySQL 扩展了 GROUP BY
的用法,所以你也可以在 GROUP BY
中指定 ASC
和 DESC
: SELECT a,COUNT(b) FROM test_table GROUP BY a DESC
GROUP BY
用法允许你选取没有在 GROUP BY
子句中提及的字段。如果你的查询没有得到你所期望的结果,请查看 GROUP BY
中的描述。
STRAIGHT_JOIN
强制优化器以表在 FROM
子句中列出的顺序联结。如果优化器以一个非优化的次序联结各表,你可以使用它来加速一个查询。
LIMIT
子句可以被用于强制 SELECT
语句返回指定的记录数。LIMIT
接受一个或两个数字参数。参数必须是一个整数常量。如果给定两个参数,第一个参数指定第一个返回记录行的偏移量,第二个参数指定返回记录行的最大数目。初始记录行的偏移量是 0(而不是 1): 为了与 PostgreSQL 兼容,MySQL 也支持句法: LIMIT # OFFSET #
。 mysql> SELECT * FROM table LIMIT 5,10; # 检索记录行 6-15为了检索从某一个偏移量到记录集的结束所有的记录行,可以指定第二个参数为 -1:
mysql> SELECT * FROM table LIMIT 95,-1; # 检索记录行 96-last.如果只给定一个参数,它表示返回最大的记录行数目:
mysql> SELECT * FROM table LIMIT 5; # 检索前 5 个记录行换句话说,
LIMIT n
等价于 LIMIT 0,n
。
SELECT ... INTO OUTFILE 'file_name'
格式的 SELECT
将选择的记录行写入一个文件。文件被建立在服务器主机上,并且不可以是已存在的 (不管别的,这可以防止数据库表和文件例如 `/etc/passwd' 被破坏)。你必须在服务器主机上有 FILE
权限来使用这个形式的 SELECT
。 SELECT ... INTO OUTFILE
主要是有意于让你能够在服务主机上快速地转储一个表。如果你希望将结果文件建立在其它的主机上,而不是服务器上,你就不能使用 SELECT ... INTO OUTFILE
。在这种情况下,你应该使用某些客户端程序例如 mysqldump --tab
或 mysql -e "SELECT ..." > outfile
产生文件来代替它。 SELECT ... INTO OUTFILE
是 LOAD DATA INFILE
的逆操作;语句中的 export_options
部分的句法由 FIELDS
和 LINES
子句组成,它们与与用在 LOAD DATA INFILE
语句中的相同。 在结果文本文件中,只有下列的字符被 ESCAPED BY
指定的字符转义:
ESCAPED BY
字符
FIELDS TERMINATED BY
中的第一个字符
LINES TERMINATED BY
中的第一个字符 ASCII 0
被转换到 ESCAPED BY
后而跟一个 0 (ASCII 48
)。 上述行为的原因是,你必须 转义任何 FIELDS TERMINATED BY
、ESCAPED BY
或LINES TERMINATED BY
字符,以便能可靠地将文件读回。ASCII 0
被转义是为了更容易地使用某些分页程序查看它。 因为结果文件并不需要遵从 SQL 句法,所以其它是不需要转义。 下面的例子得到的文件是可用于许多老程序的格式。 SELECT a,b,a+b INTO OUTFILE "/tmp/result.text" FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' LINES TERMINATED BY "\n" FROM test_table;
INTO DUMPFILE
代替 INTO OUTFILE
,MySQL 将在文件中只写一行,没任何列或行端接和任何转义。如果你希望存储一个 blob 列到文件中,这是非常有用的。
INTO OUTFILE
和 INTO DUMPFILE
创建的文件将被所有用户可读写!原因是, MySQL 服务器不能够创建一个其他用户拥有的文件,(你决不应该以 root 身份运行 mysqld
),该文件必须是公共可读写的,以便于你能操作它。
FOR UPDATE
,被检索的记录行将被写锁。 JOIN
句法MySQL 支持在 SELECT
中使用下面所示的 JOIN
句法:
table_reference, table_reference table_reference [CROSS] JOIN table_reference table_reference INNER JOIN table_reference join_condition table_reference STRAIGHT_JOIN table_reference table_reference LEFT [OUTER] JOIN table_reference join_condition table_reference LEFT [OUTER] JOIN table_reference table_reference NATURAL [LEFT [OUTER]] JOIN table_reference { OJ table_reference LEFT OUTER JOIN table_reference ON conditional_expr } table_reference RIGHT [OUTER] JOIN table_reference join_condition table_reference RIGHT [OUTER] JOIN table_reference table_reference NATURAL [RIGHT [OUTER]] JOIN table_reference
table_reference
定义如下:
table_name [[AS] alias] [[USE INDEX (key_list)] | [IGNORE INDEX (key_list)] | [FORCE INDEX (key_list)]]
join_condition
定义如下:
ON conditional_expr | USING (column_list)
通常不应该在 ON
存在任何条件式,它是用于限制在结果集中有哪个行的(对于这个规则也有例外)。如果你希望哪个记录行应该在结果中,你必须在 WHERE
子句中限制它。
注意,在早于 3.23.17 的版本中,INNER JOIN
不接受一个 join_condition
!
上面所显示的最后一个 LEFT OUTER JOIN
句法仅仅是为了与 ODBC 兼容而存在的:
tbl_name AS alias_name
或 tbl_name alias_name
命以别名: mysql> SELECT t1.name, t2.salary FROM employee AS t1, info AS t2 -> WHERE t1.name = t2.name;
ON
条件是可以用在一个 WHERE
子句中的任何形式的条件。
LEFT JOIN
的 ON
或 USING
部分中右表没有匹配的记录,一个所有列被设置为 NULL
的记录行将被用于右表。你可以通过这个行为找到一个表在另一个表中没有配对物的记录: mysql> SELECT table1.* FROM table1 -> LEFT JOIN table2 ON table1.id=table2.id -> WHERE table2.id IS NULL;这个例子在
table1
中找到所有的记录行,其 id
值没有出现在 table2
中(即,所有在 table1
存在的,但在 table2
中没有对应记录的记录行)。当然,这是假定 table2.id
被声明为 NOT NULL
的。
USING
(column_list)
子句指定了一个列的列表,列表的中列必须同时存在于两个表中。例如 USING
子句如下所示: A LEFT JOIN B USING (C1,C2,C3,...)它可以被定义为在语义上等同于一个这样的
ON
表达式: A.C1=B.C1 AND A.C2=B.C2 AND A.C3=B.C3,...
NATURAL [LEFT] JOIN
被定义为在语义上等同于使用了 USING
子句指定存在于两张表中的所有列的一个 INNER JOIN
或一个 LEFT JOIN
。
INNER JOIN
和 ,
(逗号) 在语义上是等同的。都是在所有的表之间进行一个全联结。通常,在 WHERE 条件中指定表应该如何联结。
RIGHT JOIN
作用类似于 LEFT JOIN
。为了保持数据库边的代码上精简,LEFT JOIN
被推荐使用来代替 RIGHT JOIN
。
STRAIGHT_JOIN
等同于 JOIN
,除了左表先于右表被读入。当联结优化器将表的顺序放错时(很少),这可用于这种情况。
EXPLAIN
显示 MySQL 使用了可能的索引列表中错误的索引,这个特性将是很有用的。通过指定 USE INDEX (key_list)
,你可以告诉 MySQL 使用可能的索引中最合适的一个索引在表中查找记录行。可选的二选一句法 IGNORE INDEX (key_list)
可被用于告诉 MySQL 不使用特定的索引。 在 MySQL 4.0.9 中,你也可以使用 FORCE INDEX
。这个有点像 USE INDEX (key_list)
,但是有了这个附加物,一个表的扫描被采用时,将会有非常大的开销。换句法说,如果没有方法使用给定的索引在表中寻找记录行,这时表扫描才会被使用。 USE/IGNORE/FORCE KEY
分别是 USE/IGNORE/FORCE INDEX
的同义词。 一些例子:
mysql> SELECT * FROM table1,table2 WHERE table1.id=table2.id; mysql> SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id; mysql> SELECT * FROM table1 LEFT JOIN table2 USING (id); mysql> SELECT * FROM table1 LEFT JOIN table2 ON table1.id=table2.id -> LEFT JOIN table3 ON table2.id=table3.id; mysql> SELECT * FROM table1 USE INDEX (key1,key2) -> WHERE key1=1 AND key2=2 AND key3=3; mysql> SELECT * FROM table1 IGNORE INDEX (key3) -> WHERE key1=1 AND key2=2 AND key3=3;
4.1.2 UNION
句法
SELECT ... UNION [ALL] SELECT ... [UNION SELECT ...]
UNION
在 MySQL 4.0.0 中被实现。
UNION
用于将多个 SELECT
语句的结果联合到一个结果集中。
在 SELECT
中的 select_expression 部分列出的列必须具有同样的类型。第一个 SELECT
查询中使用的列名将作为结果集的列名返回。
SELECT
命令是一个普通的选择命令,但是有下列的限制:
SELECT
命令可以有 INTO OUTFILE
。 如果你不为 UNION
使用关键词 ALL
,所有返回的记录行将是唯一的,就好像你为整个返回集使用了一个 DISTINCT
。如果你指定了 ALL
,那么你将得到从所有使用的 SELECT
语句中返回的所有匹配记录行。
如果你希望对整个 UNION
结果使用一个 ORDER BY
,你应该使用圆括号:
(SELECT a FROM table_name WHERE a=10 AND B=1 ORDER BY a LIMIT 10) UNION (SELECT a FROM table_name WHERE a=11 AND B=2 ORDER BY a LIMIT 10) ORDER BY a;
HANDLER
句法HANDLER tbl_name OPEN [ AS alias ] HANDLER tbl_name READ index_name { = | >= | <= | < } (value1,value2,...) [ WHERE ... ] [LIMIT ... ] HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST } [ WHERE ... ] [LIMIT ... ] HANDLER tbl_name READ { FIRST | NEXT } [ WHERE ... ] [LIMIT ... ] HANDLER tbl_name CLOSE
HANDLER
语句提供了直接访问 MyISAM
表存储引擎的接口。
HANDLER
语句的第一个形式打开一个表,通过后来的 HANDLER ... READ
语句使它可读取。这个表对象将不能被其它线程共享,也不会被关闭,除非线程调用 HANDLER tbl_name CLOSE
或线程关闭。
第二个形式读取指定的索引遵从那个条件并且适合 WHERE
条件的一行(或更多的,由 LIMIT
子句指定)。如果索引由几个部分组成(范围有几个列),值以逗号分隔的列表指定;如果只提供的一部分值,那么第一个列是必需的。
第三个形式从表中以索引的顺序读取匹配 WHERE
条件的一行(或更多的,由 LIMIT
子句指定)。
第四个形式(没有索引清单)从表中以自然的列顺序(在数据文件中存储的次序)读取匹配 WHERE
条件的一行(或更多的,由 LIMIT
子句指定)。如果期望做一个全表扫描,它将比 HANDLER tbl_name READ index_name
更快。
HANDLER ... CLOSE
关闭一个以 HANDLER ... OPEN
打开的表。
HANDLER
是一个稍微低级的语句。举例来说,它不提供一致性约束。更确切地说,HANDLER ... OPEN
不 接受一个表的快照,并且 不 锁定表。这就意味着在一个 HANDLER ... OPEN
被执行后,表数据仍会被 (这个或其它的线程) 修改,这些修改可能在 HANDLER ... NEXT
和 HANDLER ... PREV
扫描中才会部分地出现。
使用这个接口代替普通 SQL 的原因是:
SELECT
快,因为:
HANDLER OPEN
中,一个指定的存储引擎被分配给当前线程。
INSERT
句法INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] tbl_name [(col_name,...)] VALUES ((expression | DEFAULT),...),(...),... [ ON DUPLICATE KEY UPDATE col_name=expression, ... ] or INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] tbl_name [(col_name,...)] SELECT ... or INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] tbl_name SET col_name=(expression | DEFAULT), ... [ ON DUPLICATE KEY UPDATE col_name=expression, ... ]
INSERT
将新行插入到一个已存在的表中。INSERT ... VALUES
形式的语句基于明确的值插入记录行。INSERT ... SELECT
形式的语句从另一个或多个表中选取出值,并将其插入。有多重值列表的 INSERT ... VALUES
形式的语句在 MySQL 3.22.5 或更新的版本中被支持。col_name=expression
句法在 MySQL 3.22.10 或更新的版本中得到支持。
tbl_name
是记录将要被插入的表。列名列表或 SET
子句指出语句指定的值赋给哪个列:
INSERT ... VALUES
或 INSERT ... SELECT
中没有指定列列表,那么所有列的值必须在 VALUES()
列表中或由 SELECT
提供。如果你不知道表的列的次序,可以使用 DESCRIBE tbl_name
来决定它。
DEFAULT
来将一个列设置为它的默认值(这在 MySQL 4.0.3 中被新加入)。这使它更加容易地书写赋予值到所有除了几列的 INSERT
语句,因为它允许您避免书写一个不完全的 VALUES()
的列表(在该列表没有包含表中的每个列的列值)。否则,你将不得不在 VALUES()
列表中写出列列表指定对应的值。 MySQL 通常都会为每个字段设置一个缺省值。这是某些强加在 MySQL 上的,在事务型表与非事务型表中均工作。 我们的观点是在应用程序端检查字段的内容,而不是在数据库服务器端。
expression
可以引用先前在值列表中设置的任何列。例如,你可以这样: mysql> INSERT INTO tbl_name (col1,col2) VALUES(15,col1*2);但是不能这样:
mysql> INSERT INTO tbl_name (col1,col2) VALUES(col2*2,15);
LOW_PRIORITY
,INSERT
的执行将会被延迟,直到没有其它客户端正在读取表。在这种情况下,客户端不得不等待插入语句被完成,如果表被频繁地使用,那么这将会花费很长一段时间。这与 INSERT DELAYED
让客户端立即继续执行正好相反。注意,LOW_PRIORITY
通常不对 MyISAM
使用,因为这将禁止并发的插入。
INSERT
中指定关键词 IGNORE
,任何在表中现有的 PRIMARY
或 UNIQUE
键上重复的记录行均会被忽略而不被插入。如果你不指定 IGNORE
,当有任何记录行在一个现有的键值上重复时,插入均会被中止。你可以通过 C API 函数 mysql_info()
测定共有多少记录行被插入到表中。
ON DUPLICATE KEY UPDATE
子句(在 MySQL 4.1.0 中被新加入),并且被插入的一个记录行在 PRIMARY
或 UNIQUE
键上将会产生一个重复值,那么老的记录行将被 UPDATE
。举例来说: mysql> INSERT INTO table (a,b,c) VALUES (1,2,3) --> ON DUPLICATE KEY UPDATE c=c+1;假设列
a
被定义为 UNIQUE
,并且已存在了一个 1
,它将与下面的语句产生同样的结果: mysql> UPDATE table SET c=c+1 WHERE a=1;注意:如果列
b
也是唯一的,UPDATE
命令将要被写成这样: mysql> UPDATE table SET c=c+1 WHERE a=1 OR b=2 LIMIT 1;并且如果
a=1 OR b=2
匹配几个记录行,只有 一个 记录行将被更新!大体上,在有多重 UNIQUE
键的表上,你应该尽是避免使用 ON DUPLICATE KEY
子句。 当使用了 ON DUPLICATE KEY UPDATE
后,DELAYED
选项将被忽略。
DONT_USE_DEFAULT_FIELDS
选项,INSERT
语句将产生一个错误,除非你为所有需要一个非 NULL
值的列明确指定值。
mysql_insert_id
函数你可以找到用于一个 AUTO_INCREMENT
列的值。 如果你使用 INSERT ... SELECT
或一个 INSERT ... VALUES
语句插入多值列,你可以使用 C API 函数 mysql_info()
得到查询的信息。信息字串的格式如下:
Records: 100 Duplicates: 0 Warnings: 0
Duplicates
指出因与某些现有的唯一索引值重复而不能被插入的记录行数目。Warnings
指出在尝试插入的列值中在某些方面可能有问题的数目。在下列任何一个条件下,警告都会发生:
NOT NULL
的列中插入 NULL
值。该列被设置为它的缺省值。
'10.34 a'
的值赋给一个数字列。尾部的无用信息将被剥离,保留数字部分并将其插入。如果该值看起来根本就不是一个数字,该列将被设置为 0
。
CHAR
、VARCHAR
、TEXT
或 BLOB
列中。该值将被剪切到该列的最大长度。
INSERT ... SELECT
句法INSERT [LOW_PRIORITY] [IGNORE] [INTO] tbl_name [(column list)] SELECT ...
使用 INSERT ... SELECT
语句,你可以从一个或多个表中读取多个记录行,并将其快速地插入到一个表中。
INSERT INTO tblTemp2 (fldID) SELECT tblTemp1.fldOrder_ID FROM tblTemp1 WHERE tblTemp1.fldOrder_ID > 100;
一个 INSERT ... SELECT
语句有下列条件的限止:
INSERT
语句中的目标表不能在 SELECT
查询部分的 FROM
子句中出现,因为在 ANSI SQL 中,禁止你从正在插入的表中 SELECT
。(问题是因为,SELECT
可能会发现在同一运行期内先前被插入的记录。当使用子选择子句时,这种情况将会更容易混淆!)
AUTO_INCREMENT
列像平常一样工作。
mysql_info()
得到查询的信息。
INSERT ... SELECT
期间并发的插入。 你当然也可以使用 REPLACE
代替 INSERT
来盖写老的记录行。
INSERT DELAYED
句法INSERT DELAYED ...
INSERT
语句的 DELAYED
选项是一个 MySQL 特有的选项,如果你的客户端不能等待 INSERT
的完成,这将会是很有用的。This is a common problem when you use MySQL for logging and 当你打开日志记录使用 MySQL 并且你周期性的需花费很长时间才完成的 SELECT
和 UPDATE
语句时,这将是一个很普遍的问题。DELAYED
在 MySQL 3.22.15 中被引入。它是 MySQL 对 ANSI SQL92 的一个扩展。
INSERT DELAYED
仅仅工作与 ISAM
和 MyISAM
表。注意,因为 MyISAM
表支持并发的 SELECT
和 INSERT
,如果在数据文件中没有空闲的块,那你将很少需要对 MyISAM
表使用 INSERT DELAYED
。
当你使用 INSERT DELAYED
时,客户端将立即得到一个 OK,当表不被任何其它线程使用时,该行将被插入。
使用 INSERT DELAYED
的另一个主要的好处就是,从很多客户端来的插入请求会被打包在一起并写入一个块中。这比做许多单独的插入要快的多。
注意,当前的记录行队列是被存储在内存中的,一直到他们被插入到表中。这就意味着,如果你使用强制的方法(kill -9
) 杀死 mysqld
,或者如果意外地死掉,任何没有写到磁盘中的记录行队列都将会丢失!
下面详细地描述当你为 INSERT
或 REPLACE
使用 DELAYED
选项时会发生什么。在这个描述中,“线程”是遇到一个 INSERT DELAYED
命令的线程,“处理器”是处理所有对于一个特定表的 INSERT DELAYED
语句的线程。
DELAYED
语句时,将会创建一个处理器线程用以处理对该表的所有 DELAYED
语句,除非这样的处理器已经存在。
DELAYED
锁;如果还没有,这告诉处理程序去获得。即使其它的线程已在表上加了一个 READ
或 WRITE
锁,也能获得 DELAYED
锁。然而,处理器将等待所有的 ALTER TABLE
锁或 FLUSH TABLES
以保证表结构是最新的。
INSERT
语句,但是并不将记录行写到表中,它将最终的记录行的副本放到被处理器线程管理的队列中。任何语法错误都会被线程发现并报告给客户程序。
AUTO_INCREMENT
值;它不能从服务器获得它们,因为 INSERT
早在插入操作被完成之前就返回了。如果你使用 C API,mysql_info()
函数也因同样的原因而不能获得任何有意义的信息。
delayed_insert_limit
个记录行后,处理器检查是否仍有任何 SELECT
语句没有解决。如果是这样,处理器允许在继续之前让这些语句先执行。
delayed_insert_timeout
秒内没有接收到新的 INSERT DELAYED
命令,处理器线程将终止。
delayed_queue_size
个记录行未被解决,线程要求 INSERT DELAYED
等待,只到在队列中有可用空间。这样做是为了保证 mysqld
服务器对延迟内存队列不使用全部的内存。
Command
列上显示为 delayed_insert
。如果执行一个 FLUSH TABLES
命令或以 KILL thread_id
杀死它,它将会被杀死。然而,它在退出前会首先将所队列记录行保存到表中。这些期间,它将不再接收其它线程的任何新的 INSERT
命令。如果再此之后执行一个 INSERT DELAYED
命令,一个新处理器线程将会被创建。 注意,上面的意思是,如果一个 INSERT DELAYED
处理器已在运行,那么 INSERT DELAYED
命令将有比正常 INSERT
命令更高的优先级!其它的更新命令将不得不等到 INSERT DELAYED
队列被清空,杀死处理器线程(以 KILL thread_id
) 或执行 FLUSH TABLES
。
INSERT DELAYED
命令的信息:
变量
含义
Delayed_insert_threads
处理器线程数目
Delayed_writes
使用 INSERT DELAYED
写入的记录行的数目
Not_flushed_delayed_rows
等待被写入的记录行数目 通过发出一个 SHOW STATUS
语句或通过执行一个 mysqladmin extended-status
命令,你可以查看这些变量。 注意,如果表没有在使用中,INSERT DELAYED
将比一个正常的 INSERT 慢。让服务器为你使用 INSERT DELAYED
的每张表处理一个单独的线程,也是有额外的开销的。这就意味着,你应该在确定你的确需要它时才使用 INSERT DELAYED
。
UPDATE
句法UPDATE [LOW_PRIORITY] [IGNORE] tbl_name SET col_name1=expr1 [, col_name2=expr2 ...] [WHERE where_definition] [ORDER BY ...] [LIMIT rows] or UPDATE [LOW_PRIORITY] [IGNORE] tbl_name [, tbl_name ...] SET col_name1=expr1 [, col_name2=expr2 ...] [WHERE where_definition]
UPDATE
以新的值更新现存表中行的列。SET
子句指出要修改哪个列和他们应该给定的值。WHERE
子句如果被给出,指定哪个记录行应该被更新。否则,所有的记录行被更新。如果 ORDER BY
子句被指定,记录行将被以指定的次序更新。
如果你指定关键词 LOW_PRIORITY
,UPDATE
的执行将被延迟,直到没有其它的客户端正在读取表。
如果你指定关键词 IGNORE
,该更新语句将不会异常中止,即使在更新过程中出现重复键错误。导致冲突的记录行将不会被更新。
如果在一个表达式中从 tbl_name
中访问一个列,UPDATE
使用列的当前值。举例来说,下面的语句设置 age
列值为它的当前值加 1 :
mysql> UPDATE persondata SET age=age+1;
UPDATE
赋值是从左到右计算的。举例来说,下列语句将 age
列设置为它的两倍,然后再加 1 :
mysql> UPDATE persondata SET age=age*2, age=age+1;
如果你设置列为其当前的值,MySQL 注意到这点,并不更新它。
UPDATE
返回实际被改变的记录行数目。在 MySQL 3.22 或更新的版本中,C API 函数 mysql_info()
返回被匹配并更新的记录行数目,以及在 UPDATE
期间发生的警告的数目。
在 MySQL 3.23 中,你可以使用 LIMIT #
来确保只有给定的记录行数目被更改。
如果一个 ORDER BY
子句被使用(从 MySQL 4.0.0 开始支持),记录行将以指定的次序被更新。这实际上只有连同 LIMIT
一起才有用。
从 MySQL 4.0.4 开始,你也可以执行一个包含多个表的 UPDATE
的操作:
UPDATE items,month SET items.price=month.price WHERE items.id=month.id;
注意:多表 UPDATE
不可以使用 ORDER BY
或 LIMIT
。
DELETE
句法DELETE [LOW_PRIORITY] [QUICK] FROM table_name [WHERE where_definition] [ORDER BY ...] [LIMIT rows] or DELETE [LOW_PRIORITY] [QUICK] table_name[.*] [, table_name[.*] ...] FROM table-references [WHERE where_definition] or DELETE [LOW_PRIORITY] [QUICK] FROM table_name[.*] [, table_name[.*] ...] USING table-references [WHERE where_definition]
DELETE
从 table_name
中删除 where_definition
中给定条件的记录行,并返回删除的记录数目。
如果你发出一个没有 WHERE
子句的 DELETE
,所有的记录行将被删除。如果你以 AUTOCOMMIT
模式执行它,那么它类似于 TRUNCATE
。在 MySQL 3.23 中,没有一个 WHERE
子句的 DELETE
将返回零作为受影响的记录数目。
当你删除所有记录行时,如果你真的希望知道多少条记录被删除,你可以使用一个这种形式的 DELETE
语句:
mysql> DELETE FROM table_name WHERE 1>0;
注意,这将比一个没有 WHERE
子句的 DELETE FROM table_name
语句慢,因为它一次只删除一行。
如果你指定关键词 LOW_PRIORITY
,DELETE
的执行将被延迟,直到没有其它的客户端正在读取表。
如果你指定关键词 QUICK
,那么在删除过程中存储引擎将不会归并索引叶,这可能会加速某些类型的删除操作。
在 MyISAM
表中,删除了的记录被放在一个链接表中维护,以后的 INSERT
操作将重新使用删除后的记录位置。为了回收闲置的空间,并减小文件尺寸,使用 OPTIMIZE TABLE
语句或 myisamchk
实用程序重新组织表。OPTIMIZE TABLE
使用比较容易,但是 myisamchk
更快点。
第一个多表删除格式从 MySQL 4.0.0 开始被支持。第二个多表删除格式从 MySQL 4.0.2 开始被支持。
仅仅在 FROM
或 USING
子句 之前 列出的表中的匹配记录行被删除。效果就是,你要以从多个表中同时删除记录行,并且同样可以有其它的表用于检索。
在表名后的 .*
仅仅是为了兼容 Access
:
DELETE t1,t2 FROM t1,t2,t3 WHERE t1.id=t2.id AND t2.id=t3.id or DELETE FROM t1,t2 USING t1,t2,t3 WHERE t1.id=t2.id AND t2.id=t3.id
在上面的情况下,我们仅仅从 t1
和 t2
表中删除匹配的记录行。
如果一个 ORDER BY
子句被使用(从 MySQL 4.0.0 开始支持), 记录行将以指定的次序删除。这实际上只有连同 LIMIT
一起才有用。示例如下:
DELETE FROM somelog WHERE user = 'jcole' ORDER BY timestamp LIMIT 1
这将删除匹配 WHERE
子句的,并且最早被插入(通过 timestamp
来确定)的记录行。
DELETE
语句的LIMIT rows
选项是 MySQL 特有的,它告诉服务器在控制权被返回到客户端之前可被删除的最大记录行数目。这可以用来确保一个特定的 DELETE
命令不会占用太长的时间。你可以简单地重复使用 DELETE
命令,直到被影响的记录行数目小于 LIMIT
值。
从 MySQL 4.0 开始,在 DELETE
语句中可以指定多个表,用以从一个表中删除依赖于多表中的特殊情况的记录行。然而,在一个多表删除中,不能使用 ORDER BY
或 LIMIT
。
TRUNCATE
句法TRUNCATE TABLE table_name
在 3.23 中,TRUNCATE TABLE
被映射为 COMMIT ; DELETE FROM table_name
。
在下面的方式中,TRUNCATE TABLE
不同于 DELETE FROM ...
:
TRUNCATE
是一个 Oracle SQL 的扩展。
REPLACE
句法REPLACE [LOW_PRIORITY | DELAYED] [INTO] tbl_name [(col_name,...)] VALUES (expression,...),(...),... or REPLACE [LOW_PRIORITY | DELAYED] [INTO] tbl_name [(col_name,...)] SELECT ... or REPLACE [LOW_PRIORITY | DELAYED] [INTO] tbl_name SET col_name=expression, col_name=expression,...
REPLACE
功能与 INSERT
完全一样,除了如果在表中存在一个老的记录与新记录在一个 UNIQUE
或 PRIMARY KEY
上有相同的值,那么在新记录被插入之前,老的记录将被删除。
换句话说,你不可以从一个 REPLACE
中访问老的记录行的值。某些老的 MySQL 版本中,你或许可以这样做,但是这是一个 Bug,现在已被修正了。
为了能够使用 REPLACE
,你必须有对该表的 INSERT
和 DELETE
权限。
当你使用一个 REPLACE
时,如果新的记录行代替了老的记录行,mysql_affected_rows()
将返回 2。这是因为在新行被插入之前,重复记录行被先删除了。
这个事实使得判断 REPLACE
是否是添加一条记录还是替换一条记录很容易:检查受影响记录行的值是 1 (添加)还是 2(替换)。
注意,除非你使用一个 UNIQUE
索引或 PRIMARY KEY
,使用 REPLACE
命令是没有感觉的,因为它会仅仅执行一个 INSERT
。
LOAD DATA INFILE
句法LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name.txt' [REPLACE | IGNORE] INTO TABLE tbl_name [FIELDS [TERMINATED BY '\t'] [[OPTIONALLY] ENCLOSED BY ''] [ESCAPED BY '\\' ] ] [LINES TERMINATED BY '\n'] [IGNORE number LINES] [(col_name,...)]
LOAD DATA INFILE
语句以非常高的速度从一个文本文件中读取记录行并插入到一个表中。如果 LOCAL
关键词被指定,文件从客户端主机读取。如果 LOCAL
没有被指定,文件必须位于服务器上。(LOCAL
在 MySQL 3.22.6 或更新的版本中被支持。)
由于安全性的原因,当读取位于服务器端的文本文件时,文件必须处于数据库目录或可被所有人读取的地方。同时,为了对服务器端的文件使用 LOAD DATA INFILE
,你必须在服务器主机上有 FILE
权限。
在 MySQL 3.23.49 和 MySQL 4.0.2 中,只有当你没有以 --local-infile=0
选项启动 mysqld
,或你没有禁止你的客户端程序支持 LOCAL
的情况下,LOCAL
才会工作。
如果你指定关键词 LOW_PRIORITY
,LOAD DATA
语句的执行将会被延迟,直到没有其它的客户端正在读取表。
如果你对一个 MyISAM
表指定关键词 CONCURRENT
,那么当 LOAD DATA
正在执行时,其它的线程仍可以从表中检索数据。使用这个选项时,如果同时也有其它的线程正在使用表,这当然会有一点影响 LOAD DATA
的执行性能。
使用 LOCAL
将比让服务器直接访问文件要慢一些,因为文件的内容必须从客户端主机传送到服务器主机。而在另一方面,你不再需要有 FILE
权限用于装载本地文件。
如果你使用先于 MySQL 3.23.24 的版本,你不能够以 LOAD DATA INFILE
读取一个 FIFO 。如果你需要从一个 FIFO (例如,gunzip 的输出文件) 中读取,可以使用 LOAD DATA LOCAL INFILE
代替。
你也可以使用 mysqlimport
实用程序装载数据文件;它通过发送一个 LOAD DATA INFILE
命令到服务器来动作。--local
选项使得 mysqlimport
从客户端主机读取数据文件。如果客户端与服务器支持压缩协议,你可以指定 --compress
选项,以在较慢的网络中获得更好的性能。
当从服务器主机定位文件时,服务器使用下列规则:
注意,这些规则意味着,一个以 `./myfile.txt' 给出的文件是从服务器的数据目录中读取的,然而,以 `myfile.txt' 给出的一个文件是从当前数据库的数据目录下读取的。举例来说,下面的 LOAD DATA
语句从 db1
数据库目录下读取文件 `data.txt',因为 db1
是当前数据库,即使该语句明确地指定读取的文件被放入到 db2
数据库中的一个表中:
mysql> USE db1; mysql> LOAD DATA INFILE "data.txt" INTO TABLE db2.my_table;
REPLACE
和 IGNORE
关键词控制对与现有的记录在唯一键值上重复的记录的处理。如果你指定 REPLACE
,新的记录行将替换有相同唯一键值的现有记录行。如果你指定 IGNORE
,将跳过与现有的记录行在唯一键值上重复的输入记录行。如果你没有指定任何一个选项,当重复键值出现时,将会发生一个错误,文本文件的剩余部分也将被忽略。
如果你使用 LOCAL
关键词从一个本地文件中读取数据,在此操作过程中,服务器没有办法停止文件的传送,因此缺省的处理方式就好像是 IGNORE
被指定一样。
如果你在一个空的 MyISAM
表上使用 LOAD DATA INFILE
,所有非唯一索引会以一个分批方式被创建(就像 REPAIR
)。当有许多索引时,这通常可以使 LOAD DATA INFILE
更快一些。
LOAD DATA INFILE
的 SELECT ... INTO OUTFILE
的逆操作。使用 SELECT ... INTO OUTFILE
将数据从一个数据库写到一个文件中。使用 LOAD DATA INFILE
读取文件到数据库中。两个命令的 FIELDS
和 LINES
子句的句法是一样的。两个子句都是可选的,但是如果两个同时被指定,FIELDS
子句必须出现在 LINES
子句之前。
如果你指定一个 FIELDS
子句,它的子句 (TERMINATED BY
、[OPTIONALLY] ENCLOSED BY
和 ESCAPED BY
) 也是可选的,不过,你必须至少指定它们中的一个。
如果你没有指定一个 FIELDS
子句,缺省的相同于如果你这样写:
FIELDS TERMINATED BY '\t' ENCLOSED BY '' ESCAPED BY '\\'
如果你没有指定一个 LINES
子句,缺省的相同于如果你这样写:
LINES TERMINATED BY '\n'
换句话说,当读取输入时,缺省值导致 LOAD DATA INFILE
表现如下:
相反的,当写入输出时,缺省值导致 SELECT ... INTO OUTFILE
表现如下:
注意,为了写 FIELDS ESCAPED BY '\\'
,你必须指定两个反斜线,该值会作为一个反斜线被读入。
IGNORE number LINES
选项可被用于忽略文件开头处的一个列名的头:
mysql> LOAD DATA INFILE "/tmp/file_name" INTO TABLE test IGNORE 1 LINES;
当你一前一后地使用 SELECT ... INTO OUTFILE
和 LOAD DATA INFILE
将数据从一个数据库写到一个文件中,然后再从文件中将它读入数据库中时,两个命令的字段和行处理选项必须匹配。否则,LOAD DATA INFILE
将不能正确地解释文件内容。假设你使用 SELECT ... INTO OUTFILE
以逗号分隔字段的方式将数据写入到一个文件中:
mysql> SELECT * INTO OUTFILE 'data.txt' -> FIELDS TERMINATED BY ',' -> FROM ...;
为了将由逗号分隔的文件读回时,正确的语句应该是:
mysql> LOAD DATA INFILE 'data.txt' INTO TABLE table2 -> FIELDS TERMINATED BY ',';
如果你试图用下面所示的语句读取文件,它将不会工作,因为命令 LOAD DATA INFILE
以定位符区分字段值:
mysql> LOAD DATA INFILE 'data.txt' INTO TABLE table2 -> FIELDS TERMINATED BY '\t';
可能的结果是每个输入行将被解释为一个单独的字段。
LOAD DATA INFILE
也可以被用来读取从外部来源获得的文件。例如,dBASE 格式的文件,字段以逗号分隔并以双引号包围着。如果文件中的行以一个换行符终止,那么下面所示的可以说明你将用来装载文件的字段和行处理选项:
mysql> LOAD DATA INFILE 'data.txt' INTO TABLE tbl_name -> FIELDS TERMINATED BY ',' ENCLOSED BY '"' -> LINES TERMINATED BY '\n';
任何字段和行处理选项都可以指定一个空字符串(''
)。如果不是空的,FIELDS [OPTIONALLY] ENCLOSED BY
和 FIELDS ESCAPED BY
值必须是一个单个字符。FIELDS TERMINATED BY
和 LINES TERMINATED BY
值可以超过一个字符。例如,为了写入由回车换行符终止的行,或读取包含这样的行的文件,应该指定一个 LINES TERMINATED BY '\r\n'
子句。
举例来说,为了读取一个文件到一个 SQL 表中,文件以一行 %%
分隔(开玩笑的),你可以这样做:
CREATE TABLE jokes (a INT NOT NULL AUTO_INCREMENT PRIMARY KEY, joke TEXT NOT NULL); LOAD DATA INFILE "/tmp/jokes.txt" INTO TABLE jokes FIELDS TERMINATED BY "" LINES TERMINATED BY "\n%%\n" (joke);
FIELDS [OPTIONALLY] ENCLOSED BY
控制字段的包围字符。对于输出 (SELECT ... INTO OUTFILE
),如果你省略单词 OPTIONALLY
,所有的字段被 ENCLOSED BY
字符包围。这样的一个输出文件(以一个逗号作为字段分界符)示例如下:
"1","a string","100.20" "2","a string containing a , comma","102.20" "3","a string containing a \" quote","102.20" "4","a string containing a \", quote and comma","102.20"
如果你指定 OPTIONALLY
,ENCLOSED BY
字符仅被作用于包围 CHAR
和 VARCHAR
字段:
1,"a string",100.20 2,"a string containing a , comma",102.20 3,"a string containing a \" quote",102.20 4,"a string containing a \", quote and comma",102.20
注意,在一个字段值中出现的 ENCLOSED BY
字符,通过用 ESCAPED BY
字符作为其前缀对其转义。同时也要注意,如果你指定一个空的 ESCAPED BY
值,可能会产生不能被 LOAD DATA INFILE
正确读出的输出文件。例如,如果转义字符为空,上面显示的输出将变成如下显示的输出。请注意第四行的第二个字段,它包含一个逗号跟在一个引号后的两个字符,这(错误的)看起来像是一个字段的终止:
1,"a string",100.20 2,"a string containing a , comma",102.20 3,"a string containing a " quote",102.20 4,"a string containing a ", quote and comma",102.20
对于输入,ENCLOSED BY
字符如果存在,它将从字段值的尾部被剥离。(不管 OPTIONALLY
是否被指定,都是这样;对于输入解释,OPTIONALLY
不会影响它。) 由ESCAPED BY
字符领先于 ENCLOSED BY
字符的出现,将被解释为当前字段值的一部分。另外,在字段中出现的重复的 ENCLOSED BY
字符被解释为单个 ENCLOSED BY
,只要字段本身也是以该字符开始的。例如,如果 ENCLOSED BY '"'
被指定,引号将做如下处理:
"The ""BIG"" boss" -> The "BIG" boss The "BIG" boss -> The "BIG" boss The ""BIG"" boss -> The ""BIG"" boss
FIELDS ESCAPED BY
控制如何写入或读出特殊字符。如果 FIELDS ESCAPED BY
字符不是空的,它将被用于做为下列输出字符的前缀:
FIELDS ESCAPED BY
字符
FIELDS [OPTIONALLY] ENCLOSED BY
字符
FIELDS TERMINATED BY
和 LINES TERMINATED BY
值的第一个字符。
0
(实际上在转义字符后写上 ASCII '0'
,而不是一个零值字节) 如果 FIELDS ESCAPED BY
字符为空,没有字符被转义。指定一个空的转义字符可能不是一个好的主意,特别是如果你的数据字段值中包含刚才列表中的任何字符时。
对于输入,如果 FIELDS ESCAPED BY
字符不为空,该字符的出现将会被剥离,后续的字符在字面上做为字段值的一部分。除了一个转义的 “0” 或 “N” (即,\0
或\N
,如果转义字符为 `\')。这些序列被解释为 ASCII 0
(一个零值字节) 和 NULL
。查看下面的有关 NULL
处理的规则。
关于更多的 “\” 转义句法信息。
在某些情况下,字段与行处理相互作用:
LINES TERMINATED BY
是一个空字符串,FIELDS TERMINATED BY
是非空的,行也用 FIELDS TERMINATED BY
终止。
FIELDS TERMINATED BY
和 FIELDS ENCLOSED BY
值都是空的 (''
),一个固定行(无定界符) 格式被使用。用固定行格式时,在字段之间不使用分隔符。代替的,列值的写入和读取使用列的“显示”宽度。例如,如果一个列被定义为 INT(7)
,列的值将使用 7 个字符的字段被写入。对于输入,列值通过读取 7 个字符来获得。固定行格式也影响对 NULL
值的处理;见下面。注意,如果你正在使用一个多字节的字符集,固定长度格式将不能工作。 NULL
值的处理有很多,取决于你所使用的 FIELDS
和 LINES
选项:
FIELDS
和 LINES
值,输出时,NULL
被写成 \N
,当读入时,\N
被作为 NULL
读入(假设 ESCAPED BY
字符为 “\”)。
FIELDS ENCLOSED BY
是非空的,一个字段包含文字词 NULL
的,它的值做为一个 NULL
值被读入 (这不同于被 FIELDS ENCLOSED BY
包围的词 NULL
,它是被作为 'NULL'
读入的)。
FIELDS ESCAPED BY
是空的,NULL
值被写为词 NULL
。
FIELDS TERMINATED BY
和 FIELDS ENCLOSED BY
两者均为空),NULL
被写为一个空的字符串。注意,当将表中的 NULL
值和空字符串一起写到文件中时,它们将被混淆,因为它们都是作为空字符串被写入的。如果你在文件时,需要对他们两个进行区分,你不应该使用固定行格式。 一些不能被 LOAD DATA INFILE
支持的情况:
FIELDS TERMINATED BY
和 FIELDS ENCLOSED BY
均为空) 和 BLOB
或 TEXT
列。
LOAD DATA INFILE
可能会不能正确地解释输入。例如,下列的 FIELDS
子句将会产生问题: FIELDS TERMINATED BY '"' ENCLOSED BY '"'
FIELDS ESCAPED BY
为空,一个字段值中包含有 FIELDS ENCLOSED BY
或 LINES TERMINATED BY
被 FIELDS TERMINATED BY
跟随的值时,将会引起 LOAD DATA INFILE
过早地停止读取一个字段或一行。这是因为 LOAD DATA INFILE
不能够正确地决定字段或行值在哪里结果。 下面的例子将装载 persondata
表的所有列:
mysql> LOAD DATA INFILE 'persondata.txt' INTO TABLE persondata;
没有字段列被指定,因而 LOAD DATA INFILE
认为输入行包含表列中所有的字段。使用缺省的 FIELDS
和 LINES
值。
如果你希望装载表中的某些列,那指定一个字段列表:
mysql> LOAD DATA INFILE 'persondata.txt' -> INTO TABLE persondata (col1,col2,...);
如果输入文件的字段次序不同于表中列的顺序,你也必须指定一个字段列表。否则 MySQL 不知道如何将输入字段与表中的列匹配。
如果一个行有很少的字段,没有输入字段的列将被设置为缺省值。
一个空的字段值不同于字段值丢失的解释:
0
。
注意,如果在一个 INSERT
或 UPDATE
语句中明确地将一个空字符串赋给一个字符串、数字或日期或时间类型,你会得到与上面相同的结果。
如果对 TIMESTAMP
列指定一个 NULL
值,或者当字段列表被指定时, TIMESTAMP
在字段列表中被遗漏(仅仅第一个 TIMESTAMP
列被影响),TIMESTAMP
列会被设置为当前的日期和时间。
如果输入的记录行有太多的字段,多余的字段将被忽略,并增加警告的数目。
LOAD DATA INFILE
认为所有的输入均是字符串,因而,对于 ENUM
或 SET
列,你不能以 INSERT
语句的形式为其设置数字值。所有的 ENUM
和 SET
必须以字符串指定!
如果你正在使用 C API,当 LOAD DATA INFILE
查询结束时,你可以调用 API 函数 mysql_info()
获得有关查询的信息。信息串的格式如下:
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
警告会在某些情况下发生,这些情况与值通过 INSERT
语句插入时发生警告的情况一样,但是 LOAD DATA INFILE
有一点与它不一样,当在输入行中有太多或过少的字段,它也会产生警告。警告不会被存储在任何地主;警告的数目仅能表示一切是否顺利。如果得到警告,并希望确切地知道为什么会得到它们,一个方法就是使用 SELECT ... INTO OUTFILE
,将它保存到另外一个文件中,并与原先的输入文件进行比较。
如果你需要 LOAD DATA
从一个管道中读取,你可以使用下面的技巧:
mkfifo /mysql/db/x/x chmod 666 /mysql/db/x/x cat < /dev/tcp/10.1.1.12/4711 > /nt/mysql/db/x/x mysql -e "LOAD DATA INFILE 'x' INTO TABLE x" x
如果你使用的版本早于 MySQL 3.23.25,你只能通过 LOAD DATA LOCAL INFILE
来执行上面。
有关 INSERT
相对 LOAD DATA INFILE
的效率和加快 LOAD DATA INFILE
的更多信息。
DO
句法DO expression, [expression, ...]
执行表达式,但不返回任何结果。这是 SELECT expression, expression
的一个缩写,但是当你并不关心结果时,它稍有点优势,因为它稍稍快一点。
这主要有益于有副作用的函数,比如 RELEASE_LOCK
。