I prefer the second solution because I continue using only a sql statement.

It works but those points are a problem for me:

In a a little more complex situation ( 2 records type arguments_r1 and arguments_r2), my function will have to take 2 arguments with the same type. It's easy to switch 2 arguments that have the same type.
Therefore I would like to declare that the inputs arguments are cursors that match the records.

I have tried to do a query that return more lines. If there is a cursor inside it. It doesn't work anymore


Is there a way to fix these point?

declare
  cursor cur is select ...
  var cur%rowtype;

In your example, the table has 2 lines.

I want that f compute every line s of the table. In this case f the (cursor to the )whole table, take the first line, make the computation.

loop
  fetch ... into ...
  exit when cur%notfound
end loop;

How about a Macro, wont that fit here ?
how about something like this?

dynamically pass a table/view/rowsource using dbms_tf.table_t as optionally the needed columns as parameters...

demo@XEPDB1> create or replace function foo(
  2     p_tab dbms_tf.table_t ,
  3     p_cols dbms_tf.columns_t default null)
  4  return varchar2
  5  sql_macro
  6  as
  7     l_sql long;
  8  begin
  9     if p_cols is null then
 10             l_sql := ' select * from p_tab ';
 11     else
 12             l_sql := ' select ';
 13             for i in 1..p_cols.count
 14             loop
 15                     l_sql := l_sql || p_cols(i) ||',';
 16             end loop;
 17             l_sql := trim(',' from l_sql) ||' from p_tab ';
 18     end if;
 19     return l_sql;
 20  end;
 21  /

Function created.

demo@XEPDB1> select * from foo(dual);

D
-
X

demo@XEPDB1> select * from foo(dept,columns(deptno));

    DEPTNO
----------
        10
        20
        30
        40

demo@XEPDB1> select * from foo(dept,columns(deptno,dname));

    DEPTNO DNAME
---------- --------------
        10 ACCOUNTING
        20 RESEARCH
        30 SALES
        40 OPERATIONS

demo@XEPDB1>

"Therefore I would like to declare that the inputs arguments are cursors that match the records."

We can define "strongly typed ref cursors". They have to be declared in a package which then declares the function that uses the ref cursor.

"I have tried to do a query that return more lines. If there is a cursor inside it. It doesn't work anymore"

I assume you mean that the ref cursor returns multiple rows and you want to process each row and produce one output row for each input row. That would require a table function; I would suggest the "pipelined" variety.

create table tab(a,b,c,d,e) as
select 1,2,3,4,5 from dual
union all
select 6,7,8,9,10 from dual;

create or replace package pp as
  type tt_tab is ref cursor return tab%rowtype;
  function f(p1 in tt_tab) return sys.odcinumberlist pipelined;
end pp;
/

create or replace package body pp as
  function f(p1 in tt_tab) return sys.odcinumberlist pipelined is
  begin
    for rec in p1 loop
      pipe row(rec.a);
    end loop;
    return;
  end f;
end pp;
/
select * from table(pp.f(cursor(select * from tab)));

COLUMN_VALUE
1
6