How to Capture Run Time in an Oracle Stored Procedure - sql

Question

I'm wanting to log the run time of certain SELECT stored procedures in Oracle. I've broken this down into the following steps.
STEP 1 - Get StartTime
STEP 2 - Insert into the LOG Table that the proc is running
STEP 3 - Get Inserted RowId
STEP 4 - Run the SELECT statement within the Proc
STEP 5 - Get End Time
STEP 5 - Update the row (in LOG Table) that was inserted, with the "Total Run Time".
IMPORTANT NOTE: The SELECT statement takes several minutes to run.
What happens is this:
The procedure runs
A row gets inserted into the LOG table
The LOG table immediately gets updated with the total run time.
The SELECT statement continues to take 5 minutes to run
After the SELECT statement completes, the result data finally returns.
The LOG table should NOT be updated until the entire procedure completes.
Basically what's happening is that the procedure immediately inserts, then updates the LOG table "BEFORE" the SELECT statement finishes.
I've tried wrapping and nesting additional BEGIN and END statements. The stored procedure still runs the "UPDATE" statement at the end of the procedure BEFORE the SELECT statement returns.
CREATE OR REPLACE EDITIONABLE PROCEDURE SP_CUSTOMERDATA_GET (
PARAM_USERID IN VARCHAR2,
PARAM_FIRSTNAME IN VARCHAR2,
PARAM_LASTNAME IN VARCHAR2
OUTPUT OUT types.cursor_type)
AS
BEGIN
DECLARE
l_Id Number;
l_StartTime TIMESTAMP;
l_EndTime TIMESTAMP;
l_TotalTime Number;
BEGIN
l_StartTime:= systimestamp;
INSERT INTO PROC_LOG (SPNAME, PARM1, PARM2, PARM3)
VALUES ('SP_CUSTOMERDATA_GET',I_USERNAME, PARAM_USERID, PARAM_FIRSTNAME, PARAM_LASTNAME)
RETURNING ID INTO l_Id;
COMMIT;
OPEN OUTPUT FOR
SELECT *
FROM CUSTOMER
WHERE USERID=PARAM_USERID
AND FIRSTNAME=PARAM_FIRSTNAME
AND LASTNAME=PARAM_LASTNAME;
l_EndTime:= systimestamp;
l_TotalTime:= extract(second from (l_EndTime-l_StartTime));
--ISSUE: This statement runs before the SELECT statement above completes
UPDATE PROC_LOG
SET RUNTIME_SECONDS=l_TotalTime
WHERE ID=l_Id;
COMMIT;
END;
END SP_CUSTOMERDATA_GET;
Is there a property I can set in the PROC, to force the procedure to not run the next command until the prior command finishes. It doesn't make sense that the procedure doesn't run in order?

Answer 1

