Oracle PL/SQL中两大数据类型:标量类型与复合类型

DECLARE
  v_int   PLS_INTEGER := 100;
  v_num   NUMBER(5,2) := 123.456; -- 自动四舍五入为 123.46
  v_simple SIMPLE_INTEGER := 2147483647;
BEGIN
  DBMS_OUTPUT.PUT_LINE('PLS_INTEGER: ' || v_int);
  DBMS_OUTPUT.PUT_LINE('NUMBER(5,2): ' || v_num); -- 输出 123.46
  -- v_simple := v_simple + 1; -- 若取消注释，运行时报 VALUE_ERROR（溢出）
END;

DECLARE
  v_char    CHAR(5)      := 'Hi';
  v_varchar VARCHAR2(5)  := 'Hi';
BEGIN
  DBMS_OUTPUT.PUT_LINE('CHAR length: ' || LENGTH(v_char));     -- 输出 5（含2空格）
  DBMS_OUTPUT.PUT_LINE('VARCHAR2 length: ' || LENGTH(v_varchar)); -- 输出 2
  DBMS_OUTPUT.PUT_LINE('CHAR = VARCHAR2? ' || 
    CASE WHEN v_char = v_varchar THEN 'YES' ELSE 'NO' END); -- 输出 YES（因自动补空格）
END;

DECLARE
  v_flag BOOLEAN := TRUE;
  v_result VARCHAR2(5);
BEGIN
  IF v_flag THEN
    v_result := 'YES';
  ELSE
    v_result := 'NO';
  END IF;
  DBMS_OUTPUT.PUT_LINE(v_result);
  -- ❌ 错误！不能在 SQL 中直接使用 BOOLEAN
  -- SELECT * FROM employees WHERE is_active = v_flag;
  -- ✅ 正确：转换为 SQL 可识别类型
  FOR r IN (
    SELECT employee_id, first_name 
    FROM employees 
    WHERE (v_flag AND is_active = 'Y') OR (NOT v_flag AND is_active = 'N')
  ) LOOP
    NULL;
  END LOOP;
END;

// Java 示例：安全读取 BOOLEAN 语义字段
String sql = "SELECT employee_id, is_active FROM employees WHERE department_id = ?";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setInt(1, 10);
    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            int id = rs.getInt("employee_id");
            // 方案1：CHAR(1) 映射
            String isActiveStr = rs.getString("is_active");
            boolean isActive = "Y".equals(isActiveStr); // 安全，null-safe
            // 方案2：NUMBER(1) 映射（更紧凑）
            // int isActiveNum = rs.getInt("is_active"); // 注意：getInt() 对 null 返回 0！
            // boolean isActive = rs.wasNull() ? false : (isActiveNum == 1);
        }
    }
}

-- 创建带时区的表
CREATE TABLE event_log (
  id         NUMBER PRIMARY KEY,
  event_time TIMESTAMP WITH LOCAL TIME ZONE,
  description VARCHAR2(200)
);
-- 插入（会话时区为 +08:00）
INSERT INTO event_log VALUES (1, TIMESTAMP '2023-01-01 10:00:00', 'User login');
-- 查询（会话时区为 -05:00）→ 显示 2023-01-01 01:00:00
SELECT id, event_time, description FROM event_log;

// Java 读取 TIMESTAMP WITH LOCAL TIME ZONE（自动适配 JVM 时区）
String sql = "SELECT event_time FROM event_log WHERE id = ?";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setInt(1, 1);
    try (ResultSet rs = ps.executeQuery()) {
        if (rs.next()) {
            // ✅ 推荐：使用 OffsetDateTime 获取原始时区信息
            OffsetDateTime odt = rs.getObject("event_time", OffsetDateTime.class);
            System.out.println("Event time (with zone): " + odt); 
            // 输出类似：2023-01-01T01:00:00-05:00
            // ⚠️ 注意：LocalDateTime 会丢失时区！仅取本地视图
            LocalDateTime ldt = rs.getObject("event_time", LocalDateTime.class);
            System.out.println("Local view only: " + ldt); // 2023-01-01T01:00:00
        }
    }
}

DECLARE
  v1 NUMBER := 100; -- 分配在调用栈帧
  v2 VARCHAR2(100) := 'Hello World'; -- 同上，100字节栈空间
