包装器（通用）管道函数PL/SQL

我正在尝试使用PL/SQL创建类似于泛型函数的东西。骨架应该如下所示

这是包规范中的代码

Type r_record
IS
  Record
  (
    col_1 Table.col_1 %Type ,
    col_2 Table.col_1 %Type );
Type T_table
IS
  TABLE OF r_record;
  CURSOR cur (p_i_a IN VARCHAR2, p_i_b IN VARCHAR2)
  IS
    SELECT col_1, col_2 
    FROM Table
    WHERE col_1= p_i_a 
    AND col_2= p_i_b 

  FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined;

这是包体中的代码：

  FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor(p_i_a, p_i_b)
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Get_result;

  FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor(p_i_a, p_i_b)
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Get_result;

  FUNCTION Func1()
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor('aa', 'bb')
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Func1;

  FUNCTION Func2()
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor('cc', 'dd')
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Func2;

我需要创建许多具有相同输入参数的函数

p_I_a；p_i_b

，输出结果仅取决于它们。我的想法是将这里编写的代码作为泛型，以便其他函数可以使用它。例如：

FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor(p_i_a, p_i_b)
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Get_result;

FUNCTION Func1(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN Get_result(p_i_a, p_i_b);

FUNCTION Func2(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN Get_result(p_i_a, p_i_b);

Func1（'aa'，'bb'）

应该调用函数

Get\u result（p\u i\u a，p\u i\u b）

其中

p_i_a='aa'

和

p_i_b='bb'

及

Func2（'cc'，'dd'）

应该调用函数

Get_result（p_i_a，p_i_b）

其中

p_i_a='cc'

和

p_i_b='dd'

例如：

FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor(p_i_a, p_i_b)
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Get_result;

FUNCTION Func1(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN Get_result(p_i_a, p_i_b);

FUNCTION Func2(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN Get_result(p_i_a, p_i_b);

---

你有什么想法吗。谢谢大家!

据我所知，您只想从另一个具有不同名称的函数调用您的泛型函数：

FUNCTION Func1(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
BEGIN
    RETURN Get_result(p_i_a => p_i_a, p_i_b => p_i_b);
END;

但这看起来很琐碎，所以也许我还不明白你们到底想做什么。让包装器函数接受相同的参数并将它们传递给泛型函数似乎是不必要和多余的，因为调用方无论如何都需要知道所有参数值

如果您的

col1

是一个类别（国家、人民），而

col2

是该类别中的实际值，并且您需要一个隐藏该值的包装函数，那么这种模式可能有一定意义；但是这样，函数将被恰当地命名，并且不需要传递第一个参数；比如：

FUNCTION Get_country(
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
BEGIN
    RETURN Get_result(p_i_a => 'country', p_i_b => p_i_b);
END;

但这似乎不是您想要的。

软件包规格：

Type r_record
IS
  Record
  (
    col_1 Table.col_1 %Type ,
    col_2 Table.col_1 %Type );
Type T_table
IS
  TABLE OF r_record;
  CURSOR cur (p_i_a IN VARCHAR2, p_i_b IN VARCHAR2)
  IS
    SELECT col_1, col_2 
    FROM Table
    WHERE col_1= p_i_a 
    AND col_2= p_i_b 

  FUNCTION Func1()
    RETURN T_table Pipelined;

  FUNCTION Func2()
    RETURN T_table Pipelined;

包体：

  FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor(p_i_a, p_i_b)
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Get_result;

  FUNCTION Get_result(
      p_i_a IN VARCHAR2,
      p_i_b IN VARCHAR2)
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor(p_i_a, p_i_b)
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Get_result;

  FUNCTION Func1()
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor('aa', 'bb')
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Func1;

  FUNCTION Func2()
    RETURN T_table Pipelined
AS
    Vrow R_list;
      BEGIN
        FOR rec IN cursor('cc', 'dd')
        LOOP
          Vrow.col_1 := Rec.col_1 ;
          Vrow.col_2 := Rec.col_2 ;
          pipe row (vRow);
        END LOOP;
      END Func2;

---

我不明白。。。如果Func1和Func2只是调用Get\u result，为什么需要它们？您的意思是将

“aa”

等作为标识符用双引号括起来吗？如果是，其意义是什么？主要目的是保存代码。无论我调用Func1、Func2或其他函数，它们都应该使用指定的参数调用我们的泛型函数Get\u result。为什么不直接调用泛型函数？添加大量包装器函数如何节省代码？双引号是否意味着您试图指定游标返回的列名，而不是实际称为col1和col2的值？即使记录类型是（并且必须）基于这些固定列，调用

Func1（'aa'，'bb'）

和

Func2（'cc'，'dd'）

与调用

Func1（'cc'，'dd'）

和

Func2（'aa'，'bb'）

有何不同？他们最后都会调用

Get_Result（'aa'，'bb'）

或

Get_Result（'cc'，'dd'）

您能更好地描述您试图用这个或它应用的用例解决的问题吗？尝试包含一些示例表和数据以及预期结果。