I re-read the question and Justin's comments, and based on his proposal came up with a code solution for it.
First a general setup of database structures:
FSITJA#db01>create table customer (userid,
2 firstname,
3 lastname) as
4 select level, 'John', 'Doe'
5 from dual
6 connect by level <= 1000000;
Table created.
FSITJA#db01>create table PROC_LOG (id number generated as identity,
2 SPNAME varchar2(30),
3 PARM1 varchar2(100),
4 PARM2 varchar2(100),
5 PARM3 varchar2(100),
6 RUNTIME_SECONDS number);
Table created.
FSITJA#db01>create or replace type tp_customer_row as object (userid number,
2 firstname varchar2(100),
3 lastname varchar2(100));
4 /
Type created.
FSITJA#db01>create or replace type tp_customer as table of tp_customer_row;
2 /
Type created.
FSITJA#db01>create or replace package types as
2 type cursor_type is ref cursor return customer%rowtype;
3 end;
4 /
Package created.
Then we will need a stored procedure with the autonomous transaction to log the time, and the table function that allows us to query data from a collection. We can pass a cursor into the function in a Select to test that it works:
FSITJA#db01>create or replace procedure sp_log_customerdata_get(proc_log_id in proc_log.id%type, starttime in timestamp) as
2 pragma autonomous_transaction;
3 begin
4 UPDATE PROC_LOG
5 SET RUNTIME_SECONDS=extract(second from (systimestamp-starttime))
6 WHERE ID=proc_log_id;
7 COMMIT;
8 end;
9 /
Procedure created.
FSITJA#db01>create or replace function fn_customerdata_get(cust_cursor types.cursor_type,
2 proc_log_id in proc_log.id%type,
3 starttime in timestamp) return tp_customer
4 pipelined as
5 in_cust_rec customer%rowtype;
6 out_cust_rec tp_customer_row := tp_customer_row(null, null, null);
7 begin
8 loop
9 fetch cust_cursor into in_cust_rec;
10 exit when cust_cursor%notfound;
11 out_cust_rec.userid := in_cust_rec.userid;
12 out_cust_rec.firstname := in_cust_rec.firstname;
13 out_cust_rec.lastname := in_cust_rec.lastname;
14 pipe row(out_cust_rec);
15 end loop;
16 close cust_cursor;
17 sp_log_customerdata_get(proc_log_id, starttime);
18 return;
19 end;
20 /
Function created.
FSITJA#db01>select *
2 from table(fn_customerdata_get(cursor(select userid,
3 firstname,
4 lastname
5 from customer
6 where rownum < 5),
7 null,
8 systimestamp));
USERID FIRSTNAME LASTNAME
---------- --------------- ---------------
1 John Doe
2 John Doe
3 John Doe
4 John Doe
Now the original procedure, which will call the function passing a ref cursor, and then forward this cursor out in its parameter for the client application:
FSITJA#db01>CREATE OR REPLACE PROCEDURE SP_CUSTOMERDATA_GET (
2 PARAM_USERID IN VARCHAR2,
3 PARAM_FIRSTNAME IN VARCHAR2,
4 PARAM_LASTNAME IN VARCHAR2,
5 OUTPUT OUT types.cursor_type) AS
6 l_Id Number;
7 l_StartTime TIMESTAMP;
8 l_EndTime TIMESTAMP;
9 l_TotalTime Number;
10 l_CustResult tp_customer;
11 BEGIN
12 l_StartTime:= systimestamp;
13 INSERT INTO PROC_LOG (SPNAME, PARM1, PARM2, PARM3)
14 VALUES ('SP_CUSTOMERDATA_GET', PARAM_USERID, PARAM_FIRSTNAME, PARAM_LASTNAME)
15 RETURNING ID INTO l_Id;
16 COMMIT;
17 open output for
18 select *
19 from table(fn_customerdata_get(cursor(SELECT userid,
20 firstname,
21 lastname
22 FROM CUSTOMER
23 WHERE USERID=PARAM_USERID
24 AND FIRSTNAME=PARAM_FIRSTNAME
25 AND LASTNAME=PARAM_LASTNAME),
26 l_Id,
27 l_StartTime
28 )
29 );
30 END SP_CUSTOMERDATA_GET;
31 /
Procedure created.
And finally a piece of code to test that only after the client application fetches data from the table function there will be a log entry for time elapsed:
FSITJA#db01>declare
2 v_output types.cursor_type;
3 v_runtime_seconds number;
4 type tp_cust_table is table of customer%rowtype;
5 v_cust_table tp_cust_table;
6 begin
7 SP_CUSTOMERDATA_GET (1, 'John', 'Doe', v_output);
8 select runtime_seconds
9 into v_runtime_seconds
10 from proc_log
11 where id = 1;
12 dbms_output.put_line('Runtime before client fetches: ' || v_runtime_seconds);
13 fetch v_output
14 bulk collect into v_cust_table;
15 select runtime_seconds
16 into v_runtime_seconds
17 from proc_log
18 where id = 1;
19 dbms_output.put_line('Runtime AFTER client fetches: ' || v_runtime_seconds);
20 end;
21 /
Runtime before client fetches:
Runtime AFTER client fetches: .118791
PL/SQL procedure successfully completed.

Answer 2

The problem is that your procedure doesn't actually run the SELECT statement. Your procedure just opens the cursor which parses the statement and gets the statement handle. It doesn't cause the database to actually execute the statement. That happens when the caller goes to fetch data from the cursor that is returned. When the procedure finishes, it has no idea whether the caller is ever going to fetch data from the cursor, whether it is going to just fetch the first 10 rows, or whether it is going to eventually fetch every row. If your goal is to measure how long it takes to fetch the data from the cursor, you'd want to add logging to the caller not to this procedure.
Of course, you could also just run the SELECT statement separately. If the actual query is anything close to what you posted, I'd strongly wager that you're missing an index on customer. I'd guess that userID is unique so if there was an index on userID, that query should run in a few milliseconds.