首页 > 其他分享 >KingbaseES 对象状态规则总结

KingbaseES 对象状态规则总结

时间：2024-07-26 11:08:45浏览次数：11  
标签：总结 依赖 对象 本例 --- 规则 TABLE KingbaseES ALTER

KingbaseES 的PLSQL对象包括函数、存储过程、触发器、包、包体、对象类型、对象类型体和匿名块，其中匿名块即用即销，不具有状态属性，SQL中存在依赖的常见对象是表，视图，索引，自定义类型，自定义操作符等等。在使用编码过程会存在相互引用和被引用，就会导致对象的增删改无法“顺利”进行，本文针对V9版本开始支持的对象状态功能进行说明。

1，配置参数

1.1 配置说明

KingbaseES的PLSQL对象状态的启动功能，可以通过ora_func_style参数控制。ora_func_style为user级别的boolean型参数，默认为false，即不开启对象状态功能。参数开启后可以用来记录对象的状态有效或者无效，同时解除一些对象之间的强依赖关系，使用户能够修改或者删除依赖的对象。配置具体如下：

  1. 通过set命令进行配置，该配置是session级，session退出后将不再生效

set ora_func_style to on;

  1. 通过kingbase.conf进行配置，添加一下语句到配置文件末尾并保存，该配置是全局生效。

ora_func_style=on;

需要说明的是：

1，ora_func_style开启为ON后，plsql.compile_checks在创建对象时被启用进行相应的对象存在与否检查，不管这个参数是否被开启，因此你可能会看到创建PLSQL对象时原本不报错的地方现在会报错，比如xxx无效，xxx缺失。

2，ora_func_style开启为ON后，如果创建对象A时，缺失依赖对象B，此时A虽然能入库但是会是无效对象且报错。当B成功创建后A将自动恢复成有效，运行正常。

1.2 名词解释

为了更好的理解依赖关系问题，我们定义一些名词：

名词 说明
PL对象头 1. 其中函数，存储过程，触发器的创建语句中AS关键字到CREATE之间的语句；
2. 对包和对象类型而言，包头和对象类型头整个创建语句，即整个CREATE PACKAGE/TYPE到END的语句。
PL对象体 1. 其中函数，存储过程，触发器的创建语句中AS关键字到END之间的语句；
2. 对包和对象类型而言，包体和对象类型体的整个创建语句，即整个CREATE PACKAGE/TYPE BODY到END的语句。
其他对象头 可以简单把上述PL对象以外的都归类为其他对象头，比如自定义集合类型（CREATE TYPE）,创建索引(CREATE INDEX)，自定义操作符等等，整个完整的创建语句都是对象头结构。
主对象 当前引用其他数据库对象的对象 ，比如函数索引中的索引就是主对象，索引函数就是依赖对象
依赖对象 被主对象引用的其他数据库对象
强依赖关系 主对象不受影响，但依赖对象删除(DROP)、部分修改操作(ALTER)或者重建(CREATE OR REPLACE)会受到限制，需要先删除主对象或者使用级联删除(DROP…CASCADE)。
弱依赖关系 主对象不受影响，依赖对象的删除(DROP)、修改(ALTER)或者重建(CREATE OR REPLACE)操作不会受到任何限制。

2，依赖规则说明

KES的依赖关系总结为两大类，强依赖关系和弱依赖关系。

依赖关系的强弱只和主对象的类型以及涉及的结构(对象头还是对象体)有关，和依赖对象无关。

其中决定依赖关系的强弱的因素具体是：

  1. 主对象的类型，比如是PL包头，PL函数会产生不同强弱的依赖。
  2. 依赖对象在主对象的创建语句结构的哪部分被引用。

在启用或者关闭ora_func_style参数的两种情况下，KingbaseES中数据库对象的主对象和引用之间的依赖关系表现情况如下表 1：

表1 对象的依赖强弱规则表

NO 主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
1 函数/存储过程/触发器 对象头 NAN 强依赖关系 强依赖关系
2 函数/存储过程/触发器 对象体 NAN 弱依赖关系 弱依赖关系
3 包头，对象类型头 对象头 类型定义语句产生依赖 强依赖关系 强依赖关系
4 包头，对象类型头 对象头 其他内部对象头 弱依赖关系 强依赖关系
5 包体，对象类型体 对象体 NAN 弱依赖关系 弱依赖关系
6 SQL对象-视图 对象头 NAN 弱依赖关系 弱依赖关系
7 其余SQL对象 对象头 NAN 强依赖关系 强依赖关系

