笔记，挺乱的

                                                笔记
根据图写的。
JDT：是编写java的插件
workSet：是存放网页和属性文件等
Mylyn:就是Task List 任务管理
Preferences:是配置项，里面有很多配置，慢慢琢磨吧！
Perspective:是透视图
Web Developer:是 WTP以后会接触的
Data Explorer:数据库
Remote Systems:远程系统管理。可以远程在别的机子上写代码，还可以用本地的资源。

快捷键，有很多比如:
Ctrl+1 ：快速修正
            Ctrl+3 ：快速通道（也是万能键）
            Ctrl+D ：删除一行
            Ctrl+shift+↑:转至上一个成员
            Alt+↑:将这行上移一行
            Alt+Shift+Z:包围方式快捷菜单
            Alt+Shift+R：重命名，重构
            Ctrl+L：转至行
            Ctrl+Shift+L：辅助键
            Ctrl+Shift+F：格式化
            Alt+/：内容辅助
            Ctrl+O：快速大纲
            ctrl+T：快速层次结构
            Ctrl+Shift+O：组织导入
            Ctrl+Shift+T：打开类型
            Ctrl+Shift+R：打开资源
            Ctrl+Shift+U：在当前行显示快速菜单
            Ctrl+E：快速切换编辑器
            Ctrl+Shift+E：切换至编辑器
            F2：显示工具描述提示
            F3：打开声明
            F4：打开类型层次结构
            F5：刷新（在Debug中是进入方法里面的意思）    
            F6：在Debug中是执行下一步
            F7：执行完方法，返回到调用此方法的后一条语句。
            F8：结束当前断点，跳到下一个断点。

Code Style:

Refactor:
change Method Signature 改变方法名或增加减少参数
Extract 抽取   Constant 常量
                           Method   方法
   Local Variable 本地变量
Inline 当使用new关键字的变量只用了一次就可以用它来合并。
Convert Anonymous Class to Nested  把一个匿名类欠套出来
Convert Member Type to Top level 把一个内部元素转换成类成员
Use Supertype Wherer Possible 关于继承与多态
Push Down 从父类把方法移动到子类
Push Up 从子类吧方法移动到父类
Extract Class 把成员属性抽取一个类
Introduce Parameter Object 把参数抽取一个独立的类
Introduce Indirection 多一个方法
Introduce Factory 不想看到new关键字
Introduce Parameter 把方法里的变量抽参数
Encapsulate Field 相当于get方法


3.13笔记
F2：显示工具描述提示
            F3：打开声明
            F4：打开类型层次结构
            F5：刷新（在Debug中是进入方法里面的意思）    
            F6：在Debug中是执行下一步
            F7：执行完方法，返回到调用此方法的后一条语句。
            F8：结束当前断点，跳到下一个断点。
本来准备是充分的，可是。。。F7.F8导致没答上来。
太粗心了。其它时间就多多复习了下老师画的那张Eclipse图。
Refactor:
Convert Anonymous Class to Nested  把一个匿名类欠套出来
change Method Signature 改变方法名或增加减少参数
Inline 当使用new关键字的变量只用了一次就可以用它来合并。
Convert Member Type to Top level 把一个内部元素转换成类成员
Extract  Constant 抽取常量
            Extract  Method   抽取方法
Use Supertype Wherer Possible 关于继承与多态
Extract Local Variable 抽取本地变量
Push Down 从父类把方法移动到子类
Push Up 从子类吧方法移动到父类
Extract Class 把成员属性抽取一个类
Introduce Parameter Object 把参数抽取一个独立的类
Introduce Factory 不想看到new关键字
Introduce Indirection 多一个方法
Introduce Parameter 把方法里的变量抽参数
这个是重构里面的相关操作，记重新写了下。由于时间问题就没写那么多了。


                                3.15 笔记
FindBugs和PMD这是我们上午学的两个新插件，都是用于检查代码
规不规范的插件。这种插件的好处就是不用自己慢慢检查，有时候这种效果
是显而易见的。关于这两种插件我是学的FindBugs，关于FindBugs开始有点
认识了。
根据实验：要想看某个或多个类、包或项目里有不有不符合规范的。你只要
选中按右键点Find Bugs再选中Find Bugs，这样就相当于那里不符合要求
那里就有相应的标记。在打开Find Bugs视图就可以看到不符合要求代码的
相关标记，不同的标记就是不同的要求。里面的规则很多，看到头晕，不过
还是要看的。要是想退出Find Bugs 状态，你只要选中按右键点Find Bugs
再选中Clear Bug Markers，就可以取消Find Bugs状态.
对于PMD我们这组还没研究的，所以暂且不谈。
        下午的时候老师又给了我们一个新的插件叫Checkstyle的。可是后
来就没时间讲了。期待中...



                          3.17 笔记
                    数据库：
今天学数据库了，今天只是入门，所以就只教了数据库的安装和一些很基本的
使用。
比如说：进入数据库，也可以再doc下进去，不过先要去设置下环境变量。再
在doc下输入 mysql -u root -p  命令后在输入密码就进去了。还有可以在
开始菜单里进去。
在doc窗口下相关操作：
1。显示里面所有的库：show databases；
2。进入库：use 库名；
3。显示库里的表格：show tables；
4。显示相关信息：describe ...；
5。创建库或表格：create database/table 库名/表格名（字段名 数据类型 ...）；
6。删除库或表格：Drop database/table 库名/表格名；
其它相关操作暂时还没讲的。

3.18 笔记
1.创建学生表格
mysql> create table tbstudent
    -> (
    -> id int primary key,
    -> name char(10) not null,
    -> sex char(3) default '男',
    -> qqid int unique,
    -> birthday date,
    -> avoirdupois float,
    -> diary text)
    -> ;
Query OK, 0 rows affected (0.15 sec)

2.创建成绩表格
mysql> create table result(
    -> id int primary key,
    -> stuid int,
    -> sturesult float,
    -> foreign key(stuid) references tbstudent(id));
Query OK, 0 rows affected (0.08 sec)

3.查看表格创建是否成功！
mysql> show tables;
+-----------------------+
| Tables_in_0901student |
+-----------------------+
| newdate               |
| person                |
| result                |
| student               |
| t1                    |
| t2                    |
| t3                    |
| tbstudent             |
| test                  |
| test1                 |
+-----------------------+
10 rows in set (0.00 sec)

4.删除主表格未成功！（要删主表格就要从‘从表格’开始删除，看它们是否已经连接）
mysql> drop table tbstudent;
ERROR 1217 (23000): Cannot delete or update a parent row: a foreign key constrai
nt fails

5.查看格式
mysql> desc tbstudent;
+-------------+----------+------+-----+---------+-------+
| Field       | Type     | Null | Key | Default | Extra |
+-------------+----------+------+-----+---------+-------+
| id          | int(11)  | NO   | PRI |         |       |
| name        | char(10) | NO   |     |         |       |
| sex         | char(3)  | YES  |     | 男      |       |
| qqid        | int(11)  | YES  | UNI | NULL    |       |
| birthday    | date     | YES  |     | NULL    |       |
| avoirdupois | float    | YES  |     | NULL    |       |
| diary       | text     | YES  |     | NULL    |       |
+-------------+----------+------+-----+---------+-------+
7 rows in set (0.01 sec)

6.学号设置为空不成功！因为它是主键
mysql> insert into tbstudent(id)values();
ERROR 1136 (21S01): Column count doesn't match value count at row 1

7.姓名设置为空不成功！因为我设置它是非空的
mysql> insert into tbstudent(name)values();
ERROR 1136 (21S01): Column count doesn't match value count at row 1

