import:数据的导入
load:数据的加载
export:数据的导出
导入和加载都是将文件的数据保存到数据库中的表中;
导出是表DB2数据库的表中的数据保存在某种格式的文件中

文件的格式

  • DB2数据移动的文件格式有四种:

    • ASC
    • DEL
    • WSF
    • IXF
  • ASC和DEL都是文本文件,任何文本编辑器都能打开。
  • WSF格式的文件可以将数据迁移到电子表格软件中。
  • IXF格式文件包括了数据表的数据描述语言和里面的数据,利用它可以重建数据表
  • 在将ASC、DEL和WSF格式的文件中的数据导入到数据表中前,数据表必须存在,而IXF格式的文件导入前不需要存在相应的数据表。

export

export将数据库表写到存储在数据库外面的一个或多个文件中。
仅支持DEL、WSF、IXF三种数据文件格式,一般情况下是DEL和IXF。

  • export命令语法
export to filename of filetype select-statement
例:
export to c:\org.del of del select * from org

import

import可将输入文件写到数据库或可更新视图。
import使用SQL INSERT语句(或SQL UPDATE语句)将数据写到目标表中。
import可以读取数据的文件可以是几种标准文件格式中的一种,一般是PC/IXF、DEL或ASC。

IMPORT FROM filename OF filetype (ALLOW NO ACCESS,ALLOW WTITE ACCESS)(INSERT,INSERT UPDATE,REPLACE,REPACE_CREATE) INTO tablename

其中,INSERT模式是添加输入数据到表中,并且不会更改任何现有数据。
INSERT_UPDATE将新的输入数据添加到表中,或者用具有匹配主键值的数据数据更新现有的行。
REPLACE模式(通过删除数据对象)删除表中的所有现有数据,然后再插入输入数据。
REPLACE——CREATE模式(通过删除数据对象)删除表中的所有现有数据,然后再插入输入数据。如果该表不存在,该模式将优先于插入输入数据而创建表。该模式只对PC/IXF输入文件有效。
import from c:org2.txt of asc MODIFIED BY nullindchar=# method l(1 5,6 19,20 25,26 37,38 50) NULL INDICATORS(0,0,0,0,38 ) replace into org

load

load非常高效的将一个或多个输入文件中的数据写到数据库表中。
locd工具与import工具不一样,不是使用SQL将数据写到目标表中,而是将格式化的页写到表中,因此比import工具快得多。
读取数据的文件一般是PC/IXF、DEL或者是ASC

LOAD FROM (filename, pipename, device, cusorname) OF filetype (INSERT, REPLACE, RESTART, TERMINATE) INTO tablename (ALLOW ON ACCESS, ALLOW READ ADDCESS(USE tablespace name)) (LOCK WITH FORCE)

其中,INSERT模式是添加输入数据到表中,并且不会更改任何现有数据。
REPLACE模式(通过删除数据对象)删除表中的所有现有数据,然后再插入输入数据。

try-catch

用try-catch捕获到异常后,对其进行处理,不会影响后面程序的执行,因此在程序1捕获并处理除数为0的异常后,依旧以后可以打印irene。

程序1(在内层捕获异常):