注意ora_func_style为ON或者OFF下的依赖关系，均是在该参数下创建的对象，产生依赖形成的关系。

以上就是目前KingbaseES的整体依赖关系表现情况。

3，依赖关系实例验证

​ 我们根据《表1 对象的依赖强弱规则表》逐一对弱关系情况进行说明。

情况1：在函数等的对象头中存在依赖的情况

本情况对应《表1 对象的依赖强弱规则表》中序号1的情况。

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
函数/存储过程 触发器 对象头 NAN 强依赖关系 强依赖关系

代码示例1-1：

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE OR REPLACE PROCEDURE PROC01(p1 TT01%ROWTYPE)   ---在对象头中产生了依赖
AS
DECLARE  
  VV INT;
BEGIN
  SELECT ID INTO VV FROM TT01 WHERE ID = 10;
END;

这个例子中，

主对象：存储过程PROC01，

依赖对象：是TT01，

依赖结构：存储过程PROC01的对象头引用了TT01，

依赖关系：强依赖关系。

操作限制：无法直接删除（主对象PROC01操作不受影响）。

其他：无论ora_func_style开启与否，均是强依赖关系。函数和触发器也是同理，不再累述。

一些测试，此场景DROP不被允许，但是ALTER操作还是被允许的：

---删除表
drop table tt04;     ----不可以，报错如下
ERROR:  cannot drop table tt01 because other objects depend on it
DETAIL:  procedure proc01(tt01) depends on type tt01
HINT:  Use DROP ... CASCADE to drop the dependent objects too.

---增加表字段，可以
ALTER TABLE TT01  ADD PID NUMBER;    ---本例可以执行
---删除表字段，可以
ALTER TABLE TT01 DROP COLUMN ID;     ---本例可以执行
---重命名表，
ALTER TABLE TT01 RENAME TO TT04;     ---本例可以执行（这个尽然都可以）
---重命名表字段
ALTER TABLE TT04 RENAME COLUMN name TO sal_name;      ---本例可以执行
---修改表字段类型
ALTER TABLE TT04 ALTER COLUMN sal_name TYPE varchar(40);  ---本例可以执行
---增加默认值
ALTER TABLE TT04 ALTER COLUMN sal_name SET DEFAULT 'zzzzz';    ---本例可以执行
---删除默认值
ALTER TABLE TT04 ALTER COLUMN sal_name DROP DEFAULT;   ---本例可以执行
---增加约束
ALTER TABLE TT04 ADD CHECK (sal_name <> '');   ---本例可以执行
ALTER TABLE TT04 ADD CONSTRAINT some_name UNIQUE (pid);   ---本例可以执行

说明：

这些alter操作之所以均被允许，是因为表的OID在修改(ALTER)后也不会改变，因此不会被强依赖限制。

但并不是所有强依赖关系时（依赖表），都能对表进行任意ALTER，包头(对象头)中游标依赖表算是一种特殊情况，就算表的OID在ALTER

时不做变动也不能修改。

如下代码示例1-2：

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE TYPE tab_typ IS TABLE OF int;

CREATE OR REPLACE PACKAGE pkg_test01 AS 
    t1 tab_typ := tab_typ();    ---在包头中对外部自定义类型产生依赖
    CURSOR vcur IS SELECT * FROM tt01 WHERE id > 0;    
END;

一些测试结果：
DROP TYPE tab_typ  ;
--执行结果：
SQL 错误 [2BP01]: 错误: 无法删除 类型 tab_typ 因为有其它对象倚赖它
  Detail: 包 pkg_test01 倚赖于 类型 tab_typ
  Hint: 使用 DROP .. CASCADE 把倚赖对象一并删除.

DROP TABLE tt01 ;
--执行结果：
SQL 错误 [2BP01]: 错误: 无法删除 表 tt01 因为有其它对象倚赖它
  Detail: 包 pkg_test01 倚赖于 表 tt01
  Hint: 使用 DROP .. CASCADE 把倚赖对象一并删除.

