\(^_^)/ MySQL语句

一、连接mysql。

格式： mysql -h主机地址 -u用户名 -p用户密码

1、连接到本机上的MYSQL。

首先打开DOS窗口，然后进入目录mysql\bin，再键入命令mysql -u root -p，回车后提示你输密码.注意用户名前可以有空格也可以没有空格，但是密码前必须没有空格，否则让你重新输入密码.

如果刚安装好MYSQL，超级用户root是没有密码的，故直接回车即可进入到MYSQL中了，MYSQL的提示符是： mysql>

2、连接到远程主机上的MYSQL。假设远程主机的IP为：110.110.110.110，用户名为root,密码为abcd123。则键入以下命令：

   mysql -h110.110.110.110 -u root -p 123;（注:u与root之间可以不用加空格，其它也一样）

3、退出MYSQL命令： exit （回车）

 

 

 

 

二、修改密码。

格式：mysqladmin -u用户名 -p旧密码 password 新密码

1、给root加个密码ab12。首先在DOS下进入目录mysql\bin，然后键入以下命令

   mysqladmin -u root -password ab12

   注：因为开始时root没有密码，所以-p旧密码一项就可以省略了。

2、再将root的密码改为djg345。

   mysqladmin -u root -p ab12 password djg345

   

   

   

   

三、增加新用户。

（注意：和上面不同，下面的因为是MYSQL环境中的命令，所以后面都带一个分号作为命令结束符）

格式：grant select on 数据库.* to 用户名@登录主机 identified by "密码"

1、增加一个用户test1密码为abc，让他可以在任何主机上登录，并对所有数据库有查询、插入、修改、删除的权限。首先用root用户连入MYSQL，然后键入以下命令：

   grant select,insert,update,delete on *.* to test1@"%" identified by "abc";

   但增加的用户是十分危险的，你想如某个人知道test1的密码，那么他就可以在internet上的任何一台电脑上登录你的mysql数据库并对你的数据可以为所欲为了，解决办法见2。

2、增加一个用户test2密码为abc,让他只可以在localhost上登录，并可以对数据库mydb进行查询、插入、修改、删除的操作（localhost指本地主机，即MYSQL数据库所在的那台主机），

   这样用户即使用知道test2的密码，他也无法从internet上直接访问数据库，只能通过MYSQL主机上的web页来访问了。

   grant select,insert,update,delete on mydb.* to test2@localhost identified by "abc";

   如果你不想test2有密码，可以再打一个命令将密码消掉。

   grant select,insert,update,delete on mydb.* to test2@localhost identified by "";

 

   

   

   

四、显示命令 

mysql> select version();        查看MySQL的版本号

mysql> select current_date();        查看MySQL的当前日期

mysql> select version(),current_date(); 同时查看MySQL的版本号和当前日期

mysql> show databases;            显示当前存在的数据库

mysql> use mysql            选择使用数据库(USE和QUIT命令不需要分号结束)

Database changed

mysql> select database();        显示当前选择的数据库

mysql> show tables;            显示当前数据库中存在的表

mysql> select * from db;        显示表(db)的内容    

mysql> describe mytable;        显示表的结构

 

1、显示当前数据库服务器中的数据库列表：

mysql> SHOW DATABASES;

注意：mysql库里面有MYSQL的系统信息，我们改密码和新增用户，实际上就是用这个库进行操作。

2、显示数据库中的数据表：

mysql> USE 库名； 

mysql> SHOW TABLES;

3、显示数据表的结构：

mysql> DESCRIBE 表名;

4、建立数据库：

mysql> CREATE DATABASE 库名;

5、建立数据表：

mysql> USE 库名;

mysql> CREATE TABLE 表名 (字段名 VARCHAR(20), 字段名 CHAR(1));

6、删除数据库：

mysql> DROP DATABASE 库名;

7、删除数据表：

mysql> DROP TABLE 表名；

8、将表中记录清空：

mysql> DELETE FROM 表名;

9、显示表中的记录：

mysql> SELECT * FROM 表名;

10、往表中插入记录：

mysql> INSERT INTO 表名 VALUES ("hyq","M");

11、更新表中数据：

mysql-> UPDATE 表名 SET 字段名1='a',字段名2='b' WHERE 字段名3='c';

12、用文本方式将数据装入数据表中：

mysql> LOAD DATA LOCAL INFILE "D:/mysql.txt" INTO TABLE 表名;

13、导入.sql文件命令：

mysql> USE 数据库名;

mysql> SOURCE d:/mysql.sql;

14、命令行修改root密码：

mysql> UPDATE mysql.user SET password=PASSWORD('新密码') WHERE User='root';

mysql> FLUSH PRIVILEGES;

注意用此种方法修改密码时别忘了 password=password('新密码') 如果直接用 password='新密码'，下次登录时会出现问题以至于登录不进去，因为此密码没用经过password()函数处理，这样写入到user表中的密码系统不能识别就会显示用户名和密码错误的信息。

如果在修改密码的过程中出现问题以至于没有一个用户可以进入mysql则可以用以下的方法重新修改用户名和密码：

bin>mysqld --skip-grant-tables;然后再在 另外一个bin>mysql 便可直接进入mysql ,进入后便修改相关数据。

15、显示use的数据库名：

mysql> SELECT DATABASE();

16、显示当前的user：

mysql> SELECT USER();

 

 

 

 

五、一个建库和建表以及插入数据的实例

drop database if exists school; //如果存在SCHOOL则删除

create database school; //建立库SCHOOL

use school; //打开库SCHOOL

create table teacher //建立表TEACHER

(

id int(3) auto_increment not null primary key,

name char(10) not null,

address varchar(50) default '深圳',

year date

); //建表结束

//以下为插入字段

insert into teacher values('','allen','大连一中','1976-10-10');

insert into teacher values('','jack','大连二中','1975-12-23');

如果你在mysql提示符键入上面的命令也可以，但不方便调试。

（1）你可以将以上命令原样写入一个文本文件中，假设为school.sql，然后复制到c:\\下，并在DOS状态进入目录，然后键入以下命令：

     mysql -uroot -p密码 < c:\\school.sql

     如果成功，空出一行无任何显示；如有错误，会有提示。（以上命令已经调试，你只要将//的注释去掉即可使用）。

（2）或者进入命令行后使用 mysql> source c:\\school.sql; 也可以将school.sql文件导入数据库中。

 

 

 

 

六、将文本数据转到数据库中

1、文本数据应符合的格式：字段数据之间用tab键隔开，null值用来代替.例：

   3 rose 大连二中 1976-10-10

   4 mike 大连一中 1975-12-23

   假设你把这两组数据存为school.txt文件，放在c盘根目录下。

2、数据传入命令 load data local infile "c:\\school.txt" into table 表名;

   注意：你最好将文件复制到目录下，并且要先用use命令打表所在的库。

 

   

   

   

七、备份数据库：（命令在DOS的目录下执行）

1.导出整个数据库

导出文件默认是存在mysql\bin目录下

mysqldump -u 用户名 -p 数据库名 > 导出的文件名

mysqldump -u user_name -p123456 database_name > outfile_name.sql

2.导出一个表

mysqldump -u 用户名 -p 数据库名 表名> 导出的文件名

mysqldump -u user_name -p database_name table_name > outfile_name.sql

3.导出一个数据库结构

mysqldump -u user_name -p -d --add-drop-table database_name > outfile_name.sql

-d 没有数据 --add-drop-table 在每个create语句之前增加一个drop table

4.带语言参数导出

mysqldump -uroot -p --default-character-set=latin1 --set-charset=gbk --skip-opt database_name > outfile_name.sql

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

--语 句 功 能

 

--数据操作

SELECT --从数据库表中检索数据行和列-select

INSERT --向数据库表添加新数据行-insert

DELETE --从数据库表中删除数据行-delete

UPDATE --更新数据库表中的数据-update

 

--数据定义

CREATE TABLE --创建一个数据库表-create table

DROP TABLE --从数据库中删除表-drop table

ALTER TABLE --修改数据库表结构-alter table

CREATE VIEW --创建一个视图-create view

DROP VIEW --从数据库中删除视图-drop view

CREATE INDEX --为数据库表创建一个索引-create index

DROP INDEX --从数据库中删除索引-drop index

CREATE PROCEDURE --创建一个存储过程-create procedure

DROP PROCEDURE --从数据库中删除存储过程-drop procedure

CREATE TRIGGER --创建一个触发器-create trigger

DROP TRIGGER --从数据库中删除触发器-drop trigger

CREATE SCHEMA --向数据库添加一个新模式-create schema

DROP SCHEMA --从数据库中删除一个模式-drop schema

CREATE DOMAIN --创建一个数据值域-create domain

ALTER DOMAIN --改变域定义-alter domain

DROP DOMAIN --从数据库中删除一个域-drop domain

 

--数据控制

GRANT --授予用户访问权限-grant

DENY --拒绝用户访问-deny

REVOKE --解除用户访问权限-revoke

 

--事务控制

COMMIT --结束当前事务-commit

ROLLBACK --中止当前事务-rollback

SET TRANSACTION --定义当前事务数据访问特征-set transaction

 

--程序化SQL

DECLARE --为查询设定游标-declare

EXPLAN --为查询描述数据访问计划-explan

OPEN --检索查询结果打开一个游标-open

FETCH --检索一行查询结果-fetch

CLOSE --关闭游标-cloce

PREPARE --为动态执行准备SQL 语句-repare

EXECUTE --动态地执行SQL 语句-execute

DESCRIBE --描述准备好的查询 -describe

 

 

---局部变量

---必须以@@开头

 

--IF ELSE

declare @x int @y int @z int

select @x = 1 @y = 2 @z=3

if @x > @y

print 'x > y' --打印字符串'x > y'

else if @y > @z

print 'y > z'

else print 'z > y'

 

--CASE

use pangu

update employee

set e_wage =

case

when job_level = ’1’ then e_wage*1.08

when job_level = ’2’ then e_wage*1.07

when job_level = ’3’ then e_wage*1.06

else e_wage*1.05

end

 

--WHILE CONTINUE BREAK

declare @x int @y int @c int

select @x = 1 @y=1

while @x < 3

begin

print @x --打印变量x 的值

while @y < 3

begin

select @c = 100*@x + @y

print @c --打印变量c 的值

select @y = @y + 1

end

select @x = @x + 1

select @y = 1

end

 

--WAITFOR

--例 等待1 小时2 分零3 秒后才执行SELECT 语句

waitfor delay ’01:02:03’

select * from employee

--例 等到晚上11 点零8 分后才执行SELECT 语句

waitfor time ’23:08:00’

select * from employee

 

 

***SELECT***

select *(列名) from table_name(表名) where column_name operator value

ex:(宿主)

select * from stock_information where stockid = str(nid)

stockname = 'str_name' 

stockname like '% find this %' 

stockname like '[a-zA-Z]%' --------- ([]指定值的范围)

stockname like '[^F-M]%' --------- (^排除指定范围)

--------- 只能在使用like关键字的where子句中使用通配符)

or stockpath = 'stock_path'

or stocknumber < 1000

and stockindex = 24

not stock*** = 'man'

stocknumber between 20 and 100

stocknumber in(10,20,30)

order by stockid desc(asc) --------- 排序，desc-降序，asc-升序

order by 1,2 --------- by列号

stockname = (select stockname from stock_information where stockid = 4)

--------- 子查询

--------- 除非能确保内层select只返回一个行的值，

--------- 否则应在外层where子句中用一个in限定符

select distinct column_name form table_name --------- distinct指定检索独有的列值，不重复

select stocknumber ,"stocknumber + 10" = stocknumber + 10 from table_name

select stockname , "stocknumber" = count(*) from table_name group by stockname

--------- group by 将表按行分组,指定列中有相同的值

having count(*) = 2 --------- having选定指定的组

 

select * 

from table1, table2 

where table1.id *= table2.id -------- 左外部连接，table1中有的而table2中没有得以null表示

table1.id =* table2.id -------- 右外部连接 

 

select stockname from table1

union [all] ----- union合并查询结果集，all-保留重复行

select stockname from table2

 

 

***insert***

insert into table_name (Stock_name,Stock_number) value ("xxx","xxxx")

value (select Stockname , Stocknumber from Stock_table2)---value为select语句

 

 

***update***

update table_name set Stockname = "xxx" [where Stockid = 3]

Stockname = default

Stockname = null

Stocknumber = Stockname + 4

 

 

***delete***

delete from table_name where Stockid = 3

truncate table_name ----------- 删除表中所有行，仍保持表的完整性

drop table table_name --------------- 完全删除表

 

 

***alter table*** --- 修改数据库表结构

alter table database.owner.table_name add column_name char(2) null .....

sp_help table_name ---- 显示表已有特征

create table table_name (name char(20), age smallint, lname varchar(30))

insert into table_name select ......... ----- 实现删除列的方法（创建新表）

alter table table_name drop constraint Stockname_default ---- 删除Stockname的default约束

 

 

***function(/*常用函数*/)***

----统计函数----

AVG --求平均值

COUNT --统计数目

MAX --求最大值

MIN --求最小值

SUM --求和

 

--AVG

use pangu

select avg(e_wage) as dept_avgWage

from employee

group by dept_id

 

--MAX

--求工资最高的员工姓名

use pangu

select e_name

from employee

where e_wage =

(select max(e_wage)

from employee)

 

--STDEV()

--STDEV()函数返回表达式中所有数据的标准差

 

--STDEVP()

--STDEVP()函数返回总体标准差

 

--VAR()

--VAR()函数返回表达式中所有值的统计变异数

 

--VARP()

--VARP()函数返回总体变异数

 

 

 

----算术函数----

 

/***三角函数***/

SIN(float_expression) --返回以弧度表示的角的正弦

