第八周

最新推荐文章于 2021-01-02 15:34:48 发布

讽嘲

最新推荐文章于 2021-01-02 15:34:48 发布

阅读量338

点赞数

create table temp_001(
tid int primary key auto_increment,
tname varchar(20),
tage int);
create procedure proc5()
begin
declare var int;
set var=0;
while var<50000 do
insert into temp_001 values (null,‘zs’,12);
set var=var+1;
end while ;
end;
call proc5();
–==============================================================
–复习:关联查询
– 1、概念: 多张表查询…
– 2、等值连接:
— 3、笛卡尔积:
– 4、内连接: 表A [inner] join 表B on
– 5、外连接: 表A left [outer] join 表B on
– 表A right [outer] join 表B on
– 驱动表(主表)，从动表(副表)
– 6、自连接: 多张表的表名都是同一张表。
– 高级关联查询:
– 子查询与父查询的概念:
– 子查询的位置: 在where子句，from子句，having子句，select子句
– 7、约束: 5种
– (1)主键约束，一张表中，只能有一个主键约束，但是一个主键约束可以对多个字段进行约束。

– (2)非空约束，
– (3)唯一约束，
– (4)检查约束, 要么符合检查约束的条件，要么可以为null.
– (5)外键约束，字段B 设置外键约束，依赖于字段A，字段B的值要么是A里的值。
– 或者可以为null,字段A必须是有主键约束。
– 8、序列: 作用用来给作为主键约束的字段进行有序的自增。
– auto_increment
– 默认序列是从1开始，每次自增+1;
– reg：create table tname(tid int primary key auto_increment);
– 注意: 如果插入的第一条数据中指定了固定值，那么下次就会从此固定值开始增加。
–=========================================================================
– 分页查询：
– 需求:当每次查询的记录数比较大，通常一页显示不下，此时我们可以进行分页查询。
– 关键字limit
– 用法: limit begin,size;
– begin：记录的开始行数. 偏移量
– size：每页的最大记录数。
– 注意:limit后可以是一个参数，
– 一个参数时，是指每次最大的查询记录数，limit size;
– 默认记录数从0开始，而不是1.
–练习1:查询员工表，查询第一页的数据，每页10条。
select * from emp limit 0,10;
–练习2:查询员工表，查询第二页的数据，每页5条。
select * from emp limit 5,5;
–练习3:按照部门号升序排序，查询第二页的数据，每页5条
select * from emp order by deptno limit 5,5;
–练习4:按照员工编号降序排序，查询第二页的数据，每页5条。
select * from emp order by empno desc limit 5,5;
–练习5:使用子查询，先排序，再查询每页的数据。
– 按照员工工资降序排序，查询第二页的数据，每页6条。
select e.* from (select * from emp order by sal desc) e limit 6,6;
– 执行效率与优化
— 创建了一张表temp_001,插入了10w条的数据。
– 需求: 每页100条记录，查询第1页的数据
– 查询第11页的数据
– 查询第101页的数据
– 查询第1001页的数据
–select * from temp_001 limit 100;
–select * from temp_001 limit 1000,100;
–select * from temp_001 limit 10000,100;
–select * from temp_001 limit 143000,100;
– 当我们在做分页查询的时候，查询的效率与偏移量有关系，偏移量越大，
– 效率越低，消耗的时间就会越多。如上述分页查询
– 如何优化分页查询
– (1)我们可以使用子查询先确定作为tid偏移量的位置。
– select tid from temp_001 limit 100000,1
– (2)再进行分页查询
– select * from where tid>=(查出id的值) limit 100;
–练习:
select * from temp_001 where tid>=
(select tid from temp_001 limit 144000,1) limit 100;

– 还有一种优化：首先确定tid必须是连续的数据。
– 使用 between and
select * from temp_001
where
tid between 145000 and 145200 limit 100;