---增加表字段
ALTER TABLE TT01  ADD PID NUMBER;    ---本例不可以
---删除表字段
ALTER TABLE TT01 DROP COLUMN ID;     ---本例不可以
---重命名表，
ALTER TABLE TT01 RENAME TO TT04;     ---本例不可以
---重命名表字段
ALTER TABLE TT04 RENAME COLUMN name TO sal_name;      ---本例不可以
---修改表字段类型
ALTER TABLE TT04 ALTER COLUMN sal_name TYPE varchar(40);  ---本例不可以
---增加默认值
ALTER TABLE TT04 ALTER COLUMN sal_name SET DEFAULT 'zzzzz';    ---本例不可以
---删除默认值
ALTER TABLE TT04 ALTER COLUMN sal_name DROP DEFAULT;   ---本例不可以
---增加约束
ALTER TABLE TT04 ADD CHECK (sal_name <> '');   ---本例不可以
ALTER TABLE TT04 ADD CONSTRAINT some_name UNIQUE (pid);   ---本例不可以

值得一提的是本特殊案例，其实归属情况4，可以在ora_func_style开启为on时创建后，解除强依赖，变为弱依赖关系，届时可以对表进行ALTER和DROP操作。

情况2：在函数等的对象体中存在依赖的情况

本情况对应《表1 对象的依赖强弱规则表》中序号2的情况。

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
函数/存储过程 触发器 对象体 NAN 弱依赖关系 弱依赖关系

代码示例2：

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE OR REPLACE PROCEDURE PROC02
AS
DECLARE  
  VV INT;
  A1 TT01%ROWTYPE;   ---在函数的对象体中产生了依赖
  A2 TT01.ID%TYPE;   ---在函数的对象体中产生了依赖
BEGIN
  SELECT ID INTO VV FROM TT01 WHERE ID = 10;
END;

这个例子中，

主对象：存储过程PROC02，

依赖对象：TT01表

依赖结构：存储过程PROC01的对象体中引用了TT01，

依赖关系：弱依赖关系

操作限制：主对象和依赖对象的任何操作均不做限制

其他：无论ora_func_style开启与否，均是弱依赖关系。函数和触发器也是同理，不再累述。

一些测试（均被允许操作）：

---删除表
drop table tt01;     ----本例可以,因为是弱依赖
---增加表字段，可以
ALTER TABLE TT01  ADD PID NUMBER;    ---本例可以执行
---删除表字段，可以
ALTER TABLE TT01 DROP COLUMN ID;     ---本例可以执行
---重命名表，
ALTER TABLE TT01 RENAME TO TT04;     ---本例可以执行（这个尽然都可以）
---重命名表字段
ALTER TABLE TT04 RENAME COLUMN name TO sal_name;      ---本例可以执行
---修改表字段类型
ALTER TABLE TT04 ALTER COLUMN sal_name TYPE varchar(40);  ---本例可以执行
---增加默认值
ALTER TABLE TT04 ALTER COLUMN sal_name SET DEFAULT 'zzzzz';    ---本例可以执行
---删除默认值
ALTER TABLE TT04 ALTER COLUMN sal_name DROP DEFAULT;   ---本例可以执行
---增加约束
ALTER TABLE TT04 ADD CHECK (sal_name <> '');   ---本例可以执行
ALTER TABLE TT04 ADD CONSTRAINT some_name UNIQUE (pid);   ---本例可以执行

情况3：在包等对象头中存在依赖的情况A

本情况对应《表1 对象的依赖强弱规则表》中序号3的情况。想表达的意思是，当我们在包头，对象类型头中定义一个类型时，而这个类型对数据库中的其他数据类型产生了依赖，则是强依赖。此情况是很特殊的情况，无法通过ora_func_style解除强依赖限制。

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
包头，对象类型头 对象头 类型定义语句产生依赖 强依赖关系 强依赖关系

代码示例3：

CREATE TYPE tab_typ IS TABLE OF int;

CREATE OR REPLACE PACKAGE pkg_test01 AS 
    TYPE tab_typ2 IS TABLE OF tab_typ;
END;

这个例子中，

主对象：包pkg_test01，

依赖对象：类型tab_typ，

依赖结构：包头pkg_test01，即对象头

依赖关系：强依赖关系，

操作限制：tab_typ无法直接删除(DROP)，或者修改(ALTER)，主对象pkg_test01操作不受影响。