BEGIN
  DECLARE
    v3 PLS_INTEGER := 200; -- 新栈帧，独立生命周期
  BEGIN
    NULL;
  END; -- v3 栈空间在此释放
  -- v3 已不可访问
END; -- v1, v2 栈空间在此释放

-- 示例：三种 RECORD 声明与使用
DECLARE
  -- 1. 基于表
  dept_rec departments%ROWTYPE;
  -- 2. 基于游标
  CURSOR emp_cur IS 
    SELECT e.employee_id, e.first_name, d.department_name 
    FROM employees e JOIN departments d ON e.department_id = d.department_id;
  emp_cur_rec emp_cur%ROWTYPE;
  -- 3. 自定义 RECORD
  TYPE address_t IS RECORD (
    street VARCHAR2(100),
    city   VARCHAR2(50),
    zip    VARCHAR2(20)
  );
  TYPE person_t IS RECORD (
    id       NUMBER,
    full_name VARCHAR2(100),
    addr     address_t, -- ✅ 复合类型嵌套！
    is_active BOOLEAN
  );
  person_rec person_t;
BEGIN
  -- 查询部门（基于表 RECORD）
  SELECT * INTO dept_rec 
  FROM departments 
  WHERE department_id = 10;
  DBMS_OUTPUT.PUT_LINE('Dept: ' || dept_rec.department_name);
  -- 打开游标（基于游标 RECORD）
  OPEN emp_cur;
  FETCH emp_cur INTO emp_cur_rec;
  DBMS_OUTPUT.PUT_LINE('Emp: ' || emp_cur_rec.first_name || ' in ' || emp_cur_rec.department_name);
  CLOSE emp_cur;
  -- 使用自定义 RECORD
  person_rec.id := 1001;
  person_rec.full_name := 'Alice Johnson';
  person_rec.addr.street := '123 Main St';
  person_rec.addr.city := 'San Francisco';
  person_rec.is_active := TRUE;
  DBMS_OUTPUT.PUT_LINE('Person: ' || person_rec.full_name || ', City: ' || person_rec.addr.city);
END;

-- PL/SQL 过程：返回员工基本信息（解构为多个 OUT 参数）
CREATE OR REPLACE PROCEDURE get_employee_info(
  p_emp_id    IN  employees.employee_id%TYPE,
  p_first_name OUT employees.first_name%TYPE,
  p_last_name  OUT employees.last_name%TYPE,
  p_salary     OUT employees.salary%TYPE,
  p_dept_name  OUT departments.department_name%TYPE
) AS
BEGIN
  SELECT e.first_name, e.last_name, e.salary, d.department_name
  INTO p_first_name, p_last_name, p_salary, p_dept_name
  FROM employees e
  JOIN departments d ON e.department_id = d.department_id
  WHERE e.employee_id = p_emp_id;
END;

// Java 调用解构式 OUT 参数
String sql = "{CALL get_employee_info(?, ?, ?, ?, ?)}";
try (CallableStatement cs = conn.prepareCall(sql)) {
    cs.setInt(1, 101); // IN 参数
    cs.registerOutParameter(2, Types.VARCHAR); // first_name
    cs.registerOutParameter(3, Types.VARCHAR); // last_name
    cs.registerOutParameter(4, Types.DECIMAL); // salary
    cs.registerOutParameter(5, Types.VARCHAR); // dept_name
    cs.execute();
    String firstName = cs.getString(2);
    String lastName = cs.getString(3);
    BigDecimal salary = cs.getBigDecimal(4);
    String deptName = cs.getString(5);
    System.out.printf("Employee: %s %s, Salary: %s, Dept: %s%n", 
                      firstName, lastName, salary, deptName);
}

-- 创建 ADDRESS OBJECT TYPE
CREATE OR REPLACE TYPE address_obj AS OBJECT (
  street VARCHAR2(100),
  city   VARCHAR2(50),
  zip    VARCHAR2(20)
);
-- 创建 PERSON OBJECT TYPE（含 REF）
CREATE OR REPLACE TYPE person_obj AS OBJECT (
  id        NUMBER,
  full_name VARCHAR2(100),
  addr      address_obj,
  dept_ref  REF dept_obj -- 假设存在 dept_obj
);