COS(float_expression) --返回以弧度表示的角的余弦

TAN(float_expression) --返回以弧度表示的角的正切

COT(float_expression) --返回以弧度表示的角的余切

 

/***反三角函数***/

ASIN(float_expression) --返回正弦是FLOAT 值的以弧度表示的角

ACOS(float_expression) --返回余弦是FLOAT 值的以弧度表示的角

ATAN(float_expression) --返回正切是FLOAT 值的以弧度表示的角

ATAN2(float_expression1,float_expression2) 

 

--返回正切是float_expression1 /float_expres-sion2的以弧度表示的角

DEGREES(numeric_expression)

--把弧度转换为角度返回与表达式相同的数据类型可为

--INTEGER/MONEY/REAL/FLOAT 类型

RADIANS(numeric_expression) --把角度转换为弧度返回与表达式相同的数据类型可为

--INTEGER/MONEY/REAL/FLOAT 类型

EXP(float_expression) --返回表达式的指数值

LOG(float_expression) --返回表达式的自然对数值

LOG10(float_expression)--返回表达式的以10 为底的对数值

SQRT(float_expression) --返回表达式的平方根

 

/***取近似值函数***/

CEILING(numeric_expression) --返回>=表达式的最小整数返回的数据类型与表达式相同可为

--INTEGER/MONEY/REAL/FLOAT 类型

FLOOR(numeric_expression) --返回<=表达式的最小整数返回的数据类型与表达式相同可为

--INTEGER/MONEY/REAL/FLOAT 类型

ROUND(numeric_expression) --返回以integer_expression 为精度的四舍五入值返回的数据

--类型与表达式相同可为INTEGER/MONEY/REAL/FLOAT 类型

ABS(numeric_expression) --返回表达式的绝对值返回的数据类型与表达式相同可为

--INTEGER/MONEY/REAL/FLOAT 类型

SIGN(numeric_expression) --测试参数的正负号返回0 零值1 正数或-1 负数返回的数据类型

--与表达式相同可为INTEGER/MONEY/REAL/FLOAT 类型

PI() --返回值为π 即3.1415926535897936

RAND([integer_expression]) --用任选的[integer_expression]做种子值得出0-1 间的随机浮点数

 

----字符串函数----

ASCII() --函数返回字符表达式最左端字符的ASCII 码值

CHAR() --函数用于将ASCII 码转换为字符

--如果没有输入0 ~ 255 之间的ASCII 码值CHAR 函数会返回一个NULL 值

LOWER() --函数把字符串全部转换为小写

UPPER() --函数把字符串全部转换为大写

STR() --函数把数值型数据转换为字符型数据

LTRIM() --函数把字符串头部的空格去掉

RTRIM() --函数把字符串尾部的空格去掉

LEFT(),RIGHT(),SUBSTRING() --函数返回部分字符串

CHARINDEX(),PATINDEX() --函数返回字符串中某个指定的子串出现的开始位置

SOUNDEX() --函数返回一个四位字符码 

--SOUNDEX函数可用来查找声音相似的字符串但SOUNDEX函数对数字和汉字均只返回0 值 

DIFFERENCE() --函数返回由SOUNDEX 函数返回的两个字符表达式的值的差异

--0 两个SOUNDEX 函数返回值的第一个字符不同

--1 两个SOUNDEX 函数返回值的第一个字符相同

--2 两个SOUNDEX 函数返回值的第一二个字符相同

--3 两个SOUNDEX 函数返回值的第一二三个字符相同

--4 两个SOUNDEX 函数返回值完全相同

 

QUOTENAME() --函数返回被特定字符括起来的字符串

/*select quotename('abc', '{') quotename('abc')

运行结果如下

----------------------------------{

{abc} [abc]*/

 

REPLICATE() --函数返回一个重复character_expression 指定次数的字符串

/*select replicate('abc', 3) replicate( 'abc', -2)

运行结果如下

----------- -----------

abcabcabc NULL*/

 

REVERSE() --函数将指定的字符串的字符排列顺序颠倒

REPLACE() --函数返回被替换了指定子串的字符串

/*select replace('abc123g', '123', 'def')

运行结果如下

----------- -----------

abcdefg*/

 

SPACE() --函数返回一个有指定长度的空白字符串

STUFF() --函数用另一子串替换字符串指定位置长度的子串

 

 

----数据类型转换函数----

CAST() 函数语法如下

CAST() (<expression> AS <data_ type>[ length ])

CONVERT() 函数语法如下

CONVERT() (<data_ type>[ length ], <expression> [, style])

 

select cast(100+99 as char) convert(varchar(12), getdate())

运行结果如下

------------------------------ ------------

199 Jan 15 2000

 

----日期函数----

DAY() --函数返回date_expression 中的日期值

MONTH() --函数返回date_expression 中的月份值

YEAR() --函数返回date_expression 中的年份值

DATEADD(<datepart> ,<number> ,<date>) 

--函数返回指定日期date 加上指定的额外日期间隔number 产生的新日期

DATEDIFF(<datepart> ,<number> ,<date>)

--函数返回两个指定日期在datepart 方面的不同之处

DATENAME(<datepart> , <date>) --函数以字符串的形式返回日期的指定部分

DATEPART(<datepart> , <date>) --函数以整数值的形式返回日期的指定部分

GETDATE() --函数以DATETIME 的缺省格式返回系统当前的日期和时间

 

 

----系统函数----

APP_NAME() --函数返回当前执行的应用程序的名称

COALESCE() --函数返回众多表达式中第一个非NULL 表达式的值

COL_LENGTH(<'table_name'>, <'column_name'>) --函数返回表中指定字段的长度值

COL_NAME(<table_id>, <column_id>) --函数返回表中指定字段的名称即列名

DATALENGTH() --函数返回数据表达式的数据的实际长度

DB_ID(['database_name']) --函数返回数据库的编号

DB_NAME(database_id) --函数返回数据库的名称

HOST_ID() --函数返回服务器端计算机的名称

HOST_NAME() --函数返回服务器端计算机的名称

IDENTITY(<data_type>[, seed increment]) [AS column_name])

--IDENTITY() 函数只在SELECT INTO 语句中使用用于插入一个identity column列到新表中

/*select identity(int, 1, 1) as column_name

into newtable

from oldtable*/

ISDATE() --函数判断所给定的表达式是否为合理日期

ISNULL(<check_expression>, <replacement_value>) --函数将表达式中的NULL 值用指定值替换

ISNUMERIC() --函数判断所给定的表达式是否为合理的数值

NEWID() --函数返回一个UNIQUEIDENTIFIER 类型的数值

NULLIF(<expression1>, <expression2>)

--NULLIF 函数在expression1 与expression2 相等时返回NULL 值若不相等时则返回expression1 的值

 

 

 

sql中的保留字

 

action add aggregate all 

alter after and as 

asc avg avg_row_length auto_increment 

between bigint bit binary 

blob bool both by 

cascade case char character 

change check checksum column 

columns comment constraint create 

cross current_date current_time current_timestamp 

data database databases date 

datetime day day_hour day_minute 

day_second dayofmonth dayofweek dayofyear 

dec decimal default delayed 

delay_key_write delete desc describe 

distinct distinctrow double drop 

end else escape escaped 

enclosed enum explain exists 

fields file first float 

float4 float8 flush foreign 

from for full function 

global grant grants group 

having heap high_priority hour 

hour_minute hour_second hosts identified 

ignore in index infile 

inner insert insert_id int 

integer interval int1 int2 

int3 int4 int8 into 

if is isam join 

key keys kill last_insert_id 

leading left length like 

lines limit load local 

lock logs long longblob 

longtext low_priority max max_rows 

match mediumblob mediumtext mediumint 

middleint min_rows minute minute_second 

modify month monthname myisam 

natural numeric no not 

null on optimize option 

optionally or order outer 

outfile pack_keys partial password 

precision primary procedure process 

processlist privileges read real 

references reload regexp rename 

replace restrict returns revoke 

rlike row rows second 

select set show shutdown 

smallint soname sql_big_tables sql_big_selects 

sql_low_priority_updates sql_log_off sql_log_update sql_select_limit 

sql_small_result sql_big_result sql_warnings straight_join 

starting status string table 

tables temporary terminated text 

then time timestamp tinyblob 

tinytext tinyint trailing to 

type use using unique 

unlock unsigned update usage 

values varchar variables varying 

varbinary with write when 

where year year_month zerofill

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

第一招、mysql服务的启动和停止

net stop mysql

net start mysql

 

第二招、登陆mysql

语法如下： mysql -u用户名 -p用户密码

键入命令mysql -uroot -p， 回车后提示你输入密码，输入12345，然后回车即可进入到mysql中了，mysql的提示符是：

mysql>

注意，如果是连接到另外的机器上，则需要加入一个参数-h机器IP

 

第三招、增加新用户

格式：grant 权限 on 数据库.* to 用户名@登录主机 identified by "密码"

如，增加一个用户user1密码为password1，让其可以在本机上登录， 并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户连入mysql，然后键入以下命令：

grant select,insert,update,delete on *.* to user1@localhost Identified by "password1";

如果希望该用户能够在任何机器上登陆mysql，则将localhost改为"%"。

如果你不想user1有密码，可以再打一个命令将密码去掉。

grant select,insert,update,delete on mydb.* to user1@localhost identified by "";

 

第四招： 操作数据库

登录到mysql中，然后在mysql的提示符下运行下列命令，每个命令以分号结束。

1、 显示数据库列表。

show databases;

缺省有两个数据库：mysql和test。 mysql库存放着mysql的系统和用户权限信息，我们改密码和新增用户，实际上就是对这个库进行操作。

2、 显示库中的数据表：

use mysql;

show tables;

3、 显示数据表的结构：

describe 表名;

4、 建库与删库：

create database 库名;

drop database 库名;

5、 建表：

use 库名;

create table 表名(字段列表);

drop table 表名;

6、 清空表中记录：

delete from 表名;

7、 显示表中的记录：

select * from 表名;

 

第五招、导出和导入数据

1. 导出数据：

mysqldump --opt test > mysql.test

即将数据库test数据库导出到mysql.test文件，后者是一个文本文件

如：mysqldump -u root -p123456 --databases dbname > mysql.dbname

就是把数据库dbname导出到文件mysql.dbname中。

2. 导入数据:

mysqlimport -u root -p123456 < mysql.dbname。

不用解释了吧。

3. 将文本数据导入数据库:

文本数据的字段数据之间用tab键隔开。

use test;

load data local infile "文件名" into table 表名;

1:使用SHOW语句找出在服务器上当前存在什么数据库：

mysql> SHOW DATABASES;

2:2、创建一个数据库MYSQLDATA

mysql> CREATE DATABASE MYSQLDATA;

3:选择你所创建的数据库

mysql> USE MYSQLDATA; (按回车键出现Database changed 时说明操作成功!)

4:查看现在的数据库中存在什么表

mysql> SHOW TABLES;

5:创建一个数据库表

mysql> CREATE TABLE MYTABLE (name VARCHAR(20), sex CHAR(1));

6:显示表的结构：

mysql> DESCRIBE MYTABLE;

7:往表中加入记录

mysql> insert into MYTABLE values ("hyq","M");

8:用文本方式将数据装入数据库表中(例如D:/mysql.txt)

mysql> LOAD DATA LOCAL INFILE "D:/mysql.txt" INTO TABLE MYTABLE;

9:导入.sql文件命令(例如D:/mysql.sql)

mysql>use database;

mysql>source d:/mysql.sql;

10:删除表

mysql>drop TABLE MYTABLE;

11:清空表

mysql>delete from MYTABLE;

12:更新表中数据

mysql>update MYTABLE set sex="f" where name='hyq';

posted on 2006-01-10 16:21 happytian 阅读(6) 评论(0) 编辑 收藏 收藏至365Key

13：备份数据库

mysqldump -u root 库名>xxx.data

14：例2：连接到远程主机上的MYSQL

假设远程主机的IP为：110.110.110.110，用户名为root,密码为abcd123。则键入以下命令：

mysql -h110.110.110.110 -uroot -pabcd123

(注:u与root可以不用加空格，其它也一样)

3、退出MYSQL命令： exit (回车)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

MySQL函数大全：

 

ASCII(str) 

　返回字符串str的第一个字符的ASCII值(str是空串时返回0)

mysql> select ASCII('2');

　　-> 50

mysql> select ASCII(2);

　　-> 50

mysql> select ASCII('dete');

　　-> 100

ORD(str) 

　如果字符串str句首是单字节返回与ASCII()函数返回的相同值。