其他：无论ora_func_style开启与否，均是强依赖关系。对象类型(Object type)也是同理，不再累述。

一些测试：

DROP TYPE tab_typ ;

SQL 错误 [2BP01]: 错误: 无法删除 类型 tab_typ 因为有其它对象倚赖它
  Detail: 包 pkg_test01 倚赖于 类型 tab_typ
  Hint: 使用 DROP .. CASCADE 把倚赖对象一并删除.

情况4：在包等对象头中存在依赖的情况B

本情况对应《表1 对象的依赖强弱规则表》中序号4的情况。

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
包头，对象类型头 对象头 其他内部对象头 弱依赖关系 强依赖关系

从这个表可以看出，ora_func_style为off时原本是强依赖关系，可以在开启这个参数后变更为弱依赖关系，也就达成了对依赖对象的删除(DROP)，修改(ALTER)等操作。

代码示例4-1：ora_func_style为off时创建所有对象

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE TYPE tab_typ IS TABLE OF int;

CREATE OR REPLACE PACKAGE pkg_test01 AS 
    t1 tab_typ := tab_typ();    ---在包头中对外部自定义类型产生依赖
    t2 TT01%ROWTYPE ;          ---在包头中对外部普通表产生依赖
    FUNCTION func01() RETURN tab_typ;   ----产生依赖
END;

CREATE OR REPLACE PACKAGE BODY pkg_test01 AS 
    FUNCTION func01() RETURN tab_typ
    AS 
        tt2 tab_typ := tab_typ();
    BEGIN 
        tt2.extend();
        tt2(1) = 10;
        RETURN tt2;
    END;
END;

这个例子中，

主对象：包pkg_test01，

依赖对象：类型tab_typ，表TT01

依赖结构：包头pkg_test01，即对象头

依赖关系：强依赖关系(ora_func_style为off时)

操作限制：tt01和tab_typ无法直接删除(DROP)，主对象pkg_test01操作不受影响。

其他：对象类型(Object type)也是同理，不再累述。

一些测试：

DROP TYPE tab_typ ;

---执行结果如下
SQL 错误 [2BP01]: 错误: 无法删除 类型 tab_typ 因为有其它对象倚赖它
  Detail: 包 pkg_test01 倚赖于 类型 tab_typ
  Hint: 使用 DROP .. CASCADE 把倚赖对象一并删除.

DROP TABLE tt01 ;

---执行结果如下
SQL 错误 [2BP01]: 错误: 无法删除 表 tt01 因为有其它对象倚赖它
  Detail: 包 pkg_test01 倚赖于 类型 tt01
  Hint: 使用 DROP .. CASCADE 把倚赖对象一并删除.


---增加表字段，可以
ALTER TABLE TT01  ADD PID NUMBER;    ---本例可以执行
---删除表字段，可以
ALTER TABLE TT01 DROP COLUMN ID;     ---本例可以执行
---重命名表，
ALTER TABLE TT01 RENAME TO TT04;     ---本例可以执行
---重命名表字段
ALTER TABLE TT04 RENAME COLUMN name TO sal_name;      ---本例可以执行
---修改表字段类型
ALTER TABLE TT04 ALTER COLUMN sal_name TYPE varchar(40);  ---本例可以执行
---增加默认值
ALTER TABLE TT04 ALTER COLUMN sal_name SET DEFAULT 'zzzzz';    ---本例可以执行
---删除默认值
ALTER TABLE TT04 ALTER COLUMN sal_name DROP DEFAULT;   ---本例可以执行
---增加约束
ALTER TABLE TT04 ADD CHECK (sal_name <> '');   ---本例可以执行
ALTER TABLE TT04 ADD CONSTRAINT some_name UNIQUE (pid);   ---本例可以执行

代码示例4-2：ora_func_style为on时创建所有对象

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE TYPE tab_typ IS TABLE OF int;

CREATE OR REPLACE PACKAGE pkg_test01 AS 
    t1 tab_typ := tab_typ();    ---在包头中对外部自定义类型产生依赖
    t2 TT01%ROWTYPE ;          ---在包头中对外部普通表产生依赖
    FUNCTION func01() RETURN tab_typ;   ----产生依赖
END;