// Java 注册 STRUCT 类型（需在连接后执行一次）
conn.getTypeMap().put("HR.PERSON_OBJ", PersonObj.class); // 自定义 Java 类
// 调用返回 PERSON_OBJ 的函数
String sql = "{? = CALL get_person(?)}";
try (CallableStatement cs = conn.prepareCall(sql)) {
    cs.registerOutParameter(1, OracleTypes.STRUCT, "HR.PERSON_OBJ");
    cs.setInt(2, 1001);
    cs.execute();
    // 获取 STRUCT 并转换为 Java 对象
    STRUCT struct = (STRUCT) cs.getObject(1);
    Object[] attrs = struct.toJdbc(); // [id, full_name, address_obj, dept_ref]
    PersonObj person = new PersonObj(
        ((BigDecimal) attrs[0]).longValue(),
        (String) attrs[1],
        (AddressObj) attrs[2], // 自动映射
        (DeptRef) attrs[3]
    );
}

DECLARE
  -- 整数键关联数组
  TYPE emp_id_tab IS TABLE OF employees.employee_id%TYPE INDEX BY PLS_INTEGER;
  emp_ids emp_id_tab;
  -- 字符串键关联数组（类似 Map）
  TYPE dept_map IS TABLE OF departments.department_name%TYPE INDEX BY VARCHAR2(30);
  dept_names dept_map;
BEGIN
  -- 使用整数键
  emp_ids(1) := 101;
  emp_ids(5) := 105;
  emp_ids(10) := 110;
  -- 使用字符串键
  dept_names('HR') := 'Human Resources';
  dept_names('IT') := 'Information Technology';
  -- 遍历整数键数组（需用 FIRST/NEXT）
  DECLARE
    l_idx PLS_INTEGER := emp_ids.FIRST;
  BEGIN
    WHILE l_idx IS NOT NULL LOOP
      DBMS_OUTPUT.PUT_LINE('Emp ID at index ' || l_idx || ': ' || emp_ids(l_idx));
      l_idx := emp_ids.NEXT(l_idx);
    END LOOP;
  END;
  -- 遍历字符串键数组
  DECLARE
    l_key VARCHAR2(30) := dept_names.FIRST;
  BEGIN
    WHILE l_key IS NOT NULL LOOP
      DBMS_OUTPUT.PUT_LINE('Dept ' || l_key || ': ' || dept_names(l_key));
      l_key := dept_names.NEXT(l_key);
    END LOOP;
  END;
END;

-- 1. 创建嵌套表类型
CREATE OR REPLACE TYPE phone_list AS TABLE OF VARCHAR2(20);
-- 2. 创建含嵌套表的表
CREATE TABLE customers (
  id     NUMBER PRIMARY KEY,
  name   VARCHAR2(100),
  phones phone_list
) NESTED TABLE phones STORE AS phones_store;
-- 3. PL/SQL 中使用
DECLARE
  v_phones phone_list := phone_list('123-456-7890', '098-765-4321');
BEGIN
  INSERT INTO customers VALUES (1, 'John Doe', v_phones);
  -- 更新：添加新号码
  UPDATE customers 
  SET phones = phone_list('123-456-7890', '098-765-4321', '555-123-4567')
  WHERE id = 1;
END;
-- 4. SQL 中查询嵌套表
SELECT c.name, p.column_value AS phone
FROM customers c, TABLE(c.phones) p;
-- 返回：
-- John Doe | 123-456-7890
-- John Doe | 098-765-4321
-- John Doe | 555-123-4567

-- 创建 VARRAY 类型
CREATE OR REPLACE TYPE skill_array AS VARRAY(5) OF VARCHAR2(30);
-- 表中使用
CREATE TABLE developers (
  id     NUMBER PRIMARY KEY,
  name   VARCHAR2(100),
  skills skill_array
);
-- PL/SQL 使用
DECLARE
  v_skills skill_array := skill_array('Java', 'PL/SQL', 'SQL');