–=================================================
–视图:VIEW，表的一部分投影。也是数据库里一个对象。(表的虚拟部分)
– 视图的作用: 因为视图中含有某表中的部分数据，不在视图中的字段有隐藏效果。
– 相对来说，安全。
–如何操作视图呢？视图可以像表一样，进行增删改查。
–如何创建视图呢？
–格式： create view ViewName as subQuery
–练习1: 将员工表中的10部门的数据封装到一个视图view_emp_deptno_10
create view view_emp_deptno_10 as select * from emp where deptno=10;

– 通过视图进行DML操作，一定会对表有影响。
– 通过表进行DML操作，可能会对视图有影响。
–练习2:通过视图，插入数据 empno:9001,ename:‘zs’,部门号:10
– 插入数据 empno:9002,ename:‘ls’,部门号:20
– 查询表emp,查询视图view_emp_deptno_10
insert into view_emp_deptno_10 values (9001,‘zs’,null,null,null,null,null,10);
insert into view_emp_deptno_10 (empno,ename,deptno)values (9002,‘ls’,20);
select * from view_emp_deptno_10;

–with check option:对视图的一种检查约束选项，
– 如果在创建视图有此选项时，表示，只能对视图DML操作可见数据。
– 反之，对视图不可见的数据，是不可以通过视图进行DML操作的。
–练习2:创建一个视图view_emp_deptno_20，
– 投影20号部门的员工编号，员工姓名，职位，工资，部门号。
–练习3:通过视图view_emp_deptno_20插入数据
– empno:9003,ename:‘ww’,job:manager,sal:5000,20
– empno:9004,ename:‘zl’,job:manager,comm:500,20
– empno:9005,ename:‘qq’,job:manager,sal:500,10
create view view_emp_deptno_20 as select empno,ename,job,sal,deptno
from emp where deptno = 20 with check option;
select * from view_emp_deptno_20;
insert into view_emp_deptno_20 values(9003,‘ww’,‘manager’,5000.0,20);
insert into view_emp_deptno_20 (empno,ename,job,comm,deptno)values(9004,‘zl’,‘manager’,500.0,20);
insert into view_emp_deptno_20 values(9005,‘qq’,‘manager’,5000.0,10);
–视图的分类：
– 简单视图:subQuery是一个表中的普通查询语句
– 复杂视图:subQuery是一个可以带有分组函数的，或者关联查询的语句。
– 复杂视图不能对视图进行DML操作，只能进行DQL操作
–练习:创建一个复杂视图view_emp_100，是每个部门的平均工资，最高工资，最低工资，及其部门号。
create view view_emp_100 as select avg(ifnull(sal,0)) avg_sal,max(sal) max_sal,
min(sal) min_sal,deptno from emp group by deptno;
select * from view_emp_100;
–===================================================
– 索引(Index):目的是为了提高查询速度。相当于一本书的目录。
– 索引也是数据库的对象，占空间。每张表每个字段都可以设置相应的
– 索引
– 优点: 提高查询速度。
– 缺点: 占空间，每次进行DML操作时，数据库都要(自动)重新维护索引，
– 降低效率.
– 总体来说:表中有索引可以提高效率，但不是索引越多越好。当表中的数据量
– 比较小时，无需索引(因为直接查询可以比使用索引更快)，当某个字段的值
– 比较少时，也不需要索引，如性别字段只有’f’,‘m’.只有当数据量比较大，
– 和字段值多时，可以使用索引。
–练习1:给emp表中的empno创建索引。
create index index_emp_empno on emp(empno);
–练习2:查询empno为9003的数据。
select * from emp where empno=9003;

–删除索引，删除视图都是用drop
–drop index indexName
–drop view viewName
–可以自学： PLSQL(数据库编程语言)–触发器，存储过程
–数据库中现有以下学生信息表：
–Student学生表(SNO学号,SNAME姓名,SEX性别,BIRTHDAY出生年月,DEP院系)
–Course课程表(CNO编号，CNAME课程名称,CVAL学分)
–SC选课表(SNO学号,CNO课程编号,SCORE成绩)
–练习1:查询选修了’数据结构’的总人数
–练习2:查询’张宇’同学选修了的课程和成绩
–练习3:查询挂科学分最多的同学姓名和院系
select count(*) from sc where cno =
(select cno from Course where cname=‘数据结构’);