8.学号，姓名赋值成功！不给性别赋值看是否有默认值
mysql> insert into tbstudent(id,name)values(001,'周耀');
Query OK, 1 row affected (0.03 sec)

9.性别默认值设置成功！
mysql> select * from tbstudent;
+----+------+------+------+----------+-------------+-------+
| id | name | sex  | qqid | birthday | avoirdupois | diary |
+----+------+------+------+----------+-------------+-------+
|  1 | 周耀 | 男   | NULL | NULL     |        NULL | NULL  |
+----+------+------+------+----------+-------------+-------+
1 row in set (0.00 sec)

10.qq号唯一性设置
mysql> insert into tbstudent(id,name,qqid)values(002,'周耀',598621521);
Query OK, 1 row affected (0.04 sec)

11.对比，qq好唯一性设置成功！
mysql> insert into tbstudent(id,name,qqid)values(003,'周耀',598621521);
ERROR 1062 (23000): Duplicate entry '598621521' for key 2

12.体重float型设置成功！
mysql> insert into tbstudent(id,name,avoirdupois) values(003,'zhouyao',111.11);
Query OK, 1 row affected (0.03 sec)

13.查看以上步骤的结果
mysql> select * from tbstudent;
+----+---------+------+-----------+----------+-------------+-------+
| id | name    | sex  | qqid      | birthday | avoirdupois | diary |
+----+---------+------+-----------+----------+-------------+-------+
|  1 | 周耀    | 男   |      NULL | NULL     |        NULL | NULL  |
|  2 | 周耀    | 男   | 598621521 | NULL     |        NULL | NULL  |
|  3 | zhouyao | 男   |      NULL | NULL     |      111.11 | NULL  |
+----+---------+------+-----------+----------+-------------+-------+
3 rows in set (0.00 sec)

14.设置生日成功！
mysql> insert into tbstudent(id,name,birthday) values(004,'zhouyao','1989.05.25'
);

15.查看生日
mysql> select * from tbstudent;
+----+---------+------+-----------+------------+-------------+-------+
| id | name    | sex  | qqid      | birthday   | avoirdupois | diary |
+----+---------+------+-----------+------------+-------------+-------+
|  1 | 周耀    | 男   |      NULL | NULL       |        NULL | NULL  |
|  2 | 周耀    | 男   | 598621521 | NULL       |        NULL | NULL  |
|  3 | zhouyao | 男   |      NULL | NULL       |      111.11 | NULL  |
|  4 | zhouyao | 男   |      NULL | 1989-05-25 |        NULL | NULL  |
+----+---------+------+-----------+------------+-------------+-------+
4 rows in set (0.00 sec)

16.设置成绩单
mysql> insert into result values(001,001,300);
Query OK, 1 row affected (0.04 sec)
mysql> insert into result values(002,001,290);
Query OK, 1 row affected (0.03 sec)
mysql> insert into result values(003,004,280);
Query OK, 1 row affected (0.03 sec)

17.查看成绩单
mysql> select * from result;
+----+-------+-----------+
| id | stuid | sturesult |
+----+-------+-----------+
|  1 |     1 |       300 |
|  2 |     1 |       290 |
|  3 |     4 |       280 |
+----+-------+-----------+
3 rows in set (0.00 sec)

18.看数据是否连接，删除主表格为成功！数据连接成功！
mysql> drop table tbstudent;
ERROR 1217 (23000): Cannot delete or update a parent row: a foreign key constrai
nt fails


3.19  笔记
今天我们教了很多的命令：
select 1+2+3等相关操作 from 表名;                      计算
返回值  select 1>3 from 表名;                            0是false，1是true.
连接字符 select concat ('d','dd');                       这样结果就显示为 ddd。
select concat ('d','dd',。。。,null);                    这样中间只要出一个null 结果就显示为null。
select length('ddfsdfsd');                               结果就显示字符串的长度。
trim 去掉前后的空格        ltrim去掉左边的空格           rtrim 去掉右边的空格。
例：mysql> select ltrim('           s   ');
+--------------------------+
| ltrim('           s   ') |
+--------------------------+
| s                        |
+--------------------------+
1 row in set (0.00 sec)
select substring('abc',1,3);                             从第一个显示到第三个。
alter table person drop id;                              删除单个字段。
select replace（'sbbbs','bbb','sss'）;                     是把sbbbs中的bbb替换成sss；
sql 包括两种语言：
       1.数据操纵语言DML：data manoeuvre language
       2.数据定义语言DDL: data define language

       其中属于DML的有： select insert delete update
       其中输入DDL的有： create drop alter
日期和时间：
select new（）；                                         显示当前日期时间
select current_time();                                   显示当前时间
select current_date();                                   显示当前日期
select current_timestamp();                              显示当前时间戳
select curtime();                                        显示当前时间
select curdate();                                        显示当前日期
select sysdate();                                        显示当前时间戳
select avg(age) from classes;                            求平均值
select max(age) from classes;                            求最大值
select * from classes where age > 16 ；                  判断求值
select count(*) from classes；                           显示信息总条数
select sum(age) from classes;                            求总和
alter table person modify names varchar(10);             更改字段类型
select * from classes limit 3;                           这个是查询最前面的三个，可根据要求查询
update classes set age=20 where id = 008;                修改某个特定的元素。
等等。。。

周芳鹏日记
sql 包括两种语言：
1.数据操纵语言DML：data manoeuvre language
2.数据定义语言DDL: data define language

其中属于DML的有： select insert delete update
其中输入DDL的有： create drop alter

    主要的主要有以下一些：
1.去掉表里面重复的数据： 语法： select distinct 字段，字段(可以有多个) from 表名
2.向表中添加一列： 语法：alter table 表名 add 列名 类型
3.删除一列： 语法：alter table 表名 drop 列名
4.添加主键： 语法：alter table 表名 drop primary key(字段)
5.取消字段： 语法：alter table 表名 drop primary key
6.添加别名： 语法：select name as 别名 from 表名
7.修改列名： 语法：alter table 表名 change 字段 新字段 新字段类型
8.修改表名： 语法：alter table 表名 rename 新表名
9.修改字段的类型： 语法：alter table 表名 modify 列名 数据类型

3.mysql的聚集函数：
    1.select count(*) 表示表中的列数 返回的是一个数值
2.select count(某列名) 表示表中的列数但是不包括有null的那一列 返回的也是一个数值
3.select count(distinct 列名1，列名2) 表示表中的列数但是不包括有null的那一列
        而且不包括重复的列，返回的也是一个数值

4.取最值： 语法：select max(字段)/min(字段) from 表名
5.取平均值： 语法：select avg(distinct 列名) from 表名
6.求和： 语法：select sun(列名) from 表名

4.查询返回指定的行数：
    语法：select * from 表名 limit 开始的前一个数字，几个数字
5.条件查询：
    语法：select * from 表名 where 字段=/</>/!=(what) and 字段=/</>/!=(what)
6.删除：
    语法：delete from 表名 where 字段=/</>/!=(what)
7.修改：
    语法：update 表名 set 字段=新值 where 字段=旧值


                           3.20 笔记
select*from 表名 where 字段+条件语句 or 字段+条件语句;
例：select*from 表名 where id>1 or id<4;
select*from 表名 where 字段 in(条件语句。。。);
例：select*from 表名 where id in(1,3,4,5,2,6);
select*from 表名 where 字段 not in(条件语句。。。);
模糊查询：
select *from 表名 where 字段 like 'X%';
以x开头的，%a以a结尾的。%a%含有a的 。。。
select *from 表名 where 字段 is null;
select *from person where name is not null;
第一范式（1NF）：在关系模式R中的每一个具体关系r中，如果每个属性值 都是不可再分
的最小数据单位，则称R是第一范式的关系

第二范式（2NF）：如果关系模式R（U，F）中的所有非主属性都完全依赖于组合关键字，
则称关系R 是属于第二范式的

如果某个字段或多个字段的值可以唯一地标识一条记录，则该字段就称为关键字。

如果一个关键字是用以区别每条记录的唯一性标志，并作为该表与其他表实现关联的，则称为主关键字或 主码。
    
除主关键字以外的其他关键字称候选关键字。

如有一个表，字段为：
id  firstname lastname address phone IDcard
那么id或IDcard或firstname+lastname都可以说是关键字。
其中id为主关键字,IDcard和firstname+lastname为候选关键字

第三范式（3NF）：如果关系模式R（U，F）中的所有非主属性对任何候选关键字都不存在传递信赖，则称关系R是属于第三范式的。



mysql> select*from test;
+------+------+------+
| a    | b    | c    |
+------+------+------+
| a1   | b1   | c1   |
| b1   | b3   | c    |
| a1   | b4   | c    |
| a1   | b1   | c    |
| b1   | b5   | c    |
| c1   | b3   | c    |
+------+------+------+
6 rows in set (0.00 sec)

mysql> select * from test group by a,b;
+------+------+------+
| a    | b    | c    |
+------+------+------+
| a1   | b1   | c1   |
| a1   | b4   | c    |
| b1   | b3   | c    |
| b1   | b5   | c    |
| c1   | b3   | c    |
+------+------+------+
5 rows in set (0.00 sec)

mysql> select * from test group by a;
+------+------+------+
| a    | b    | c    |
+------+------+------+
| a1   | b1   | c1   |
| b1   | b3   | c    |
| c1   | b3   | c    |
+------+------+------+
3 rows in set (0.00 sec)

mysql> select * from test1;
+------+------+--------+
| name | kemu | result |
+------+------+--------+
| a    | 语文 | 90     |
| b    | 语文 | 80     |
| c    | 语文 | 80     |
| a    | 数学 | 80     |
| c    | 数学 | 100    |
| b    | 数学 | 60     |
+------+------+--------+
6 rows in set (0.00 sec)
mysql> select name,sum(result) from test1 group by name;
+------+-------------+
| name | sum(result) |
+------+-------------+
| a    |         170 |
| b    |         140 |
| c    |         180 |
+------+-------------+
3 rows in set (0.02 sec)
                               3.23 笔记

条件里有聚集函数一般要和group by 和order by 一起用。
mysql> select name,sum(score) from test group by name having sum(score) > 150;
select 字段，聚集函数 from 表名 group by 字段 having 条件语句；
group by前面是where+过滤条件，后面则是having+判断语句。

mysql> select name,sum(score) from test group by name having sum(score) > 150,na
me != 'a';
select 字段，聚集函数 from 表名 group by 字段 having 条件语句，条件语句；

mysql> select name,sum(score) from test group by name having count(name) >= 2;

mysql> select name,avg(score) from test group by name having avg(score) > 70;

mysql> select*from test order by name;
select*from 表名 order by 字段；
以正序排列显示相关信息。

mysql> select name,sum(score) from test group by name having sum(score) > 150 or
der by score desc;
select 字段，聚集函数 from 表名 group by 字段 having 条件语句 order by 字段 desc；
显示group by分组在有having判断，order by ... desc则是倒序。
+------+------------+
| name | sum(score) |
+------+------------+
| a    |        230 |
| b    |        155 |
+------+------------+
2 rows in set (0.00 sec)

select date_format（date，format）；
例：
select date_format(now(),'%y-%m-%d %h:%i:%s');
+----------------------------------------+
| date_format(now(),'%y-%m-%d %h:%i:%s') |
+----------------------------------------+
| 10-03-23 07:49:16                      |
+----------------------------------------+
1 row in set (0.02 sec)
日期格式化，
DATE_ADD(date,INTERVAL expr type)
DATE_SUB(date,INTERVAL expr type)
ADDDATE(date,INTERVAL expr type)
SUBDATE(date,INTERVAL expr type)

SELECT DATE_ADD('1997-12-31 23:59:59',INTERVAL 1 SECOND);
增加一秒，
SELECT DATE_ADD(”1997-12-31 23:59:59″,INTERVAL 1 day);
增加一天
mysql>  SELECT DATE_ADD('1997-12-31 23:59:59',INTERVAL '1:1' minute_second);
增加一分一秒

mysql> create table a(id int primary key auto_increment,title varchar(255));
Query OK, 0 rows affected (0.15 sec)
自动递增。

                              等值连接
内连接    不等值连接
  自然连接 *
 
连接查询       左外连接 *
外连接    右外连接 *
  全连接   *
交叉连接

3.交叉连接又叫笛卡尔连接也叫无条件连接查询。(cross join)
    SELECT * FROM A CROSS JOIN B;
内连接查询：定义：返回两个数据集合之间匹配关系的那些行，内连接使用比较运算符进
行表问某些累数据的比较操作

外连接查询：定义：外连接查询要取得匹配的行，以外还有必要从一张或两张表中取得不
匹配的行，匹配的行显示数据，不匹配的行显示null


mysql> select*from stu1;
+----+------+
| id | name |
+----+------+
|  1 | 张三 |
|  2 | 李四 |
|  3 | 王五 |
|  4 | 萝卜 |
|  5 | 青菜 |
+----+------+
5 rows in set (0.00 sec)
mysql> select*from stu2;
+----+-------+--------+
| id | score | stu_id |
+----+-------+--------+
|  1 |   100 |      1 |
|  2 |    80 |      3 |
|  3 |    70 |      5 |
+----+-------+--------+
3 rows in set (0.00 sec)
mysql> select*from stu1,stu2 where stu1.id=stu2.stu_id;
//自然连接
+----+------+----+-------+--------+
| id | name | id | score | stu_id |
+----+------+----+-------+--------+
|  1 | 张三 |  1 |   100 |      1 |
|  3 | 王五 |  2 |    80 |      3 |
|  5 | 青菜 |  3 |    70 |      5 |
+----+------+----+-------+--------+
3 rows in set (0.00 sec)
mysql> select*from stu1 inner join stu2 on stu1.id=stu2.stu_id;
//自然内连接
inner 实际上是可以省略。
+----+------+----+-------+--------+
| id | name | id | score | stu_id |
+----+------+----+-------+--------+
|  1 | 张三 |  1 |   100 |      1 |
|  3 | 王五 |  2 |    80 |      3 |
|  5 | 青菜 |  3 |    70 |      5 |
+----+------+----+-------+--------+吧
3 rows in set (0.00 sec)

mysql> select*from stu1 as s1,stu2 as s2 where s1.id=s2.stu_id;
给个别名容易用些

mysql> select stu1.name,stu2.score from stu1 left join stu2 on stu1.id=stu2.stu_
id;
这个是左连接查询。
left 左外连接.
表1(连接表) left join 表2(被连接表) on
取(以左边的表为基准)连接表的所有行,被连接表找出匹配连接表的数据,没有匹配的则以null填充
+------+-------+
| name | score |
+------+-------+
| 张三 |   100 |
| 李四 |  NULL |
| 王五 |    80 |
| 萝卜 |  NULL |
| 青菜 |    70 |
+------+-------+