　如果是一个多字节字符,以格式返回((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]

mysql> select ORD('2');

　　-> 50

 

CONV(N,from_base,to_base) 

　对数字N进制转换,并转换为字串返回(任何参数为NULL时返回NULL,进制范围为2-36进制,当to_base是负数时N作为有符号数否则作无符号数,CONV以64位点精度工作)

mysql> select CONV("a",16,2);

　　-> '1010'

mysql> select CONV("6E",18,8);

　　-> '172'

mysql> select CONV(-17,10,-18);

　　-> '-H'

mysql> select CONV(10+"10"+'10'+0xa,10,10);

　　-> '40'

 

BIN(N) 

　把N转为二进制值并以字串返回(N是BIGINT数字,等价于CONV(N,10,2))

mysql> select BIN(12);

　　-> '1100'

OCT(N) 

　把N转为八进制值并以字串返回(N是BIGINT数字,等价于CONV(N,10,8))

mysql> select OCT(12);

　　-> '14'

 

HEX(N) 

　把N转为十六进制并以字串返回(N是BIGINT数字,等价于CONV(N,10,16))

mysql> select HEX(255);

　　-> 'FF'

 

CHAR(N,...) 

　返回由参数N,...对应的ASCII代码字符组成的一个字串(参数是N,...是数字序列,NULL值被跳过) 

mysql> select CHAR(77,121,83,81,'76');

　　-> 'MySQL'

mysql> select CHAR(77,77.3,'77.3');

　　-> 'MMM'

 

CONCAT(str1,str2,...) 

　把参数连成一个长字符串并返回(任何参数是NULL时返回NULL) 

mysql> select CONCAT('My', 'S', 'QL');

　　-> 'MySQL'

mysql> select CONCAT('My', NULL, 'QL');

　　-> NULL

mysql> select CONCAT(14.3);

　　-> '14.3'

LENGTH(str) 

OCTET_LENGTH(str)

CHAR_LENGTH(str)

CHARACTER_LENGTH(str)

　返回字符串str的长度(对于多字节字符CHAR_LENGTH仅计算一次)

mysql> select LENGTH('text');

　　-> 4

mysql> select OCTET_LENGTH('text');

　　-> 4

LOCATE(substr,str) 

POSITION(substr IN str) 

　返回字符串substr在字符串str第一次出现的位置(str不包含substr时返回0)

mysql> select LOCATE('bar', 'foobarbar');

　　-> 4

mysql> select LOCATE('xbar', 'foobar');

　　-> 0

  

LOCATE(substr,str,pos)

　返回字符串substr在字符串str的第pos个位置起第一次出现的位置(str不包含substr时返回0)

mysql> select LOCATE('bar', 'foobarbar',5);

　　-> 7

INSTR(str,substr) 

　返回字符串substr在字符串str第一次出现的位置(str不包含substr时返回0)

mysql> select INSTR('foobarbar', 'bar');

　　-> 4

mysql> select INSTR('xbar', 'foobar');

　　-> 0

LPAD(str,len,padstr) 

　用字符串padstr填补str左端直到字串长度为len并返回

mysql> select LPAD('hi',4,'??');

　　-> '??hi'

 

RPAD(str,len,padstr) 

　用字符串padstr填补str右端直到字串长度为len并返回

mysql> select RPAD('hi',5,'?');

　　-> 'hi???'

LEFT(str,len) 

　返回字符串str的左端len个字符

mysql> select LEFT('foobarbar', 5);

　　-> 'fooba'

RIGHT(str,len) 

　返回字符串str的右端len个字符 

mysql> select RIGHT('foobarbar', 4);

　　-> 'rbar'

SUBSTRING(str,pos,len) 

SUBSTRING(str FROM pos FOR len) 

MID(str,pos,len) 

　返回字符串str的位置pos起len个字符(使用FROM的丑陋语法是ANSI SQL92标准)

mysql> select SUBSTRING('Quadratically',5,6);

　　-> 'ratica'

SUBSTRING(str,pos) 

SUBSTRING(str FROM pos) 

　返回字符串str的位置pos起的一个子串

mysql> select SUBSTRING('Quadratically',5);

　　-> 'ratically'

mysql> select SUBSTRING('foobarbar' FROM 4);

　　-> 'barbar'

SUBSTRING_INDEX(str,delim,count) 

　返回从字符串str的第count个出现的分隔符delim之后的子串(count为正数时返回左端,否则返回右端子串)

mysql> select SUBSTRING_INDEX('www.mysql.com', '.', 2);

　　-> 'www.mysql'

mysql> select SUBSTRING_INDEX('www.mysql.com', '.', -2);

　　-> 'mysql.com'

LTRIM(str) 

　返回删除了左空格的字符串str

mysql> select LTRIM('  barbar');

　　-> 'barbar'

RTRIM(str) 

　返回删除了右空格的字符串str

mysql> select RTRIM('barbar   ');

　　-> 'barbar'

TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str) 

　返回前缀或后缀remstr被删除了的字符串str(位置参数默认BOTH,remstr默认值为空格)

mysql> select TRIM('  bar   ');

　　-> 'bar'

mysql> select TRIM(LEADING 'x' FROM 'xxxbarxxx');

　　-> 'barxxx'

mysql> select TRIM(BOTH 'x' FROM 'xxxbarxxx');

　　-> 'bar'

mysql> select TRIM(TRAILING 'xyz' FROM 'barxxyz');

　　-> 'barx'

SOUNDEX(str) 

　返回str的一个同音字符串(听起来“大致相同”字符串有相同的同音字符串,非数字字母字符被忽略,在A-Z外的字母被当作元音)

mysql> select SOUNDEX('Hello');

　　-> 'H400'

mysql> select SOUNDEX('Quadratically');

　　-> 'Q36324'

 

SPACE(N) 

　返回由N个空格字符组成的一个字符串

mysql> select SPACE(6);

　　-> '      '

 

REPLACE(str,from_str,to_str) 

　用字符串to_str替换字符串str中的子串from_str并返回

mysql> select REPLACE('www.mysql.com', 'w', 'Ww');

　　-> 'WwWwWw.mysql.com'

REPEAT(str,count) 

　返回由count个字符串str连成的一个字符串(任何参数为NULL时返回NULL,count<=0时返回一个空字符串)

mysql> select REPEAT('MySQL', 3);

　　-> 'MySQLMySQLMySQL'

 

REVERSE(str) 

　颠倒字符串str的字符顺序并返回

mysql> select REVERSE('abc');

　　-> 'cba'

INSERT(str,pos,len,newstr) 

　把字符串str由位置pos起len个字符长的子串替换为字符串newstr并返回

mysql> select INSERT('Quadratic', 3, 4, 'What');

　　-> 'QuWhattic'

ELT(N,str1,str2,str3,...) 

　返回第N个字符串(N小于1或大于参数个数返回NULL)

mysql> select ELT(1, 'ej', 'Heja', 'hej', 'foo');

　　-> 'ej'

mysql> select ELT(4, 'ej', 'Heja', 'hej', 'foo');

　　-> 'foo'

FIELD(str,str1,str2,str3,...) 

　返回str等于其后的第N个字符串的序号(如果str没找到返回0)

mysql> select FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');

　　-> 2

mysql> select FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');

　　-> 0

FIND_IN_SET(str,strlist) 

　返回str在字符串集strlist中的序号(任何参数是NULL则返回NULL,如果str没找到返回0,参数1包含","时工作异常)

mysql> SELECT FIND_IN_SET('b','a,b,c,d');

　　-> 2

 

MAKE_SET(bits,str1,str2,...)

　把参数1的数字转为二进制,假如某个位置的二进制位等于1,对应位置的字串选入字串集并返回(NULL串不添加到结果中)

mysql> SELECT MAKE_SET(1,'a','b','c');

　　-> 'a'

mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');

　　-> 'hello,world'

mysql> SELECT MAKE_SET(0,'a','b','c');

　　-> ''

EXPORT_SET(bits,on,off,[separator,[number_of_bits]]) 

　按bits排列字符串集,只有当位等于1时插入字串on,否则插入off(separator默认值",",number_of_bits参数使用时长度不足补0而过长截断) 

mysql> select EXPORT_SET(5,'Y','N',',',4)

　　-> Y,N,Y,N

LCASE(str)

LOWER(str) 

　返回小写的字符串str

mysql> select LCASE('QUADRATICALLY');

　　-> 'quadratically'

 

UCASE(str) 

UPPER(str) 

　返回大写的字符串str

mysql> select UCASE('quadratically');

　　-> 'QUADRATICALLY'

LOAD_FILE(file_name) 

　读入文件并且作为一个字符串返回文件内容(文件无法找到,路径不完整,没有权限,长度大于max_allowed_packet会返回NULL)

mysql> UPDATE table_name SET blob_column=LOAD_FILE("/tmp/picture") WHERE id=1;

[color=red]数学函数[/color]

ABS(N)

　返回N的绝对值

mysql> select ABS(2);  

　　-> 2  

mysql> select ABS(-32);  

　　-> 32  

 

SIGN(N)

　返回参数的符号(为-1、0或1)

mysql> select SIGN(-32);  

　　-> -1  

mysql> select SIGN(0);  

　　-> 0  

mysql> select SIGN(234);  

　　-> 1 

MOD(N,M)  

　取模运算,返回N被M除的余数(同%操作符)  

mysql> select MOD(234, 10);  

　　-> 4  

mysql> select 234 % 10;  

　　-> 4  

mysql> select MOD(29,9);  

　　-> 2 

FLOOR(N)

　返回不大于N的最大整数值

mysql> select FLOOR(1.23);  

　　-> 1  

mysql> select FLOOR(-1.23);  

　　-> -2 

CEILING(N)

　返回不小于N的最小整数值

mysql> select CEILING(1.23);  

　　-> 2  

mysql> select CEILING(-1.23);  

　　-> -1 

ROUND(N,D)

　返回N的四舍五入值,保留D位小数(D的默认值为0)

mysql> select ROUND(-1.23);  

　　-> -1  

mysql> select ROUND(-1.58);  

　　-> -2  

mysql> select ROUND(1.58);  

　　-> 2  

mysql> select ROUND(1.298, 1);  

　　-> 1.3  

mysql> select ROUND(1.298, 0);  

　　-> 1 

EXP(N)

　返回值e的N次方(自然对数的底)

mysql> select EXP(2);  

　　-> 7.389056  

mysql> select EXP(-2);  

　　-> 0.135335 

LOG(N)

　返回N的自然对数

mysql> select LOG(2);  

　　-> 0.693147  

mysql> select LOG(-2);  

　　-> NULL 

LOG10(N)

　返回N以10为底的对数

mysql> select LOG10(2);  

　　-> 0.301030  

mysql> select LOG10(100);  

　　-> 2.000000  

mysql> select LOG10(-100);  

　　-> NULL 

POW(X,Y)  

POWER(X,Y)  

　返回值X的Y次幂

mysql> select POW(2,2);  

　　-> 4.000000  

mysql> select POW(2,-2);  

　　-> 0.250000

SQRT(N)

　返回非负数N的平方根

mysql> select SQRT(4);  

　　-> 2.000000  

mysql> select SQRT(20);  

　　-> 4.472136 

PI()  

　返回圆周率 

mysql> select PI();  

　　-> 3.141593 

COS(N)

　返回N的余弦值

mysql> select COS(PI());

　　-> -1.000000 

SIN(N)

　返回N的正弦值 

mysql> select SIN(PI());  

　　-> 0.000000 

TAN(N)

　返回N的正切值

mysql> select TAN(PI()+1);  

　　-> 1.557408 

ACOS(N)

　返回N反余弦(N是余弦值,在-1到1的范围,否则返回NULL)

mysql> select ACOS(1);  

　　-> 0.000000  

mysql> select ACOS(1.0001);  

　　-> NULL  

mysql> select ACOS(0);  

　　-> 1.570796 

ASIN(N)

　返回N反正弦值

mysql> select ASIN(0.2);  

　　-> 0.201358  

mysql> select ASIN('foo');  

　　-> 0.000000 

ATAN(N)

　返回N的反正切值

mysql> select ATAN(2);  

　　-> 1.107149  

mysql> select ATAN(-2);  

　　-> -1.107149  

ATAN2(X,Y)  

　返回2个变量X和Y的反正切(类似Y/X的反正切,符号决定象限)

mysql> select ATAN(-2,2);  

　　-> -0.785398  

mysql> select ATAN(PI(),0);  

　　-> 1.570796 

COT(N)

　返回X的余切

mysql> select COT(12);  

　　-> -1.57267341  

mysql> select COT(0);  

　　-> NULL 

RAND()

RAND(N)  

　返回在范围0到1.0内的随机浮点值(可以使用数字N作为初始值)

mysql> select RAND();  

　　-> 0.5925  

mysql> select RAND(20);  

　　-> 0.1811  

mysql> select RAND(20);  

　　-> 0.1811  

mysql> select RAND();  

　　-> 0.2079  

mysql> select RAND();  

　　-> 0.7888 

DEGREES(N)

　把N从弧度变换为角度并返回

mysql> select DEGREES(PI());  

　　-> 180.000000 

RADIANS(N)

　把N从角度变换为弧度并返回 

mysql> select RADIANS(90);  

　　-> 1.570796 

TRUNCATE(N,D)  

　保留数字N的D位小数并返回

mysql> select TRUNCATE(1.223,1);  

　　-> 1.2  

mysql> select TRUNCATE(1.999,1);  

　　-> 1.9  

mysql> select TRUNCATE(1.999,0);  

　　-> 1 

LEAST(X,Y,...)  

　返回最小值(如果返回值被用在整数(实数或大小敏感字串)上下文或所有参数都是整数(实数或大小敏感字串)则他们作为整数(实数或大小敏感字串)比较,否则按忽略大小写的字符串被比较)

mysql> select LEAST(2,0);  

　　-> 0  

mysql> select LEAST(34.0,3.0,5.0,767.0);  

　　-> 3.0  

mysql> select LEAST("B","A","C");  

　　-> "A" 

GREATEST(X,Y,...)  

　返回最大值(其余同LEAST())

mysql> select GREATEST(2,0);  

　　-> 2  

mysql> select GREATEST(34.0,3.0,5.0,767.0);  

　　-> 767.0  

mysql> select GREATEST("B","A","C");  

　　-> "C"  

[color=red]时期时间函数[/color]

DAYOFWEEK(date)  

　返回日期date是星期几(1=星期天,2=星期一,……7=星期六,ODBC标准)

mysql> select DAYOFWEEK('1998-02-03');  

　　-> 3 

WEEKDAY(date)  

　返回日期date是星期几(0=星期一,1=星期二,……6= 星期天)。  

mysql> select WEEKDAY('1997-10-04 22:23:00');  

　　-> 5  

mysql> select WEEKDAY('1997-11-05');  

　　-> 2 

DAYOFMONTH(date)  

　返回date是一月中的第几日(在1到31范围内)  

mysql> select DAYOFMONTH('1998-02-03');  

　　-> 3 

DAYOFYEAR(date)  

　返回date是一年中的第几日(在1到366范围内)  

mysql> select DAYOFYEAR('1998-02-03');  

　　-> 34 

MONTH(date)  

　返回date中的月份数值  

mysql> select MONTH('1998-02-03');  

　　-> 2 

DAYNAME(date)  

　返回date是星期几(按英文名返回)

mysql> select DAYNAME("1998-02-05");  

　　-> 'Thursday' 

MONTHNAME(date)  

　返回date是几月(按英文名返回)

mysql> select MONTHNAME("1998-02-05");  

　　-> 'February' 

QUARTER(date)  

　返回date是一年的第几个季度  

mysql> select QUARTER('98-04-01');  

　　-> 2 

WEEK(date,first) 

　返回date是一年的第几周(first默认值0,first取值1表示周一是周的开始,0从周日开始)

mysql> select WEEK('1998-02-20');  

　　-> 7  

mysql> select WEEK('1998-02-20',0);  

　　-> 7  

mysql> select WEEK('1998-02-20',1);  

　　-> 8 

YEAR(date)  

　返回date的年份(范围在1000到9999)  

mysql> select YEAR('98-02-03');  

　　-> 1998 

HOUR(time)  

　返回time的小时数(范围是0到23) 

mysql> select HOUR('10:05:03');  

　　-> 10 

MINUTE(time)  

　返回time的分钟数(范围是0到59)  

mysql> select MINUTE('98-02-03 10:05:03');  

　　-> 5 

SECOND(time)  

　返回time的秒数(范围是0到59) 

mysql> select SECOND('10:05:03');  

　　-> 3 

PERIOD_ADD(P,N)  

　增加N个月到时期P并返回(P的格式YYMM或YYYYMM)  

mysql> select PERIOD_ADD(9801,2);  

　　-> 199803 

PERIOD_DIFF(P1,P2)  

　返回在时期P1和P2之间月数(P1和P2的格式YYMM或YYYYMM)

mysql> select PERIOD_DIFF(9802,199703);  

　　-> 11 

DATE_ADD(date,INTERVAL expr type)

DATE_SUB(date,INTERVAL expr type)  

ADDDATE(date,INTERVAL expr type)  

SUBDATE(date,INTERVAL expr type)

　对日期时间进行加减法运算

　(ADDDATE()和SUBDATE()是DATE_ADD()和DATE_SUB()的同义词,也可以用运算符+和-而不是函数

　date是一个DATETIME或DATE值,expr对date进行加减法的一个表达式字符串type指明表达式expr应该如何被解释

　[type值 含义 期望的expr格式]:

　SECOND 秒 SECONDS  

　MINUTE 分钟 MINUTES  

　HOUR 时间 HOURS  

　DAY 天 DAYS  

　MONTH 月 MONTHS  

　YEAR 年 YEARS  

　MINUTE_SECOND 分钟和秒 "MINUTES:SECONDS"  

　HOUR_MINUTE 小时和分钟 "HOURS:MINUTES"  

　DAY_HOUR 天和小时 "DAYS HOURS"  

　YEAR_MONTH 年和月 "YEARS-MONTHS"  

　HOUR_SECOND 小时, 分钟， "HOURS:MINUTES:SECONDS"  

　DAY_MINUTE 天, 小时, 分钟 "DAYS HOURS:MINUTES"  

　DAY_SECOND 天, 小时, 分钟, 秒 "DAYS HOURS:MINUTES:SECONDS"

　expr中允许任何标点做分隔符,如果所有是DATE值时结果是一个DATE值,否则结果是一个DATETIME值)

　如果type关键词不完整,则MySQL从右端取值,DAY_SECOND因为缺少小时分钟等于MINUTE_SECOND)

　如果增加MONTH、YEAR_MONTH或YEAR,天数大于结果月份的最大天数则使用最大天数)  

mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;  

　　-> 1998-01-01 00:00:00  

mysql> SELECT INTERVAL 1 DAY + "1997-12-31";  

　　-> 1998-01-01  

mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND;  

　　-> 1997-12-31 23:59:59  

mysql> SELECT DATE_ADD("1997-12-31 23:59:59",INTERVAL 1 SECOND);  

　　-> 1998-01-01 00:00:00  

mysql> SELECT DATE_ADD("1997-12-31 23:59:59",INTERVAL 1 DAY);  

　　-> 1998-01-01 23:59:59  

mysql> SELECT DATE_ADD("1997-12-31 23:59:59",INTERVAL "1:1" MINUTE_SECOND);  

　　-> 1998-01-01 00:01:00  

mysql> SELECT DATE_SUB("1998-01-01 00:00:00",INTERVAL "1 1:1:1" DAY_SECOND);  

　　-> 1997-12-30 22:58:59  

mysql> SELECT DATE_ADD("1998-01-01 00:00:00", INTERVAL "-1 10" DAY_HOUR);

　　-> 1997-12-30 14:00:00  

mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);  

　　-> 1997-12-02  

mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");  

　　-> 1999  

mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");  

　　-> 199907  

mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");  

　　-> 20102 

TO_DAYS(date)  

　返回日期date是西元0年至今多少天(不计算1582年以前)

mysql> select TO_DAYS(950501);  

　　-> 728779  

mysql> select TO_DAYS('1997-10-07');  

　　-> 729669 

FROM_DAYS(N)  

　给出西元0年至今多少天返回DATE值(不计算1582年以前) 

mysql> select FROM_DAYS(729669);  

　　-> '1997-10-07' 

DATE_FORMAT(date,format)  

　根据format字符串格式化date值

　(在format字符串中可用标志符:

　%M 月名字(January……December)  

　%W 星期名字(Sunday……Saturday)  

　%D 有英语前缀的月份的日期(1st, 2nd, 3rd, 等等。）  

　%Y 年, 数字, 4 位  

　%y 年, 数字, 2 位  

　%a 缩写的星期名字(Sun……Sat)  

　%d 月份中的天数, 数字(00……31)  

　%e 月份中的天数, 数字(0……31)  

　%m 月, 数字(01……12)  

　%c 月, 数字(1……12)  

　%b 缩写的月份名字(Jan……Dec)  

　%j 一年中的天数(001……366)  

　%H 小时(00……23)  

　%k 小时(0……23)  

　%h 小时(01……12)  

　%I 小时(01……12)  

　%l 小时(1……12)  

　%i 分钟, 数字(00……59)  

　%r 时间,12 小时(hh:mm:ss [AP]M)  

　%T 时间,24 小时(hh:mm:ss)  

　%S 秒(00……59)  

　%s 秒(00……59)  

　%p AM或PM  

　%w 一个星期中的天数(0=Sunday ……6=Saturday ）  

　%U 星期(0……52), 这里星期天是星期的第一天  

　%u 星期(0……52), 这里星期一是星期的第一天  

　%% 字符% )

mysql> select DATE_FORMAT('1997-10-04 22:23:00','%W %M %Y');  

　　-> 'Saturday October 1997'  

mysql> select DATE_FORMAT('1997-10-04 22:23:00','%H:%i:%s');  

　　-> '22:23:00'  

mysql> select DATE_FORMAT('1997-10-04 22:23:00','%D %y %a %d %m %b %j');  

　　-> '4th 97 Sat 04 10 Oct 277'  

mysql> select DATE_FORMAT('1997-10-04 22:23:00','%H %k %I %r %T %S %w');  

　　-> '22 22 10 10:23:00 PM 22:23:00 00 6' 

TIME_FORMAT(time,format)

　和DATE_FORMAT()类似,但TIME_FORMAT只处理小时、分钟和秒(其余符号产生一个NULL值或0)

CURDATE()   

CURRENT_DATE()

　以'YYYY-MM-DD'或YYYYMMDD格式返回当前日期值(根据返回值所处上下文是字符串或数字)  

mysql> select CURDATE();  

　　-> '1997-12-15'  

mysql> select CURDATE() + 0;  

　　-> 19971215 

CURTIME()  

CURRENT_TIME()

　以'HH:MM:SS'或HHMMSS格式返回当前时间值(根据返回值所处上下文是字符串或数字)    

mysql> select CURTIME();  

　　-> '23:50:26'  

mysql> select CURTIME() + 0;  

　　-> 235026 

NOW()  

SYSDATE()  

CURRENT_TIMESTAMP()

　以'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS格式返回当前日期时间(根据返回值所处上下文是字符串或数字)   

mysql> select NOW();  

　　-> '1997-12-15 23:50:26'  

mysql> select NOW() + 0;  

　　-> 19971215235026 

UNIX_TIMESTAMP()  

UNIX_TIMESTAMP(date)  

　返回一个Unix时间戳(从'1970-01-01 00:00:00'GMT开始的秒数,date默认值为当前时间)

mysql> select UNIX_TIMESTAMP();  

　　-> 882226357  

mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');  

　　-> 875996580 

FROM_UNIXTIME(unix_timestamp)  

　以'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS格式返回时间戳的值(根据返回值所处上下文是字符串或数字)   

mysql> select FROM_UNIXTIME(875996580);  

　　-> '1997-10-04 22:23:00'  

mysql> select FROM_UNIXTIME(875996580) + 0;  

　　-> 19971004222300 

FROM_UNIXTIME(unix_timestamp,format)  

　以format字符串格式返回时间戳的值

mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),'%Y %D %M %h:%i:%s %x');  

　　-> '1997 23rd December 03:43:30 x' 

SEC_TO_TIME(seconds)  

　以'HH:MM:SS'或HHMMSS格式返回秒数转成的TIME值(根据返回值所处上下文是字符串或数字)   

mysql> select SEC_TO_TIME(2378);  

　　-> '00:39:38'  

mysql> select SEC_TO_TIME(2378) + 0;  

　　-> 3938 

TIME_TO_SEC(time)  

　返回time值有多少秒  

mysql> select TIME_TO_SEC('22:23:00');  

　　-> 80580  

mysql> select TIME_TO_SEC('00:39:38');  

　　-> 2378

 

 

 

 

 

MySQL有关权限的表:

MySQL服务器通过权限表来控制用户对数据库的访问，权限表存放在mysql数据库里，由mysql_install_db脚本初始化。这些权限表分别user，db，table_priv，columns_priv和host。

下面分别介绍一下这些表的结构和内容：

1.user权限表：记录允许连接到服务器的用户帐号信息，里面的权限是全局级的。

2.db权限表：记录各个帐号在各个数据库上的操作权限。

3.table_priv权限表：记录数据表级的操作权限。

4.columns_priv权限表：记录数据列级的操作权限。

5.host权限表：配合db权限表对给定主机上数据库级操作权限作更细致的控制。这个权限表不受GRANT和REVOKE语句的影响。

 

 

 

 

 

MYSQL支持事务：

在缺省模式下，MYSQL是autocommit模式的，所有的数据库更新操作都会即时提交，所以在缺省情况下，mysql是不支持事务的。

但是如果你的MYSQL表类型是使用InnoDB Tables 或 BDB tables的话，你的MYSQL就可以使用事务处理,使用SET AUTOCOMMIT=0就可以使MYSQL允许在非autocommit模式，

在非autocommit模式下，你必须使用COMMIT来提交你的更改，或者用ROLLBACK来回滚你的更改。

示例如下：

START TRANSACTION;

SELECT @A:=SUM(salary) FROM table1 WHERE type=1;

UPDATE table2 SET summmary=@A WHERE type=1;

COMMIT;

 

 

 

MYSQL中的索引：

索引类型: B-TREE索引，哈希索引

 

B-TREE索引加速了数据访问，因为存储引擎不会扫描整个表得到需要的数据。相反，它从根节点开始。根节点保存了指向子节点的指针，并且存储引擎会根据指针寻找数据。它通过查找节点页中的值找到正确的指针，节点页包含子节点的指针，并且存储引擎会根据指针寻找数据。它通过查找节点页中的值找到正确的指针，节点页包含子节点中值的上界和下界。最后，存储引擎可能无法找到需要的数据，也可能成功地找到包含数据的叶子页面。

例：B-TREE索引 对于以下类型查询有用。匹配全名、匹配最左前缀、匹配列前缀、匹配范围值、精确匹配一部分并且匹配某个范围中的另一部分；

B-TREE索引的局限：如果查找没有从索引列的最左边开始，它就没什么用处。不能跳过索引中的列，存储引擎不能优先访问任何在第一个范围条件右边的列。例：如果查询是where last_name=’Smith’ AND first_name LIKE ‘J%’ AND dob=’1976-12-23’;访问就只能使用索引的头两列，因为LIKE是范围条件。

 

哈希索引建立在哈希表的基础上，它只对使用了索引中的每一列的精确查找有用。对于每一行，存储引擎计算出了被索引列的哈希码，它是一个较小的值，并且有可能和其他行的哈希码不同。它把哈希码保存在索引中，并且保存了一个指向哈希表中每一行的指针。

因为索引只包含了哈希码和行指针，而不是值自身，MYSQL不能使用索引中的值来避免读取行。

MYSQL不能使用哈希索引进行排序，因为它们不会按序保存行。

哈希索引不支持部分键匹配，因为它们是由被索引的全部值计算出来的。也就是说，如果在（A，B）两列上有索引，并且WHERE子句中只使用了A，那么索引就不会起作用。

哈希索引只支持使用了= IN（）和<=>的相等比较。它们不能加快范围查询。例如WHERE  price > 100;

访问哈希索引中的数据非常快，除非碰撞率很高。当发生碰撞的时候，存储引擎必须访问链表中的每一个行指针，然后逐行进行数据比较，以确定正确的数据。如果有很多碰撞，一些索引维护操作就有可能会变慢。

 

 

 

MySQL中数据类型：

VARCHAR和CHAR类型，varchar是变长的，需要额外的1-2个字节存储，能节约空间，可能会对性能有帮助。但由于是变长，可能发生碎片，如更新数据；

使用ENUM代替字符串类型，数据实际存储为整型。

字符串类型

要尽可能地避免使用字符串来做标识符，因为它们占用了很多空间并且通常比整数类型要慢。特别注意不要在MYISAM表上使用字符串标识符。MYISAM默认情况下为字符串使用了压缩索引（Packed Index），这使查找更为缓慢。据测试，使用了压缩索引的MYISAM表性能要慢6倍。

还要特别注意完全‘随机’的字符串，例如由MD5（）、SHA1（）、UUID（）产生的。它们产生的每一个新值都会被任意地保存在很大的空间范围内，这会减慢INSERT及一些SELECT查询。1）它们会减慢INSERT查询，因为插入的值会被随机地放入索引中。这会导致分页、随机磁盘访问及聚集存储引擎上的聚集索引碎片。2)它们会减慢SELECT查询，因为逻辑上相邻的行会分布在磁盘和内存中的各个地方。3）随机值导致缓存对所有类型的查询性能都很差，因为它们会使缓存赖以工作的访问局部性失效。如果整个数据集都变得同样“热”的时候，那么把特定部分的数据缓存到内存中就没有任何的优势了。并且如果工作集不能被装入内存中，缓存就会进行很多刷写的工作，并且会导致很多缓存未命中。

如果保存UUID值，就应该移除其中的短横线，更好的办法是使用UHEX（）把UUID值转化为16字节的数字，并把它保存在BINARY（16）列中。

 

 

 

 

 

聚集索引：

聚集索引

?术语“聚集”指实际的数据行和相关的键值都保存在一起。每个表只能有一个聚集索引。但是，覆盖索引可以模拟多个聚集索引。存储引擎负责实现索引，因此不是所有的存储索引都支持聚集索引。当前，SolidDB和InnoDB是唯一支持聚集索引的存储引擎。

优点：

?可以把相关数据保存在一起。这样从磁盘上提取几个页面的数据就能把某个用户的邮件全部抓取出来。如果没有使用聚集，读取每个邮件都会访问磁盘。

?数据访问快。聚集索引把索引和数据都保存到了同一棵B-TREE中，因此从聚集索引中取得数据通常比在非聚集索引进行查找要快。

缺点：

?聚集能最大限度地提升I/O密集负载的性能。如果数据能装入内存，那么其顺序也就无所谓了。这样聚集就没有什么用处。

?插入速度严重依赖于插入顺序。更新聚集索引列是昂贵的，因为强制InnoDB把每个更新的行移到新的位置。

?建立在聚集索引上的表在插入新行，或者在行的主键被更新，该行必须被移动的时候会进行分页。

?聚集表可会比全表扫描慢，尤其在表存储得比较稀疏或因为分页而没有顺序存储的时候。

?第二（非聚集）索引可能会比预想的大，因为它们的叶子节点包含了被引用行的主键列。第二索引访问需要两次索引查找，而不是一次。 InnoDB的第二索引叶子节点包含了主键值作为指向行的“指针”，而不是“行指针”。 这种策略减少了在移动行或数据分页的时候索引的维护工作。使用行的主键值作为指针使得索引变得更大，但是这意味着InnoDB可以移动行，而无须更新指针。

 

 

 

 

 

 

 

 

 

 

MYSQL优化：

1.数据库的设计

尽量把数据库设计的更小的占磁盘空间.

1).尽可能使用更小的整数类型.(mediumint就比int更合适).

2).尽可能的定义字段为not   null,除非这个字段需要null.

3).如果没有用到变长字段的话比如varchar,那就采用固定大小的纪录格式比如char.

4).表的主索引应该尽可能的短.这样的话每条纪录都有名字标志且更高效.

5).只创建确实需要的索引。索引有利于检索记录，但是不利于快速保存记录。如果总是要在表的组合字段上做搜索，那么就在这些字段上创建索引。索引的第一部分必须是最常使用的字段.如果总是需要用到很多字段，首先就应该多复制这些字段，使索引更好的压缩。

6).所有数据都得在保存到数据库前进行处理。

7).所有字段都得有默认值。

8).在某些情况下,把一个频繁扫描的表分成两个速度会快好多。在对动态格式表扫描以取得相关记录时，它可能使用更小的静态格式表的情况下更是如此。

2.系统的用途

1).尽量使用长连接.

2).explain   复杂的SQL语句。

3).如果两个关联表要做比较话，做比较的字段必须类型和长度都一致.

4).LIMIT语句尽量要跟order   by或者   distinct.这样可以避免做一次full   table   scan.

5).如果想要清空表的所有纪录,建议用truncate   table   tablename而不是delete   from   tablename.

6).能使用STORE   PROCEDURE   或者   USER   FUNCTION的时候.

7).在一条insert语句中采用多重纪录插入格式.而且使用load   data   infile来导入大量数据，这比单纯的indert快好多.

8).经常OPTIMIZE   TABLE   来整理碎片.

9).还有就是date   类型的数据如果频繁要做比较的话尽量保存在unsigned   int   类型比较快。

3.系统的瓶颈

1).磁盘搜索.

并行搜索,把数据分开存放到多个磁盘中，这样能加快搜索时间.

2).磁盘读写(IO)

可以从多个媒介中并行的读取数据。

3).CPU周期

数据存放在主内存中.这样就得增加CPU的个数来处理这些数据。

4).内存带宽

当CPU要将更多的数据存放到CPU的缓存中来的话,内存的带宽就成了瓶颈.

 

 

 

 

 

MySQL 自带 slow log 的分析工具 mysqldumpslow ，但是没有说明。本文通过分析该脚本，介绍了其用法。

slow log 是 MySQL 根据 SQL 语句的执行时间设定，写入的一个文件，用于分析执行较慢的语句。

 

只要在 my.cnf 文件中配置好：

log-slow-queries = [slow_query_log_filename]

即可记录超过默认的 10s 执行时间的 SQL 语句。

如果要修改默认设置，可以添加：

long_query_time = 5

设定为 5s 。

 

如果要记录所有 SQL 语句，可以写入：

log-long-format

 

# t=time, l=lock time, r=rows

# at, al, 以及 ar 是对应的平均值

 

mysqldumpslow 可以接受的参数有：

‘v+’, # verbose

‘d+’, # debug

‘s=s’, # 排序 (t, at, l, al, r, ar etc)

‘r!’, # 倒排序 (largest last instead of first)

‘t=i’, # 显示最高的 n 个查询

‘a!’, # 不把所有的数字以 N ，字符串以 ‘S’ 显示

‘n=i’, # abstract numbers with at least n digits within names

‘g=s’, # grep: only consider stmts that include this string

‘h=s’, # hostname of db server for *-slow.log filename (can be wildcard)

‘i=s’, # name of server instance (if using mysql.server startup script)

‘l!’, # don’t subtract lock time from total time

 

mysql explain的使用说明

explain显示了mysql如何使用索引来处理select语句以及连接表。可以帮助选择更好的索引和写出更优化的查询语句。

使用方法，在select语句前加上explain就可以了：

如：explain select surname,first_name form a,b  where  a.id=b.id

分析结果形式如下：

引用

 

mysql> explain SELECT * FROM `whisper` WHERE to_id = 6696 AND del = 0  AND whisper=0 ORDER BY `send_time` DESC LIMIT 4;

+—-+————-+———+——+—————+——-+———+——-+——+—————————–+

| id | select_type | table   | type | possible_keys | key   | key_len | ref   | rows | Extra                       |

+—-+————-+———+——+—————+——-+———+——-+——+—————————–+

|  1 | SIMPLE      | whisper | ref  | to_id         | to_id |       4 | const |    1 | Using where; Using filesort |

+—-+————-+———+——+—————+——-+———+——-+——+—————————–+

1 row in set (0.00 sec)

 

EXPLAIN列的解释：

table 显示这一行的数据是关于哪张表的

type  这是重要的列，显示连接使用了何种类型。从最好到最差的连接类型为const、eq_reg、ref、range、indexhe和ALL

possible_keys 显示可能应用在这张表中的索引。如果为空，没有可能的索引。可以为相关的域从WHERE语句中选择一个合适的语句

key 实际使用的索引。如果为NULL，则没有使用索引。很少的情况下，MYSQL会选择优化不足的索引。这种情况下，可以在SELECT语句中使用USE INDEX（indexname）来强制使用一个索引或者用IGNORE INDEX（indexname）来强制MYSQL忽略索引

key_len 使用的索引的长度。在不损失精确性的情况下，长度越短越好

ref 显示索引的哪一列被使用了，如果可能的话，是一个常数

rows MYSQL认为必须检查的用来返回请求数据的行数

Extra 关于MYSQL如何解析查询的额外信息。将在表4.3中讨论，但这里可以看到的坏的例子是Using temporary和Using filesort，意思MYSQL根本不能使用索引，结果是检索会很慢

 

extra 列返回的描述的意义

Distinct 一旦MYSQL找到了与行相联合匹配的行，就不再搜索了

Not exists MYSQL优化了LEFT JOIN，一旦它找到了匹配LEFT JOIN标准的行，就不再搜索了

Range checked for each

Record（index map:#）没有找到理想的索引，因此对于从前面表中来的每一个行组合，MYSQL检查使用哪个索引，并用它来从表中返回行。这是使用索引的最慢的连接之一

Using filesort 看到这个的时候，查询就需要优化了。MYSQL需要进行额外的步骤来发现如何对返回的行排序。它根据连接类型以及存储排序键值和匹配条件的全部行的行指针来排序全部行

Using index 列数据是从仅仅使用了索引中的信息而没有读取实际的行动的表返回的，这发生在对表的全部的请求列都是同一个索引的部分的时候

Using temporary 看到这个的时候，查询需要优化了。这里，MYSQL需要创建一个临时表来存储结果，这通常发生在对不同的列集进行ORDER BY上，而不是GROUP BY上

Where used 使用了WHERE从句来限制哪些行将与下一张表匹配或者是返回给用户。如果不想返回表中的全部行，并且连接类型ALL或index，这就会发生，或者是查询有问题

 

不同连接类型的解释（按照效率高低的顺序排序）

system 表只有一行：system表。这是const连接类型的特殊情况

const 表中的一个记录的最大值能够匹配这个查询（索引可以是主键或惟一索引）。因为只有一行，这个值实际就是常数，因为MYSQL先读这个值然后把它当做常数来对待

eq_ref 在连接中，MYSQL在查询时，从前面的表中，对每一个记录的联合都从表中读取一个记录，它在查询使用了索引为主键或惟一键的全部时使用

ref 这个连接类型只有在查询使用了不是惟一或主键的键或者是这些类型的部分（比如，利用最左边前缀）时发生。对于之前的表的每一个行联合，全部记录都将从表中读出。这个类型严重依赖于根据索引匹配的记录多少—越少越好

range 这个连接类型使用索引返回一个范围中的行，比如使用>或<查找东西时发生的情况

index 这个连接类型对前面的表中的每一个记录联合进行完全扫描（比ALL更好，因为索引一般小于表数据）

ALL 这个连接类型对于前面的每一个记录联合进行完全扫描，这一般比较糟糕，应该尽量避免

 

mysql常用的hint（原创）

 

mysql常用的hint

对于经常使用oracle的朋友可能知道，oracle的hint功能种类很多，对于优化sql语句提供了很多方法。同样，在mysql里，也有类似的hint功能。下面介绍一些常用的。

[b]强制索引 FORCE INDEX[/b]

SELECT * FROM TABLE1 FORCE INDEX (FIELD1) …

以上的SQL语句只使用建立在FIELD1上的索引，而不使用其它字段上的索引。

[b]忽略索引 IGNORE INDEX[/b]

SELECT * FROM TABLE1 IGNORE INDEX (FIELD1, FIELD2) …

在上面的SQL语句中，TABLE1表中FIELD1和FIELD2上的索引不被使用。

[b]关闭查询缓冲 SQL_NO_CACHE[/b]

SELECT SQL_NO_CACHE field1, field2 FROM TABLE1;

有一些SQL语句需要实时地查询数据，或者并不经常使用（可能一天就执行一两次）,这样就需要把缓冲关了,不管这条SQL语句是否被执行过，服务器都不会在缓冲区中查找，每次都会执行它。

[b]强制查询缓冲 SQL_CACHE[/b]

SELECT SQL_CALHE * FROM TABLE1;

如果在my.ini中的query_cache_type设成2，这样只有在使用了SQL_CACHE后，才使用查询缓冲。

 

[b]优先操作 HIGH_PRIORITY[/b]

HIGH_PRIORITY可以使用在select和insert操作中，让MYSQL知道，这个操作优先进行。

SELECT HIGH_PRIORITY * FROM TABLE1;

[b]滞后操作 LOW_PRIORITY[/b]

LOW_PRIORITY可以使用在insert和update操作中，让mysql知道，这个操作滞后。

update LOW_PRIORITY table1 set field1= where field1= …

[b]延时插入 INSERT DELAYED[/b]

INSERT DELAYED INTO table1 set field1= …

INSERT DELAYED INTO，是客户端提交数据给MySQL，MySQL返回OK状态给客户端。而这是并不是已经将数据插入表，而是存储在内存里面等待排队。当mysql有 空余时，再插入。另一个重要的好处是，来自许多客户端的插入被集中在一起，并被编写入一个块。这比执行许多独立的插入要快很多。坏处是，不能返回自动递增 的ID，以及系统崩溃时，MySQL还没有来得及插入数据的话，这些数据将会丢失。

 

[b]强制连接顺序 STRAIGHT_JOIN[/b]

