Question

如果我们将对象变量设置为pl / sql中的其他对象变量，则克隆该对象，因为pl / sql不能使用引用。例如，以下代码将打印两个不同的句子：

create or replace type cla as object    -- class (would be very complex)
(
  name  varchar2(50)
);

declare
    o1 cla;
    o2 cla;
begin
    o1 := cla('hi cloning world');
    o2 := o1;
    o1.name = 'goodbye cloning world';

    dbms_output.put_line('o1.name: ' || o1.name);
    dbms_output.put_line('o2.name: ' || o2.name);
end;

所以我认为我可以将对象封装到其他对象（外部对象）中，如果我将外部对象分配给其他外部对象，那么内部对象就不会被克隆：

create or replace type cla as object    -- class (would be very complex)
(
  name  varchar2(10)
);

create or replace type eo_c as object   -- class to encapsulate objects
(
  o  cla                                -- encapsulation is easy
);

declare
    eo eo_c;
    eo2 eo_c;
begin
    eo := eo_c( cla('n1') );            -- eo is easy to create
    dbms_output.put_line('eo.name: ' || eo.o.name); -- real object is easy to access

    eo2 := eo;      -- eo_c object is cloned, cla object shouldn't be cloned
    eo.o.name := 'n2';      -- if eo.o == eo2.o then we are changing both names
    dbms_output.put_line('eo.name: '  || eo.o.name);
    dbms_output.put_line('eo2 name: ' || eo2.o.name);
end;

但是再次打印两个不同的句子，所以内部对象也被克隆了。

我可以将对象封装到其他类型的变量中以避免克隆内部对象吗？或者更一般地说，是否有一些技巧可以避免克隆对象，同时允许一种简单的方法来处理它？</ p>

Answer 1

基于Alex建议（使用关联数组），我创建了一个封装对象的包，因此我们可以以抽象的方式使用它们，就像它们是引用一样：

create or replace type cla as object        -- complex class
(
    name varchar2(10)
);


create or replace package eo as     -- package to encapsulate objects
    type ao_t                       -- type for hash (associative array)
        is table of cla
        index by varchar2(100);
    o ao_t;                         -- hash of objects
end;


declare
    o1 varchar2(100);
    o2 varchar2(100);
begin
    o1 := 'o1';                         -- objects are hash indexes now
    eo.o(o1) := new cla('hi');          -- store new object into the hash
    o2 := o1;                           -- assign object == assign index
    eo.o(o1).name := 'bye';             -- change object attribute

    dbms_output.put_line('eo.o(o1).name: ' || eo.o(o1).name);
    dbms_output.put_line('eo.o(o2).name: ' || eo.o(o2).name);   -- equal?
end;

现在'bye'被写入两次，与对象引用一样。诀窍是o1和o2都包含相同对象的相同索引（〜reference）。语法有点复杂，但在访问属性和方法时仍然非常类似于标准对象操作。

将对象分配给其他对象与分配标准对象完全相同：

o2 := o1;

将对象用作函数参数：

afunc(o1);

在内部，afunc（）只会使用具有相同特殊语法的o1来访问方法或属性（并且没有特殊的语法来分配）：

eo.o(o1).attrib := 5;
eo.o(o1).method('nice');
o3 := o1;

使用此技巧的唯一要求是为我们要封装的每个类的eo包添加一个哈希（类型和变量）。

更新：基于变量名称的索引值：

o1 := 'o1';

例如，如果我们在函数中创建对象，则

可能是个问题，因为函数必须知道程序其余部分中使用的所有值，以避免重复某个值。解决方案是从散列大小中获取值：

o1 := eo.o.count;

这将我们引入其他问题：哈希内容是persitent（因为它是一个包），因此当我们创建对象时，越来越多的对象将被添加到哈希中（即使对象是由相同的函数创建的））。一个解决方案是在完成对象时从哈希中删除对象：

eo.o(o1) = null;

所以固定的程序将是：

create or replace type cla as object        -- complex class
(
    name varchar2(10)
);


create or replace package eo as     -- package to encapsulate objects
    type ao_t                       -- type for hash (associative array)
        is table of cla
        index by varchar2(100);
    o ao_t;                         -- hash of objects
end;


declare
    o1 varchar2(100);
    o2 varchar2(100);
begin
    o1 := eo.o.count;                   -- index based on hash size
    eo.o(o1) := new cla('hi');          -- store new object into the hash
    o2 := o1;                           -- assign object == assign index
    eo.o(o1).name := 'bye';             -- change object attribute

    dbms_output.put_line('eo.o(o1).name: ' || eo.o(o1).name);
    dbms_output.put_line('eo.o(o2).name: ' || eo.o(o2).name);   -- equal?

    eo.o(o1) = null;                    -- remove object
    eo.o(o2) = null;                    -- remove object (redundant)
end;

PL / SQL：避免克隆对象的任何技巧？

1 个答案: