• PL/SQL 训练09--面向对象


    ---对象基本声明、实现、使用
    --对象类型,类似与JAVA中的类,通俗的讲,就是捆绑了相关函数和过程的记录类型。

    ---对象声明
    --create type 创建一个对象类型的规范部分
    create or replace type hello_object as object (
     obj_name varchar2(100),
     constructor function hello_object return self as result, 
     constructor function hello_object(obj_name varchar2 /*:='world'*/) return self as result,
     member function to_string return varchar2
    ) instantiable not final;
    
    -- obj_name :实例变量
    -- constructor function:声明 构造函数,构造函数可以重载,但名字必须更类名称一致
    -- self as result : 构造函数总是返回一个对象实例,java中的this?
    
    -- member procedure/function:定义成员函数,成员函数只能用于对象实例
    -- not final   表示可以被继承
    -- instantiable:表示可实例化,如果指定NOT INSTANTIABLE ,则这种类型只能做一个基类
    --每个成员之间,使用逗号分隔
    --构造函数要尽可能多的给当前对象任何一个属性赋值

    --定义对象类型后,就可以创建对象体,跟创建包体规则一样

    --create type body 创建对象体
    create or replace type body hello_object as
     --默认构造方法 
     constructor function hello_object return self as result is
        v_obj hello_object := hello_object('generic object');
      begin
        self := v_obj;
        return;
      end hello_object;
       --重写构造方法
      constructor function hello_object(obj_name varchar2) return self as result is
      begin
        self.obj_name := obj_name;
        return;  -- 返回一个副本,即对象实例的当前内存引用
      end hello_object;
      --成员函数
      member function to_string return varchar2 is
      begin
        return 'hello,' || self.obj_name ;
      end to_string;
    
    end;
    /

    --不懂Java?self只不过是在编写成员方法时,用来引用调用当前对象的一个手段,可以用SELF指代对象自己,也可以
    --用句点法来引用对象的属性或者方法

    --缺省情况下,SELF是函数的IN 变量,是过程和构造函数的IN OUT变量 。怎么理解?
    --可以把SELF作为第一个形参来改变缺省模式


    --如果另外一个带参数的构造函数,使用了默认的入参,则这种构造函数,跟默认构造函数会有冲突
    --当调用无入参的构造函数构建对象时,会出现多个可调用的构造函数,引发混乱报错

    --使用对象类型

    select hello_object().to_string() from dual;
    select hello_object('world').to_string() from dual;
    
    declare
      v_obj hello_object := hello_object();
    begin
    
      dbms_output.put_line(v_obj.obj_name);
      dbms_output.put_line(v_obj.to_string());
    end;
    /
    
    --对象在运行时创建并丢弃,这种对象就叫做瞬态对象;有瞬态的就有持久型对象
    create table sample_object(persistent hello_object); --创建表,字段是对象类型
    insert into sample_object values( hello_object());
    insert into sample_object values( hello_object('world'));
    select * from  sample_object ;
    
    select t.persistent.obj_name from  sample_object  t ;
    --两种调用方式
    select t.persistent.to_string() from  sample_object  t ;
    select treat(t.persistent as hello_object).to_string() from  sample_object  t ;
    
    drop table sample_object;
    --实现getter和setter
    --getter是一个方法,可以达到对象内部获取一些信息,setter也是一个方法,可以发送信息到对象内部
    --设置实例变量
    create or replace type hello_object as object (
     obj_name varchar2(100),
     constructor function hello_object return self as result, 
     constructor function hello_object(obj_name varchar2/* :='world'*/) return self as result,
     member function to_string return varchar2,
     member function get_name return varchar2,
     member procedure set_name(i_name in varchar2)
    ) instantiable not final;
    
    create or replace type body hello_object as
     --默认构造方法 
     constructor function hello_object return self as result is
        v_obj hello_object := hello_object('generic object');
      begin
        self := v_obj;
        return;
      end hello_object;
       --重写构造方法
      constructor function hello_object(obj_name varchar2) return self as result is
      begin
        self.obj_name := obj_name;
        return;  -- 返回一个副本,即对象实例的当前内存引用
      end hello_object;
      --成员函数
      member function to_string return varchar2 is
      begin
        return 'hello,' || self.obj_name ;
      end to_string;
      member function get_name return varchar2 is 
      begin 
          return self.obj_name;
      end get_name;
      
       member procedure set_name(i_name in varchar2)is 
       begin 
         self.obj_name := i_name;
       end set_name;
    end;
    /
    declare
      v_obj hello_object := hello_object();
    begin
      dbms_output.put_line(v_obj.get_name());
      v_obj.set_name('test');
      dbms_output.put_line(v_obj.get_name());
      v_obj.obj_name :='ssdddee';
      dbms_output.put_line(v_obj.obj_name);
    end;
    /

    --实现静态方法

    create or replace type hello_object as object (
     obj_name varchar2(100),
     constructor function hello_object return self as result, 
     constructor function hello_object(obj_name varchar2/* :='world'*/) return self as result,
     member function to_string return varchar2,
     member function get_name return varchar2,
     member procedure set_name(i_name in varchar2),
     static procedure print 
    ) instantiable not final;
    
    create or replace type body hello_object as
     --默认构造方法 
     constructor function hello_object return self as result is
        v_obj hello_object := hello_object('generic object');
      begin
        self := v_obj;
        return;
      end hello_object;
       --重写构造方法
      constructor function hello_object(obj_name varchar2) return self as result is
      begin
        self.obj_name := obj_name;
        return;  -- 返回一个副本,即对象实例的当前内存引用
      end hello_object;
      --成员函数
      member function to_string return varchar2 is
      begin
        return 'hello,' || self.obj_name ;
      end to_string;
      member function get_name return varchar2 is 
      begin 
          return self.obj_name;
      end get_name;
      
       member procedure set_name(i_name in varchar2)is 
       begin 
         self.obj_name := i_name;
       end set_name;
       static procedure print is 
       begin 
          dbms_output.put_line('welcome to learn object');
       end print ;
    
       
    end;
    /

    --使用static来声明一个静态方法或函数
    --静态方法允许像使用标准包一样使用对象类型。可以使用静态函数和过程来打印常量和消息
    --但不能使用其访问实例变量。静态函数可以返回一个实例化类
    --静态方法中不能使用SELF,因为对于静态方法而言没有当前对象

    begin
    hello_object.print();
    end;
    /
    --比较对象
    --先来看一个例子

    declare
    
      v_obj1 hello_object := hello_object();
      v_obj2 hello_object := hello_object();
    begin
    
      if v_obj1 = v_obj2 then
        dbms_output.put_line('equal');
      else
        dbms_output.put_line('not equal');
      end if;
    end;
    /
    --怎样比较两个对象呢?比如数值变量,我们可以直接比较数值来判断大小,对象却没有那么方便
    --但我们可以给对象指定比较的规则,规定在什么情况下相等,什么情况下哪个比较大,哪个比较小
    --使用MAP或者ORDER方法,可以来定义比较规则

    --Map函数比较

    --Map 函数不接受形参,只返回CHAR、DATE ,NUMBER或VARCHAR2的标量类型
    create or replace type map_comp is object (
      cmp_data varchar2(20),
      constructor function map_comp(cmp_data varchar2) return self as result,
      map member function equal return varchar2
    );
    create or replace type body map_comp is 
         
       constructor function map_comp(cmp_data varchar2) return self as result
       is 
       begin 
           self.cmp_data := cmp_data;
           return ;
       end map_comp;
       map member function equal return varchar2 is 
       begin 
          return self.cmp_data;
       end equal;
    
    end ;
    /
    declare
      v_data1 map_comp := map_comp('a');
      v_data2 map_comp := map_comp('a');
      v_data3 map_comp := map_comp('b');
    
    begin
      if v_data1 = v_data2 then
        dbms_output.put_line('equal');
      else
        dbms_output.put_line('not equal');
      end if;
    
      if v_data1 = v_data3 then
        dbms_output.put_line('equal');
      else
        dbms_output.put_line('not equal');
      end if;
    
    end;
    /

    --作业:给定上述对象的对象列表,使用冒泡排序法进行排序

    --ORDER 方法比较
    --order 函数运行将任何数据类型定义为形参。通过将形参定义为相同的对象类型,可以模拟JAVA中的
    --对象比较方法,这样可以把某个对象的副本传递给另一个对象,然后比较这两个对象
    
    create or replace type order_comp is object (
      first_name varchar2(100),
      second_name varchar2(100),
      constructor function order_comp(first_name varchar2,second_name varchar2) return self as result,
      order member function equal(i_obj order_comp) return number,
      member function to_string return varchar2
     ) instantiable not final; --没有指定NOT FINAL 默认是FINAL的
     
     
    create or replace type body order_comp is
    
      constructor function order_comp(first_name  varchar2,
                                      second_name varchar2) return self as result is
      begin
        self.first_name  := first_name;
        self.second_name := second_name;
        return;
      end order_comp;
      order member function equal(i_obj order_comp) return number is
      begin
    
        if self.first_name  > i_obj.first_name then
          return -1;
        elsif self.first_name = i_obj.first_name 
           and self.second_name > i_obj.second_name then
            return -1;
        elsif self.first_name = i_obj.first_name
          and self.second_name = i_obj.second_name  then 
           return  0 ;
        else 
           return 1 ;
       end if;
      end equal;
      
       member function to_string return varchar2 is 
       begin 
            return self.first_name||'-'||self.second_name;
       end to_string;
    
    end;
    /
    --如果self < i_obj order函数返回任意负数 -1
    --如果SELF = i_obj 返回 0 
    --如果SELF > i_obj 返回 任意正数 1 
    declare
      v_data1 order_comp := order_comp('a','c');
      v_data2 order_comp := order_comp('a','d');
      v_data3 order_comp := order_comp('b','s');
    
    begin
      if v_data1< v_data2 then
        dbms_output.put_line('yes');
      else
        dbms_output.put_line('no');
      end if;
    end;
    /
    
    ---map 和order在同一个对象类型中不能并存,只能使用一个
    --当有大量的对象需要排序和比较时,比如在SQL语句中,ORACLE建议使用MAP
    --ORACLE并不关系方法的名字,我们可以任意起名
    --子类型也可以有MAP方法,不过只有当基类也有这个方法时才行
    --子类型不能有ORDER方法;我们必须聪明地把所有比较都放在基类中

    ---继承和多态
    --跟JAVA中类可以被继承外,对象类型也可以被继承
    --在其它语言中,比如JAVA都有一个基类型,比如Object,在ORACLE里没有定义一个主的基类

    drop type order_subcomp;
    ---under 标识子类型的关键字
    create or replace type order_subcomp under order_comp
    (
      salucation varchar2(20),
      constructor function order_subcomp(first_name  varchar2,
                                         second_name varchar2,
                                         salucation  varchar2)
        return self as result,
      overriding member function to_string return varchar2
    )instantiable final;
    
    create or replace type body order_subcomp is
      constructor function order_subcomp(first_name  varchar2,
                                         second_name varchar2,
                                         salucation  varchar2)
        return self as result is
      begin
        self.first_name  := first_name;
        self.second_name := second_name;
        self.salucation  := salucation;
        return;
      end order_subcomp;
      overriding member function to_string return varchar2 is
      
      begin
        return(self as order_comp) .to_string() || ',' || self.salucation;
      end to_string;
    
    end;
    /

    ---使用(self as supertype) 来调用父类的方法,11g及之后可以这样使用
    --11g之前,这是不可能的

    declare
      v_data1 order_subcomp := order_subcomp('a','c','s');
      v_data2 order_subcomp := order_subcomp('a','d','t');
      v_data3 order_subcomp := order_subcomp('b','s','y');
      
      v_parent order_comp ;
    
    begin
      if v_data1< v_data2 then
        dbms_output.put_line('small');
      else
        dbms_output.put_line('not small');
      end if;
      
      v_parent := v_data1;
      dbms_output.put_line(v_data1.to_string());
      dbms_output.put_line(v_parent.to_string());
    end;
    /
    --声明子类型时,父类型中的属性不用列出,因其自动继承
    --子类型构建,将变量分配给父类型属性
    --子类型可以访问父类型的构造函数
    --子类型不能覆写父类型的构造函数
    --对象的子类型不能覆写对象的MAP和ORDER函数

    --我们来看下多态
    --创建基类型

    create or replace type ma_product is object (
      product_id number,
      product_name varchar2(100),
      product_price number,
      not instantiable member procedure show_discount
    ) not instantiable not final 
    ;
    
    --创建子类型
    create or replace type ma_book under ma_product
    (
      book_author varchar2(100),
      book_pages  number,
      constructor function ma_book(product_id    number,
                                   product_name  varchar2,
                                   product_price number,
                                   book_author   varchar2,
                                   book_pages    number) return self as result,
    
      overriding member procedure show_discount
    )
    instantiable not final;
    
    create or replace type body ma_book is
    
      constructor function ma_book(product_id    number,
                                   product_name  varchar2,
                                   product_price number,
                                   book_author   varchar2,
                                   book_pages    number) return self as result is
      
      begin
        self.product_id    := product_id;
        self.product_name  := product_name;
        self.product_price := product_price;
        self.book_author   := book_author;
        self.book_pages    := book_pages;
      
        return;
      end ma_book;
    
      overriding member procedure show_discount is
      
      begin
        dbms_output.put_line(self.product_name || ' 作者是' || self.book_author ||
                             ',共' || self.book_pages || '');
      
      end show_discount;
    end;
    /
    
    --创建子类型
    create or replace type ma_computer under ma_product
    (
      cpu_size number,
      brand    varchar2(100),
      constructor function ma_computer(product_id    number,
                                       product_name  varchar2,
                                       product_price number,
                                       brand         varchar2,
                                       cpu_size      number)
        return self as result,
    
      overriding member procedure show_discount
    )
    instantiable not final;
    
    create or replace type body ma_computer is
    
      constructor function ma_computer(product_id    number,
                                       product_name  varchar2,
                                       product_price number,
                                       brand         varchar2,
                                       cpu_size      number)
        return self as result is
      
      begin
        self.product_id    := product_id;
        self.product_name  := product_name;
        self.product_price := product_price;
        self.brand         := brand;
        self.cpu_size      := cpu_size;
      
        return;
      end ma_computer;
    
      overriding member procedure show_discount is
      
      begin
        dbms_output.put_line(self.product_name || ' 品牌是' || self.brand ||
                             ',CPU大小' || self.cpu_size || 'M');
      
      end show_discount;
    end;
    /
    
    declare
      type list_t is table of ma_product;
      product_list list_t;
      v_product1   ma_book := ma_book(1, 'plsql实战训练', 25, 'testma', 55);
      v_product2   ma_book := ma_book(1, 'plsql实战训练2', 30, 'testma12', 56);
      v_product3   ma_computer := ma_computer(1,
                                              '联想笔记本',
                                              3000,
                                              '联想',
                                              1024);
      v_product4   ma_computer := ma_computer(1,
                                              '清华同方笔记本',
                                              1999,
                                              '清华同方',
                                              2048);
    
    begin
    
      product_list := list_t(v_product1, v_product3, v_product2, v_product4);
      for i in 1 .. product_list.count loop
        product_list(i) .show_discount();
      end loop;
    end;
    /

    --对象集合

    --对象类型和集合对象类型之间的唯一区别是,对象只保存单个对象类型,而集合
    --保存一个对象类型数组或嵌套表

    ma_order_items 
    create or replace type order_item is object 
    (  order_id varchar2(32),
       product_no number,
       product_name varchar2(100),
       product_size varchar2(20),
       product_num number ,
       product_ori_price number ,
       product_new_price number
    );
    
    declare
      v order_item := order_item('','','','','','','');--不能使用ORDER_ITEM()进行初始化
    begin
      v.order_id := sys_guid();
      dbms_output.put_line(v.order_id);
    end;
    /
    create or replace type order_item_table is table of order_item;
    
    create or replace type order_objects is object
    (
      order_table order_item_table,
      constructor function order_objects(order_table order_item_table)
        return self as result,
      constructor function order_objects return self as result,
      member function get_size return number,
      member function get_table return order_item_table,
      static function get_order_items(i_low number, i_high number)
        return order_item_table
    )
    instantiable not final;
    
    
    create or replace type body order_objects is
      constructor function order_objects(order_table order_item_table)
        return self as result is
      begin
        self.order_table := order_table;
        return;
      end order_objects;
    
      constructor function order_objects return self as result is
      
        cursor cur_item is
          select * from ma_order_items;
        c      number := 1;
        v_item order_item;
      begin
        self.order_table := order_item_table();
        for v in cur_item loop
        
          v_item := order_item(v.ID_MA_ORDERS,
                               v.product_no,
                               v.product_name,
                               v.product_size,
                               v.product_num,
                               v.product_ori_price,
                               v.product_new_price);
          self.order_table.extend;
          self.order_table(c) := v_item;
          c := c + 1;
        end loop;
        return;
      
      end order_objects;
      member function get_size return number is
      
      begin
        return self.order_table.count;
      end get_size;
    
      member function get_table return order_item_table is
      begin
        return self.order_table;
      end get_table;
    
      static function get_order_items(i_low number, i_high number)
        return order_item_table is
        cursor cur_item is
          select *
            from ma_order_items t
           where t.product_no between i_low and i_high;
        c             number := 1;
        v_item        order_item;
        v_order_table order_item_table;
      begin
        v_order_table := order_item_table();
        for v in cur_item loop
        
          v_item := order_item(v.ID_MA_ORDERS,
                               v.product_no,
                               v.product_name,
                               v.product_size,
                               v.product_num,
                               v.product_ori_price,
                               v.product_new_price);
          v_order_table.extend;
          v_order_table(c) := v_item;
          c := c + 1;
        end loop;
        return v_order_table;
      end get_order_items;
    end;
    /
    
    select  * from table(order_objects().get_table()); 

    ---对象表

    --在ORACLE里,可以把对象保存到数据库中

    create table product_objects of  ma_product
    (constraint pk_ma_product primary key(product_id));
    
    --这个语句创建了一个叫做ma_product的对象表,每一行都是一个ma_product对象
    --一般来说,对象的每个属性都对应着表中的一列
    select * from product_objects ;
    --需注意的是ma_product是不可实例化的,这个表中的每一行实际是类似于ma_book或ma_computer的子类型
    insert into product_objects values (ma_book(1, 'plsql实战训练', 25, 'testma', 55));
    insert into product_objects values (ma_book(2, 'plsql实战训练2', 30, 'testma12', 56));
    insert into product_objects values (ma_computer(3,'联想笔记本',3000,'联想',1024));
    insert into product_objects values (ma_computer(4,'清华同方笔记本',1999,'清华同方',2048));
    
    select *  from product_objects;

    ---所属子类型的属性哪去了呢?
    --oracle 把子类型专有的属性放在了product_objects的隐藏列中
    --从对象编程角度来看,这种方法既保留了商品的抽象性,有能够在需要的时候暴露子类型的而外信息

    --对象标识符
    --ORALE可以用主键值或这系统生成的值(SYS_NC_OID$)来产生对象标识符

    --系统生成的OID:不透明,可以数据库全局唯一,不可变;

    ---VALUE函数
    --从数据库中提取一个对象,可以使用VALUE函数
    select value(p) from product_objects p ;
    
    --value只接受一个参数,这个参数必须是当前FROM子句中的表别名,返回的是一个用于定义表的类型对象;
    
    declare
      v_product ma_product;
      cursor cur_product is
        select value(p) from product_objects p;
    
    begin
      open cur_product;
      loop
        fetch cur_product
          into v_product;
        exit when cur_product%notfound;
        v_product.show_discount();
      end loop;
    end;
    /
    --还可以直接访问属于基类的属性
    select value(p).product_id from product_objects p ;
    --能否直接访问子类型的属性呢?
    select value(p).book_author from product_objects p ;
    
    ---如果一个对象表基于的对象类型没有子类,就可以利用传统的SQL语句对于所有的列执行选择,插入,更新,删除操作
    select product_id from product_objects p ;
    update  product_objects p 
    set p.product_id = 6 
    where p.product_id = 1;
    --对于那些因为是子类型而被当作隐藏的列,就不能使用传统的关系DML操作,,必须使用对象DML方法
    update  product_objects p 
    set p = ma_book(1, 'plsql实战训练', 25, 'testma', 55)
    where p.product_id = 6;
    --要想更新某个子类型特有列值,唯一的好办法是更新整个对象

    --TREAT 函数

    --怎样去访问对象表中子类型的特有属性呢?

    DECLARE
      V_BOOK    ma_book;
      V_PRODUCT ma_product := ma_book(1, 'plsql实战训练', 25, 'testma', 55);
    BEGIN
      v_book := treat(v_product as ma_book);---从父类型向子类型转换,向下转换或者缩小
      v_book.show_discount();
    END;
    /
    
    --TREAT函数的语法
    treat(object_instance as subtype)[.{attribute|method(args...)}];
    --怎么去感知某个父类型是某个子类型呢?
    OBJECT IS OF ([ONLY] TYPENAME)
    --ONLY:如果一个对象属于指定的类型或者任意一个子类型,不带ONLY的话,返回TRUE
    --如果使用了ONLY,这个表达式不会检查子类型,只有对象完全匹配时才返回TRUE
    
    declare
      v_product ma_product;
      cursor cur_product is
        select value(p) product from product_objects p;
    begin
    
      for v in cur_product loop
        case
          when v.product is of(ma_book) then
            dbms_output.put_line(treat(v.product as ma_book).book_author);
          
          when v.product is of(ma_computer) then
            dbms_output.put_line(treat(v.product as ma_computer).brand);
          else
            dbms_output.put_line('unknown object');
        end case; 
       end loop;
    
    end;
    /
    
    ---如果想修改MA_PRODUCT,怎么办
    --比如删除对象类型
    drop type ma_product validate;
    
    drop type typename [force | validate]
    --在MA_PRODUCT新增一个属性?
    alter type ma_product add attribute publication_date date
    cascade including table data ;
    --删除类型ma_book的方法
    alter type ma_book drop  constructor function ma_book(product_id    number,
                                   product_name  varchar2,
                                   product_price number,
                                   book_author   varchar2,
                                   book_pages    number) return self as result cascade;

    ----------------------------------------------------

    declare
      p_numbers varchar2(100) :='tydbser';
      type t_table is table of char index by pls_integer;
      v_tab t_table;
      v_tmp char(1);
      Result varchar2(100);
    begin
      for i in 1 .. nvl(length(p_numbers), 0) loop
        v_tab(i) := substr(p_numbers, i, 1);
      end loop;
    
      for p in 1 .. nvl(length(p_numbers), 0) - 1 loop
        for q in reverse p .. nvl(length(p_numbers), 0)-1 loop ---一定要从冒泡轨迹的起点开始比较。
          if v_tab(q) <= v_tab(q+1) then 
            v_tmp := v_tab(q);
            v_tab(q) := v_tab(q+1);
            v_tab(q+1) := v_tmp;
          end if;
        end loop;
      end loop;
    
      for i in 1 .. nvl(length(p_numbers), 0) loop
        Result := Result || v_tab(i);
      end loop;
    
        dbms_output.put_line(Result);
    end ;
    
    
    
    declare
      v_data1 map_comp := map_comp('a');
      v_data2 map_comp := map_comp('a');
      v_data3 map_comp := map_comp('b');
       v_data4 map_comp;
    
    begin
      if v_data1 = v_data2 then
        dbms_output.put_line('equal');
      else
        dbms_output.put_line('not equal');
      end if;
    
      if v_data1 = v_data3 then
        dbms_output.put_line('equal');
      else
        dbms_output.put_line('not equal');
      end if;
      
            if v_data1 <= v_data2 then 
            v_data4 := v_data1;
            v_data1 := v_data2;
            v_data2:= v_data4;
    --        dbms_output.put_line(v_data1);
    --        dbms_output.put_line(v_data2);
    --        dbms_output.put_line(v_data4);
          end if;
    
    end;
    /
    
    --定义对象
    create or replace type bhgx_obj is object
    (
           letter varchar2(1),
           constructor function bhgx_obj return self as result, 
           constructor function bhgx_obj(letter varchar2) return self as result,
           member function toString return varchar2,
           order member function equal(v_obj bhgx_obj) return number
    ) instantiable not final;
    
    CREATE OR REPLACE TYPE let_obj IS TABLE OF bhgx_obj;
    
    --创建对象体
    create or replace type body bhgx_obj as
     --默认构造方法 
     constructor function bhgx_obj return self as result is
        v_obj bhgx_obj := bhgx_obj('');
      begin
        self := v_obj;
        return;
      end bhgx_obj;
       --重写构造方法
      constructor function bhgx_obj(letter varchar2) return self as result is
      begin
        self.letter := letter;
        return;  -- 返回一个副本,即对象实例的当前内存引用
      end bhgx_obj;
      --成员函数
      member function toString return varchar2 is
      begin
        return self.letter ;
      end toString;
      order member function equal(v_obj bhgx_obj) return number is
      begin
        if self.letter  > v_obj.letter then
          return 1 ;
        elsif self.letter < v_obj.letter then
            return -1 ;
        elsif self.letter = v_obj.letter then 
           return  0 ;
        else 
           return 0 ;
       end if;
      end equal;
    end;
    --创建包
    create or replace package pkg_data_order is  
         function order_letter(v_l let_obj) return let_obj ;
    end pkg_data_order;
    --创建包体
    CREATE OR REPLACE PACKAGE BODY pkg_data_order IS
     function order_letter(v_l let_obj) 
             return let_obj as 
        v_t bhgx_obj;
        v_letts let_obj:=v_l;
        begin
          FOR i IN 1..v_letts.COUNT LOOP
            FOR j IN 1..(v_letts.COUNT-i) LOOP
              if v_letts(j).equal(v_letts(j+1))>0 then
                v_t := v_letts(j) ;
                v_letts(j) := v_letts(j+1);
                v_letts(j+1) := v_t;
              end if;
            END LOOP;
          END LOOP;
          return v_letts ;
        end;
    end pkg_data_order;
    
    
    --调用
    declare
        v_p let_obj:=let_obj() ;
    begin
        v_p.extend ;
        v_p(1):=bhgx_obj('z');
        v_p.extend ;
        v_p(2):=bhgx_obj('b');
        v_p.extend ;
        v_p(3):=bhgx_obj('d');
        v_p.extend ;
        v_p(4):=bhgx_obj('m');
        v_p.extend ;
        v_p(5):=bhgx_obj('a');
        v_p.extend ;
        v_p(6):=bhgx_obj('k');
        v_p.extend ;
        v_p(7):=bhgx_obj('c');
        v_p.extend ;
        v_p(8):=bhgx_obj('q');
        
        v_p := pkg_data_order.order_letter(v_p) ;
        FOR i IN 1..v_p.COUNT LOOP
          dbms_output.put_line(v_p(i).toString());
        END LOOP;
    end;
    
    --------
    CREATE OR REPLACE procedure test_bubble(str IN VARCHAR2) IS
      type  v_type is varray(1000) of varchar2(100);
       var v_type;
       temp varchar2(100);
       flag boolean;
       results VARCHAR2(4000);
    BEGIN
    select  substr(str,level,1) bulk collect into  var
    from dual connect by level <=length(str);
    <<outer_scope>>
      for i in  1 .. var.count-1 loop
       flag := false;
       for j in reverse i .. var.count-1 loop
         if var(j+1) <  var(j) then
           temp := var(j+1);
           var(j+1) := var(j);
           var(j) := temp;
         flag := true;
         end if;
       end loop;
       if (not flag) then
        exit outer_scope;  
       end if;
      end loop;
      for i in var.first .. var.last loop
        results :=concat(results,var(i));
      end loop;
      dbms_output.put_line('out_results='||results);
    END test_bubble;
    
    --测试过程
    declare
    begin
      test_bubble('zlmbwacgiofrskne');
    end;
    -----------
    
    create or replace type map_comp is object(
    cmp_data varchar2(1),
    constructor function map_comp(cmp_data varchar2) return self as result,
    map member function equal return varchar2,
    member function to_string return varchar2
    )instantiable not final;
    
    create or replace type body map_comp is
      constructor function map_comp(cmp_data varchar2) return self as result is
      begin
        self.cmp_data := cmp_data;
        return;
      end map_comp;
      map member function equal return varchar2 is
      begin
        return self.cmp_data;
      end equal;
      member function to_string return varchar2 is
      begin
        return self.cmp_data;
      end to_string;
    end;
    
    --赋值和排序
    declare
      type ind_obj_type is table of map_comp index by pls_integer;
      v_ind_obj ind_obj_type;
      v_aaa     map_comp;
    begin
      --初始化,随机赋值
      for i in 1 .. 15 loop
        v_ind_obj(i) := map_comp(chr(97 + dbms_random.value(1, 25)));
      end loop;
      --打印排序前对象中的字母
      dbms_output.put('排序前: ');
      for i in 1 .. v_ind_obj.count loop
        dbms_output.put(v_ind_obj(i).to_string() || ' ');
      end loop;
      dbms_output.put_line('');
      --冒泡排序
      for i in 1 .. v_ind_obj.count loop
        for j in i + 1 .. v_ind_obj.count loop
          if v_ind_obj(i) > v_ind_obj(j) then
            v_aaa := v_ind_obj(j);
            v_ind_obj(j) := v_ind_obj(i);
            v_ind_obj(i) := v_aaa;
          end if;
        end loop;
      end loop;
      --打印排序后
      dbms_output.put('排序后: ');
      for i in 1 .. v_ind_obj.count loop
        dbms_output.put(v_ind_obj(i).to_string() || ' ');
      end loop;
      dbms_output.put_line('');
    exception
      when others then
        dbms_output.put_line(sqlerrm);
    end;
  • 相关阅读:
    傻傻分不清的__proto__与prototype
    Groovy 学习资料
    ES6箭头函数()=>{} 与function的区别
    032_磁盘格式时不同的分区label的区别
    004windows输入输出重定向
    SpringBoot @Configuration、@Bean注解的使用详解(配置类的实现)
    SpringBoot 自定义错误页2(进阶:简单地自定义Error数据、Error视图)
    SpringBoot Lombok使用详解4(@Data、@Value、@NonNull、@Cleanup)
    SpringBoot Lombok使用详解2(@Setter、@Getter、@ToString、@EqualsAndHashCode)
    SpringBoot 自定义错误页1(基础:配置404等错误的静态页面、动态模版页面)
  • 原文地址:https://www.cnblogs.com/yhq1314/p/10614765.html
Copyright © 2020-2023  润新知