SELECT TABLE1.FIELD1, TABLE2.FIELD2 FROM TABLE1 STRAIGHT_JOIN TABLE2 WHERE …

由上面的SQL语句可知，通过STRAIGHT_JOIN强迫MySQL按TABLE1、TABLE2的顺序连接表。如果你认为按自己的顺序比MySQL推荐的顺序进行连接的效率高的话，就可以通过STRAIGHT_JOIN来确定连接顺序。

[b]强制使用临时表 SQL_BUFFER_RESULT[/b]

SELECT SQL_BUFFER_RESULT * FROM TABLE1 WHERE …

当我们查询的结果集中的数据比较多时，可以通过SQL_BUFFER_RESULT.选项强制将结果集放到临时表中，这样就可以很快地释放MySQL的表锁（这样其它的SQL语句就可以对这些记录进行查询了），并且可以长时间地为客户端提供大记录集。

[b]分组使用临时表 SQL_BIG_RESULT和SQL_SMALL_RESULT[/b]

SELECT SQL_BUFFER_RESULT FIELD1, COUNT(*) FROM TABLE1 GROUP BY FIELD1;

一般用于分组或DISTINCT关键字，这个选项通知MySQL，如果有必要，就将查询结果放到临时表中，甚至在临时表中进行排序。SQL_SMALL_RESULT比起SQL_BIG_RESULT差不多，很少使用。

 

查询是数据库技术中最常用的操作。查询操作的过程比较简单，首先从客户端发出查询的SQL语句，数据库服务端在接收到由客户端发来的 SQL语句后， 执行这条SQL语句，然后将查询到的结果返回给客户端。虽然过程很简单，但不同的查询方式和数据库设置，对查询的性能将会有很在的影响。

因此，本文就在MySQL中常用的查询优化技术进行讨论。讨论的内容如：通过查询缓冲提高查询速度；MySQL对查询的自动优化；基于索引的排序；不可达查询的检测和使用各种查询选择来提高性能。

一、 通过查询缓冲提高查询速度

一般我们使用SQL语句进行查询时，数据库服务器每次在收到客户端发来SQL后，都会执行这条SQL语句。但当在一定间隔内(如1分钟内)，接到完 全一样的SQL语句，也同样执行它。虽然这样可以保证数据的实时性，但在大多数时候，数据并不要求完全的实时，也就是说可以有一定的延时。如果是这样的 话，在短时间内执行完全一样的SQL就有些得不偿失。

幸好MySQL为我们提供了查询缓冲的功能(只能在MySQL 4.0.1及以上版本使用查询缓冲)。我们可以通过查询缓冲在一定程度上提高查询性能。

我们可以通过在MySQL安装目录中的my.ini文件设置查询缓冲。设置也非常简单，只需要将query_cache_type设为1即可。在设 置了这个属性后，MySQL在执行任何SELECT语句之前，都会在它的缓冲区中查询是否在相同的SELECT语句被执行过，如果有，并且执行结果没有过 期，那么就直接取查询结果返回给客户端。但在写SQL语句时注意，MySQL的查询缓冲是区分大小写的。如下列的两条SELECT语句:

1.    SELECT * from TABLE1

2.

3.    SELECT * FROM TABLE1

上面的两条SQL语句对于查询缓冲是完全不同的SELECT。而且查询缓冲并不自动处理空格，因此，在写SQL语句时，应尽量减少空格的使用，尤其是在SQL首和尾的空格(因为，查询缓冲并不自动截取首尾空格)。

虽然不设置查询缓冲，有时可能带来性能上的损失，但有一些SQL语句需要实时地查询数据，或者并不经常使用(可能一天就执行一两次)。这样就需要把 缓冲关了。当然，这可以通过设置query_cache_type的值来关闭查询缓冲，但这就将查询缓冲永久地关闭了。在MySQL 5.0中提供了一种可以临时关闭查询缓冲的方法:

1.    SELECT SQL_NO_CACHE field1, field2 FROM TABLE1

以上的SQL语句由于使用了SQL_NO_CACHE，因此，不管这条SQL语句是否被执行过，服务器都不会在缓冲区中查找，每次都会执行它。

我们还可以将my.ini中的query_cache_type设成2，这样只有在使用了SQL_CACHE后，才使用查询缓冲。

1.    SELECT SQL_CALHE * FROM TABLE1

 

二、MySQL对查询的自动优化

索引对于数据库是非常重要的。在查询时可以通过索引来提高性能。但有时使用索引反而会降低性能。我们可以看如下的SALES表:

1.    CREATE TABLE SALES

2.

3.    (

4.

5.    ID INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,

6.

7.    NAME VARCHAR(100) NOT NULL,

8.

9.    PRICE FLOAT NOT NULL,

10.

11.    SALE_COUNT INT NOT NULL,

12.

13.    SALE_DATE DATE NOT NULL,

14.

15.    PRIMARY KEY(ID)，

16.

17.    INDEX (NAME)，

18.

19.    INDEX (SALE_DATE)

20.

21.    );

假设这个表中保存了数百万条数据，而我们要查询商品号为1000的商品在2004年和2005年的平均价格。我们可以写如下的SQL语句:

SELECT AVG(PRICE) FROM SALES

WHERE ID = 1000 AND SALE_DATE BETWEEN ’2004-01-01′ AND ’2005-12-31′;

如果这种商品的数量非常多，差不多占了SALES表的记录的50%或更多。那么使用SALE_DATE字段上索引来计算平均数就有些慢。因为如果使 用索引，就得对索引进行排序操作。当满足条件的记录非常多时(如占整个表的记录的50%或更多的比例)，速度会变慢，这样还不如对整个表进行扫描。因 此，MySQL会自动根据满足条件的数据占整个表的数据的比例自动决定是否使用索引进行查询。

对于MySQL来说，上述的查询结果占整个表的记录的比例是30%左右时就不使用索引了，这个比例是MySQL的开发人员根据他们的经验得出的。然而，实际的比例值会根据所使用的数据库引擎不同而不同。

三、 基于索引的排序

MySQL的弱点之一是它的排序。虽然MySQL可以在1秒中查询大约15,000条记录，但由于MySQL在查询时最多只能使用一个索引。因此，如果WHERE条件已经占用了索引，那么在排序中就不使用索引了，这将大大降低查询的速度。我们可以看看如下的SQL语句:

1.    SELECT * FROM SALES WHERE NAME = “name” ORDER BY SALE_DATE DESC;

在以上的SQL的WHERE子句中已经使用了NAME字段上的索引，因此，在对SALE_DATE进行排序时将不再使用索引。为了解决这个问题，我们可以对SALES表建立复合索引:

1.    ALTER TABLE SALES DROP INDEX NAME, ADD INDEX (NAME, SALE_DATE)

这样再使用上述的SELECT语句进行查询时速度就会大副提升。但要注意，在使用这个方法时，要确保WHERE子句中没有排序字段，在上例中就是不能用SALE_DATE进行查询，否则虽然排序快了，但是SALE_DATE字段上没有单独的索引，因此查询又会慢下来。

四、 不可达查询的检测

在执行SQL语句时，难免会遇到一些必假的条件。所谓必假的条件是无论表中的数据如何变化，这个条件都为假。如WHERE value < 100 AND value > 200。我们永远无法找到一个既小于100又大于200的数。

如果遇到这样的查询条件，再去执行这样的SQL语句就是多此一举。幸好MySQL可以自动检测这种情况。如我们可以看看如下的SQL语句:

1.    SELECT * FROM SALES WHERE NAME = “name1” AND NAME = “name2”

以上的查询语句要查找NAME既等于name1又等于name2的记录。很明显，这是一个不可达的查询，WHERE条件一定是假。MySQL在执行 SQL语句之前，会先分析WHERE条件是否是不可达的查询，如果是，就不再执行这条SQL语句了。为了验证这一点。我们首先对如下的SQL使用 EXPLAIN进行测试:

1.    EXPLAIN SELECT * FROM SALES WHERE NAME = “name1”

上面的查询是一个正常的查询，我们可以看到使用EXPLAIN返回的执行信息数据中table项是SALES。这说明MySQL对SALES进行操作了。再看看下面的语句:

1.    EXPLAIN SELECT * FROM SALES WHERE NAME = “name1” AND NAME = “name2”

我们可以看到，table项是空，这说明MySQL并没有对SALES表进行操作。

五、 使用各种查询选择来提高性能

SELECT语句除了正常的使用外，MySQL还为我们提供了很多可以增强查询性能的选项。如上面介绍的用于控制查询缓冲的SQL_NO_CACHE和SQL_CACHE就是其中两个选项。在这一部分，我将介绍几个常用的查询选项。

1. STRAIGHT_JOIN:强制连接顺序

当我们将两个或多个表连接起来进行查询时，我们并不用关心MySQL先连哪个表，后连哪个表。而这一切都是由MySQL内部通过一系列的计算、评估，最后得出的一个连接顺序决定的。如下列的SQL语句中，TABLE1和TABLE2并不一定是谁连接谁:

1.    SELECT TABLE1.FIELD1, TABLE2.FIELD2 FROM TABLE1 ,TABLE2 WHERE …

如果开发人员需要人为地干预连接的顺序，就得使用STRAIGHT_JOIN关键字，如下列的SQL语句:

1.    SELECT TABLE1.FIELD1, TABLE2.FIELD2 FROM TABLE1 STRAIGHT_JOIN TABLE2 WHERE …

由上面的SQL语句可知，通过STRAIGHT_JOIN强迫MySQL按TABLE1、TABLE2的顺序连接表。如果你认为按自己的顺序比MySQL推荐的顺序进行连接的效率高的话，就可以通过STRAIGHT_JOIN来确定连接顺序。

2. 干预索引使用，提高性能

在上面已经提到了索引的使用。一般情况下，在查询时MySQL将自己决定是否使用索引，使用哪一个索引。但在一些特殊情况下，我们希望MySQL只使用一个或几个索引，或者不希望使用某个索引。这就需要使用MySQL的控制索引的一些查询选项。

限制使用索引的范围

有时我们在数据表里建立了很多索引，当MySQL对索引进行选择时，这些索引都在考虑的范围内。但有时我们希望MySQL只考虑几个索引，而不是全部的索引，这就需要用到USE INDEX对查询语句进行设置。

1.    SELECT * FROM TABLE1 USE INDEX (FIELD1, FIELD2) …

从以上SQL语句可以看出，无论在TABLE1中已经建立了多少个索引，MySQL在选择索引时，只考虑在FIELD1和FIELD2上建立的索引。

限制不使用索引的范围

如果我们要考虑的索引很多，而不被使用的索引又很少时，可以使用IGNORE INDEX进行反向选取。在上面的例子中是选择被考虑的索引，而使用IGNORE INDEX是选择不被考虑的索引。

1.    SELECT * FROM TABLE1 IGNORE INDEX (FIELD1, FIELD2) …

在上面的SQL语句中，TABLE1表中只有FIELD1和FIELD2上的索引不被使用。

强迫使用某一个索引

上面的两个例子都是给MySQL提供一个选择，也就是说MySQL并不一定要使用这些索引。而有时我们希望MySQL必须要使用某一个索引(由于 MySQL在查询时只能使用一个索引，因此只能强迫MySQL使用一个索引)。这就需要使用FORCE INDEX来完成这个功能。

1.    SELECT * FROM TABLE1 FORCE INDEX (FIELD1) …

以上的SQL语句只使用建立在FIELD1上的索引，而不使用其它字段上的索引。

3. 使用临时表提供查询性能

当我们查询的结果集中的数据比较多时，可以通过SQL_BUFFER_RESULT.选项强制将结果集放到临时表中，这样就可以很快地释放MySQL的表锁(这样其它的SQL语句就可以对这些记录进行查询了)，并且可以长时间地为客户端提供大记录集。

1.    SELECT SQL_BUFFER_RESULT * FROM TABLE1 WHERE …

和SQL_BUFFER_RESULT.选项类似的还有SQL_BIG_RESULT，这个选项一般用于分组或DISTINCT关键字，这个选项通知MySQL，如果有必要，就将查询结果放到临时表中，甚至在临时表中进行排序。

1.    SELECT SQL_BUFFER_RESULT FIELD1, COUNT(*) FROM TABLE1 GROUP BY FIELD1

 

 

 

 

 

 

一、在编译时优化MySQL

如果你从源代码分发安装MySQL，要注意，编译过程对以后的目标程序性能有重要的影响，不同的编译方式可能得到类似的目标文件，但性能可能相差很大，因此，在编译安装MySQL适应仔细根据你的应用类型选择最可能好的编译选项。这种定制的MySQL可以为你的应用提供最佳性能。

技巧：选用较好的编译器和较好的编译器选项，这样应用可提高性能10-30%。（MySQL文档如是说）

1.1、使用pgcc（Pentium GCC)编译器

该编译器（http://www.goof.com/pcg/）针对运行在奔腾处理器系统上的程序进行优化，用pgcc编译MySQL源代码，总体性能可提高10%。当然如果你的服务器不是用奔腾处理器，就不必用它了，因为它是专为奔腾系统设计的。

1.2、仅使用你想使用的字符集编译MySQL

MySQL目前提供多达24种不同的字符集，为全球用户以他们自己的语言插入或查看表中的数据。却省情况下，MySQL安装所有者这些字符集，热然而，最好的选择是指选择一种你需要的。如，禁止除Latin1字符集以外的所有其它字符集：

——————————————————————————–

%>./configure -with-extra-charsets=none [--other-configuration-options]

——————————————————————————–

1.3、将mysqld编译成静态执行文件

将mysqld编译成静态执行文件而无需共享库也能获得更好的性能。通过在配置时指定下列选项，可静态编译mysqld。

——————————————————————————–

%>./configure -with-mysqld-ldflags=-all-static [--other-configuration-options]