CREATE OR REPLACE PACKAGE BODY pkg_test01 AS 
    FUNCTION func01() RETURN tab_typ
    AS 
        tt2 tab_typ := tab_typ();
    BEGIN 
        tt2.extend();
        tt2(1) = 10;
        RETURN tt2;
    END;
END;

这个例子中，

主对象：包pkg_test01，

依赖对象：类型tab_typ，表TT01

依赖结构：包头pkg_test01，即对象头

依赖关系：弱依赖关系(ora_func_style为on时)

操作限制：依赖对象的操作不受限制，主对象pkg_test01操作不受影响。

其他：对象类型(Object type)也是同理，不再累述。这个场景实际上就是ora_func_style要针对和处理的场景，将强依赖变更为弱依赖。

一些测试：

DROP TYPE tab_typ;     ---本例可以
DROP TABLE tt01;     ---本例可以

CREATE TABLE TT01(ID INT,NAME VARCHAR(20));  ---删除后重新创建
INSERT INTO TT01 VALUES(10,'AAAA');
DROP TABLE tt04;

---增加表字段
ALTER TABLE TT01  ADD PID NUMBER;    ---本例可以
---删除表字段
ALTER TABLE TT01 DROP COLUMN ID;     ---本例可以
---重命名表，
ALTER TABLE TT01 RENAME TO TT04;     ---本例可以
---重命名表字段
ALTER TABLE TT04 RENAME COLUMN name TO sal_name;      ---本例可以
---修改表字段类型
ALTER TABLE TT04 ALTER COLUMN sal_name TYPE varchar(40);  ---本例可以
---增加默认值
ALTER TABLE TT04 ALTER COLUMN sal_name SET DEFAULT 'zzzzz';    ---本例可以
---删除默认值
ALTER TABLE TT04 ALTER COLUMN sal_name DROP DEFAULT;   ---本例可以
---增加约束
ALTER TABLE TT04 ADD CHECK (sal_name <> '');   ---本例可以
ALTER TABLE TT04 ADD CONSTRAINT some_name UNIQUE (pid);   ---本例可以

可以看出ora_func_style开启为ON此情况将转换为弱依赖情况，对依赖对象的操作不做限制。

情况5：在包等对象体中存在依赖的情况

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
包体，对象类型体 对象体 NAN 弱依赖关系 弱依赖关系

代码示例5：

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE TYPE tab_typ IS TABLE OF int;

CREATE OR REPLACE PACKAGE pkg_test01 AS 
    FUNCTION func01() RETURN int ;   ----产生依赖
END;

CREATE OR REPLACE PACKAGE BODY pkg_test01 AS 
    FUNCTION func01() RETURN int 
    AS 
        t1 tab_typ := tab_typ();    ---在包头中对外部自定义类型产生依赖
        t2 TT01%ROWTYPE ;          ---在包头中对外部普通表产生依赖
        t3 TT01.ID%TYPE ;          ---在包头中对外部普通表产生依赖
    BEGIN 
        t1.extend();
        t1(1) = 10;
        RETURN 1;
    END;
END;

这个例子中，

主对象：包pkg_test01，

依赖对象：是TT01表，tab_typ自定义类型

依赖结构：包pkg_test01体的函数func01，即对象体

依赖关系：弱依赖关系，

操作限制：依赖对象和主对象的操作均不受影响。

其他：无论ora_func_style开启与否，均是弱依赖关系。对象类型（Object Type）也是同理，不再累述。

一些测试：

DROP TYPE tab_typ;    --本例可以
DROP TABLE tt01;    --本例可以

CREATE TABLE TT01(ID INT,NAME VARCHAR(20));  ---删除后重新创建
INSERT INTO TT01 VALUES(10,'AAAA');

DROP TABLE tt04;
---增加表字段
ALTER TABLE TT01  ADD PID NUMBER;    ---本例可以
---删除表字段
ALTER TABLE TT01 DROP COLUMN ID;     ---本例可以
---重命名表，
ALTER TABLE TT01 RENAME TO TT04;     ---本例可以
---重命名表字段
ALTER TABLE TT04 RENAME COLUMN name TO sal_name;      ---本例可以
---修改表字段类型
ALTER TABLE TT04 ALTER COLUMN sal_name TYPE varchar(40);  ---本例可以
---增加默认值
ALTER TABLE TT04 ALTER COLUMN sal_name SET DEFAULT 'zzzzz';    ---本例可以
---删除默认值
ALTER TABLE TT04 ALTER COLUMN sal_name DROP DEFAULT;   ---本例可以
---增加约束
ALTER TABLE TT04 ADD CHECK (sal_name <> '');   ---本例可以
ALTER TABLE TT04 ADD CONSTRAINT some_name UNIQUE (pid);   ---本例可以

