Newsgroup: it.comp.software.database
Titolo: [ORACLE] funzione che ritorni un record

Oracle mi dice che "la funzione PARAM non esiste" mentre io vorrei che la
funzione qui sotto mi ritorni un record di tipo PARAM. 
Il tipo PARAM l'ho definito nell'interfaccia del package.
Quale può essere il problema?
Ecco il codice:
CREATE OR REPLACE PACKAGE test
IS
   TYPE param IS RECORD (
      -- type puo' essere 'date', 'string', 'number' 
      NAME                          VARCHAR2 (20),
      VALUE                         VARCHAR2 (32767),
      TYPE                          VARCHAR2 (20));
   FUNCTION pvar (
      n     IN   VARCHAR2,
      v     IN   VARCHAR2,
   )
      RETURN param;
END test;
CREATE OR REPLACE PACKAGE BODY test
IS
   FUNCTION PVAR(n IN varchar2
               , v IN varchar2
               )
     RETURN PARAM IS
     BEGIN
         RETURN PARAM(n, v, 'varchar2');
     END PVAR;
END test;
Grazie anticipate!
Alx
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

          RETURN PARAM(n, v, 'varchar2');
Ad occhio la causa dell'errore dovrebbe essere qui.
Cosi' come l'hai scritta oracle interpreta PARAM come una funzione (che 
non hai mai dichiarato).
L'assegnazione dovrebbe essere fatta come:
PIPPO.NAME
 := n
PIPPO.VALUE := v;
PIPPO.TYPE := 'varchar2';
Ovviamente PIPPO deve essere dichiarata come PARAM.
Fino a domani non avro' un Oracle su cui fare delle prove, quindi il mio 
debugging "a spanne" deve essere preso con le pinze.
Ciao
-- 
Fabrizio Magni
fabrizi...@mycontinent.com
replace mycontinent with europe

 Quale puň essere il problema?
Č semanticamente non corretta.
Oracle cerca una funzione param che non trova nel catalogo.
Su due piedi la soluzione piů semplice č l'instanziamento di
una variabile alla quale assegnare i valori (vedi esempio).
IMHO non so quanto abbia senso dichiarare il tipo nel package.
g
create or replace package test
is
   type param is record (name varchar2(10), value varchar2(1000));
   function pvar( p_name in varchar2, p_value in varchar2)
     return param;
end;
/
create or replace package body test
is
   function pvar( p_name in varchar2, p_value in varchar2)
     return param
   is
     l_pvar param;
   begin
 
l_pvar.name
  := p_name;
     l_pvar.value := p_value;
     return l_pvar;
   end;
end;
/

      l_pvar.value := p_value;
Sospettavo qualcosa del genere. Molto scomodo da usare, conviene creare
una funzione CREATEPARAM che faccia l'inizializzazione delle variabili;
giusto per usare una notazione un po' piů compatta e leggibile.
Grazie a tutti per la prontezza!!
Alx
PS.
Deduco che č universalmente accettata la notazione p_???? per i parametri
delle funzioni e l_???? per le variabili dello scope interno. E' cosě? Ci
sono altre notazioni di cui dovrei tenere conto?
Grazie ancora


 sono altre notazioni di cui dovrei tenere conto?
"universalmente" mi sembra eccessivo... diciamo che dopo anni, mi trovo
bene con questa. La trovo abbastanza ordinata (anche se qualche ritocco
personale non guasta).
g

 ....onestamente non credo di capire cosa ci vuoi fare con questo pkg :)
In altri linguaggi è uso creare una matrice di configurazione per testare
n per m parametri di ingresso di tipo non predeterminato (può essere
varchar2, number, date, etc..) e costruire la query giusta di conseguenza.
Devo farlo in PL/SQL e che sia molto laborioso. Qualche idea alternativa?


 In altri linguaggi è uso creare una matrice di configurazione 
Sottinteso: altrimenti dovrei scrivere n per m query differenti... Una
cosa praticamente impossibile da modificare/manutenere... e forse anche da
scrivere!
Alx


 Devo farlo in PL/SQL e che sia molto laborioso. Qualche idea alternativa?
Overloading?
È l'unica idea che mi viene in mente da quel poco che hai detto...
g

 > In altri linguaggi è uso creare una matrice di configurazione per testare


Questo era proprio quello che volevo evitare, perché costringe a
scrivere/manutenere n x m procedure sovraccaricate (10 x 50 nel mio caso).
Alx


 
sql dinamico ?
beh... un'arma a doppio taglio, se non fatto bene non scala gran ché.
g