select cname,score
from Student s,Sc,Course c
where s.sno=sc.sno and c.cno = sc.cno and sname=‘张宇’;

–张宇同学的编号：
select sno from student where sname=‘张宇’;

;
select c.cname,a.score
from Course c join
(select cno,score from sc where sno =
(select sno from student where sname=‘张宇’)
) a
on c.cno = a.cno

每个人都挂了多少学分
select sname,dep from student where
sno in(

select sno from Course,SC
where Course.cno = sc.cno and sc.score<60
group by sc.sno having sum(cval)=

(select sum(cval) sum_ from Course,SC
where Course.cno = sc.cno and sc.score<60
group by sc.sno order by sum_ desc limit 1
)

);
select sname,dep from student where
sno in(

select sno from Course,SC
where Course.cno = sc.cno and sc.score<60
group by sc.sno having sum(cval)=

(select sum(cval) sum_ from Course,SC
where Course.cno = sc.cno and sc.score<60
group by sc.sno order by sum_ desc limit 1
)

);
一、JDBC的原理
1、概念
Java DataBase Connectivity:java数据库连接技术，简称JDBC.
它是使用java语言编写的一套API.为多种关系型数据库提供了
统一接口。同时，也是一个“低级”接口，在其之上可以使用“高级”接口，
更方便的连接数据库。
2、目的
为了给程序员提供同一种方式连接不同的数据库
（提供一个与任何数据库的java连接界面）
3、原理
JDBC负责提供接口
数据库厂商使用自己数据库的特点来实现接口。
程序员调用接口，实际上底层调用数据库厂商实现的部门
实际工作过程
(1)加载驱动，建立连接
(2)获取Sql语句执行对象
(3)执行SQl语句
(4)处理结果集
(5)关闭连接
4、接口与类型
(1)驱动管理类型：DriverManager
static Connection getConnection(url,user,password)
作用: 通过地址，数据库用户名，用户密码获取连接对象
(2)连接接口：Connection
Statement createStatement()
作用:获取一个SQL语句编译对象
PreparedStatement prepareStatement(String sql)
作用:获取一个SQL语句预编译对象
(3)SQL语句对象接口:
Statement: 用于编译静态SQL语句(编译多次)。
boolean execute(String sql):用来执行DDL语言
ResultSet executeQuery(String sql):用于执行DQL语言
int executeUpdate(String sql):用于执行DML语言
void addBatch(String sql):添加批处理
int[] executeBatch(): 执行批处理
PreparedStatement:用于编译静态SQL语句，是Statement的一个子类型，执行效率
比Statement要高(只编译一次)
boolean execute():用来执行DDL语言
ResultSet executeQuery():用来执行DQL语言
int executeUpdate():用于执行DML语言
void addBatch():添加批处理
int[] executeBatch():执行批处理
(4)结果集接口：ResultSet
在进行DQL操作时，将查询的所有记录信息封装
到ResultSet对象中 .
boolean next(): 询问结果集对象中是否有下一行记录。
如果返回true,光标会自动移到下一行。

         还提供了一些数据库类型转java数据类型的方法：
   int getInt(int columnIndex)/getInt(String columnName)
   double getDouble(int columnIndex)/getDouble(String columnName)
   String getString(int columnIndex)/getString(String columnName)
   Date getDate(int columnIndex)/getDate(String columnName)
   .........

5、驱动
Oracle
jar包:ojdbc5.jar/ojdbc14.jar
Class.forName(“oracle.jdbc.driver.OracleDriver”);

Mysql
jar包: mysql-connector-java-5.1.7-bin.jar
Class.forName(“com.mysql.jdbc.Driver”);
二、JDBC编程基础
…
三、工具类的封装DBUtil
从上述练习中发现，每次都需要加载驱动，建立链接。
其中的参数我们书写的次数比较多。

 方法1:   
 为了方便，为了节省资源，我们可以使用静态块来加载驱动，
 将参数值当成类的静态属性进行封装。 (加载一次就可以)  
 方法2:
 使用Properties 读取配置文件里的信息
 (将可能需要改变的信息存储在配置文件中)
 
 通常情况下都会选择方法2:

四:异常
jdbc发生的异常一般都是SQLException或者是其子类异常
是检查性异常。使用try-catch机制处理一下。
finally里通常用来进行关闭数据库操作。
五、SQL注入:(injection)
在使用Statement时，因为Statement会对静态SQL语句进行编译。
有可能会改变SQL语句的结构。因此有注入安全隐患。

创建一个表 login_info
字段： login_id int 主键约束序列自增
login_user varchar(20) 唯一约束
login_pwd varchar(50) 非空约束
login_phone varchar(11)
插入两条记录：
1001,‘zhangsan123’,‘111111’,‘13100001111’
1002,‘lisi123456’,‘888888’,‘13700001111’

create table login_info(
login_id int primary key auto_increment,
login_user varchar(20) unique,
login_pwd varchar(50) not null,
login_phone varchar(11)
);
insert into login_info values(1001,‘zhangsan123’,‘111111’,‘13100001111’);
insert into login_info values(1002,‘lisi123456’,‘888888’,‘13700001111’);

select * from login_user=‘zhangsan123’ and login_pwd=‘wang’;
由上面两个条件的sql结构
变成了下面的三个条件的结构，就是SQL注入现象。
select * from login_user=‘zhangsan123’ and login_pwd=‘wang’ or ‘a’ = ‘a’;

后来改用Statement的子类PreparedStatement来代替。
PreparedStatement叫预编译sql语句类型，
对静态sql语句编译一次。编译后无法再改变sql语句结构
六、PreparedStatement的用法
可以对静态SQL语句使用问号"？"充当占位符。

如:
select * from login_info
where login_user = ? and login_pwd= ?

使用此类中提供的类型转换方法进行给问号赋值

ps.setInt(int parameterIndex,int value)
ps.setDouble(int parameterIndex,double value)
ps.setString(int parameterIndex,String value)
ps.setDate(int parameterIndex,Date value)
一、Junit:java方法的另外一种测试方式。
(1)导入Junit4的jar
(2)在非静态方法上添加注解@Test
(3)选中非静态方法的名称右键运行
或者在类的树形结构中选中方法运行。

@Before：此注解的位置也是非静态方法上。
运行时机：在运行@Test注解方法前会自动执行。
@After:
二、JDBC对事务的支持
事务要满足四个条件:ACID
原子性：一个事务，要么成功，要么回滚(撤回)
一致性：事务开始前的数据要和结束后的数据保持一致。
隔离性：一个事务正在进行，另外的事务要等待。
持久性：事务提交后，数据的改变是永久性的。

JDBC对DML语言的操作是默认提交的。
当有多个DML操作时，我们应该取消自动提交。改为手动提交

Connection接口提供了一个方法
void setAutoCommit(boolean flag):
true：表示自动提交
false:表示取消自动提交

void commit(): 提交事务
void rollback():事务回滚

三、批处理
在进行插入数据操作时，有的时候，一条一条的操作，比较耗时。
我们可以进行批量的插入操作。

Statement:
addBatch(String sql)
executeBatch():
PreparedStatement:
addBatch():
executeBatch():

insert into account_info values (null,‘62251111’,2000,‘1370000’);