情况6：在视图中存在依赖的情况

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
视图 对象头 NAN 弱依赖关系 弱依赖关系

代码示例6：

CREATE OR REPLACE FUNCTION calculate_id(oldid int)  
RETURNS int 
AS 
BEGIN  
    RETURN oldid * 2 + 1;  
END;

DROP VIEW  IF EXISTS "tt01_view";
DROP TABLE  IF EXISTS  "TT01";
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE VIEW tt01_view AS  
SELECT  
    name,  
    calculate_id(id) AS newid  
FROM  
    tt01;

SELECT * FROM tt01_view;

因为是弱依赖，直接测试：

DROP FUNCTION calculate_id;  --可以执行

--提示
视图 tt01_view 倚赖于 function calculate_id(integer)

其他：此情况相当于是SQL对象作为主对象，在依赖其他对象时的一种特殊情况（其余情况可以参见情况7），只有这种情况是弱依赖。

如果是其他对象，比如索引(索引函数)，属于强依赖，将存在操作限制。

情况7：在其他SQL对象存在依赖的情况

主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
其余SQL对象 对象头 NAN 强依赖关系 强依赖关系

代码示例7：

DROP TABLE  IF EXISTS  TT01;
CREATE TABLE TT01(ID INT,NAME VARCHAR(20));
INSERT INTO TT01 VALUES(10,'AAAA');

CREATE INDEX tt01_name_upper ON TT01 (my_UPPER(name));

CREATE OR REPLACE FUNCTION my_UPPER(pname varchar)  
RETURNS varchar 
AS 
$$
BEGIN  
    RETURN upper(pname)  ;
END;
$$language plpgsql IMMUTABLE ;

一些测试：

DROP FUNCTION my_UPPER;

--执行后报错：
SQL 错误 [2BP01]: 错误: 无法删除 function my_upper(varchar) 因为有其它对象倚赖它
  Detail: 索引 tt01_name_upper 倚赖于 function my_upper(varchar)
  Hint: 使用 DROP .. CASCADE 把倚赖对象一并删除.

---支持重建 
CREATE OR REPLACE FUNCTION my_UPPER(pname varchar)  
RETURNS varchar 
AS 
$$
BEGIN  
    RETURN upper(pname) || 'aaa';
END;
$$language plpgsql IMMUTABLE ;

主对象：索引tt01_name_upper，

依赖对象：索引函数my_upper，

依赖结构：SQL对象，即对象头

依赖关系：强依赖关系，

操作限制：依赖对象的删除(DROP)，将受到限制。

其他：无论ora_func_style开启与否，均是强依赖关系。其他SQL对象不再累述。

4，总结

再次回到这张表：

表1 对象的依赖强弱规则表

NO 主对象类型 主对象结构类型 特殊说明 ora_func_style ora_func_style
1 函数/存储过程/触发器 对象头 NAN 强依赖关系 强依赖关系
2 函数/存储过程/触发器 对象体 NAN 弱依赖关系 弱依赖关系
3 包头，对象类型头 对象头 类型定义语句产生依赖 强依赖关系 强依赖关系
4 包头，对象类型头 对象头 其他内部对象头 弱依赖关系 强依赖关系
5 包体，对象类型体 对象体 NAN 弱依赖关系 弱依赖关系
6 SQL对象-视图 对象头 NAN 弱依赖关系 弱依赖关系
7 其余SQL对象 对象头 NAN 强依赖关系 强依赖关系

总体上归纳为：

  1. 如果ora_func_style为OFF时是弱依赖，那ora_func_style为ON也是弱依赖。

  2. KES中ora_func_style的核心作用就是解决表中序号为4的使用场景，将其置为弱依赖状态。

  3. 弱依赖关系，在对象体(创建语句中的执行语句区域)中产生的关系；弱依赖对主依赖对象和依赖对象的增删改都不做限制。

  4. 强依赖关系，在对象头(创建语句中的定义语句区域)中产生的关系；强依赖对主依赖对象不做限制，但对依赖对象的增删改有一些限