——————————————————————————–

1.4、配置样本

下列配置命令常用于提高性能：

——————————————————————————-

%>CFLAGS=”-O6 -mpentiumpro -fomit-frame-pointer” CXX=gcc CXXFLAGS=”-O6 -mpentiumpro -fomit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti” ./configure –prefix=/usr/local –enable-assembler –with-mysqld-ldflags=-all-static –disable-shared

二、调整服务器

确保运用正确的编译固然重要，但这只是成功的第一步，配置众多的MySQL变量同样对服务器的正常运行起关键作用。你可以将这些变量的赋值存在一个配置文件中，以确保它们在每次启动MySQL时均起作用，这个配置文件就是my.cnf文件。

MySQL 已经提供了几个my.cnf文件的样本，可在/usr/local/mysqld/share/mysql/目录下找到。这些文件分别命名为my- small.cnf、 my-medium.cnf、my-large.cnf和my-huge.cnf，规模说明可在描述配置文件适用的系统类型标题中找到。如果在只有相当少内存的系统上运行MySQL，而且只是偶尔的用一下，那么my-small.cnf会比较理想，因为它命令mysqld只使用最少的资源。类似地，如果你计划构建电子商务超市，而且系统拥有2G内存，那么你可能要用到mysql-huge.cnf文件了。

为了利用这些文件中的一个，你需要复制一个最适合需求的文件，改名为my.cnf。你可以选择使用配置文件三种作用范围的一种：

Global：将my.cnf文件复制到服务器的/etc目录下，这使得配置文件中的变量作用于全局，即对所有服务器上的MySQL数据库服务器有效。

Local：将my.cnf文件复制到[MYSQL-INSTALL-DIR]/var/目录下，使得my.cnf作用于特定的服务器。[MYSQL-INSTALL-DIR]表示MySQL安装目录。

User：你可以再限制作用于特定的用户，将my.cnf复制到用户的根目录下。

究竟如何设置my.cnf中的这些变量呢？更进一步说，你可以设置哪一个变量。虽然所用变量对MySQL服务器相对通用，每一个变量与MySQL的的某些组件有更特定的关系。如变量max_connects归在mysqld类别下。执行下列命令即可知道：

——————————————————————————–

%>/usr/local/mysql/libexec/mysqld –help

——————————————————————————–

它显示大量的选项及与mysqld相关的变量。你可以很容易地在该行文字之下找出变量：

——————————————————————————–

Possible variables for option –set-variable (-O) are

——————————————————————————–

然后你可以如下设置my.cnf中的那些变量：

——————————————————————————–

set-variable = max_connections=100

——————————————————————————–

它设置MySQL服务器的最大并发连接数为100。要确保在my.cnf文件中的[mysqld]标题下插入变量设置。

三、表类型

很多MySQL用户可能很惊讶，MySQL确实为用户提供5种不同的表类型，称为DBD、HEAP、ISAM、MERGE和MyIASM。DBD归为事务安全类，而其他为非事务安全类。

3.1、事务安全

DBD

