精华内容
下载资源
问答
  • :索要定义的基本表的名字 :组成该表的各个属性(列) :涉及相应属性列的完整性约束条件 :涉及一个或多个属性列的完整性约束条件 建表的同时通常还可以定义该表有关的完整性约束条件,这些完整性约束条件被存入...

    定义基本表
    CREATE TABLE<表名>
    (<列名><数据类型>[<列级完整性约束条件>]
    [,<列名><数据类型>[<列级完整性约束条件>]

    [,<表级完整性约束条件>]);
    <表名>:索要定义的基本表的名字
    <列名>:组成该表的各个属性(列)
    <列级完整性约束条件>:涉及相应属性列的完整性约束条件
    <表级完整性约束条件>:涉及一个或多个属性列的完整性约束条件
    建表的同时通常还可以定义与该表有关的完整性约束条件,这些完整性约束条件被存入系统的数据字典中,当用户操作表中数据时由关系数据库管理系统自动检查该操作是否违背这些完整性约束条件。如果完整性约束条件涉及该表的多个属性列,则必须定义在表级上,否则既可以定义在列级也可以定义在表级。
    例1.1:建立“学生”表student,学号是主码,姓名唯一:

    CREATE TABLE student(
         Sno CHAR(9) PRIMARY KEY,/*列级完整性约束条件,Sno是主码*/
    Sname CHAR(20) UNIQUE,/*Sname取唯一值*/
    Ssex CHAR(2),
    Sage SMALLINT,
    Sdept CHAR(20)
    );
    

    例1.2:建立一个“课程”表Course

    CREATE TABLE Course(
     Cno CHAR(4) PRIMARY KEY,/*列级完整性约束条件,Cname不能取空值*/
     Cname CHAR(40) NOT NULL,/*Cpno的含义是先修课*/
     Cpno CHAR(4),
     Ccredit SMALLINT,
     FOREING KEY(Cpno)REFERENCES Course(Cno)/*表级完整性约束条件,Cpno是外码,被参照表是Course,被参照列是Cno*/
     );
    

    例1.2说明参照表和被参照表可以是同一个表
    例1.3:建立学生选课表SC:

    CREATE TABLE SC(
    Sno CHAR(9),
    Cno CHAR(4),
    Grade SMALLINT,
    PRIMARY KEY(Sno,Cno),/*主码由两个属性构成,必须作为表级完整性进行定义*/
    FOREIGN KEY(Sno)REFERENCES Student(Sno),/*表级完整性约束条件,Sno是外码,被参照表示Student*/
    FOREIGN KEY(Cno)REFERENCES Course(Cno)/*表级完整性约束条件,Cno是外码,被参照表是Course*/
    );
    

    修改基本表
    ALTER TABLE <表名>
    [ ADD[COLUMN] <新列名> <数据类型> [ 完整性约束 ] ]
    [ ADD <表级完整性约束>]
    [ DROP [ COLUMN ] <列名> [CASCADE| RESTRICT] ]
    [ DR O P CO N ST R A I N T < 完 整 性 约 束 名 > [ R E ST R I CT | CASCADE ] ]
    [ALTER COLUMN <列名><数据类型> ] ;
    <表名>:是要修改的基本表 。
    ADD子句:用于增加新列、新的列级完整性约束条件和新的表级完整性约束 条件。
    DROP COLUMN子句:用于删除表中的列
    如果指定了CASCADE短语,则自动删除引用了该列的其他对象 ;
    如果指定了RESTRICT短语,则如果该列被其他对象引用,关系数据库管理系 统将拒绝删除该列 。
    DROP CONSTRAINT子句:用于删除指定的完整性约束条件 。
    ALTER COLUMN子句:用于修改原有的列定义,包括修改列名和数据类型。
    例1.4:向Student表中增加“入学时间”列,其数据类型为日期型:

    ALTER TABLE Student ADD S_entrance DATE;
    

    例1.5:增加课程名称必须取唯一值的约束条件:

    ALTER TABLE Course ADD UNIQUE(Cname);
    

    例1.6:讲年龄的数据类型由字符型改为整数:

    ALTER TABLE Student ALTER COLUMN Sage INT;
    

    删除基本表
    DROP TABLE <表名>[RESTRICT|CASCADE];
    RESTRICT:删除表是有限制的。
    CASCADE:删除该表没有限制。
    例1.7:删除Student表:

    DROP TABLE Student CASCADE;
    

    例1.8:若表上建有视图,选择RESTRICT时表不能删除:

    CREATE VIEW IS_Student /*Student表上建立视图*/
    AS
    SELECT Sno, Sname, Sage 
    FROM Student 
    WHERE Sdept='IS';
    DROP TABLE Student RESTRICT;/*删除Student表*/
    --ERROR:cannot drop table Student because other objects depend on it/*系统返回错误信息,存在依赖该表的对象,此表不能被删除*/
    DROP TABLE Student CASCADE;/*删除Student表*/
    --NOTICE:drop cascades to view IS_Student/*系统返回提示,此表上的视图也被删除*/
    SELECT* FROM IS_Student;
    --ERROR:relation"IS_Student"does not exist
    
    展开全文
  • 约束 MySQL中的约束:是对数据的一种限定,为了保证数据的有效性和完整性。 MySQL中常见的约束: 主键约束: PRIMARY KEY 自增长约束: AUTO_...方式1:建表的时候,就可以添加主键: CREATE TABLE test( usern

    约束

    MySQL中的约束:是对数据的一种限定,为了保证数据的有效性和完整性。
    MySQL中常见的约束:
    主键约束: PRIMARY KEY
    自增长约束: 	AUTO_INCREMENT  加在整数型的字段配和主键约束来使用
    唯一约束: 	UNIQUE
    非空约束: NOT NULL
    非负约束:  UNSIGNED
    外键约束:
    

    (1)主键约束

    非空且唯一,一张表中只能有一个主键,我们建议在表中提供主键
    添加主键的方式1:
    方式1:建表的时候,就可以添加主键:

    CREATE TABLE test(
    	username VARCHAR(20) PRIMARY KEY,
    	PASSWORD VARCHAR(30)
    )
    
    INSERT INTO test VALUES('aaa','123456')
    

    在这里插入图片描述
    方式2:

    CREATE TABLE test2(
    	username VARCHAR(20),
    	PASSWORD VARCHAR(30),
    	PRIMARY KEY(username)  -- 指定主键
    )
    

    方式3:表已经建好了,我们突然想加一个主键约束,我们可以通过修改表来添加主键

    CREATE TABLE test3(
    	username VARCHAR(20),
    	PASSWORD VARCHAR(30)
    )
    ALTER TABLE test3 ADD PRIMARY KEY(username,PASSWORD);
    
    INSERT INTO test3 VALUES('zhangsan','123456');
    INSERT INTO test3 VALUES('zhangsan','1234567'); -- 一定要非空且唯一
    

    在这里插入图片描述

    联合主键

    联合主键:把多个字段看成是一个整体,设定为主键

    CREATE TABLE test4(
    	username VARCHAR(20),
    	PASSWORD VARCHAR(30)
    )
    -- 采用修改表的方式来设置联合主键
    ALTER TABLE test4 ADD PRIMARY KEY(username,PASSWORD);
    
    INSERT INTO test4 VALUES('aaa','123456');
    INSERT INTO test4 VALUES('bbb','123456');
    INSERT INTO test4 VALUES('bbb',NULL);
    INSERT INTO test4 VALUES('aaa','1234567');
    

    在这里插入图片描述

    (2)自增长约束

    它是要配合这个主键PRIMARY KEY一块来使用,而且针对的还是整数型的字段 AUTO_INCREMENT

    CREATE TABLE test5(
    	id INT PRIMARY KEY AUTO_INCREMENT, -- 主键自增长
    	username VARCHAR(20),
    	PASSWORD VARCHAR(30)
    )
    INSERT INTO test5 VALUES(NULL,'bbb','12345678')
    -- 当你删除了一条数据,下次再增加一条时,不会再用你之前删过的那条主键的值
    DELETE FROM test5 WHERE id=23;
    

    在这里插入图片描述

    (3)唯一约束

    UNIQUE 注意对null值没有作用

    CREATE TABLE test6(
    	id INT PRIMARY KEY AUTO_INCREMENT,  -- 主键自增长
    	username VARCHAR(20) UNIQUE,  -- 唯一约束
    	PASSWORD VARCHAR(30)
    )
    INSERT INTO test6 VALUES(NULL,'aaa','123456')
    INSERT INTO test6 VALUES(NULL,'bbb','123456')
    INSERT INTO test6 VALUES(NULL,NULL,'1234567')
    

    在这里插入图片描述

    (4)非空约束

    CREATE TABLE test7(
    	id INT PRIMARY KEY AUTO_INCREMENT,  -- 主键自增长
    	username VARCHAR(20) UNIQUE NOT NULL, -- 唯一约束 非空约束
    	PASSWORD VARCHAR(30) NOT NULL
    )
    INSERT INTO test7 VALUES(NULL,'aaa','123456')
    INSERT INTO test7 VALUES(NULL,NULL,'1234567')
    INSERT INTO test7 VALUES(NULL,NULL,NULL)
    

    在这里插入图片描述

    (5)非负约束

    UNSIGNED, 非负
    TINYINT, TINYINT的取值范围是-128~127

    CREATE TABLE test8(
    	id TINYINT, -- TINYINT的取值范围是-128~127
    	username VARCHAR(20) UNIQUE NOT NULL,  -- 唯一约束 非空约束
    	PASSWORD VARCHAR(30) NOT NULL
    )
    INSERT INTO test8 VALUES(-1,'aaa','123')
    INSERT INTO test8 VALUES(127,'aaac','1234')
    

    在这里插入图片描述

    CREATE TABLE test9(
    	id TINYINT UNSIGNED,  -- 非负
    	username VARCHAR(20),
    	PASSWORD VARCHAR(30)
    )
    INSERT INTO TEST9 VALUES(127,'aaa','123')
    INSERT INTO TEST9 VALUES(255,'bbb','123')
    

    在这里插入图片描述

    (6)ENUM() 枚举类型

    CREATE TABLE test10(
    	id TINYINT UNSIGNED, -- 非负
    	username VARCHAR(20),
    	sex ENUM('男','女','妖') -- 枚举类型 能起到类似这个约束的作用
    )
    
    INSERT INTO test10 VALUES(1,'aaa','男')
    INSERT INTO test10 VALUES(1,'aaa','女')
    INSERT INTO test10 VALUES(1,'aaa','妖')
    INSERT INTO test10 VALUES(1,'aaa','好')
    

    在这里插入图片描述

    创建多表

    案例2-创建多表,可以描述出表于表之间的关系
    需求:
    	把网上商城里面用的实体创建成表,并且将他们之间建立关系.
    技术分析:
    	sql
    	
    网上商城的实体:
    	用户 订单 商品 分类
    常见关系:
    	一对多. 用户和订单  分类和商品
    	多对多. 订单和商品	学生和课程
    	一对一. 丈夫和妻子	
    ER图可以描述实体于实体之间的关系
    	实体用矩形表示
    	属性用椭圆表示
    	关系用菱形表示
    
    ER图 
    在ER图中有如下四个成分:
    矩形框:表示实体,在框中记入实体名。
    菱形框:表示联系,在框中记入联系名。
    椭圆形框:表示实体或联系的属性,将属性名记入框中。对于主属性名,则在其名称下划一下划线。
    连线:实体与属性之间;实体与联系之间;联系与属性之间用直线相连,并在直线上标注联系的类型。
    (对于一对一联系,要在两个实体连线方向各写1; 
    对于一对多联系,要在一的一方写1,多的一方写N;对于多对多关系,则要在两个实体连线方向各写N,M。)  
    

    创建一对多表

    一对多:用户表1–订单表N,我们把用户表一般会称为主表或单表或一表,把订单表称为多表或从表。
    在这里插入图片描述
    创建用户表:

    CREATE TABLE USER(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	username VARCHAR(20)
    );
    

    创建订单表:

    CREATE TABLE orders(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	totalprice DOUBLE,
    	user_id INT
    );
    

    为了保证数据的有效性和完整性,我可以添加外键约束,让两张表之间形成外键约束,来避免数据的不合理。
    一般我们会在多表一方添加外键约束,去关联主表一方的主键。

    ALTER TABLE orders ADD FOREIGN KEY(user_id) REFERENCES USER(id);
    

    如果我们添加了外键约束后会有如下特点:
    (1)主表一方不能删除从表还在引用的数据
    (2)从表一方不能添加任何主表不存在的数据
    开发中一对多:在多表中添加一个外键,名称一般是主表的名称id,字段类型一般和主表的主键类型保持一致。
    为了保证数据的有效性和完整性,在多表的外键上添加外键约束即可。
    那么我们添加了外键约束后,我们还是想要删除主表中的数据,怎么办?

    方式1:级联删除

    主表和从表添加了外键约束后,我要删除主表中一个数据,但是这个数据还在从表中引用着,我们删除不掉,那么我们就只能这么做,先去从表中把这个人的数据给删除了,再去主表中把这个人给删除了。这样做太麻烦,有一种做法叫级联删除。我们删除这个人的时候,把这个人在表中相关联的数据也一并删除。
    
    ALTER TABLE orders ADD FOREIGN KEY(user_id) REFERENCES USER(id) on delete cascade;
    

    方式2:

    先把带有外键的多表的数据删除,再删除一表中的数据。
    

    级联更新:

    当主表中把数据改了,在从表中关联的数据也得跟着改。
    
    CREATE TABLE zhu(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	username VARCHAR(20)
    );
    
    CREATE TABLE cong(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	totalprice DOUBLE,
    	user_id INT,
    	-- 在建表的时候就加上了级联更新ON UPDATE CASCADE和级联删除ON DELETE CASCADE
    	FOREIGN KEY(user_id) REFERENCES zhu(id) ON DELETE CASCADE ON UPDATE CASCADE
    );
    

    在这里插入图片描述

    创建多对多表

    创建用户表

    CREATE TABLE USER(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	username VARCHAR(20)
    );
    

    创建商品表

    CREATE TABLE product(
    	id INT PRIMARY KEY AUTO_INCREMENT,
    	NAME VARCHAR(20),
    	price DOUBLE
    );
    

    创建中间表

    CREATE TABLE orderitem(
    	oid INT,   -- 外键
    	pid INT    -- 外键
    );
    

    创建订单表

    CREATE TABLE orders(
    	oid INT,   -- 外键
    	pid INT    -- 外键
    );
    

    在这里插入图片描述

    -- 添加外键约束
    -- 中间表 oid 这个外键和 订单表的这个主键,要加上外键约束
    ALTER TABLE orderitem ADD FOREIGN KEY(oid) REFERENCES orders(id);
    -- 中间表的 pid 这个外键 和商品表的主键,要加上外键约束 
    ALTER TABLE orderitem ADD FOREIGN KEY(pid) REFERENCES product(id);
    
    INSERT INTO USER VALUES(3,zhangsan);
    INSERT INTO USER VALUES(4,lisi);
    INSERT INTO USER VALUES(5,wangwu);
    INSERT INTO USER VALUES(6,zhaoliu);
    
    INSERT INTO orders VALUES(1,1314,3);
    INSERT INTO orders VALUES(2,1314,3);
    INSERT INTO orders VALUES(3,800,4);
    INSERT INTO orders VALUES(4,150,5);
    
    INSERT INTO product VALUES(1,主机,1000);
    INSERT INTO product VALUES(2,键盘,300);
    INSERT INTO product VALUES(3,水杯,14);
    INSERT INTO product VALUES(4,显示屏,800);
    INSERT INTO product VALUES(5,鼠标,150);
    

    多表查询

    多表查询:多张表联合起来进行查询。		多表联合:我要查询每个人的订单信息。
    多张表没有关联条件的查询,查询出的结果是没有任何意义的。
    像这种把多张表简单关联起来进行查询,多表联合是没有条件的查询,它就是把多张表的列数相加,行数相乘,这样得出的结果称为笛卡尔积。
    SELECT user.*,'orders'.* FROM USER,orders; -- 多表联合没有条件查询
    
    我们在进行多表查询的时候,要有关联条件,如果是对N张表进行关联查询,至少需要N-1个关联条件。
    我要查询每个人的订单信息。
    SELECT user.*,orders.* FROM USER,orders WHERE user.`id`=orders.`uer_id`
    
    SELECT user.`id`,user.`username`,orders.`id` AS uid,orders.`totalprice`,orders.`uer_id` 
    FROM USER,orders 
    WHERE user.`id`=orders.`uer_id`
    

    内连接:不符合条件的数据不会展示出来
    隐式内连接:

    SELECT user.*,orders.* FROM USER,orders WHERE user.`id`=orders.`uer_id`;
    

    显式内连接:

    SELECT user.*,orders.* FROM USER INNER JOIN orders ON user.`id`=orders.`uer_id`;
    

    外连接:左外连接和右外连接,这两个其实可以互换。
    我要穿所有的订单,所有的用户都必须展示出来,这个用户没有订单,他的订单信息就会以null展示。
    左外连接: LEFT OUTER JOIN 表 ON 关联条件 outer 可以省略不写
    以LEFT这个单词分左右,left左边的表它的数据是全部展示出来的

    SELECT user.*,orders.* FROM USER LEFT OUTER JOIN orders ON user.`id`=orders.`uer_id`
    

    我想看所有的订单信息以及他所属用户 订单信息全部展示,订单没有对应的用户,它的订单信息以null来展示

    SELECT orders.*,user.* FROM orders LEFT OUTER JOIN USER ON user.`id`=orders.`uer_id`
    

    右外连接:

    SELECT user.*,orders.* FROM orders RIGHT OUTER JOIN USER ON user.`id`=orders.`uer_id`
    

    子查询:一个主查询所要的条件,他来另一个子查询,用途:一步查不出来,然后分步骤查,最后再用子查询一步写出来

    1.查看用户为张三的订单详情
    第一步:我们现在user表中把张三的id查出来
    SELECT user.id FROM USER WHERE user.`username`='zhangsan'
    第二步:拿着上一步找到的id去订单表中的查找订单的信息
    SELECT orders.* FROM orders WHERE orders.`uer_id`=3
    
    使用子查询,把上面两步合二为一  注意:子查询需要用括号引起来
    SELECT orders.* FROM orders WHERE orders.`uer_id`=(SELECT user.id FROM USER WHERE user.`username`='zhangsan')
    
    SELECT user.*,lsb.* FROM USER,(SELECT orders.* FROM orders WHERE orders.`uer_id`=(SELECT user.id FROM USER WHERE user.`username`='zhangsan'))
    AS lsb WHERE user.`id`=lsb.uer_id
    

    在这里插入图片描述

    查询出订单价格大于300的所有用户信息
    
    第一步:在订单表中把大于300的订单的user_id查出来
    SELECT orders.`uer_id` FROM orders WHERE orders.`totalprice`>300
    
    第二步:拿着上一步找到的user_id去用户表里查询
    SELECT user.* FROM USER WHERE id =3 OR id=4
    
    合二为一
    SELECT user.* FROM USER WHERE id IN(SELECT orders.`uer_id` FROM orders WHERE orders.`totalprice`>300)
    
    SELECT lsb.*,orders.* FROM (SELECT user.* FROM USER WHERE id IN(SELECT orders.`uer_id` FROM orders WHERE orders.`totalprice`>300))
     AS lsb INNER JOIN orders ON lsb.id=orders.`uer_id`
    
    SELECT lsb.*,orders.* FROM (SELECT user.* FROM USER WHERE id IN(SELECT orders.`uer_id` FROM orders WHERE orders.`totalprice`>300)) 
    AS lsb LEFT OUTER JOIN orders ON lsb.id=orders.`uer_id`
    

    在这里插入图片描述

    查询所有用户的所有订单以及订单中的商品信息
    显式内连接
    SELECT u.*,o.*,product.* FROM USER AS u INNER JOIN orders AS o ON u.id=o.uer_id INNER JOIN orderitem 
    ON o.`id`=orderitem.`oid` INNER JOIN product ON orderitem.`pid`=product.`id`
    
    左外连接
    SELECT u.*,o.*,product.* FROM USER AS u LEFT JOIN orders AS o ON u.`id`=o.`uer_id` LEFT JOIN orderitem
    ON o.`id`=orderitem.`oid` LEFT JOIN product ON orderitem.`pid`=product.`id`
    

    显式内连接:
    在这里插入图片描述
    左外连接:
    在这里插入图片描述

    用子查询来做:查询所有用户的所有订单以及订单中的商品信息。
    第一步先得出用户和id的关系
    select user.* from user;
    先得出用户表和订单表之间的关系
    SELECT user.*,orders.* FROM USER LEFT OUTER JOIN orders ON user.`id`=orders.`uer_id`;
    再得出订单表和中间表之间的关系
    SELECT orders.*,orderitem.* FROM orders LEFT OUTER JOIN orderitem ON orders.`id`=orderitem.`oid`;
    最后得出中间表和商品表之间的关系
    SELECT orderitem.*,product.* FROM orderitem LEFT OUTER JOIN product ON orderitem.pid=product.`id`;
    合在一起
    SELECT user.username,orders.* FROM USER,orders WHERE user.`id`=orders.`uer_id`;
    SELECT orderitem.*,lsb.* FROM orderitem,(SELECT user.username,orders.* FROM USER,orders WHERE user.`id`=orders.`uer_id`)AS lsb WHERE orderitem.`oid`=lsb.id;
    SELECT lsb2.*,product.*FROM (SELECT orderitem.*,lsb.* FROM orderitem,
    (SELECT user.username,orders.* FROM USER,orders WHERE user.`id`=orders.`uer_id`)AS lsb WHERE orderitem.`oid`=lsb.id) AS lsb2, product WHERE lsb2.pid=product.`id`;
    

    在这里插入图片描述

    清空表

    truncate 清空表
    格式:		truncate 表名;干掉表,重新创建一张空表
    和delete from区别:
    delete属于DML语句,truncate属于DDL语句
    delete逐条删除,truncate干掉表,重新创建一张空表
    

    ER图

    在ER图中有如下四个成分:
    矩形框:表示实体,在框中记入实体名。
    菱形框:表示联系,在框中记入联系名。
    椭圆形框:表示实体或联系的属性,将属性名记入框中。对于主属性名,则在其名称下划一下划线。
    连线:实体与属性之间;实体与联系之间;联系与属性之间用直线相连,并在直线上标注联系的类型。

    展开全文
  • 级联

    2017-07-08 18:10:00
    级联一般用于扩展网段的设备接入数量和延长距离,如交换机和集线器就是最常见的级联设备。   通过这些应用是否对级联有了个初步的形象了呢。   在Web项目中也会经常使用到级联的。比如: 货物...

    级联,英语:Cascade。是计算机科学里比较常见的概念。通常是指多个对象按照一定的规则有级别地或者是有梯度地联接在一起,也就是按照树形结构有层次地把对象组织在一起。

     

    ■应用:

    级联的应用比较广泛,表现在很多方面。

    功放,一个功放块或是三极管的放大效果达不到要求的功率,这时候就要用多片级连的方法来实现。

    微机原理的8259(中断处理器)是可以级联在一起,从而能处理更多的中断(扩容效果)。

     

    网络上的交换机,路由器级联。

    级联一般用于扩展网段的设备接入数量和延长距离,如交换机和集线器就是最常见的级联设备。

     

    通过这些应用是否对级联有了个初步的形象了呢。

     

    在Web项目中也会经常使用到级联的。比如:

    货物分类,组织体制结构,行政区划等。

    这里以行政区划为例。

    数据来源:http://www.stats.gov.cn/tjsj/tjbz/tjyqhdmhcxhfdm/

    ■表设计

    ■前端:

    <!DOCTYPE html>
    
    <html>
    
    <head><title>级联</title>
    
    <style>
    
    .divinline {
    
    display:inline;/* 删除Div的换行*/
    
    }
    
    </style>
    
    </head>
    
    <body>
    
    <div id="area_0" class="divinline"></div>
    
    <script>
    
    window.onload = function() {
    
        createXmlHttp();
    
        xmlHttp.open("post", "http://192.168.11.32:8080/teapot/t/?_a=14", true);
    
        xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded" );
    
        xmlHttp.onreadystatechange = callback;
    
        xmlHttp.send("owner=" + "area_0");
    
    };
    
    var xmlHttp ;
    
    
    
    function createXmlHttp() {
    
        if(window.ActiveXObject) {
    
            xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
    
        } else {
    
            xmlHttp = new XMLHttpRequest();
    
        }
    
    }
    
    
    
    function callback() {
    
        if(xmlHttp.readyState == 4) {
    
            if(xmlHttp.status == 200) {
    
                var json = JSON.parse(xmlHttp.responseText);
    
                // 得到的数据追加到谁的下面
    
                var owner = document.getElementById(json.owner);
    
                if ( json.options.length > 1 ) {
    
                    var div1_old = document.getElementById(json.divid);
    
                    if (div1_old != null) {
    
                        owner.removeChild(div1_old);
    
                    }
    
                    var div1 = document.createElement("div");
    
                    div1.id=json.divid;
    
                    div1.className="divinline";
    
                    owner.appendChild(div1);
    
                    var sel1 = document.createElement("select");
    
                    for(var i = 0; i < json.options.length; i ++) {
    
                        var city = json.options[i];
    
                        var option = new Option(city.cdNm,city.cdVal);
    
                        sel1.options.add(option);
    
                    };
    
                    sel1.onchange = function() {
    
                        createXmlHttp();
    
                        var name = this.value;
    
                        if(name != "") {
    
                            xmlHttp.open("post", "http://192.168.11.32:8080/teapot/t/?_a=14", true);
    
                            xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded" );
    
                            xmlHttp.onreadystatechange = callback;
    
                            // 当前owner和值
    
                            xmlHttp.send("owner=" + json.divid + "&value=" + name);
    
                        };
    
                    };
    
                    div1.appendChild(sel1);
    
                }
    
            }else {
    
                alert("Ajax Error : " + xmlHttp.status);
    
            };
    
        }else {
    
        };
    
    };
    
    </script>
    
    </body>
    
    </html>

    从上面的代码可以看出,html和css部分很简单。

    在html里主要使用了div的嵌套。因为使用动态创建,主要处理都在Javascript里了。

    Javascript中主要使用了这些计数。Ajax,Json,DOM。回调函数。

    对旧的数据删除也是一个小点。

     

    ■后端:

        public void action(HttpServletRequest req, HttpServletResponse resp)
    
                throws IOException {
    
            long st1a = System.currentTimeMillis();
    
            req.setCharacterEncoding("utf-8");
    
            String owner = (String) req.getAttribute("owner");
    
            String value = (String) req.getAttribute("value");
    
            if (value == null) {
    
                value = "";
    
            }
    
    
    
            String subDiv = owner;
    
            int idy = owner.indexOf("_");
    
            int idx = 0;
    
            if (idy >= 0) {
    
                idx = Integer.parseInt(owner.substring(idy + 1));
    
                subDiv = owner.substring(0, idy) + "_" + (idx + 1);
    
            } else {
    
                subDiv = subDiv + "_1";
    
            }
    
    
    
            String val2 = "";
    
            if (idx == 0) {
    
                val2 = "0000000000";
    
            }
    
            if (idx == 1) {
    
                val2 = "00000000";
    
            }
    
            if (idx == 2) {
    
                val2 = "000000";
    
            }
    
            if (idx == 3) {
    
                val2 = "000";
    
            }
    
    
    
            long ed1 = System.currentTimeMillis();
    
            log.info("★★★★action 1 耗时" + (ed1 - st1a));
    
            long st1 = System.currentTimeMillis();
    
            Connection conn = null;
    
            Statement stmt = null;
    
            ResultSet rs = null;
    
            List<TblCd> cds = new ArrayList<TblCd>();
    
            try {
    
                conn = TeapotDb.getConnection();
    
                stmt = conn.createStatement();
    
                String sqlCmd = "SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div' ";
    
                if (value != "" ) {
    
                    sqlCmd = sqlCmd + "AND CD_VAL LIKE '" + value + "%' AND CD_VAL LIKE '%" + val2 + "' ";
    
                }
    
                else {
    
                    sqlCmd = sqlCmd + " AND CD_VAL IN ( '110000000000', '120000000000', '130000000000', '140000000000', '150000000000', '210000000000', '220000000000', '230000000000', '310000000000', '320000000000', '330000000000', '340000000000', '350000000000', '360000000000', '370000000000', '410000000000', '420000000000', '430000000000', '440000000000', '450000000000', '460000000000', '500000000000', '510000000000', '520000000000', '530000000000', '540000000000', '610000000000', '620000000000', '630000000000', '640000000000', '650000000000' )";
    
                }
    
                sqlCmd = sqlCmd + " ORDER BY CD_VAL;";
    
    
    
                System.out.println("SQL:" + sqlCmd);
    
                rs = stmt.executeQuery(sqlCmd);
    
                System.out.println(sqlCmd);
    
                while (rs.next()) {
    
                    TblCd e = new TblCd();
    
                    if (idx == 0) {
    
                        e.setCdVal(rs.getString("CD_VAL").substring(0, 2));
    
                    } else if (idx == 1) {
    
                        e.setCdVal(rs.getString("CD_VAL").substring(0, 4));
    
                    } else  if (idx == 2) {
    
                        e.setCdVal(rs.getString("CD_VAL").substring(0, 6));
    
                    } else  if (idx == 3) {
    
                        e.setCdVal(rs.getString("CD_VAL").substring(0, 9));
    
                    } else {
    
                        e.setCdVal(rs.getString("CD_VAL"));
    
                    }
    
                    e.setCdNm(rs.getString("CD_NM"));
    
                    cds.add(e);
    
                }
    
            } catch(Exception e) {
    
                e.printStackTrace();
    
                System.out.println(e);
    
            } finally {
    
                if (rs != null ) { try {rs.close(); } catch (SQLException e) {e.printStackTrace();} }
    
                if (stmt != null ) { try {stmt.close(); } catch (SQLException e) {e.printStackTrace();} }
    
                if (conn != null ) { try {TeapotDb.releaseConnection(conn); } catch (SQLException e) {e.printStackTrace();} }
    
            }
    
            ed1 = System.currentTimeMillis();
    
            log.info("★★★★action 数据库检索 耗时" + (ed1 - st1));
    
            st1 = System.currentTimeMillis();
    
    
    
            resp.setContentType("application/json;charset=UTF-8");
    
            resp.setHeader("Access-Control-Allow-Origin", "*");
    
            PrintWriter out = resp.getWriter();
    
    
    
            Gson gson = new Gson();
    
            CascadeMdl mdl = new CascadeMdl(owner, subDiv, cds);
    
            String jsonObject = gson.toJson(mdl);
    
            System.out.println(jsonObject);
    
            out.println(jsonObject);
    
            ed1 = System.currentTimeMillis();
    
            log.info("★★★★action 3 耗时" + (ed1 - st1) + "总耗时" + (ed1 - st1a));
    
        }

     

    查询数据库,结果以json形式返回。

    在获取省列表的时候,有些慢,主要是数据库检索的问题,参照性能测试。

     

    ■性能测试:

    在下面这句时表现不好。

    SELECT CD_VAL, CD_NM FROM teapot.tbl_cd WHERE CD_TYPE = 'adm_div' AND CD_VAL LIKE '%0000000000' ORDER BY CD_VAL;

    发现建表时没有指定主键,那么就先用大招一:为搜索字段建索引。

     

    无PRIMARY第一次

    SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div' AND CD_VAL LIKE '%0000000000' ORDER BY CD_VAL;

    08:59:58.674 [http-nio-8080-exec-4] INFO  o.teapot.servlet.controller.Cascade - ★★★★action 数据库检索 耗时4083

     

    无PRIMARY第二次

    SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div' AND CD_VAL LIKE '%0000000000' ORDER BY CD_VAL;

    09:05:37.980 [http-nio-8080-exec-2] INFO  o.teapot.servlet.controller.Cascade - ★★★★action 数据库检索 耗时1848

     

    有PRIMARY

    SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div' AND CD_VAL LIKE '%0000000000' ORDER BY CD_VAL;

    10:13:58.131 [http-nio-8080-exec-10] INFO  o.teapot.servlet.controller.Cascade - ★★★★action 数据库检索 耗时12645

     

    有PRIMARY

    SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div' AND ( CD_VAL LIKE '0%' OR  CD_VAL LIKE '1%' OR  CD_VAL LIKE '2%' OR  CD_VAL LIKE '3%' OR  CD_VAL LIKE '4%' OR  CD_VAL LIKE '5%' OR  CD_VAL LIKE '6%' OR  CD_VAL LIKE '7%' OR  CD_VAL LIKE '8%' OR  CD_VAL LIKE '9%' )AND CD_VAL LIKE '%0000000000' ORDER BY CD_VAL;

    10:17:37.137 [http-nio-8080-exec-4] INFO  o.teapot.servlet.controller.Cascade - ★★★★action 数据库检索 耗时9472

     

    SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div'  AND CD_VAL IN ( '110000000000', '120000000000', '130000000000', '140000000000', '150000000000', '210000000000', '220000000000', '230000000000', '310000000000', '320000000000', '330000000000', '340000000000', '350000000000', '360000000000', '370000000000', '410000000000', '420000000000', '430000000000', '440000000000', '450000000000', '460000000000', '500000000000', '510000000000', '520000000000', '530000000000', '540000000000', '610000000000', '620000000000', '630000000000', '640000000000', '650000000000' , '710000000000', '810000000000', '820000000000' ) ORDER BY CD_VAL;

    17:40:42.474 [http-nio-8080-exec-2] INFO  o.teapot.servlet.controller.Cascade - ★★★★action 数据库检索 耗时1428

     

    SELECT CD_VAL, CD_NM FROM tbl_cd WHERE CD_TYPE = 'adm_div'  AND CD_VAL IN ( '110000000000', '120000000000', '130000000000', '140000000000', '150000000000', '210000000000', '220000000000', '230000000000', '310000000000', '320000000000', '330000000000', '340000000000', '350000000000', '360000000000', '370000000000', '410000000000', '420000000000', '430000000000', '440000000000', '450000000000', '460000000000', '500000000000', '510000000000', '520000000000', '530000000000', '540000000000', '610000000000', '620000000000', '630000000000', '640000000000', '650000000000' , '710000000000', '810000000000', '820000000000' ) ORDER BY CD_VAL;

    17:41:13.834 [http-nio-8080-exec-8] INFO  o.teapot.servlet.controller.Cascade - ★★★★action 数据库检索 耗时26

    还可以凑合,就这样吧。

    转载于:https://my.oschina.net/dubenju/blog/1217749

    展开全文
  •  on delete cascade//级联删除,把引用了该表的另一张表中所有引用的行都删除  on delete set null//如果被其他表引用,就把其他表中的外键的那一列的值都设置为空,然后把该表删除    on delete语句是在 ...

    第九章:DML语句
        主要内容:
            insert
            update
            delete

            ------------ 事务
            commit
            savepoint
            rollback

        sql语句的分类:
            select查询语句
            DML
            DDL
            DCL
            事务控制语句

        DML: insert update delete
        

        测试使用的表: 没有主外键关联
        create table t_user(
            id number,
            name varchar2(50) constraint user_name_nn not null,
            email varchar2(50),
            gender char(1),
            age number,
            birthday date,
            constraint user_id_pk primary key(id),
            constraint user_email_un unique(email),
            constraint user_gender_ck check(gender in('f','m'))
        );
        drop table t_user;

        insert语句:

            向表中插入数据:
            //默认是向表中的每一个列中【依次】插入数据
            insert into t_user values(1,'tom','abc','f',20,'11-8月-98');
            注:违反任意一种约束那么就插入数据失败

            //也可以指明向表中的哪些列插入数据
            //注意:可以任意交换下面列名的位置,只有values语句中的值也对应交换即可
            insert into t_user(id,name,email,gender,age,birthday) values(2,'tom','abc1','f',20,'11-8月-98');

            //列的值可以是null的话,那么也在插入的时候不指定这个列
            //注意:unique约束和check约束的值,都可以为null
            //注意:主键约束和非空约束的值,都不可以为null
            insert into t_user(id,name,email,gender) values(3,'tom','abc3','f');

            insert into t_user(id,name,email) values(4,'tom','abc4');

            insert into t_user(id,name) values(5,'tom');
            


            //使用运行时参数设置需要输入表中的值
            insert into t_user(id,name) values(&id,'&name');
            如果这里的'&name'没加'',那么在输入tom时需要加'':'tom'


            //把查询的结果 插入到表中
            //前提是查询的列的顺序和要插入表中列的顺序是一致的,这个一致指的的是数据类型是一种的
            insert into t_user(id,name,birthday)
            select id,last_name,start_date
            from s_emp;

        
        
        update语句:
            //修改表中所有数据的age值为20岁
            update t_user set age=20;
            
            //修改表中所有数据的age和gender的值
            update t_user set age=25,gender='m';
            
            //修改表中id小于10数据的age和gender的值为null
            update t_user
            set
            age=null,gender=null
            where id<10;
            
            //修改id为18的用户的名字为zhangsan
            update t_user set name='zhangsan' where id=18;

        
        delete语句
            //删除表中id大于20的用户信息
            delete from t_user where id>20;
            
            //删除名字为张三的用户信息
            delete from t_user where name='zhangsan';
            
            //删除表中所有的数据
            delete from t_user;

        
        
        测试使用的表: 主外键关联
        create table t_customer(
                id number,
                name varchar2(20) constraint customer_name_nn not null,
                constraint customer_id_pk primary key(id)
        );

        create table t_order(
            id number,
            price number,
            customer_id number,
            constraint order_id_pk primary key(id),
            constraint order_cid_fk foreign key(customer_id) references t_customer(id)
        );
        
        drop table t_order;
        drop table t_customer;

        
        insert语句:
            //t_customer表中插入数据
            insert into t_customer(id,name) values(1,'tom1');

            insert into t_customer(id,name) values(2,'tom2');

            insert into t_customer(id,name) values(3,'tom3');

            //t_order表中插入数据
            //customer_id外键列的值必须是t_customer表中出现过的
            insert into t_order(id,price,customer_id) values(1,1000,1);
            insert into t_order(id,price,customer_id) values(2,2000,2);

            //插入出错,因为6这个值并没有在t_customer表中出现过的
            insert into t_order(id,price,customer_id) values(3,3000,6);


            //t_order表中插入数据
            //默认情况下,外键列上的值是可以为空的
            insert into t_order(id,price,customer_id) values(3,3000,null);
            insert into t_order(id,price) values(4,4000);
            注意:如果在外键列上加一个非空约束,那么这个外键列的值就不能为null了(可以给一个列上添加多种约束)


            //t_order表中插入数据
            //默认情况下,外键列上的值是可以重复的
            insert into t_order(id,price,customer_id) values(5,5000,1);
            insert into t_order(id,price,customer_id) values(6,6000,1);
            注意:如果在外键列上加一个唯一约束,那么这个外键列的值就不能重复了(可以给一个列上添加多种约束)

        
        update语句:
            把俩个测试表删除了重新创建,然后向表中插入一些数据
            //t_customer表中插入数据
            insert into t_customer(id,name) values(1,'tom1');
            insert into t_customer(id,name) values(2,'tom2');
            insert into t_customer(id,name) values(3,'tom3');

            //t_order表中插入数据
            insert into t_order(id,price,customer_id) values(1,1000,1);
            insert into t_order(id,price,customer_id) values(2,2000,2);
            
            //把t_order表中id=1的数据的customer_id列修改为3
            update t_order set customer_id = 3 where id = 1;

            //把t_order表中id=1的数据的customer_id列修改为null
            update t_order set customer_id = null where id = 1;
        
            //把t_order表中id=1的数据的customer_id列修改为20
            //sql执行出错,因为就没id=20的顾客
            update t_order set customer_id = 20 where id = 1;
            

        delete语句:
            
            //删除t_order表中的的所有数据
            //可以成功删除,没有问题,因为删除t_order不会对t_customer表的数据产生任何影响
            delete from t_order;
            
            //t_order表中插入数据
            insert into t_order(id,price,customer_id) values(1,1000,1);
            insert into t_order(id,price,customer_id) values(2,2000,2);

            
            //删除t_customer表中id=3的数据
            //删除成功,因为t_order表中外键列中没有引用过这个值
            delete from t_customer where id = 3;

            //删除t_customer表中id=1的数据
            //删除失败,因为t_order表中外键列中已经引用了这个值
            delete from t_customer where id = 1;

           【在这种情况下,on delete 语句就可以起作用了】

     

        on delete语句
            on delete no action(默认情况:什么不都写)//如果删除的表的值被其他表当作外键引用,就报提示信息,并回滚删除事务
            on delete cascade//级联删除,把引用了该表的另一张表中所有引用的行都删除
            on delete set null//如果被其他表引用,就把其他表中的外键的那一列的值都设置为空,然后把该表删除

            
            on delete语句是在声明外键约束的时候使用的。用户在删除A表中的一条数据,而这条数据被B表中的外键列所引用了,这个时候on delete语句的设置可以告诉oracle这个时候该如何处理
                    
            如果在建外键的时候,不加on delete语句,就是on delete no action
            例如1: on delete no action
            create table t_customer(
                id number,
                name varchar2(20) constraint customer_name_nn not null,
                constraint customer_id_pk primary key(id)
            );

            create table t_order(
                id number,
                price number,
                customer_id number,
                constraint order_id_pk primary key(id),
                constraint order_cid_fk foreign key(customer_id) references t_customer(id)
            );
            
            drop table t_order;
            drop table t_customer;

            插入测试数据:
            //t_customer表中插入数据
            insert into t_customer(id,name) values(1,'tom1');
            insert into t_customer(id,name) values(2,'tom2');
            insert into t_customer(id,name) values(3,'tom3');
            //t_order表中插入数据
            insert into t_order(id,price,customer_id) values(1,1000,1);
            insert into t_order(id,price,customer_id) values(2,2000,2);

            //删除失败
            //ORA-02292: 违反完整约束条件 - 已找到子记录
            delete from t_customer where id = 1;

            
            例如2: on delete cascade
            建表语句和测试数据上例1相同,只是在声明外键列的时候加入on delete cascade语句
            create table t_order(
                id number,
                price number,
                customer_id number,
                constraint order_id_pk primary key(id),
                constraint order_cid_fk foreign key(customer_id) references t_customer(id) on delete cascade
            );

            insert into t_order(id,price,customer_id) values(1,1000,1);
            insert into t_order(id,price,customer_id) values(2,2000,2);

                
            //同样做删除测试
            //删除成功,同时级联(cascade)删除了t_order表中所关联的那条数据
            delete from t_customer where id = 1;
            
        

            例如3: on delete set null
            建表语句和测试数据上例1相同,只是在声明外键列的时候加入on delete set null语句
            create table t_order(
                id number,
                price number,
                customer_id number,
                constraint order_id_pk primary key(id),
                constraint order_cid_fk foreign key(customer_id) references t_customer(id) on delete set null
            );

            insert into t_order(id,price,customer_id) values(2,2000,2);

                
            //同样做删除测试
            //删除成功,同时把t_order表中所关联的那条数据的外键设置为了null
            delete from t_customer where id = 2;


        
        数据库事务
            1.DML语句执行的时候,如果当前有事务,那么就使用这个事务,如果当前没有事务,这个执行的DML语句就会产生一个新的事务。
            2.只有DML语句才会产生事务,其他语句不会产生事务
            3.commit/rollback/DDL语句都可以把当前事务给结束掉
            4.commit和DDL语句结束事务的方式把这个事务给提交了
            5.rollback结束事务的方式是把这个事务给回滚
            注:
                提交事务是指让这个事务里面所有操作生效到数据库
                回滚事务是指让这个事务里面所有操作都撤销
           
            
            测试用的表:
            create table t_customer(
                id number,
                name varchar2(20) constraint customer_name_nn not null,
                constraint customer_id_pk primary key(id)
            );
            drop table t_customer;
            

            测试: 使用俩个终端窗口,同一个账号登录到数据库中,观察事务是否提交对用户查看数据的影响
            注:一个用户对A表做了DML操作,但是没有提交事务,这时候别的用户是不能对A表再做其他的DML操作。(为了保证数据的安全和一致性)
            可以使用以下语句:
            insert into t_customer(id,name) values(1,'tom1');

            commit;

            delete from t_customer;


            例如1:
            insert ....产生事务A
            update ... 这个操作是事务A中的操作
            insert ..  这个操作是事务A中的操作
            commit;    让事务A里面的三个操作生效、事务A结束


            delete ... 产生新的事务B
            insert ..  这个操作是事务B中的操作
            insert ..  这个操作是事务B中的操作
            insert ..  这个操作是事务B中的操作
            rollback;  让事务B中的四个操作都撤销,事务B结束


            例如2:
            insert ....产生事务A
            update ... 这个操作是事务A中的操作
            insert ..  这个操作是事务A中的操作
            DDL语句;   事务A会被提交,事务A结束
            rollback;  这时候回滚已经对事务A不起作用,因为事务A以及被提交了,当前已经没有事务了

            
            注:create语句 drop语句 alter语句等都属于DDL语句

        
        事务特征ACID:    
            原子性:Atomicity

                同时成功或者同时失败
            一致性:Consistency
                事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。
                事务操作成功后,数据库所处的状态和他的业务规则是一致的,即数据不会被破坏。如A账户转账100元到B账户,不管操作成功与否,A和B账户的存款总额是不变的。
            隔离性:Isolation
                事务操作应该相互独立
            持久性:Durability
                事务所做的影响 ,在事务结束之后应该能够是持久的。
        

        isolation  事务隔离级别
            
            事务中产生的问题:

            1.脏读  主要针对update操作。 一个事务A读到另一个事务B中修改过但是还没有提交的数据

            2.不可重复读  主要针对update操作。 一个事务A在第一次读数据和第二次读数据之间,有另一个事务B把这个数据更改并提交了,所以就出现了事务A里面读一个数据俩次,但是读到的结果是不同的。

            3.幻读  主要针对的是insert/delete操作。事务A第一次用where条件筛选出了10条数据,事务A第二次用通样的where条件筛选出的却是11条数据,因为事务B在事务A的第一次和第二次查询之间进行了插入操作,并且插入的这个数据满足事务A的where筛选条件.

            
            事务隔离级别有:
            read-uncommitted  不提交也能读
            read-committed    提交之后才能读 解决了脏读
            repeatable-read   解决了脏读和不可重复读
            serializable      三个问题都解决了

            级别越高解决的问题越多但是效率越低
            注意:并不是所有数据库都支持这四种事务隔离级别,比如oracle就只支持第二种和第四种这俩种,比如mysql就四种全支持.

            oracle里面默认的事务隔离级别是第二种:read-committed

            oralce里面设置事务隔离级别:
            Set Transaction Isolation Level Read Uncommitted;
            Set Transaction Isolation Level Read Committed;
            Set Transaction Isolation Level Read Repeatable;
            Set Transaction Isolation Level Serializable;

        

        回滚点/保存点 savepoint
            例如:

            DML语句1
            savepoint A
            DML语句2
            savepoint B
            DML语句3
            rollback to A/B

            这个时候可以通过这个回滚点让事务回滚到指定的位置,如果不指定回滚点而是直接rollback,那么事务会一下子回滚完.

            【特别注意】:rollback到回滚点之后,这个事务并没结束,这个时候还可以接着回滚或者commit提交事务。
            

            create table t_user(
                id number primary key,
                name varchar2(100),
                salary number
            );
            drop table t_user;
            例如:
            insert into t_user values(1,'tom',1000);
            savepoint A;
            insert into t_user(id,name) values(2,'zs');
            savepoint B;
            delete from t_user;
            rollback to B;

            然后查询看结果
            select * from t_user;

     


    第十章: 修改表和约束(alter语句)

        测试的表:
        create table t_user(
                id number constraint user_id_pk primary key,
                name varchar2(100),
                salary number
        );
        drop table t_user;

        //在表中添加一个新的列
        alter table t_user
        add birthday date;

        //删除表的某列
        alter table t_user
        drop column birthday;


        //给表中的列添加约束
        //这个约束相当于之前的表级约束
        alter table t_user
        add constraint user_name_un
        unique(name);

        
        //测试刚添加的唯一约束是否生效
        insert into t_user(id,name) values(1,'zs');
        insert into t_user(id,name) values(2,'zs');

        
        //删除表中的约束
        alter table t_user
        drop constraint user_name_un;


        //修改表的名字:
        rename t_user to mytest;
        rename mytest to t_user;

        //修改表中某列的类型
        alter table t_user
        modify (name varchar2(500));


        //让约束失效:必须知道约束的名字
        alter table t_user
        disable constraint user_id_pk cascade;
        
        //测试是否设置成功
        insert into t_user(id,name) values(1,'zs1');
        insert into t_user(id,name) values(1,'zs2');


        //让失效的约束再次生效
        alter table t_user
        enable constraint user_id_pk;


        //截断表中的数据(删除),不需要提交,默认已经提交,并且不能回滚
        truncate table t_user;
        相当于:
        delete from t_user;
        commit;


        //给表添加注释
        comment on table t_user is '很好';
        //给列添加注释
        comment on column t_user.name is 'good';
        //查看表中注释
        select * from user_tab_comments where table_name=upper('t_user');//因为数据库中的所有命令表名默认是大写,可以用小写输入,数据库会默认转换为大写
        //查看列中的注释
        select * from user_col_comments
        where
        comments is not null
        and
        table_name=upper('t_user');

     

    第十一章: 序列
        Sequence 序列
        作用:帮我们生成主键列的值(特点:非空唯一)

        创建序列:
        一般不需要设置sequence的属性,使用默认的方式去创建就可以了.
        create sequence 序列名;

        如果需要设置属性,那么就加上下面的语句.
        [INCREMENT BY n]  每次拿出值加多少
        [START WITH n]    初始值从几开始
        [{MAXVALUE n | NOMAXVALUE}]  最大值
        [{MINVALUE n | NOMINVALUE}]  最小值
        [{CYCLE | NOCYCLE}]  到了最大值后是否循环(如果循环会从1开始)
        [{CACHE n | NOCACHE}] 每次在缓存里面放多少个值.


        例如:创建序列并设置属性
        create sequence seq_test
        increment by 2
        start with 45
        maxvalue 60
        cycle
        nocache;

        drop sequence seq_test;

        例如:创建序列使用默认属性
        create sequence seq_test;

        
        对应序列,我们只有俩种操作:
            1.获得序列中的下一个值
                //这个值对于当前这个序列来的其他值来说,肯定是非空唯一
                select seq_test.nextval
                from dual;

            2.查询序列中当前的值是多少
                select seq_test.currval
                from dual;//得先有值才能看当前值,也就是现有.nextval

        
        向t_user表插入数据,其中id值可以需要生成
            create table t_user(
                id number constraint user_id_pk primary key,
                name varchar2(100),
                salary number
            );
            drop table t_user;
        
        //创建序列
        drop sequence t_user_seq;
        create sequence t_user_seq;
        
        //插入数据 使用序列产生id值
        insert into t_user(id,name,salary) values(t_user_seq.nextval,'tom',2000);
        

        通过数据字典查询当前用户的序列
            select sequence_name
            from user_sequences;

            select table_name
            from user_tables;

        

    第十二章: 视图view(虚表)
        视图就是提取一张或者多张表的数据生成一个映射,操作视图可以达到操作原表的效果,方便数据的管理以及安全操作。

        视图的作用:
            1.隐藏表中的重要数据
            2.代替一些比较长的sql语句

        视图分为俩类: 视图的本质就是一条sql语句
            简单视图:
               视图所代表的sql中如果没有group by语句,没有组函数,查询的只有一张表,那么这样的视图就是简单视图.
            复杂视图:
               视图所代表的sql中如果有group by语句,或者有组函数,或者查询的是多张表,那么这样的视图就是复杂视图.


        简单视图和复杂视图的区别:
            通过简单视图可以修改原来表中的数据,通过复杂视图是不能修改原来的数据的。

        创建视图:
            create or replace view 视图名字
            as
            sql语句

        
        删除视图
            drop view 视图名字;


        测试表:
        create table t_user(
            id number constraint user_id_pk primary key,
            name varchar2(100),
            salary number
        );
        drop table t_user;
        
        插入数据:
        insert into t_user(id,name,salary)
        select id,last_name,salary
        from s_emp;

        //创建视图
        create or replace view v_test
        as
        select *
        from t_user
        where id > 10;

        //查看视图内容
        select *
        from v_test;


        //可以通过*简单视图*对原来的表进行数据的删除/更新/插入
        delete from v_test where id=16;

        update v_test set name = 'zhangsan' where id = 20;

        insert into v_test(id,name,salary) values(28,'tom1',3000);

        

        
        with read only语句
            特点:只能通过视图进行查询数据,不能修改
            例如:
            create or replace view v_test
            as
            select *
            from t_user
            where id > 10
            with read only;
            
            这个视图v_test将来只能查询,不能进行修改
            
            此时再使用上面的DML进行操作数据就会报错。

     


        with check option语句
            特点:通过视图进行的修改 那么也必须可以通过这个视图能够显示出来,否则就操作失败

        例如:
            //测试用的表及其数据
            drop table t_user;
            create table t_user(
                id number constraint user_id_pk primary key,
                name varchar2(100),
                salary number
            );

            insert into t_user values(1,'tom1',1000);
            insert into t_user values(2,'tom2',2000);
            
            
            创建视图:
            create or replace view v_test
            as
            select id,name,salary
            from t_user
            where id=2
            with check option;
            

            //查询视图中的数据
            select * from v_test;

            //插入报错 因为这个操作通过视图显示不出来
            insert into v_test values(3,'tom3',3000);

            //更新失败 因为这个操作通过视图显示不出来
            update v_test
            set name='lily'
            where id=1;

            //更新成功 因为这个操作通过视图可以显示出来
            update v_test
            set name='lily'
            where id=2;

        
        复杂视图
            例如:
                create or replace view v_test
                as
                select avg(salary) avgSal
                from t_user;

            
            复杂视图只能用来查询,不能修改
            
            select * from v_test;

            update v_test
            set avgSal=2019;

     

    第十三章: 索引(index)
        索引的概念:
            1. 类似书的目录结构
            2. Oracle 的"索引"是一种对象,是与表关联的可选对象,能提高SQL查询语句的速度
            3. 索引直接指向包含所查询值的行的位置,减少磁盘I/O
            4. 索引和表是相互独立的物理结构
            5. Oracle 自动使用并维护索引,插入、删除、更新表后,自动更新索引
        

        索引的原理:
            例如:一个表中有name字段,假设要查找name='tom'的这条数据,可能会有多条

            若没有索引,查找这个记录时,需要搜索表中所有的记录,因为不能保证只有一个tom,那么就必须将表中数据全部搜索一遍

            若在name上建立索引,oracle会对全表进行一次搜索,将每条记录的name值在什么位置按照一定的规则进行排列,然后构建索引条目,存储到索引段中,查询name为tom时,可以直接查找该数据所在的对应地方。

            创建了索引并不一定就会使用,因为oracle在自动统计表的信息后,会决定是否使用索引,表中数据很少时,使用全表扫描速度已经很快了,那么就没有必要使用索引了。
        

        索引的创建:
            1.自动创建
                当在表中指定了primary Key或者unique约束时会自动创建唯一值索引。
            2.用户创建。
            用户可以创建非唯一值索引以提高在访问数据时的效率。

            语法:
                create index 索引名
                on 表名(列名);

            例如:
                 create index emp_index
                 on s_emp(last_name);

            
            删除索引:
                drop index 索引名;
            例如:
                drop index emp_index;

            创建成功后可以通过如下语句查看:
                select index_name from user_indexes;

        给某列创建索引的原则
            1.列经常作为where子句的限定条件或者作为连接条件
            2.列包含的数据量很大,并且很多非空的值。
            3.两个或者更多列频繁的组合在一起作为where的限定条件或者连接条件
            4.列总是作为搜索条件
            5.索引查出的数据量占2%~4%
            6.索引不是越多越好,不是索引越多越能加速查找。
            7.要索引的表不经常进行修改操作

        
        注意:
            1.在表中的某一个合适的列加入上了索引,那么也只有在数据量很大的时候,才能有所体现出这个查询的效率.
            2.索引一旦建立成功,那么之后这个索引就由系统来管理,我们自己是控制不了的.


        索引的种类:
            Single column 单列索引
            Concatenated  多列索引
            Unique          唯一索引
            NonUnique     非唯一索引

        

        索引结构分为:
            B-tree(默认是这种结构)
                适合大量的增、删、改;
                不能用包含OR操作符的查询;
                适合高基数的列(唯一值多)
                典型的树状结构;

                默认创建的索引就是这种结构。
                create index emp_index on s_emp(last_name);

                drop index emp_index;

            位图
                做UPDATE代价非常高(oracle要根据表的每次修改来更新索引)
                非常适合OR操作符的查询;
                数据基数比较少的时候较适合建位图索引。

                create bitmap index bitmap_index on s_emp(last_name);

                drop index bitmap_index;
                

                注意:查询是否具备了bitmap索引的功能
                select * from v$option Where PARAMETER='Bit-mapped indexes'

                如果value值为false表示,Oracle该版本不具有bitmap索引功能或未装

            反序
                反向索引是B-tree索引的一个分支,主要是在创建索引时,针对索引列的索引键值进行字节反转。
                例如,键值1001、1002、1003,反转后1001、2001、3001,进而将值分散到不用的节点中。

                create index emp_index_reverse on s_emp(last_name) reverse;

                drop index emp_index_reverse;

            函数索引
                经常对某个字段做查询的时候,并且是带函数操作的,那么此时函数索引就可以发挥作用,提高检索速度。

                create index func_index  on s_emp(upper(last_name));

                drop index func_index;

    展开全文
  • varchar2型varchar型的区别: 1、varchar2把所有字符都占两字节处理(一般情况下),varchar只对汉字和全角等字符占两字节,数字,英文字符等都是一个字节; 2、VARCHAR2把空串等同于null处理,而varchar仍按照...
  • Oracle-用户权限管理

    2021-05-03 08:45:14
    Oracle-用户权限管理目标:1,掌握建立用户、概要文件的使用2,掌握系统权限的含义及授予、回收3,掌握对象权限的含义及授予、回收4,掌握角色的含义、对角色授予权限、把角色分配给用户Oracle11g默认用户SYS:用于...
  • mybatishibernate的区别

    2021-09-18 15:30:26
    hibernate拥有完整的日志系统,hibernate日志系统非常健全,涉及广泛,包括sql记录、关系异常、优化警告、缓存提示、脏数据警告等 级联删除、更新 不支持级联更新、级联删除 支持 二 JDBC关系 Hibernate是在JDBC...
  • 数据库建表技巧

    2015-03-05 14:24:35
    我这里说的谨慎,是因为级联删除和级联更新有些突破了传统的关于外键的定义,功能有点太过强大,使用前必须确定自己已经把握好 其功能范围,否则,级联删除和级联更新可能让你的数据莫名其妙的被修改或者丢失。...
  • 主要讲解mysql的表操作相关内容包括: mysql存储引擎详解 事务的隔离级别解析 建表、修改表、查看表、删除表详细图解 mysql数据类型详细图解 表的完整性约束详解 mysql建表的思路 多表结构分析
  • NoSQL数据库笔谈NoSQL数据库笔谈appdir , ssv , paper颜开 , v0.2 , 2010.2 序 思想篇 CAP 最终一致性 变体 BASE 其他 I/O的五分钟法则 不要删除数据 RAM是硬盘,硬盘是磁带 ...
  • 你可能经常会有这样的顾虑,在删除唯一约束或者主键约束的时候,附带的索引会不会被删除掉?现在的团队有一个规范,但凡是增加主键,都需要先手工创建索引,再增加主键。给出的原因是:这样删除主键的时候,索引就...
  • Impala的核心开发语言是SQL语句,Impala有shell命令行窗口、JDBC等方式来接收SQL语句执行,...Impala SQL语法,关系型数据库的SQL语法类似;导入数据以及JDBC方式查询Impala,有多种数据导入方式,也支持接口编程。
  • 5.5 InnoDB存储引擎表在线DDL5.5.1.在线DDL概述以前,InnoDB存储引擎表的许多DDL操作代价是非常昂贵的...在旧表所有行被拷贝完,旧表被删除和那新表被重命名为旧的表名。 MySQL5.5,和MySQL5.1 有了InnoDB Plugin,优...
  • // 级联删除 // jpa的注解里面 @OneToMany 添加属性cascade=CascadeType.REMOVE (All) /** * 客户的实体类 */ @Entity @Table(name="cst_customer") public class Customer implements...
  • 一、索引简介:索引是用于加速数据存取的数据对象,合理的使用索引可以大大降低I/O次数,从而提高数据访问性能。索引有很多种主要介绍常用的几种:1-单列索引:单列索引是基于单个列所建立的索引,语法:create ...
  • 03MySQL中的约束索引

    2020-09-10 17:50:13
    MySQL中的约束索引约束主键约束唯一约束检查约束默认值约束外键约束索引 约束和索引是两种重要的数据库对象。常用的数据库对象还有表、数据字典、视图、函数、存储过程、触发器。 约束 约束是插入和处理数据库数据...
  • Hibernate入门这一篇就够了 前言 本博文主要讲解介绍Hibernate框架,...Hibernate是一种ORM框架,全称为 Object_Relative DateBase-Mapping,在Java对象关系数据库之间建立某种映射,以实现直接存取Java对象! ...
  • 1.建表(复制表结构和内容)DDL Create table xxx as select * from yyy 把yyy的内容和结构复制到xxx中了 alter table 旧表名 rename to 新表名 alter table xx add(name int ,id int)//可多个同时修改 新增...
  • O是object,也就类对象的意思,R是relation,翻译成中文是关系,也就是关系数据库中数据表的意思,M是mapping,是映射的意思。在ORM框架中,它帮我们把类和数据表进行了一个映射,可以让我们通过类和类对象就能操作...
  • beego的orm模型定义学习实际测试

    千次阅读 2019-04-15 19:06:31
    因为我没怎么用过orm,一般就直接用着sql驱动直接上了。数据库上的也有一段时间了,对于各种关系忘得也是差不多了。 这里主要是官方写的不是特别好,比如官方中文文档在这里给出的models.go的例子,让人看的很迷茫。...
  • ( ( 一) ) 建表规约 建表规约 ............................................................................................................................................................. 22 ( ( 二) )...
  • MySQL 8 复制(六)——拓扑性能

    千次阅读 多人点赞 2019-07-04 16:39:59
    5. Blackhole引擎日志服务器 二、复制性能 1. 测试规划 2. sync_binloginnodb_flush_log_at_trx_commit 3. 组提交多线程复制 4. 基于WriteSet的多线程复制 可以在任意个主从库之间建立复杂的复制拓扑...
  • 的后缀接口区别。 正例: CacheServiceImpl 实现 CacheService 接口。 2 /  32   阿里巴巴 JAVA 开发手册 2 )【推荐】 如果是形容能力的接口名称,取对应的形容词做接口名(通常是 – able 的形 式)。 ...
  • 外键的级联更新和级联删除(了解)二 表关系(重点)2.1概述2.2一对一(了解)2.3一对多2.4多对多三、多表查询(重点)1.多表查询-数据准备2.多表查询-笛卡尔积查询(了解)3.多表查询-内连接查询4.多表查询-外连接查询5.多表...
  • 我的Hibernate学习笔记

    2009-10-13 10:05:51
    注:持久对象临时对象最大的区别是有没有数据库id标识。 2.hibernate.cfg.xml的样板: Xml代码    1. <?xml?version='1.0'?encoding='UTF-8'?>? ?? 2. <!DOCTYPE?hibernate-configuration?PUBLIC? ?? 3. ???...
  • 目录 前言 ORM概述 测试 ...本博文主要讲解介绍Hibernate框架,ORM的概念和Hibernate... Hibernate是一种ORM框架,全称为 Object_Relative DateBase-Mapping,在Java对象关系数据库之间建立某种映射,以实现...
  • 外键的级联类型 级联类型 解释 on delete restrict 默认值,抛异常 on delete cascade 如果主表被引用的外键删除,相关联的表的记录也会被删除 on delete set null 如果主表被引用的外键删除,相关联的表的外键设置...
  • Oracle 9iMS SQL Server 2000之比较连载五 2008-04-14 18:13 四、Oracle中新的数据库对象:  实例化视图、快照、序列、程序包、同义词、抽象的数据类型 ● 实例化视图又称显形图:实例化说明它有...
  • =, , <=>         和 =的区别         可以检测NULL值       IS [NOT] NULL         检测值是否为NULL或者NOT NULL       指定范围         [NOT] BETWEEN ......
  • @Id //指定该字段是主键,直接也可以写在getter方法上 //@GeneratedValue //默认是自适应的主键策略:strategy=GenerationType.AUTO //@GeneratedValue(strategy=GenerationType.AUTO) //有点像native @...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,735
精华内容 694
关键字:

.直接级联删除与建表指定级联删除o区别?

友情链接: pitch.rar