制(不允许直接删除，可能也会影响部分ALTER操作，并非所有的操作都不被允许)。

标签：总结,依赖,对象,本例,---,规则,TABLE,KingbaseES,ALTER
From： https://www.cnblogs.com/kingbase/p/18280380

相关文章

  • KingbaseES 自定义操作符使用示例
    本文详细介绍了KingbaseES中在兼容适配过程中，当遇到不支持的操作符，如何通过自定义方式解决兼容适配问题。Kingbase自定义操作符语法和用例如下：用例数据：createtabledemo(idnumeric(10,5));insertintodemovalues(1.1);insertintodemovalues(0);insertintodemoval......
  • KingbaseES 集群运维典型案例 03 --“双主” sys_rewind恢复机制
    案例说明：主库主机系统重启，触发failover切换，原主库系统启动后，数据库服务被启动，出现“双主”，使用“repmgrnoderejoin--force-rewind”恢复集群。通过本案例了解，集群“双主”产生的原因及解决方案，并熟悉sys_rewind在集群恢复中的应用。数据库版本：KingbaseESV8R6一、集群架构......
  • 代码随想录算法训练营第44天 | 动态规划9：买卖股票总结
    188.买卖股票的最佳时机IVhttps://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/description/代码随想录https://programmercarl.com/0188.买卖股票的最佳时机IV.html#算法公开课309.最佳买卖股票时机含冷冻期https://leetcode.cn/problems/best-time-to-buy-a......
  • 修改数据库的默认校对规则
    在Linux下，要修改MySQL服务器的默认字符集和校对规则，您需要按照以下步骤操作： ###1.查找MySQL配置文件 首先，您需要找到MySQL的配置文件。配置文件通常位于`/etc/mysql/my.cnf`或`/etc/my.cnf`。您可以使用`find`命令来查找它： ```bashsudofind/-namemy.cnf```......
  • 标识符的命名规则
    标识符：就是给类,接口,方法,变量等起名字时使用的字符序列起名字时的规则（法律）：1.英文大小写字母2.数字字符3.$和_起名字时的规范（道德）：1、不能以数字开头2、不能是关键字3、不能除$和_以外的特殊符号出现4、要见名知意(推荐是英语单词构成，拼音构成)常见......
  • Git版本管理及相关操作总结
    Git常用操作Git是开源的版本控制系统，常用于项目代码管理，文件管理等场景。Git的常见操作命令按照操作顺序介绍新建、管理远程仓库克隆、更新本地仓库副本上传本地修改、修改记录是每次上传更新的记录，一个修改记录可能包含多个文件的修改每个修改记录对应唯一的修改记录......
  • 【测试工作跳槽复习之工作总结】常规性能测试步骤经验总结
    业务功能测试通过了解被测业务以及业务需求和访问量①业务实际应用场景②日活③日最大用户数④日高低峰时段⑤用户期望性能等获取被测业务的性能指标（如果没有现成指标，可以按如下方法确定基准）①生产环境拉取性能基准③测试压测环境压测（7*24h），获取性能测试结果，再拉......
  • sql-DQL基础语句总结
    一·基础查询1.语法SELECT*|{[DISTINCT]column|expression[alias],...}FROMtable;select查询列表from表名;注意：（1）SELECT：标识选择哪些列（2）FROM：标识从哪个表中选择2、特点（1）查询列表可以是：表中的字段、常量值、表达式、函数。（2）查询的结果是一个虚拟的表格。二·......
  • 标识符定义以及命名规则（驼峰命名法）
    标识符定义：就是用来给类、方法、变量命名的名字要求：做到见名知意命名规则硬性要求组成：数字、字母、$和_（美元符和下划线）不能以数字开头不能使用关键字区分大小写软性要求——驼峰命名法（1）小驼峰命名法：方法、变量只有一个单词时、全部小写有多个单词时......
  • 7.25第二周周四学习总结
    算法竞赛（差分）（上午）初始化#include<algorithm>intarr[100];std::fill(arr,arr+100,0);//比memset更高效intarr[100]={};//所有元素都初始化为0栈溢出为局部变量每次运行时都在运行栈中分配，如果数组很大，结果会造成运行栈溢出，自然就运行不了另外，使用全局变......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99