mysql> select stu1.name,stu2.score from stu1 right join stu2 on stu1.id=stu2.stu
_id;
这个是右连接查询。
表1(连接表) right join 表2(被连接表) on
取(以right边的表为基准)被连接表的所有行,连接表找出匹配被连接表的数据,没有匹配的则以null填充
+------+-------+
| name | score |
+------+-------+
| 张三 |   100 |
| 王五 |    80 |
| 青菜 |    70 |
| NULL |    60 |
+------+-------+

mysql> select * from stu2 left join stu1 on stu1.id=stu2.stu_id union
    -> select*from stu2 right join stu1 on stu1.id=stu2.stu_id;
这个是满连接查询。
+------+-------+--------+------+------+------+
| id   | score | stu_id | id   | name | age  |
+------+-------+--------+------+------+------+
|    1 |   100 |      1 |    1 | 张三 |   20 |
|    2 |    80 |      3 |    3 | 王五 |   20 |
|    3 |    70 |      5 |    5 | 青菜 |   20 |
|    4 |    60 |      7 | NULL | NULL | NULL |
| NULL |  NULL |   NULL |    2 | 李四 |   20 |
| NULL |  NULL |   NULL |    4 | 萝卜 |   20 |
+------+-------+--------+------+------+------+
6 rows in set (0.01 sec)

mysql> select score.sno,degree from score,student1 where score.sno=student1.sno
union select cname,degree from score,coorse where score.cno=coorse.cno;

select * from 表1 full join 表2；
那么显示20条记录了？

mysql> select*from stu3 cross join stu4;
mysql> select*from stu3 join stu4;
这两个是交叉连接查询




3.24笔记
1.首先确定单表，多表
2.出息的条件是否在不同表中    表连接条件+单表条件
3.是否出息聚集函数的可能group by 或非group by
4.group by 之后考虑group by 前条件也后条件。
DB=database
DBA=database administrator
DBMS=database manage system
                    层次数据库
数据库分类          网状数据库
            关系数据库 *

            数据结构
数据3大要素        数据操作
            完整性约束
完整性约束包括实体完整性、参照完整性、域完整性和用户定义完整性。实体完整性用于保证数据库中数据表的每一
个特定实体的记录都是惟一的。

约束：
    目的：就是保证数据的完整性
    作用:限制存放到表中数据的可能值
它的种类：主键约束、外键约束、唯一性约束、检查约束、默认值约束、空值约束
每个约束的详解：
一 主键约束：1、唯一的确定一行
    2、主要用来确保表中每一条记录的每一列或者多列集合有唯一的值
    3、只定义一个主键约束
    4、主键所包含的那些列不可能为空
二 外键约束：定义：限制本表中某列的值必须和参照表某列进行关联，及参照两个表建立约束之后，在外键表中对约束
域中的所有数据的修改和插入。
三 唯一性约束(uniquc)：不能与主键一起使用，不同之处：
     1、在一个表中可以有多个唯一性约束但主键只能有一个
     2、唯一性约束可以为空值，而主键不能。
四：检查约束又叫check约束：就是值域值范围约束
五默认值约束又叫default约束：它只能在插入数据时，并且没有提供值的时候才能使用自动它。


                     3.25笔记
1. 子查询的定义
    子查询是指将一条查询语句嵌入到另一条查询语句中。数据库引擎将子查询做为虚表

执行查询操作。子查询可做为连接语句中的一个表，可做为选择语句中的一个值，也可以

是mysql查询子句，还可以是mysql查询子句的字句，与数据操作语句混合在一起。子查询

的执行依赖于嵌套查询。查询树从最里层开始，一层一层向外执行。高层的嵌套查询可以

访问低层嵌套查询的结果。

    子查询有两种类型:
          A. 标准(简单)子查询
          B. 相关联子查询

1.使用any，in和some进行子查询。
ANY关键词必须接一个比较操作符。ANY关键词的意思是“对于在子查询返回的列中的任
一数值，如果比较结果为TRUE的话，则返回TRUE”
例：按stusex表查询student里的性别。
select*from 表 where 字段=any（select 字段 from 表）；
什么是相关子查询?
   与标准子查询不同，相关子查询依赖于外部查询。外部查询和子查询是有联系的，尤其
   在子查询的WHERE语句中更是如此。
  相关子查询与简单(普遍)子查询的区别?
相关子查询引用了外部查询中的列! 这种用外部查询来限制子查询的方法使SQL查询变得更加强大和灵活。
因为相关子查询能够引用外部查询，所以它们尤其适合编写复杂的where条件!
mysql> select*from student where sex=any(select sex from stusex);
+-----+-------+------+
| sno | sname | sex  |
+-----+-------+------+
|   1 | a     | 男   |
|   2 | b     | 女   |
+-----+-------+------+
2 rows in set (0.00 sec)
mysql> select*from student where not sex=any(select sex from stusex);

mysql> select*from student where sex in(select sex from stusex);
+-----+-------+------+
| sno | sname | sex  |
+-----+-------+------+
|   1 | a     | 男   |
|   2 | b     | 女   |
+-----+-------+------+
2 rows in set (0.00 sec)
mysql> select*from student where sex not in(select sex from stusex);

*****in 就等于 =any。

mysql> select*from student where sex=some(select sex from stusex);
+-----+-------+------+
| sno | sname | sex  |
+-----+-------+------+
|   1 | a     | 男   |
|   2 | b     | 女   |
+-----+-------+------+
2 rows in set (0.00 sec)
=some 和=any是一样的
2.使用all
ALL的意思是“对于子查询返回的列中的所有值，如果比较结果为TRUE，则返回TRUE。”例如：
mysql> select*from student where sex=all(select sex from stusex);
mysql> select*from student where sex!=all(select sex from stusex);
+-----+-------+------+
| sno | sname | sex  |
+-----+-------+------+
|   3 | c     | 坏   |
|   4 | d     | 好   |
+-----+-------+------+
2 rows in set (0.00 sec)
!=all等同于not in
> all......<all 等等。

mysql> select*from a where a=any(select a from b) and b=any(select b from b);
+------+------+
| a    | b    |
+------+------+
|    3 |    3 |
+------+------+
1 row in set (0.01 sec)

1。查找与删除两个表中相同的数据。
select*from A where A.a in(select a from B) and A.b in(select b from B);
mysql> select*from a where exists(select*from b where a.a=b.a and a.b=b.b);
条件多的时候最好用exists。
+------+------+
| a    | b    |
+------+------+
|    3 |    3 |
+------+------+
1 row in set (0.00 sec)
2。查找与删除单表中的重复记录
分组
mysql> select*from c group by a,b having count(*)>1;
+----+------+------+
| id | a    | b    |
+----+------+------+
|  1 |    1 |    1 |
|  3 |    2 |    2 |
+----+------+------+
2 rows in set (0.00 sec)
子查询
mysql> select*from c as c1 where c1.id!=(select max(id) from c as c2 where c1.a=c2.a and c1.b=c2.b);***********
+----+------+------+
| id | a    | b    |
+----+------+------+
|  1 |    1 |    1 |
|  3 |    2 |    2 |
+----+------+------+
2 rows in set (0.01 sec)

mysql> select*from a where a.t1 in(select t1 from b where a.t2=b.t2);
相关子查询。
+------+------+
| t1   | t2   |
+------+------+
|    1 |    1 |
|    1 |    3 |
+------+------+
2 rows in set (0.00 sec)

                     3.26 笔记
(表类型)存储引擎：MyiSAM、innoDB、BDB(BerkeleyDB).

    1。支持的字段数据类型
2。锁定类型
3。索引
4。事务处理

各存储引擎之间的区别
　　为了做出选择哪一个存储引擎的决定，我们首先需要考虑每一个存储引擎提供了
哪些不同的核心功能。这种功能使我们能够把不同的存储引擎区别开来。我们一般把
这些核心功能分为四类:支持的字段和数据类型、锁定类型、索引和处理。一些引擎
具有能过促使你做出决定的独特的功能，我们一会儿再仔细研究这些具体问题。

　　字段和数据类型

　　虽然所有这些引擎都支持通用的数据类型，例如整型、实型和字符型等，但是，
并不是所有的引擎都支持其它的字段类型，特别是BLOG（二进制大对象）或者TEXT
文本类型。其它引擎也许仅支持有限的字符宽度和数据大小。

　　这些局限性可能直接影响到你可以存储的数据，同时也可能会对你实施的搜索
的类型或者你对那些信息创建的索引产生间接的影响。这些区别能够影响你的应用
程序的性能和功能，因为你必须要根据你要存储需要的存储的数据类型选择对引擎的功能做出决策。

　　锁定

　　数据库引擎中的锁定功能决定了如何管理信息的访问和更新。当数据库中的一
个对象为信息更新锁定了，在更新完成之前，其它处理不能修改这个数据(在某些
情况下还不允许读这种数据)。

　　锁定不仅影响许多不同的应用程序如何更新数据库中的信息，而且还影响对那
个数据的查询。这是因为查询可能要访问正在被修改或者更新的数据。总的来说，
这种延迟是很小的。大多数锁定机制主要是为了防止多个处理更新同一个数据。由
于向数据中插入信息和更新信息这两种情况都需要锁定，你可以想象，多个应用程
序使用同一个数据库可能会有很大的影响。　　不同的存储引擎在不同的对象级别
支持锁定，而且这些级别将影响可以同时访问的信息。得到支持的级别有三种:表锁
定、块锁定和行锁定。支持最多的是表锁定，这种锁定是在MyISAM中提供的。在数
据更新时，它锁定了整个表。这就防止了许多应用程序同时更新一个具体的表。这
对应用很多的多用户数据库有很大的影响，因为它延迟了更新的过程。

　　页级锁定使用Berkeley DB引擎，并且根据上载的信息页(8KB)锁定数据。当在
数据库的很多地方进行更新的时候，这种锁定不会出现什么问题。但是，由于增加
几行信息就要锁定数据结构的最后8KB，当需要增加大量的行，也别是大量的小型
数据，就会带来问题。

　　行级锁定提供了最佳的并行访问功能，一个表中只有一行数据被锁定。这就意
味着很多应用程序能够更新同一个表中的不同行的数据，而不会引起锁定的问题。
只有InnoDB存储引擎支持行级锁定。

　　建立索引

　　建立索引在搜索和恢复数据库中的数据的时候能够显著提高性能。不同的存储
引擎提供不同的制作索引的技术。有些技术也许会更适合你存储的数据类型。

　　有些存储引擎根本就不支持索引，其原因可能是它们使用基本表索引(如MERGE引擎)
或者是因为数据存储的方式不允许索引(例如FEDERATED或者BLACKHOLE引擎)。

　　事务处理

　　事务处理功能通过提供在向表中更新和插入信息期间的可靠性。这种可靠性是通过
如下方法实现的，它允许你更新表中的数据，但仅当应用的应用程序的所有相关操作完
全完成后才接受你对表的更改。例如，在会计处理中每一笔会计分录处理将包括对借方
科目和贷方科目数据的更改，你需要要使用事务处理功能保证对借方科目和贷方科目的
数据更改都顺利完成，才接受所做的修改。如果任一项操作失败了，你都可以取消这个
事务处理，这些修改就不存在了。如果这个事务处理过程完成了，我们可以通过允许这
个修改来确认这个操作。

总结：
       1.子查询引用了外部查询的区别：exists，in，all，any
   2.mysql-front     auto_increment
                 表类型
   3.索引：数据库没了索引就好像一塘死水，why？
    1）.数据库引入了索引
　　用户对数据库最频繁的操作是进行数据查询。一般情况下，
数据库在进行查询操作时需要对整个表进行数据搜索。当表中
的数据很多时，搜索数据就需要很长的时间，这就造成了服务
器的资源浪费。为了提高检索数据的能力，数据库引入了索引
机制。
        2）.有关“索引”的比喻
　　从某种程度上，可以把数据库看作一本书，把索引看作书
的目录，通过目录查找书中的信息，显然较没有目录的书方便、快捷。
        3）.数据库索引实际是什么？（两部分组成）
　　索引是一个单独的、物理的数据库结构，它是某个表中一列或若
干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单。
        
                   3.29笔记
4.索引在表中的角色
　　一个表的存储是由两部分组成的，一部分用来存放表的数据页面，
另一部分存放索引页面。索引就存放在索引页面上， 
索引高效原理
　　通常，索引页面相对于数据页面来说小得多。当进行数据检索时，
系统先搜索索引页面，从中找到所需数据的指针，再直接通过指针从
数据页面中读取数据。
索引的概念
　　索引就是加快检索表中数据的方法。数据库的索引类似于书籍的
索引。在书籍中，索引允许用户不必翻阅完整个书就能迅速地找到所
需要的信息。在数据库中，索引也允许数据库程序迅速地找到表中的
数据，而不必扫描整个数据库。
索引的优点
　　1.创建唯一性索引，保证数据库表中每一行数据的唯一性
　  2.大大加快数据的检索速度，这也是创建索引的最主要的原因
　　3.加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
　　4.在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
　　5.通过使用索引，可以在查询的过程中使用优化隐藏器，提高系统的性能。
索引的缺点
　　1.创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加
　　2.索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占
一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大
　　3.当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，
降低了数据的维护速度

索引分类
    1.聚集索引（簇索引）与非聚集索引（非簇索引）
聚簇索引：物理索引，与基表的物理顺序相同，数据值的顺序总是按照顺序排列

聚集索引和非聚集索引的根本区别是表记录的排列顺序和与索引的排列顺序是否一致，
聚集索引表记录的排列顺序与索引的排列顺序一致，优点是查询速度快，因为一旦具
有第一个索引值的纪录被找到，具有连续索引值的记录也一定物理的紧跟其后。聚集
索引的缺点是对表进行修改速度较慢，这是为了保持表中的记录的物理顺序与索引的
顺序一致，而把记录插入到数据页的相应位置，必须在数据页中进行数据重排，降低
了执行速度。建议使用聚集索引的场合为： 　　a.此列包含有限数目的不同值； 　
　b.查询的结果返回一个区间的值； 　　c.查询的结果返回某值相同的大量结果集。
　　非聚集索引指定了表中记录的逻辑顺序，但记录的物理顺序和索引的顺序不一致，
聚集索引和非聚集索引都采用了B+树的结构，但非聚集索引的叶子层并不与实际的数
据页相重叠，而采用叶子层包含一个指向表中的记录在数据页中的指针的方式。非聚
集索引比聚集索引层次多，添加记录不会引起数据顺序的重组。建议使用非聚集索引
的场合为： 　　a.此列包含了大量数目不同的值； 　　b.查询的结束返回的是少量
的结果集； 　　c.order by 子句中使用了该列。

1.直接创建索引和间接创建索引
　　直接创建索引： CREATE INDEX mycolumn_index ON mytable (myclumn)
　　间接创建索引：定义主键约束或者唯一性键约束，可以间接创建索引
建索引

CREATE INDEX indexName ON mytable(字段名(length)); 如果是CHAR，VARCHAR类型，
length可以小于字段实际长度；如果是BLOB和TEXT类型，必须指定 length，下同。
mysql> create index indexName on a(a);
删除索引：DROP INDEX 索引名 ON 表名


普通索引和唯一性索引
　　普通索引：CREATE INDEX mycolumn_index ON mytable (myclumn)
　　唯一性索引：保证在索引列中的全部数据是唯一的，对聚簇索引和非聚簇索引都可以使用
　　CREATE UNIQUE INDEX myclumn_cindex ON mytable(mycolumn)
    CREATE UNIQUE INDEX 索引名 ON 表名(字段名(length))

单个索引和复合索引
　　单个索引：即非复合索引
　　复合索引：又叫组合索引，在索引建立语句中同时包含多个字段名

六、索引的使用
　　1.当字段数据更新频率较低，查询使用频率较高并且存在大量重复值是建议使用聚簇索引
　　2.经常同时存取多列，且每列都含有重复值可考虑建立组合索引
　　3.复合索引的前导列一定要控制好，否则无法起到索引的效果。如果查询时前导列
不在查询条件中则该复合索引不会被使用。前导列一定是使用最频繁的列
　　4.多表操作在被实际执行前，查询优化器会根据连接条件，列出几组可能的连接方
案并从中找出系统开销最小的最佳方案。连接条件要充份考虑带有索引的表、行数多的
表；内外表的选择可由公式：外层表中的匹配行数*内层表中每一次查找的次数确定，
乘积最小为最佳方案
　　5.where子句中对列的任何操作结果都是在sql运行时逐列计算得到的，因此它不得
不进行表搜索，而没有使用该列上面的索引；如果这些结果在查询编译时就能得到，那
么就可以被sql优化器优化，使用索引，避免表搜索(例：select * from record where
substring(card_no,1,4)=’5378’
　　&& select * from record where card_no like ’5378%’)任何对列的操作都将导致
表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边
　　6.where条件中的’in’在逻辑上相当于’or’，所以语法分析器会将in (’0′,’1′)转化
为column=’0′ or column=’1′来执行。我们 期望它会根据每个or子句分别查找，再将结
果相加，这样可以利用column上的索引；但实际上它却采用了"or策略"，即先取出满足
每个or子句的行，存入临时数据库的工作表中，再建立唯一索引以去掉重复行，最后从
这个临时表中计算结果。因此，实际过程没有利用column上索引，并且完成时间还要受
tempdb数据库性能的影响。in、or子句常会使用工作表，使索引失效；如果不产生大量
重复值，可以考虑把子句拆开；拆开的子句中应该包含索引

（1）避免在列上进行操作否则导致全部扫描。（要避免全表扫描）
不能在null上建立索引，会导致索引失效。
最好不要在经常修改或删除等列上建立索引。

create view 视图名称 as select a,b from 表；
drop view 视图名称；
select*from 视图名称；

视图与表的区别：
1、表的数据是存储在磁盘上，而视图在默认情况下物理上是不存在的；
2、视图由表派生出来的一个数据库对象，视图又叫虚表；
3、唯一物理存在的只有视图名和从表中查询行的方法。
视图的作用：
    1、限制表中特定行和列的使用，因此视图可以用来控制一个或多个表中特定部分的访问；
    2、简化操作，隐藏复杂查询；
    3、安全性，让客户只能看到视图，没有操作的任何权限；
    4、合并分割数据；
    5、将插入或更新数据限制在一定范围中。

delete from 表；
truncate 表；
清空表记录。
删除数据delete和truncate的区别：
    1、truncate是逐页删除数据的而delete是逐行删除的，所以说truncate比delete删除速度要快
    2、truncate操作立即生效,原数据不放到回滚段中,不能回滚,删除数据没有日志文件不能恢复，
而delete这个操作会放到回滚段中,事务提交之后才生效;可以恢复。
    3、delete语句是dml,如果有相应的触发器,执行的时候将被触发. truncate是ddl,  操作不触
发触发器.
truncate 删除表信息时。它是删除表和表里信息以后在建一个一样的表、
而delete则是逐行删除的。而且delete删除后假如id主键是自动递增。它
会记住上次id的位置。而truncate不记录。
delete可以选择性的删除指定列或全部列,而truncate只能是删除全部数据.
    truncate删除了表,然后根据表结构重新建立它,当我们再次插入数据时,auto_increment会从1重新开始
自增.而delete删除的是表里的记录.当我们再次插入数据时,auto_increment值会接着前面的序列.

MySQL表的复制
创建表的副本：
创建一个完全和上表表结构一样，数据也一样的新表，即直接复制原表的表结构可以用如下ＳＱＬ语句
/*
用子查询，创建表，表的结构呢完全和nickname一致，并且数据也相同
*/
create table new_nickname select * from nickname;
只创建含有特定字段的表副本：
有的时候呢，我需要一个新表，只需要有昵称表的name与desc两个字段即可，不需要id字段，同样
使用子查询，不过不再是select * 而是直接select 想要的字段即可
/*
因为只想要name和desc字段，所以我只查询原表的这两个字段即可
*/
create table new_nickname select name, desc from nickname;
只创建含有约束条件的值的表副本：
比如说，突然间我只想要那个id < 3的昵称表的所有数据咋办呢？(我不是 矫情啊，是为了举例啊！
)这个时候，我们就需要为子查询加上条件限制，where 语句大家没有忘吧？
/*
限定条件，只要id<3的数据
*/
create table new_nickname select * from nickname where id < 3;
只复制表结构，咱爷们不要表数据：
有的时候呢，我只想复制旧表的表结构，至于里面的数据呢？已经old了，我是不想要的，即我只
想复制一个表的表结构，这个时候咋办呢？别怕，我教你三种方法，均可解决此问题。
/*
和上面复制特定数据一样，只不过呢，咱这个条件弄个恶心点的，
当0=1的时候我才要你的数据，显然不会复制任何数据了
*/
create table new_nickname select * from nickname where 0 = 1;
上面的方法是取巧，因为没有合格的数据符合限制条件，所以被复制的当然只有表结构了。另外
MySQL提供了一个现成的语法，那就是：create table new_talbe_name like old_table_name;
/*
应用create table like 语法，只复制表结构
*/
create table new_nickname like nickname;
第三种方法就是用咱们之前取过外键key_id的方法，显示创建表时的SQL语句然后复制，显示建
表语句的方法为：show create table table_name;
复制旧表部分结构，同时增加新字段：
人都要创新嘛，社会在进步，如果还停留不前的话是会淘汰的，所以咱也不能单纯的复制，也
要有点自己的个性，在我的地盘听我的嘛。比如说复制昵称表的同时呢，我要创建一个新的字
段，就是昵称创建日期字段。嗯。
/*
咱也个性点，新字段咋的也得先声明一下，再复制想要的那部分字段，嘿嘿
*/
create table new_nickname (create_time date not null, status enum('1','2')) select
name, desc from nickname;

                                3.30
什么是存储例程?
存储例程是存储在数据库服务器中的一组sql语句，通过在查询中调用一个指定的名称来执行
这些sql语句命令。
    存储过程：是一组为了完成特定功能的SQL语句，经过编译后存储在数据库服务器之中
优点：
      1、减少应用程序的逻辑复杂性；
          2、存储过程允许模块化设置；
          3、存储过程创建后，可以多次调用，对存储过程的修改对应用程序毫无影响；
          4、存储过程可以快速的执行效率；
          5、能够减少网络流量；
          6、可以作为一种安全机制来充分利用。防止sql被攻击；
 
存储过程
    create procedure xxx() select 字符串/select*from 表（等插入，删除，修改）；