Berkeley DB(DBD)表是支持事务处理的表，由Sleepycat软件公司(http://www.sleepycat.com)开发。它提供MySQL用户期待已久的功能-事务控制。事务控制在任何数据库系统中都是一个极有价值的功能，因为它们确保一组命令能成功地执行。

3.2、非事务安全

 

HEAP

 

HEAP表是MySQL中存取数据最快的表。这是因为他们使用存储在动态内存中的一个哈希索引。另一个要点是如果MySQL或服务器崩溃，数据将丢失。

 

ISAM

 

ISAM表是早期MySQL版本的缺省表类型，直到MyIASM开发出来。建议不要再使用它。

 

MERGE

MERGE是一个有趣的新类型，在3.23.25之后出现。一个MERGE表实际上是一个相同MyISAM表的集合，合并成一个表，主要是为了效率原因。这样可以提高速度、搜索效率、修复效率并节省磁盘空间。

MyIASM

 

这是MySQL的缺省表类型。它基于IASM代码，但有很多有用的扩展。MyIASM比较好的原因：

MyIASM表小于IASM表，所以使用较少资源。

MyIASM表在不同的平台上二进制层可移植。

更大的键码尺寸，更大的键码上限。

3.3、指定表类型

你可在创建表时指定表的类型。下例创建一个HEAP表：

——————————————————————————–

mysql>CREATE TABLE email_addresses TYPE=HEAP (

->email char(55) NOT NULL,

->name char(30) NOT NULL,

->PRIMARY KEY(email) );

——————————————————————————–

BDB表需要一些配置工作，参见http://www.mysql.com/doc/B/D/BDB_overview.html。

 

3.4、更多的表类型

 

为了使MySQL管理工作更有趣，即将发布的MySQL 4.0将提供两种新的表类型，称为Innobase和Gemeni。

 

4、优化工具

 

MySQL服务器本身提供了几条内置命令用于帮助优化。

 

4.1、SHOW

 

你可能有兴趣知道MySQL服务器究竟更了什么，下列命令给出一个总结：

 

——————————————————————————–

mysql>show status;

——————————————————————————–

 

它给出了一个相当长的状态变量及其值的列表。有些变量包含了异常终止客户的数量、异常终止连接的数量、连接尝试的次数、最大并发连接数和大量其他有用的信息。这些信息对找出系统问题和低效极具价值。

 

SHOW还能做更多的事情。它可以显示关于日志文件、特定数据库、表、索引、进程和权限表中有价值的信息。详见MySQL手册。

 

4.2、EXPLAIN

 

当你面对SELECT语句时，EXPLAIN解释SELECT命令如何被处理。这不仅对决定是否应该增加一个索引，而且对决定一个复杂的Join如何被MySQL处理都是有帮助的。

 

4.3、OPTIMIZE

 

OPTIMIZE语句允许你恢复空间和合并数据文件碎片，对包含变长行的表进行了大量更新和删除后，这样做特别重要。OPTIMIZE目前只工作于MyIASM和BDB表。

 

 

 

 

 

 

 

 

下面就某些SQL语句的where子句编写中需要注意的问题作详细介绍。在这些where子句中，即使某些列存在索引，但是由于编写了劣质的SQL，系统在运行该SQL语句时也不能使用该索引，而同样使用全表扫描，这就造成了响应速度的极大降低。

 

1. IS NULL 与 IS NOT NULL

 

不能用null作索引，任何包含null值的列都将不会被包含在索引中。即使索引有多列这样的情况下，只要这些列中有一列含有null，该列就会从索引中排除。也就是说如果某列存在空值，即使对该列建索引也不会提高性能。

 

任何在where子句中使用is null或is not null的语句优化器是不允许使用索引的。

 

2. 联接列

 

对于有联接的列，即使最后的联接值为一个静态值，优化器是不会使用索引的。我们一起 来看一个例子，假定有一个职工表（employee），对于一个职工的姓和名分成两列存放（FIRST_NAME和LAST_NAME），现在要查询一个 叫比尔.克林顿（Bill Cliton）的职工。

 

下面是一个采用联接查询的SQL语句，

 

select * from employss

where

first_name||''||last_name ='Beill Cliton'

上面这条语句完全可以查询出是否有Bill Cliton这个员工，但是这里需要注意，系统优化器对基于last_name创建的索引没有使用。

 

当采用下面这种SQL语句的编写，Oracle系统就可以采用基于last_name创建的索引。

 

Select * from employee

where

first_name ='Beill' and last_name ='Cliton'

遇到下面这种情况又如何处理呢？如果一个变量（name）中存放着Bill Cliton这个员工的姓名，对于这种情况我们又如何避免全程遍历，使用索引呢？可以使用一个函数，将变量name中的姓和名分开就可以了，但是有一点需 要注意，这个函数是不能作用在索引列上。下面是SQL查询脚本：

 

select * from employee

where

first_name = SUBSTR('&&name',1,INSTR('&&name',' ')-1)

and

last_name = SUBSTR('&&name',INSTR('&&name’,' ')+1)

3. 带通配符（%）的like语句

 

同样以上面的例子来看这种情况。目前的需求是这样的，要求在职工表中查询名字中包含cliton的人。可以采用如下的查询SQL语句：

 

select * from employee where last_name like '%cliton%'

这里由于通配符（%）在搜寻词首出现，所以Oracle系统不使用last_name的索 引。在很多情况下可能无法避免这种情况，但是一定要心中有底，通配符如此使用会降低查询速度。然而当通配符出现在字符串其他位置时，优化器就能利用索引。 在下面的查询中索引得到了使用：

 

select * from employee where last_name like 'c%'

4. Order by语句

 

ORDER BY语句决定了Oracle如何将返回的查询结果排序。Order by语句对要排序的列没有什么特别的限制，也可以将函数加入列中（象联接或者附加等）。任何在Order by语句的非索引项或者有计算表达式都将降低查询速度。

 

仔细检查order by语句以找出非索引项或者表达式，它们会降低性能。解决这个问题的办法就是重写order by语句以使用索引，也可以为所使用的列建立另外一个索引，同时应绝对避免在order by子句中使用表达式。

 

5. NOT

 

我们在查询时经常在where子句使用一些逻辑表达式，如大于、小于、等于以及不等于等等，也可以使用and（与）、or（或）以及not（非）。NOT可用来对任何逻辑运算符号取反。下面是一个NOT子句的例子：

 

… where not (status =’VALID’)

 

如果要使用NOT，则应在取反的短语前面加上括号，并在短语前面加上NOT运算符。NOT运算符包含在另外一个逻辑运算符中，这就是不等于（<>）运算符。换句话说，即使不在查询where子句中显式地加入NOT词，NOT仍在运算符中，见下例：

 

… where status <>’INVALID’

 

再看下面这个例子：

 

select * from employee where salary<>3000;

 

对这个查询，可以改写为不使用NOT：

 

select * from employee where salary<3000 or salary>3000;

 

虽然这两种查询的结果一样，但是第二种查询方案会比第一种查询方案更快些。第二种查询允许Oracle对salary列使用索引，而第一种查询则不能使用索引。

 

6. IN和EXISTS

 

有时候会将一列和一系列值相比较。最简单的办法就是在where子句中使用子查询。在where子句中可以使用两种格式的子查询。

 

第一种格式是使用IN操作符：

 

… where column in(select * from … where …);

 

第二种格式是使用EXIST操作符：

 

… where exists (select ‘X’ from …where …);

 

我相信绝大多数人会使用第一种格式，因为它比较容易编写，而实际上第二种格式要远比第一种格式的效率高。在Oracle中可以几乎将所有的IN操作符子查询改写为使用EXISTS的子查询。

 

第二种格式中，子查询以‘select ‘X’开始。运用EXISTS子句不管子查询从表中抽取什么数据它只查看where子句。这样优化器就不必遍历整个表而仅根据索引就可完成工作（这里假定在where语句中使用的列存在索引）。相对于IN子句来说，EXISTS使用相连子查询，构造起来要比IN子查询困难一些。

 

通过使用EXIST，Oracle系统会首先检查主查询，然后运行子查询直到它找到第一个匹配项，这就节省了时间。Oracle系统在执行IN子查询时，首先执行子查询，并将获得的结果列表存放在在一个加了索引的临时表中。在执行子查询之前，系统先将主查询挂起，待子查询执行完毕，存放在临时表中以后再执行主查询。这也就是使用EXISTS比使用IN通常查询速度快的原因。

 

同时应尽可能使用NOT EXISTS来代替NOT IN，尽管二者都使用了NOT（不能使用索引而降低速度），NOT EXISTS要比NOT IN查询效率更高。

 

 

 

 

 

 

 

 

 

 

 

 

曾经偷偷的面试了两个单位，都提到了Mysql的优化问题，所以以后要多多学习数据库的优化知识了。建设数据库的优化大概主要就是索引的优化了吧，因为我们不可能修改数据结构的情况下，提高数据库的查询效率似乎也只能用索引了。当然这也是建立在你sql语句写的比较科学的情况下，如果你的sql语句本身就写的比较垃圾，神仙也救不了你！

下边是在网上找到的一些资料，保留下来备用吧

1，创建索引

对于查询占主要的应用来说，索引显得尤为重要。很多时候性能问题很简单的就是因为我们忘了添加索引而造成的，或者说没有添加更为有效的索引导致。如果不加索引的话，那么查找任何哪怕只是一条特定的数据都会进行一次全表扫描，如果一张表的数据量很大而符合条件的结果又很少，那么不加索引会引起致命的性能下降。但是也不是什么情况都非得建索引不可，比如性别可能就只有两个值，建索引不仅没什么优势，还会影响到更新速度，这被称为过度索引。

2，复合索引

比如有一条语句是这样的：select * from users where area=’beijing’ and age=22;

如果我们是在area和age上分别创建单个索引的话，由于mysql查询每次只能使用一个索引，所以虽然这样已经相对不做索引时全表扫描提高了很多效率，但是如果在area、age两列上创建复合索引的话将带来更高的效率。如果我们创建了(area, age, salary)的复合索引，那么其实相当于创建了(area,age,salary)、(area,age)、(area)三个索引，这被称为最佳左前缀特性。因此我们在创建复合索引时应该将最常用作限制条件的列放在最左边，依次递减。

3，索引不会包含有NULL值的列

只要列中包含有NULL值都将不会被包含在索引中，复合索引中只要有一列含有NULL值，那么这一列对于此复合索引就是无效的。所以我们在数据库设计时不要让字段的默认值为NULL。

4，使用短索引

对串列进行索引，如果可能应该指定一个前缀长度。例如，如果有一个CHAR(255)的 列，如果在前10 个或20 个字符内，多数值是惟一的，那么就不要对整个列进行索引。短索引不仅可以提高查询速度而且可以节省磁盘空间和I/O操作。

5，排序的索引问题

mysql查询只使用一个索引，因此如果where子句中已经使用了索引的话，那么order by中的列是不会使用索引的。因此数据库默认排序可以符合要求的情况下不要使用排序操作；尽量不要包含多个列的排序，如果需要最好给这些列创建复合索引。

6，like语句操作

一般情况下不鼓励使用like操作，如果非使用不可，如何使用也是一个问题。like “%aaa%” 不会使用索引而like “aaa%”可以使用索引。

7，不要在列上进行运算

select * from users where YEAR(adddate)<2007;

将在每个行上进行运算，这将导致索引失效而进行全表扫描，因此我们可以改成

select * from users where adddate<‘2007-01-01’;

8，不使用NOT IN和<>操作

NOT IN和<>操作都不会使用索引将进行全表扫描。NOT IN可以NOT EXISTS代替，id<>3则可使用id>3 or id<3来代替。

 

 

 

 

 

 

 

 

 

 

 

1.如果MYSQL客户端和服务器端的连接需要跨越并通过不可信任的网络，那么需要使用ssh隧道来加密该连接的通信。

 

2.使用set password语句来修改用户的密码，先“mysql -u root”登陆数据库系统，然后“mysql> update mysql.user set password=password(‘newpwd’)”，最后执行“flush privileges”就可以了。

 

3.Mysql需要提防的攻击有，防偷听、篡改、回放、拒绝服务等，不涉及可用性和容错方面。对所有的连接、查询、其他操作使用基于acl即访问控制列表的安全措施来完成。也有一些对ssl连接的支持。

 

4.设置除了root用户外的其他任何用户不允许访问mysql主数据库中的user表;

 

加密后存放在user表中的加密后的用户密码一旦泄露，其他人可以随意用该用户名/密码相应的数据库;

 

5.使用grant和revoke语句来进行用户访问控制的工作;

 

6.不要使用明文密码，而是使用md5()和sha1()等单向的哈系函数来设置密码;

 

7.不要选用字典中的字来做密码;

 

8.采用防火墙可以去掉50%的外部危险，让数据库系统躲在防火墙后面工作，或放置在dmz区域中;

 

9.从因特网上用nmap来扫描3306端口，也可用telnet server_host 3306的方法测试，不允许从非信任网络中访问数据库服务器的3306号tcp端口，需要在防火墙或路由器上做设定;

 

10.为了防止被恶意传入非法参数，例如where id=234，别人却输入where id=234 or 1=1导致全部显示，所以在web的表单中使用”或”"来用字符串，在动态url中加入%22代表双引号、%23代表井号、%27代表单引号;传递未检查过的值给mysql数据库是非常危险的;

 

11.在传递数据给mysql时检查一下大小;

 

12.应用程序需要连接到数据库应该使用一般的用户帐号，开放少数必要的权限给该用户;

 

$page_devide$

 

13.在各编程接口(c c++ php perl java jdbc等)中使用特定‘逃脱字符’函数;

 

在因特网上使用mysql数据库时一定少用传输明文的数据，而用ssl和ssh的加密方式数据来传输;

 

14.学会使用tcpdump和strings工具来查看传输数据的安全性，例如tcpdump -l -i eth0 -w -src or dst port 3306 strings。以普通用户来启动mysql数据库服务;

 

15.不使用到表的联结符号，选用的参数 –skip-symbolic-links;

 

16.确信在mysql目录中只有启动数据库服务的用户才可以对文件有读和写的权限;

 

17.不许将process或super权限付给非管理用户，该mysqladmin processlist可以列举出当前执行的查询文本;super权限可用于切断客户端连接、改变服务器运行参数状态、控制拷贝复制数据库的服务器;

 

18.file权限不付给管理员以外的用户，防止出现load data ‘/etc/passwd’到表中再用select 显示出来的问题;

 

19.如果不相信dns服务公司的服务，可以在主机名称允许表中只设置ip数字地址;

 

20.使用max_user_connections变量来使mysqld服务进程，对一个指定帐户限定连接数;

 

21.grant语句也支持资源控制选项;

 

22.启动mysqld服务进程的安全选项开关，–local-infile=0或1 若是0则客户端程序就无法使用local load data了，赋权的一个例子grant insert(user) on mysql.user to ‘user_name’@'host_name’;若使用–skip-grant-tables系统将对任何用户的访问不做任何访问控制，但可以用 mysqladmin flush-privileges或mysqladmin reload来开启访问控制;默认情况是show databases语句对所有用户开放，可以用–skip-show-databases来关闭掉。

 

23.碰到error 1045(28000) access denied for user ‘root’@'localhost’ (using password:no)错误时，你需要重新设置密码，具体方法是:先用–skip-grant-tables参数启动mysqld，然后执行 mysql -u root mysql,mysql>update user set password=password(‘newpassword’) where user=’root’;mysql>flush privileges;，最后重新启动mysql就可以了。

 

 

 

 

 

 

 

 

 

 

试题：

1mysql你都修改了那些配置文件来进行优化(问配置文件中具体修改的内容)?

2数据库用的什么？mysql用了几台？是否做读写分离？主从复制做了读写分离，主挂了或者从挂了你怎么办？

3mysql出现过什么问题，如何解决的？

4mysql如何创建一个库，添加一个表，在表中插入数据。

5mysql做过什么优化

6以前工作中mysql连接数

7数据库 怎么备份的

8oracle怎么调优的

9你们mysql数据量有多大？

10你们备份数据是备份在同一设备？

11你们是用什么备份的

12MYSQL会什么？会SQL语句么？

13会MYSQL调优么？

14mysql是怎么备份的

15找出当前目录30天之前的文件，并删除

16主从复制出错怎么解决

17mysql的配置文件位置

18“mysql 四中操作操作是什么

”

19“增删改查 你觉得那个最占用资源

”

20mysql 简单的 怎么登入 怎么创建数据库bbb创建 用户 密码 授权

21mysql数据库同步怎样实现

22ms2005数据库怎样做优化

23查询mysql数据库中用户，密码，权限的命令

24mysql会安装么？主从复制会做么？

25MySQL语句调优会不会？用的什么工具？

26MySQL索引你会么？平时怎么用的？你是每个表都加上索引么？你怎么确定你加上索引后速度会快？

27对数据库这方面有没有什么培训打算。

28oracle日常管理都做哪些

29oracle加过索引吗

30b数索引对更新数据有什么影响

31你们用软件处理过的数据量有多少，处理过上百万的数据吗

32哦，你们还有转业的dba，你做过什么

33你迁移多少数据量

34 mysql 数据库的备份与还原 例如一个数据库test

35mysql都做了哪些，是你自己搭建的么？

36oracle你都会什么？

37了解非关系性数据库么

38Mysql之前用过什么引擎

39Mysql怎么解决故障切换

40  Mysql都有那几种日志

41为什么你们用apache不用nginx

42SQL server的备份与恢复

43mysql用的是什么？主从？

44 mysql数据库的备份，用的是脚本？

45mysql 主从数据库的搭建，配置的命令

46“nagios 的搭建，监控的内容，遇到过什么问题？怎么解决的？

”

47Oracle启动关闭的命令有哪几种，都代表什么含义

48Oracle逻辑备份工具是什么

49写出三种数据库对象

50数据库死锁概念

51编译与解释的区别

52oracle内存空间的特点？

53写出至少5种Oracle文件类型

54主从复制在停机和不停机情况下，分别怎么加从服务器

55Sybase数据库相关的东西很多

56索引的创建（index)

57表空间的创建、迁移

58如何利用存储过程提高数据库读取的性能。

59选择不同的存储引擎，对数据库的工作有何影响

60跨库时用存储引擎好不好？为何？

61nosql的利用价值

62如何合理分配表空间、创建？

63数据空间的扩容？

64对表空间如何监控？

65把数据分开放在不同的表空间，利与弊？

66如何实现MySQL服务器的冗余。

67查看是否安装了mysql

68启动mysql，进入mysql

69查看oracle是否运行，有多少个数据库

70怎么样进入oracle

71查看oracle的用户

72oracle的登录方式

73mysql怎么样，主从复制做过吗，怎样查看复制的状态

74oracle rac与一般DB的区别？

75数据库有几种数据保护方式（AAA）

76session是否被锁怎么看，写出查询与处理过程

77rman还原的几种方式（优劣）

78rac切换所有主机日志的命令

79oracle数据查询如何做到一致

80sql查询语句

81mysql主从复制怎么做的

82mysql备份时备份主的还是备份从的？

83“基于数据库中的成绩表

成绩（学号，课程名，成绩）

用SQL语句创建成绩表，并往成绩表中插入一个元组（20010101，管理信息系统，80）

”

84

85mysql安装的时候自己选择路径怎么做？

86mysql语句你熟么

87如果一个表被drop，在有完善的归档和备份情况下，如何恢复

88.对于一个恢复时间比较短的系统（数据库50G，每天归档5G），你如何设计备份策略

89mysql 存储方式？

90简述MSMQ消息队列的作用及工作原理。

91说说你用的数据库及区别

92oracle数据库要多看

93备份 存储过程

94有oracle里面的sql语句问题；查找、按条件显示等

95mysql出过什么故障？

96oracle接触过么

97怎样修改mysql表中的信息

98mysql主从能一个人完成吗，怎么指定主的服务器

99什么时候恢复数据库？

100怎么恢复？

101为什么要备份数据库？

102备份的周期？

103系统调优都做哪些？

104如何删除？

105mysql远程备份

106mysql熟悉吗？

107备份怎么做？

108你怎么给mysql备份

109会使用sqlserver么

110mysql怎么备份

111mysql同步有几个进程

112怎么做的mysql数据库备份

113如果数据库中有一个表的数据量很大，无法用rm删除，该怎么办

114MYSQL用得怎么样

115对oracle都做过哪些操作

116让我进入mysql的目录，他告诉我了路径

117问我mysqldump是什么意思，mysqld和mysqld_safe什么区别

118然后问mysql这个命令跟mysqld有什么区别么

119之后让我打开mysql的配置文件my.cnf问了里面一个参数是什么意思

120mysql怎么做的备份

121mysql做的是主从吗

122主用的是什么引擎

123主从都用的是innoDB吗

124innoDB和myisam有什么区别

125mysql的备份命令是什么

126 在mysql服务器运行缓慢的情况下输入什么命令能缓解服务器压力

127怎么导出表结构？

128Oracle的几种模式？

129oracle的报警日志文件路径？

130几种关闭数据库方法？参数？区别？

131会写 Ksh csh 吗？

132精通oracle吗？

133会写存储过程吗？

134oracle的rman怎么用？

135上一家公司主要是做什么的？你负责哪一块

136mysql的优化会吗？是怎么做的？

137搭建过oracle的集群吗？

138nginx用过吗？做什么用的？测试时最大的负载是多少？

139正常登入MYSQL后使用什么命令查看其进程是否正常，和变量

140查看命令的使用方法

141每小时的0,24,40分钟 执行/home/sh 用crontab

142怎样重新启动named

143linux 中查找文件最快的命令是什么

144linux mysql 重设root密码

145mysql远程连接命令

146mysql主从用什么方式传输日志

147介绍一下mysql

148mysql、oracle、sqlserver的默认端口是

149数据库的备份方式

150mysql用户test 只能由abc.com访问test表且test只能访问test密码testpasswd

151介绍一下mysql

152介绍下mysql的管理，备份，主备

153mysql主从数据不同步如何解决

154mysql主从做过切换吗?当主的失效,从的自动切换成主?

155oracle管理过吗?

156给mysql创建个用户，并对表test有访问权限

157mysql备份，备份某个库中的某个表

158查看mysql数据库是否支持innodb

159如何在mysql某个表中随机抽取10条记录

160如何查看连接mysql的当前用户

161书写出mysql常用的命令，以及备份命令

162写出mysql怎么修改密码？怎么修复损坏的表？

163mysql用户test 只能由abc.com访问test表且test只能访问test密码testpasswd

164mysql的备份，数据的导入

165oracle数据库的安装过程

166oracle中创建数据库

167用oracle用户test登录数据库，密码test

168创建oracle表空间

169ls，rm，man，vi的含义与作用

170mysql数据库中多个表结合查询

171在系统中有个sql文件，怎么在数据库中执行sql文件中的命令

172mysql的ab复制的原理

173mysql主从复制数据丢失怎么知道的

174mysql优化

175mysql备份流程

176mysql主从原理

177书写出mysql常用的命令，以及备份命令

178写出mysql怎么修改密码？怎么修复损坏的表？

179Oracle用什么备份

180都使用过什么数据库？Oracle、mysql？Mysql主从压力大的时候，怎么在不影响业务的前提下，在加入一台mysql

181mysql数据库用的多吗

182mysql复制

183oracle dataguard

184 想知道一个查询用到了哪个index,如何查看?

185 如何强制mysql 使用某一个index ?

186 一张表,里面有ID自增主键,当insert了17条记录之后,删除了第15,16,17条记录,再把Mysql重启,再insert一条记录,这条记录的ID是18还是15？

187 一个查询 select * from abc where a = 123 and b = 456 order by c limit 10; 请分析一下如何优化?需要哪些更多的信息?

188 数据库 load 非常高, 现在要添加一个新server来设置成master-slave模式，请问一般的步骤是什么? my.cnf里的相关的设置大概是什么样子（对如何拼写不做要求) ？

189 主从模式出现错误 1062,导致数据库不能同步,请问如何修复?

190 数据库不能停机，请问如何备份? 如何进行全备份和增量备份?

191 数据库性能下降，想找到哪些sql耗时较长，应该如何操作? my.cnf里如何配置?

192 什么是聚集索引?

193 MYSQL数据库服务器性能分析的方法命令有哪些？

194 mysql有关权限的表都有哪几个？