BEGIN
  INSERT INTO developers VALUES (1, 'Alice', v_skills);
  -- ✅ 合法：未超上限
  -- v_skills.EXTEND; v_skills(v_skills.COUNT) := 'Python'; 
  -- ❌ 运行时报错：ORA-22165: given index [4] must be in range of [1] to [3]
  -- v_skills(4) := 'Python';
END;

// Java 调用返回 VARRAY 的函数
String sql = "{? = CALL get_top_skills(?)}"; // 返回 skill_array
try (CallableStatement cs = conn.prepareCall(sql)) {
    cs.registerOutParameter(1, OracleTypes.ARRAY, "SKILL_ARRAY");
    cs.setInt(2, 1001);
    cs.execute();
    ARRAY array = (ARRAY) cs.getArray(1);
    String[] skills = (String[]) array.getArray(); // 直接转 Java 数组
    System.out.println("Top skills: " + Arrays.toString(skills));
}
// 插入 NESTED TABLE（需构造 ARRAY 对象）
String[] phones = {"123-456-7890", "098-765-4321"};
ARRAY phoneArray = ((OracleConnection) conn).createARRAY("PHONE_LIST", phones);
String insertSql = "INSERT INTO customers VALUES (?, ?, ?)";
try (PreparedStatement ps = conn.prepareStatement(insertSql)) {
    ps.setInt(1, 2);
    ps.setString(2, "Jane Smith");
    ps.setArray(3, phoneArray); // 绑定 ARRAY
    ps.executeUpdate();
}

-- 1. 创建 ADDRESS 对象类型（无方法）
CREATE OR REPLACE TYPE address_obj AS OBJECT (
  street VARCHAR2(100),
  city   VARCHAR2(50),
  state  CHAR(2),
  zip    VARCHAR2(10)
);
-- 2. 创建 PERSON 对象类型（含构造函数和成员函数）
CREATE OR REPLACE TYPE person_obj AS OBJECT (
  id        NUMBER,
  first_name VARCHAR2(50),
  last_name  VARCHAR2(50),
  birth_date DATE,
  addr       address_obj,
  -- 构造函数（必须与类型同名）
  CONSTRUCTOR FUNCTION person_obj(
    self IN OUT NOCOPY person_obj,
    id NUMBER,
    first_name VARCHAR2,
    last_name VARCHAR2,
    birth_date DATE DEFAULT NULL,
    addr address_obj DEFAULT NULL
  ) RETURN SELF AS RESULT,
  -- 成员函数（可修改属性）
  MEMBER FUNCTION get_full_name RETURN VARCHAR2,
  MEMBER FUNCTION get_age RETURN NUMBER,
  MEMBER PROCEDURE set_address(new_addr address_obj)
);
/
-- 3. 实现类型体
CREATE OR REPLACE TYPE BODY person_obj AS
  CONSTRUCTOR FUNCTION person_obj(
    self IN OUT NOCOPY person_obj,
    id NUMBER,
    first_name VARCHAR2,
    last_name VARCHAR2,
    birth_date DATE DEFAULT NULL,
    addr address_obj DEFAULT NULL
  ) RETURN SELF AS RESULT IS
  BEGIN
    self.id := id;
    self.first_name := first_name;
    self.last_name := last_name;
    self.birth_date := birth_date;
    self.addr := addr;
    RETURN;
  END;
  MEMBER FUNCTION get_full_name RETURN VARCHAR2 IS
  BEGIN
    RETURN self.first_name || ' ' || self.last_name;
  END;
  MEMBER FUNCTION get_age RETURN NUMBER IS
  BEGIN
    IF self.birth_date IS NULL THEN
      RETURN NULL;
    ELSE
      RETURN FLOOR(MONTHS_BETWEEN(SYSDATE, self.birth_date) / 12);
    END IF;
  END;
  MEMBER PROCEDURE set_address(new_addr address_obj) IS
  BEGIN
    self.addr := new_addr;
  END;
END;
/

DECLARE
  -- 创建对象实例（调用构造函数）
  v_person person_obj := person_obj(
    id => 1001,
    first_name => 'Alice',
    last_name => 'Johnson',
    birth_date => DATE '1990-05-15',
    addr => address_obj('123 Main St', 'San Francisco', 'CA', '94105')
  );
  -- 或用 NEW（Oracle 12c+）
  -- v_person person_obj := NEW person_obj(1001, 'Alice', 'Johnson', ...);