drop procedure if exists 表;

调用 call xxx();

存储 ——）无参
     ——）有输入参数
——）有输出
——）输入输出的
无参：
CREATE PROCEDURE `aa`()
    begin
    select 字符串;
    select*from 表;
。。。。
    end;
CREATE PROCEDURE `aa`()
    begin
    declare a int DEFAULT 1;
    set a=2;
    select a;
    select*from student1;
    end;

CREATE PROCEDURE `aa`()
begin
declare a int DEFAULT 2;
if a=1 then
select a+1;
else
select a-1;
end if;
select*from student1;
end;
有输入参数：
CREATE procedure `aaa`(in `x` varchar(10))
BEGIN
select x;
END;
在doc下是call aaa(参数);
在MySQL-Front中写代码左上角。会有个输入窗口

CREATE PROCEDURE `aaa`(in `x` varchar(10),`y` char(10))
BEGIN
select*from emp where x=empno and y=deptno;
END;
在doc下是call aaa(参数，参数);
有输出：
CREATE PROCEDURE `x`(out `xx` char(11))
BEGIN
select 'hello!' into xx;/可以根据要求select。。。
END;
把hello!赋给xx;
输出台：call x(@+字符)；
select @+字符（显示）；

CREATE PROCEDURE `aa`(in a int(11),out b varchar(10))
BEGIN
select sname into b from student1 where a=sno;
END;
输出台
CALL aa(2,@b);
select*from student1;
select @b;

1.过程（无返回值，但可以有多个输出输入参数）与函数（函数有且只有一个返回值）
mysql> create function 函数名() returns int return 100;
Query OK, 0 rows affected (0.00 sec)
mysql> select 函数名(); 函数

CREATE FUNCTION `fone`(s int) RETURNS char(10)
return (select name from student where id=s);
select fone(参数);



       3.31笔记
111：   
create function ss(ids int) returns varchar(100)
begin
return (select concat(id,sex,age) from student where id=ids);
end;
112：
CREATE FUNCTION `ss`(id int) RETURNS varchar(100)
begin
declare outName varchar(10);
declare outSex varchar(10);
declare outAge int;
select name,sex,age into outName,outSex,outAge from student s where s.id=id;
return concat(outName,'   ',outSex,'  ',outAge);
end;

循环：
CREATE PROCEDURE `aa`(`id` int(11))
BEGIN
declare i int default 0;
while(i<5) do
set i=i+1;
select i;
end while;
END;

*****1.游标
        ——声明游标（定义游标）；
declare 游标名 cursor for 结果集（select*from student）;
——打开游标；
open 游标名；
——使用游标；
——关闭游标；
游标：*定义：它是一种能从包括多数据记录的结果集中，每次只读一条记录的机制，
把集合操作转换成单个记录处理方式，游标机制允许用户在数据库内逐行的访问这些
记录，按照用户自己的意愿来显示和处理这些记录。

declare continue handler for sqlstate '02000' set 变量名 = null;
执行游标
CREATE PROCEDURE `aa`()
BEGIN
declare outName varchar(10);
declare cursor_name cursor for select id from youbiao;
declare continue handler for sqlstate '02000' set outName = null;
open cursor_name;
fetch cursor_name into outName;
while(outName is not null) do
select outName;
fetch cursor_name into outName;
end while;
close cursor_name;
END;

CREATE PROCEDURE `aa`()
BEGIN
declare outName varchar(10);
declare outId int;
declare temp int default 3;
declare cursor_name cursor for select name,id from youbiao;
（declare temp int default 3;一定要定义到游标的前面。）
/*declare continue handler for sqlstate '02000' set outName = null,outId=0;*/
declare continue handler for not found set temp=0;
open cursor_name;
fetch cursor_name into outName,outId;
/*while(outName is not null) do*/
while(temp=3)do
select outName,outId;
fetch cursor_name into outName,outId;
end while;
close cursor_name;
END;

2.触发器（mysql 5.0版本不支持的）
触发器：定义：对一个特点表格中发生特定操作时，所激活的一种机制，
当事件(update insert delete)发生时，才被自动激活，不能够显示的调用。

触发器与存储过程区别：是一种特殊的存储过程。（触发器是自己触发自己。而存储过程则是动手调用的）
最主要的其区别我认为就是
触发器是事件触发自动执行的
存储过程需要调用执行
事件（增，删，改）    
                                 构成——）触发器名           触发频率——）语句级
类型——）事前触发（before）           ——）触发器动作事件             ——）行级
    ——）事后触发 (after)           ——）操作过程
插入用new修改可以用new。old。删除old。

create trigger xt before insert on 表1 for each row
begin
insert into 表2 values(插入表2的值);
end;
  或   create trigger xt before insert on 表1 for each row insert into 表2 values(插入表2的值)
【values(new.字段)(是当前aa插入的值)】;
触发器是一种特殊类型的存储过程，它不同于我们前面介绍过的存储过程。
触发器主要是通过事件进行触发而被执行的，而存储过程可以通过存储过程名字而被直接调用。
当对某一表进行诸如UPDATE、 INSERT、 DELETE 这些操作时， 数据库系统就会自动执行触发器所定义的SQL 语句，
从而确保对数据的处理必须符合由这些SQL 语句所定义的规则。

drop trigger 触发器名。
values(old.字段/new.字段)
delete用old、insert用new、修改old于new都可以
create trigger xt before delete on aa for each row
insert into bb values(old.a);
就把删除信息赋给了bb。

                                   4.1笔记
1。事务的ACID属性
ACID事务概念
ACID（Atomic、 Consistent、 Isolated、 Durable）即：事务的原子性、一致性、隔离性及持久性
事务的原子性是指一个事务要么全部执行,要么不执行.也就是说一个事务不可能只执行了一半就停止了
.比如你从取款机取钱,这 个事务可以分成两个步骤:1划卡,2出钱.不可能划了卡,而钱却没出来.这两步
必须同时完成.要么就不完成. 事务的一致性是指事务的运行并不改变数据库中数据的一致性.例如,完
整性约束了a+b=10,一个事务改变了a,那么b也应该随之改 变.
事务的隔离性是指两个以上的事务不会出现交错执行的状态.因为这样可能会导致数据不一致.
事务的持久性是指事务运行成功以后,就系统的更新是永久的.不会无缘无故的回滚.

2。数据库设计ER（entity-Relation 实体关系图）图设


*database设计流程：*需求分析 -> 概念结构设计 -> 逻辑结构设计 -> 物理结构设计 -> 数据库实施
-> 数据库运行与管理。

1。设计流程
2。数据字典
是各类数据描述的集合。它是关于数据库中数据的描述，而不是数据本身。它包括数据项、数据结构、
数据流、数据存储、数据处理过程。它至少要包含每个字段的数据类型，每个表中的主、外键。

concat(字段。。。。。);包含

DBMS就是mysl。奥Oracle。SQL Server
ORM对象关系映射。
                              
   4.2笔记
1.phpmyadmin

多对多时它的解决方案是搞个中间表。

SCJP是sun公司的。。。。。。？

   E-R图也即实体-联系图(Entity Relationship Diagram)，提供了表示实体型、属性和联系的方法，
   用来描述现实世界的概念模型。
　　E-R方法:是“实体-联系方法”（Entity-Relationship Approach）的简称。它是描述现实世界概念
结构模型的有效方法。
　　构成E-R图的基本要素是实体型、属性和联系，其表示方法为：
　　? 实体型(Entity)：具有相同属性的实体具有相同的特征和性质，用实体名及其属性名集合来抽
象和刻画同类实体;在E-R图中用矩形表示，矩形框内写明实体名；比如学生张三丰、学生李寻欢都是
实体。如果是弱实体的话，在矩形外面再套实线矩形。
　　? 属性(Attribute)：实体所具有的某一特性，一个实体可由若干个属性来刻画。在E-R图中用椭
圆形表示，并用无向边将其与相应的实体连接起来；比如学生的姓名、学号、性别、都是属性。如果
是多值属性的话，再椭圆形外面再套实线椭圆。如果是派生属性则用虚线椭圆表示。
　　? 联系(Relationship)：联系也称关系，信息世界中反映实体内部或实体之间的联系。实体内部
的联系通常是指组成实体的各属性之间的联系；实体之间的联系通常是指不同实体集之间的联系。在
E-R图中用菱形表示，菱形框内写明联系名，并用无向边分别与有关实体连接起来，同时在无向边旁
标上联系的类型（1 : 1，1 : n或m : n）。 比如老师给学生授课存在授课关系，学生选课存在选
课关系。如果是弱实体的联系则在菱形外面再套菱形。

                              4.3笔记

图设工具 ~powerdesigner---数据库建模工具
  ~together
  ~ERwin
  ~rose-软件需求

sql优化
0。select尽量避免‘*’。
1。exists>in>or。
2。对列的操作，尽量将操作符移至右边。
3。索引列不应该有null值。
4。from与where中的表顺序规则（）。
5。like字句中的通配符%在前面时索引失效（%x），（x%）这个会得到使用
6。避免相关子查询。
7。尽量使用前条件，用where子句替换having子句。
8。where条件之后的列建索引。

explain 是查看扫描信息。

4.6笔记
1。事务的ACID属性
ACID事务概念
ACID（Atomic、 Consistent、 Isolated、 Durable）即：事务的原子性、一致性、隔离性及持久性
事务的原子性是指一个事务要么全部执行,要么不执行.也就是说一个事务不可能只执行了一半就停止了
.比如你从取款机取钱,这 个事务可以分成两个步骤:1划卡,2出钱.不可能划了卡,而钱却没出来.这两步
必须同时完成.要么就不完成. 事务的一致性是指事务的运行并不改变数据库中数据的一致性.例如,完
整性约束了a+b=10,一个事务改变了a,那么b也应该随之改 变.
事务的隔离性是指两个以上的事务不会出现交错执行的状态.因为这样可能会导致数据不一致.
事务的持久性是指事务运行成功以后,就系统的更新是永久的.不会无缘无故的回滚.
写事务的时候的注意一点必须给自动提交设为false，为什么呢？不改的话它会成功一条就加入到数据库，而只回滚错误的数据

1。JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的
Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接
口组成。JDBC为工具/数据库开发人员提供了一个标准的API，据此可以构建更高级的
工具和接口，使数据库开发人员能够用纯 Java API 编写数据库应用程序，同时，
JDBC也是个商标名。

有了JDBC，向各种关系数据发送SQL语句就是一件很容易的事。换言之，有了JDBC API，
就不必为访问Sybase数据库专门写一个程序，为访问Oracle数据库又专门写一个程序，
或为访问Informix数据库又编写另一个程序等等，程序员只需用JDBC API写一个程序
就够了，它可向相应数据库发送SQL调用。同时，将Java语言和JDBC结合起来使程序
员不必为不同的平台编写不同的应用程序，只须写一遍程序就可以让它在任何平台上
运行，这也是Java语言“编写一次，处处运行”的优势。

2。jdbc访问数据库步骤
   1）。加载数据库驱动（Java包类）。
Class.forName("com.mysql.jdbc.Driver");
2。通过DriverManager类 获取数据库连接得到Connection对象
java.sql.Connection connection = DriverManager.getConnection("jdbc:mysql://192.168.1.80/jdbc", "root", "root");
jdbc:mysql://主机编号/数据库名
3、通过connection对象创建Statement对象。
java.sql.Statement statement = connection.createStatement();
4、使用Statement执行sql语句。
java.sql.ResultSet resultSet = statement.executeQuery("select*from person");
  while (resultSet.next()) {
        System.out.print(resultSet.getString("id"));
        System.out.print(resultSet.getString("sex"));
        System.out.print(resultSet.getString("age"));
  }
int newResultSet = statement.executeUpdate("delete from person where id=10");
executeUpdate返回影响的记录行数。
int newResultSet = statement.executeUpdate("update person set age=200 where id=1");
int newResultSet = statement.executeUpdate("insert into person values(10,'想',13,'女')");
5.关闭数据库资源。

■DriverManager 类
DriverManager 类是 JDBC 的管理层，作用于用户和驱动程序之间。它跟踪可用的驱动程序，并在数据
库和相应驱动程序之间建立连接。另外，DriverManager 类也处理诸如驱动程序登录时间限制及登录和
跟踪消息的显示等事务。
对于简单的应用程序，一般程序员需要在此类中直接使用的唯一方法是 DriverManager.getConnection。
正如名称所示，该方法将建立与数据库的连接。JDBC 允许用户调用 DriverManager 的方法 getDriver、
getDrivers 和 registerDriver 及 Driver 的方法 connect。但多数情况下，让 DriverManager 类管
理建立连接的细节为上策。
■跟踪可用驱动程序
DriverManager 类包含一列 Driver 类，它们已通过调用方法 DriverManager.registerDriver 对自己
进行了注册。所有 Driver 类都必须包含有一个静态部分。它创建该类的实例，然后在加载该实例时
DriverManager 类进行注册。这样，用户正常情况下将不会直接调用 DriverManager.registerDriver；
而是在加载驱动程序时由驱动程序自动调用。加载 Driver 类，然后自动在 DriverManager 中注册的方式有两种：
? 通过调用方法 Class.forName。这将显式地加载驱动程序类。由于这与外部设置无关，因此推荐使用
这种加载驱动程序的方法。以下代码加载类 acme.db.Driver：
Class.forName("acme.db.Driver");
如果将 acme.db.Driver 编写为加载时创建实例，并调用以该实例为参数的 DriverManager.registerDriver
（本该如此），则它在 DriverManager 的驱动程序列表中，并可用于创建连接。
? 通过将驱动程序添加到 java.lang.System 的属性 jdbc.drivers 中。这是一个由 DriverManager
类加载的驱动程序类名的列表，由冒号分隔：初始化 DriverManager 类时，它搜索系统属性 jdbc.drivers，
如果用户已输入了一个或多个驱动程序，则 DriverManager 类将试图加载它们。以下代码说明程序员如何在
~/.hotjava/properties 中输入三个驱动程序类（启动时，HotJava 将把它加载到系统属性列表中）：
jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.test.ourDriver;
对 DriverManager 方法的第一次调用将自动加载这些驱动程序类。
注意：加载驱动程序的第二种方法需要持久的预设环境。如果对这一点不能保证，则调用方法 Class.forName
显式地加载每个驱动程序就显得更为安全。这也是引入特定驱动程序的方法，因为一旦 DriverManager 类被
初始化，它将不再检查 jdbc.drivers 属性列表。
在以上两种情况中，新加载的 Driver 类都要通过调用 DriverManager.registerDriver 类进行自我注册。
如上所述，加载类时将自动执行这一过程。
由于安全方面的原因，JDBC 管理层将跟踪哪个类加载器提供哪个驱动程序。这样，当 DriverManager 类打
开连接时，它仅使用本地文件系统或与发出连接请求的代码相同的类加载器提供的驱动程序。
■建立连接
加载 Driver 类并在 DriverManager 类中