Oracle SQL et PL/SQL: comment réduire le temps d'exécution de la récupération des membres de l'objet (retourné par la fonction utilisateur)

Question

J'ai écrit une fonction pour obtenir un certain nombre de valeurs dans une vue Oracle. Comme les fonctions ne peuvent pas retourner plus d'une valeur, j'ai utilisé un objet (avec une signature de 8 chiffres). Cela fonctionne, mais pas bien ...

Le temps d'exécution d'une requête de sélection (et la sélection de la vue, à partir de cette requête) est proportionnelle au nombre de membres récupéré, à savoir:

récupération de 1 attribut consomme 1 seconde (il est égal à récupérer un objet entier, mais la valeur de l'objet est inutilisable pour le rapport), récupération de 2 attributs consomme 2 secondes, et ainsi de suite ...

Cela ressemble à Oracle exécute la fonction PL pour obtenir tous les membres de retour objet. Je pense que cette fonction, retourner varray (8) de nombres ne résoudra pas le problème aussi: huit appels implicites doivent être remplacés par huit sous-requêtes explicites. Quelqu'un peut-il résoudre ce problème? (À l'exception de réécrire à utiliser une fonction renvoyant une chaîne, que je vais essayer moi-même maintenant ...)

Voici la déclaration de type:

create or replace type "ARD"."PAY_FINE_FR_12_" AS object 
    (fed1 number 
     , reg1 number 
     , fed_nach number 
     , reg_nach number 
     , fed_upl number 
     , reg_upl number 
     , fed2 number 
     , reg2 number); 

Answer 1

Je considère que vous avez donné des noms significatifs à votre type de les attributs. Dans ce cas, vous ne renvoyez pas huit nombres mais quatre paires de nombres. Cela suggère une façon possible d'améliorer les choses. Si elle pourrait réellement résoudre votre problème dépendra des détails précis de votre situation (que vous n'avez pas fourni).

Voici un type représentant ces paires de nombres et un type de tableau imbriqué que nous pouvons utiliser pour le traitement de tableau.

create or replace type pay_pair as object 
    (pay_cat varchar2(4) 
     , fed number 
     , reg number) 
/

create or replace type pay_pair_nt as table of pay_pair 
/

Ceci est une fonction qui remplit un tableau avec quatre paires de nombres. En l'absence de toute règle commerciale réelle, j'ai choisi l'exemple le plus simple possible.

create or replace function get_pay_pairs 
    return pay_pair_nt 
is 
    return_value pay_pair_nt; 
begin 
    select 
     pay_pair (
      case col1 
       when 1 then 'one' 
       when 2 then 'nach' 
       when 3 then 'upl' 
       when 4 then 'two' 
       else null; 
      end 
      , fed 
      , pay) 
    bulk collect into return_value 
    from v23; 
    return return_value; 
end; 
/

Si vous avez besoin de la signature du type d'origine, vous pouvez réécrire votre fonction comme ceci:

create or replace function get_pay_fine 
    return PAY_FINE_FR_12_ 
is 
    return_value PAY_FINE_FR_12_; 
    l_array pay_pair_nt; 
begin  
    l_array := get_pay_pairs; 
    for i in 1..4 loop 
     case l_array(i).pay_cat 
      when 'one' then 
       return_value.fed1 := l_array(i).fed; 
       return_value.reg1 := l_array(i).reg; 
      when 'nach' then 
       return_value.fed_nach := l_array(i).fed; 
       return_value.reg_nach := l_array(i).reg; 
      when 'upl' then 
       return_value.fed_upl := l_array(i).fed; 
       return_value.reg_upl := l_array(i).reg;    
      else 
       return_value.fed2 := l_array(i).fed; 
       return_value.reg2 := l_array(i).reg; 
      end case; 
     end loop; 
    return return_value; 
end; 

Je le répète, ceci est une démonstration des techniques disponibles plutôt qu'une solution proposée. Le point crucial est la façon dont votre vue fournit les valeurs.