BEGIN
  DBMS_OUTPUT.PUT_LINE('Full name: ' || v_person.get_full_name());
  DBMS_OUTPUT.PUT_LINE('Age: ' || v_person.get_age());
  -- 调用成员过程
  v_person.set_address(address_obj('456 Oak Ave', 'Palo Alto', 'CA', '94301'));
  DBMS_OUTPUT.PUT_LINE('New city: ' || v_person.addr.city);
END;

// Java 定义匹配的 POJO（需 public fields 或 getters/setters）
public class AddressObj implements SQLData {
    public String street;
    public String city;
    public String state;
    public String zip;
    @Override
    public void readSQL(SQLInput stream, String typeName) throws SQLException {
        this.street = stream.readString();
        this.city = stream.readString();
        this.state = stream.readString();
        this.zip = stream.readString();
    }
    @Override
    public void writeSQL(SQLOutput stream) throws SQLException {
        stream.writeString(street);
        stream.writeString(city);
        stream.writeString(state);
        stream.writeString(zip);
    }
}
public class PersonObj implements SQLData {
    public long id;
    public String firstName;
    public String lastName;
    public java.sql.Date birthDate;
    public AddressObj addr;
    @Override
    public void readSQL(SQLInput stream, String typeName) throws SQLException {
        this.id = stream.readLong();
        this.firstName = stream.readString();
        this.lastName = stream.readString();
        this.birthDate = stream.readDate();
        this.addr = (AddressObj) stream.readObject(); // 递归读取嵌套对象
    }
    @Override
    public void writeSQL(SQLOutput stream) throws SQLException {
        stream.writeLong(id);
        stream.writeString(firstName);
        stream.writeString(lastName);
        stream.writeDate(birthDate);
        stream.writeObject(addr);
    }
}

// 注册类型映射并调用
conn.getTypeMap().put("HR.ADDRESS_OBJ", AddressObj.class);
conn.getTypeMap().put("HR.PERSON_OBJ", PersonObj.class);
String sql = "{? = CALL create_person(?)}";
try (CallableStatement cs = conn.prepareCall(sql)) {
    cs.registerOutParameter(1, OracleTypes.STRUCT, "HR.PERSON_OBJ");
    cs.setString(2, "Bob Smith");
    cs.execute();
    // 自动反序列化为 PersonObj 实例
    PersonObj person = (PersonObj) cs.getObject(1);
    System.out.printf("Created: %s, Age: %d, City: %s%n", 
                      person.firstName + " " + person.lastName,
                      person.getAge(), // 可调用业务方法
                      person.addr.city);
}

DECLARE
  v_date DATE := TO_DATE('2023-01-01', 'YYYY-MM-DD'); -- ✅ 显式格式
  v_num  NUMBER := TO_NUMBER('123.45'); -- ✅ 无格式，依赖 NLS_NUMERIC_CHARACTERS
  v_rec  employees%ROWTYPE;
  v_xml  CLOB;
BEGIN
  SELECT * INTO v_rec FROM employees WHERE ROWNUM = 1;
  -- 将 RECORD 转为 XML（需先构造查询）
  v_xml := SYS.DBMS_XMLGEN.GETXML(
    'SELECT ' || v_rec.employee_id || ' id, ''' || v_rec.first_name || ''' name FROM DUAL'
  );
  DBMS_OUTPUT.PUT_LINE('XML: ' || DBMS_LOB.SUBSTR(v_xml, 200, 1));
END;

// ✅ 正确处理 CLOB：流式读取，避免 OOM
String sql = "SELECT resume FROM candidates WHERE id = ?";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
    ps.setInt(1, 123);
    try (ResultSet rs = ps.executeQuery()) {
        if (rs.next()) {
            Clob clob = rs.getClob("resume");
            if (clob != null) {
                try (Reader reader = clob.getCharacterStream()) {
                    char[] buffer = new char[4096];
                    int len;
                    StringBuilder content = new StringBuilder();
                    while ((len = reader.read(buffer)) != -1) {
                        content.append(buffer, 0, len);
                    }
                    System.out.println("Resume length: " + content.length());
                }
            }
        }
    }
}