public class Test {
    public static void main(String[] args) {
        int a = 6, b = 0;
        divi(a, b);
        System.out.print("irene");
    }
    public static void divi(int a, int b) {
        try {
            int c = a / b;
            System.out.println(c);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

输出:
/ by zero
irene

程序2(内层未捕获在外层捕获异常):

public class Test {
    public static void main(String[] args) {
        try {
            int a = 6, b = 0;
            divi(a, b);
        } catch(Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.print("irene");
    }
    public static void divi(int a, int b) {
        int c = a / b;
        System.out.println(c);
    }
}
输出:
/ by zero
irene

程序3(内层捕获异常后,调用者不再捕获):

public class Test {
    public static void main(String[] args) {
        int a = 6, b = 0;
        try{
            div(a, b);
        } catch(Exception e){
            System.out.println("外层"+ e.getMessage());
        }
        System.out.println("irene");
    }
    public static void div(int a, int b) {
        try {
            int c = a / b;
            System.out.println(c);
        } catch (Exception e) {
            System.out.println("内层" + e.getMessage());
        }
    }
}
输出:
内层/ by zero
irene

throws

可以将不对异常做处理,而是交给调用者去处理,被调用的方法如果有异常可以直接通过throws抛给上层去进行处理。

public class Test {
    public static void main(String[] args) {
        try {
            int a = 6, b = 0;
            divi(a, b);
        } catch(Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.print("irene");
    }
    public static void divi(int a, int b) throws Exception{
        int c = a / b;
        System.out.println(c);
    }
}
输出:
/ by zero
irene

throw

如果在被调用的方法中加了try-catch,必须通过throw抛出异常给上层去处理,不能自动将异常抛给上层去处理
throw要和try-catch或者throws搭配起来使用。
程序1:

public class Test {
    public static void main(String[] args) {
        int a = 6, b = 0;
        try {
            div(a, b);
        } catch (Exception e) {
            System.out.println("外层" + e.getMessage());
        }
        System.out.println("irene");
    }
    public static void div(int a, int b) {
        try {
            int c = a / b;
        } catch (Exception e) {
            throw e;
        }
    }
}
输出:
外层/ by zero
irene

程序2(和try-catch搭配使用):

public class Test {
    public static void main(String[] args) {
        int a = 6, b = 0;
        try {
            div(a, b);
        } catch (Exception e) {
            System.out.println("外层" + e.getMessage());
        }
        System.out.println("irene");
    }
    public static void div(int a, int b) {
        int c = a / b;
        if(b == 0) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
输出:
外层/ by zero
irene

程序3(和throws搭配使用):

public class Test {
    public static void main(String[] args) {
        int a = 6, b = 0;
        try {
            div(a, b);
        } catch (Exception e) {
            System.out.println("外层" + e.getMessage());
        }
        System.out.println("irene");
    }
    public static void div(int a, int b) throws Exception{
        int c = a / b;
        if(b == 0) {
           throw new Exception();
        }
    }
}
输出:
外层/ by zero
irene

程序4:

public class Test {
    public static void div(int a, int b){
        if (a == 6) {
            throw new IllegalArgumentException("被除数为6");
        }
    }
    public static void main(String[] args) {
        int a = 6, b = 2;
        try {
            div(a, b);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        System.out.println("irene");
    }
}
输出:
被除数为6
irene

但是,并不是throw每一种异常,需要和try-catch和throws搭配使用,如NullPointerException异常就是可以单独使用的

自定义异常

public class Test {
    public static void main(String[] args) {
        int a = 6, b = 0;
        try {
            div(a, b);
        } catch (myException myException) {
            System.out.println("自定义异常:" + myException.getMessage());
        } catch (Exception e) {
            System.out.println("flag");
        }
        System.out.println("irene");
    }
    public static void div(int a, int b) throws myException,Exception {
        if(a == 6) {
            throw new myException("被除数为6");
        }
        int c = a / b;
    }
}
class myException extends Exception{
    myException(String s){
        super(s);
    }
}
输出:
自定义异常:被除数为6
irene

使用SELECT语句从数据库中检索数据

  • 适用的对象:

    • 视图
  • 最简单的形式
SELECT * FROM staff
SELECT name, salary FROM staff
  • 限制结果行数,使用FETCH FIRST字句
SELECT * FROM staff FETCH FIRST 10 ROWS ONLY
  • 使用DISTINCT字句来排除重复行。
SELECT DISTINCT dept, job FROM staff
  • AS为结果列赋予一个新的名字
SELECT name, salary+comm AS pay FROM staff

如果没有AS语句的话,列名可能会是salary + comm

使用INSERT语句向表或视图中添加新行

  • 适用对象:

    • 视图
      向视图中插入一行,视图所基于的表也会被插入数据。
INSERT INTO staff VALUES(1212,'ceny',20,'Sales',3)
INSERT INTO satff(id, name, dept, jod, years) 
  VALUES 
 (1212,'ceny',20,'Sales',3),
  (1213,'ceny',20,'Sales',3)

使用UPDATE语句来改变表或者视图中的数据

  • 适用对象:

    • 视图
UPDATE staff 
  SET dept=51, salary=7000
  WHERE id=750

或者

UPDATE staff 
  SET (dept,salary)=(51,7000)
  WHERE id=750

如果不指定WHERE字句,就会更新表或者视图的每一行

使用DELETE语句来删除数据

DELETE FROM staff 
  WHERE id IN(1212,1213)

如果不指定WHERE字句,DB2会把表或者视图中的所有行删除掉

使用CREATE语句创建新的数据库对象

  • 创建的数据库对象包括

    • 缓冲池
    • 事件监听器
    • 函数
    • 索引
    • 模式
    • 存储过程
    • 表空间
    • 触发器
    • 视图

    每当用户创建数据库对象时,都会更新系统目录。

CREATE TABLE student(
  stdid INTEGER NOT NULL,
  name VARCHAR(5),
  local VARCHAR(13)
) 

使用DECLARE语句生成新的数据库对象

  • 用DECLARE创建的是只能在数据库连接期间存在的临时表。当要用到中间结果时,临时表很有用。
  • 声明的表可以被引用、修改和删除。
  • 表是唯一一个可以被声明的数据库对象。
  • 当用户声明临时表时,系统目录不会被更新。
DECLARE GLOBAL TEMPORORY TABLE session.temp1
  LIKE employee
  ON COMMIT PRESERVE ROWS
  NOT LOGGED
 IN mytempspace
  • DECLARE GLOBAL TEMPRORY TABLE声明一个临时表
  • temp1为表名,列名同employee
  • mytempspace为临时表空间(用户的临时表空间必须存在)
  • 每当处理COMMIT语句时,临时表中的行就会被保留下来(不会被删除)
  • session为模式,临时表必须由模式名显示限定,因为每个定义声明过的表的会话对该临时表都有自己的(可能是唯一的)描述

使用ALTER语句来改变数据库对象

  • ALTER语句可以用来改变现有数据库对象的一些特性,包括:

    • 缓冲池
    • 模式
    • 表空间
    • 触发器
    • 视图

不可以修改索引,如果想要改变索引,那么必须删除它然后用不同的定义创建一个新的。

   ALTER TABLE org
     ADD state char(2)

使用DROP语句来去掉数据库对象

可以删除任何CREATE和DECLARE语句创建的对象。

DROP TABLE org

DROP语句从系统目录中删除对象的定义,所以也从数据库本身中删除了表。数据库对象可能会依赖其他的数据库对象,所以删除对象可能会使有关的对象变成无效的。

  • 使用GRANT语句授予权限

    调用grant语句,权限和特权可以被显示授予单个的用户或者组。其中,可授出的对象包括数据库、表空间、表、视图、索引、包和模式。

    GRANT privilege ON object-type object-name TO [{USER|GROUP|PUBLIC}] 
    authorization-name [WITH GRANT OPTION]
    如,GRANT CONTROL ON TABLE students TO USER ccpt
    GRANT INSERT,UPDATE,DELETE ON TABLE students TO USER ccpt WITH GRANT 
    OPTION
    • 其中,PUBLIC是将特权授权给所有用户。
    • WITH GRANT OPTION是允许authorization-name将特权授权给其他用户。
    • 如果用户拥有包含students表的数据库上的SYSADM和DBADM或者students表的CONTROL特权,那么这个用户已经拥有授予students表上的INSERT,UPDATE,DELETE特权的权限了。
  • 使用REVOKE语句撤销权限

    调用revoke语句,可以将特权从单个的用户或者组显示撤销。可撤销的对象同上。

    REVOKE privilege ON object-type obect-name FROM [{USER|GROUP|PUBLIC}] 
    authorization-name
    • 撤销所有特权,可以用ALL
    REVOKE ALL PRIVILEGES ON TABLE students FROM ccpt
    • 必须拥有包含students表的数据库上的SYSADM和DBADM或者students表的CONTROL特权才能让用户撤销该对象上的特权,WITH GRANT OPTOION并不可以
    • 如果组内的任何成员曾作为个体或者另外一个组的成员被授予过权限,那么使用...FROM GROUP ...不能撤销其特权。