“insert into account_info values (null,’”
+account_idcar
+"’,"
+money
+",’"
+account_phone
+"’)"

四、
1、oracle学习版安装
(1)添加SYS和System用户的口令
(2)我们要启动数据库主页，使用System进行登录
(3)创建一个普通用户scott,密码tiger
2、连接方式
(1)命令提示符界面
选择自带的运行SQl命令行界面
输入 conn username/password
(2)使用客户端sqldeveloper
连接名:
用户名:scott
口令:
主机名：ip
端口号: tcp/ip协议，1521 /http协议的端口号默认是8080/80
SID:oracle特有的唯一标识符 xe/orcl
(3)使用JDBC连接oralce数据库

3、使用
数据类型:

  数字类型:number 
    number(m):表示最长m位整数
    number(m,n):表示整数位最长m-n,小数点后保留n位。
  字符串类型：
    char(m):固定长度字符串类型     
    varchar(m)
    varchar2(m):oracle独有的一个可变字符串类型
    Blob   
  日期类型：date:  年月日时分秒
        timestamp：可以精确到纳秒

servlet的学习
一、程序的演变
1、单机程序：txt文档，word文档，ppt文档
2、两层CS架构
客户端：client，设计用户界面和少量的逻辑代码
服务端: 数据库，大量的逻辑代码
优点:交互简单
缺点：业务逻辑使用数据库编程语言编写
在程序移植方面非常差，需要重新编写业务逻辑代码
3、三层CS架构
c:client 用户界面设计及其少量的业务逻辑代码
s:应用服务器，大量的逻辑代码
db:数据库, 至进行数据的交互

  优点:移植性好
  缺点:开发客户端成本高，维护性差。

4、BS架构
B:browser,浏览器
s:应用服务器，所有的业务逻辑代码
db:数据库，进行数据的交互
优点: 只需要遵循浏览器的HTTP通信协议即可，无客户端开发
成本。所有的逻辑代码都在服务器端开发。
移植性好
二、BS架构的工作原理
如图:
三、Servlet
1、概念
是Sun(Oracle)公司制定的用于扩展web应用服务器的
一个组件规范。
2、web应用服务器:可以部署bs架构项目的服务器。
最开始，web应用服务器只能进行一些静态资源的处理。
无法满足需要经过计算得到的动态资源。
之后出现了CGI,通用编程接口，来实现动态技术。
但是CGI编程非常复杂，不利于开发与维护。
之后就出现了替代CGI的技术，Servlet.
3、组件
通过继承或实现某些类或接口，符合一定规范、可以
完成部分功能，并且需要部署到容器里的组件。
4、容器
就是能实现组件功能的一个程序。

四、Tomcat
1、tomcat是apache基金会的一个servlet容器。
也相应于一个微型的web应用服务器。
2、安装：
解压，放在某一路径下
3、在conf文件夹下
server.xml里的<Connector port=“8080”…
修改成你想要的端口号: 不修改的话可能与oracle的http协议端口号碰撞
4、启动服务器
window:
startup.bat
linux:
start.sh

   PS:启动后窗口不要关闭
   异常:
      闪退：没有配置JAVA_HOME环境变量
  Address already in use:.......port
        端口号被占用。

5、打开任意浏览器进行测试：
   http://localhost:port
   例子:
   http://localhost:8088

   出现一只猫 即成功

六、手工编写一个web程序。
web程序的组织架构

(1)appName:
     --WEB-INF
     --classes
	---xxx.class
         --lib(可选)
        ---xxx.jar
     --web.xml
     --index.html(可选)
(2) 自定义一个源文件(如：HelloWorld)
    0)先导包
1)继承HttpServlet
2)重写service方法
3)获取流对象，输出信息
(3) 编译源文件
    javac -classpath servlet-api.jar的全路径 源文件.java
(4) 将class文件放入组织架构里的classes文件夹下
(5) 编写web.xml
    1)、注册servlet组件
 <servlet>
     <!-- 组件昵称  -->
     <servlet-name>firstweb</servlet-name>
     <!-- 组件的类全名  -->
     <servlet-class>HelloWorld</servlet-class>
 </servlet>
 2)、注册servlet组件的映射信息
 <servlet-mapping>
     <!-- 必须与组件昵称一致  -->
     <servlet-name>firstweb</servlet-name>
     <!-- url-pattern的值与浏览器地址栏上的值必须匹配   -->
     <url-pattern>/hello</url-pattern>
 </servlet-mapping>
 (6)部署项目到服务器中
    将(1)的整个组织架构放入webapps中
 (7)启动服务器
 (8)使用浏览器访问服务器中的项目
    http://ip:port/appName
     访问的是项目的首页
    http://ip:port/appName/url-pattern