Counting the number of lines for each procedure in a package

Question

Hi,
I would like to write a query on USER_SOURCE that can display the number of code lines for each procedure/function in a package.
Is it possible to write such a query? Maybe by using analytical functions?
for example in the following example i would like to count the lines between "PROCEDURE proc1 IS" and "END proc1;" and between "PROCEDURE proc2 IS" and "END proc2;"
SQL> select text  from user_source where name='PKG_TEST' and type='PACKAGE BODY';
TEXT
PACKAGE BODY PKG_TEST IS
  PROCEDURE proc1 IS
  BEGIN
    update t1 set EDITION_NAME = 'AAAAAAA';
    commit;
  END proc1;
PROCEDURE proc2 IS
  BEGIN
   update t1 set EDITION_NAME = 'AAAAAAA';
    commit;
  END proc2;
END PKG_TEST;thanks for helping

Answer 1

onedbguru wrote:
Hopefully some idiot manager isn't trying to use this sort of thing to base their decisions on developer productivity. If so, they ARE idiots. Number of code lines NEVER, EVER, EVER!!! translates into an efficient application. If I were paid by the line, my code would look like:
select
1
from
dual
Based on the idiocy of this method of determining "performance" I would get paid $5.00 at $1.00/line. And trust me, I saw this back in the 80's and 90's and saw similar idiotic code and had to clean up the mess. Most of it wasn't efficient code to start with let alone the number of lines generated.Or the other extreme, when the PHB firmly believed that execution efficiency was gained by reducing the number of lines of code. So instead of nicely formatted, easy to read code:
      *GET NEXT ORDER NUMBER                                                               
            EXEC SQL                                                                        
                 SELECT (MAX(ORDER_NUM) + 1)                                                
                 INTO   :NEXT-NUM:IND-NULL                                                  
                 FROM   PART_ORDER                                                          
            END-EXEC.                                                                       
            IF IND-NULL < 0                                                                 
              MOVE 1 TO NEXT-NUM.                                                           
            EXEC SQL                                                                        
                 INSERT                                                                     
                 INTO    PART_ORDER                                                         
                        (ORDER_NUM,                                                         
                         ORIGIN_LOC,                                                        
                         ORDER_TYPE,                                                        
                         ORDER_STAT,                                                        
                         CREAT_TIME)                                                        
                 VALUES (:NEXT-NUM,                                                         
                         :LOC, 'R', 'O',                                                    
                         CURRENT TIMESTAMP)                                                 
               END-EXEC.                                                                    
            MOVE NEXT-NUM TO MASK0.                                                         
            PERFORM HEADER-PROC THRU HEADER-EXIT.                                           
        CREATE-ORDER-EXIT. EXIT.                                                     You got this:
       *GET NEXT ORDER NUMBER
        EXEC SQL SELECT (MAX(ORDER_NUM) + 1) INTO :NEXT-NUM:IND-NULL FROM
        PART_ORDER END-EXEC. IF IND-NULL < 0 MOVE 1 TO NEXT-NUM. EXEC SQL INSERT
        INTO PART_ORDER (ORDER_NUM, ORIGIN_LOC, ORDER_TYPE, ORDER_STAT,
        CREAT_TIME) VALUES (:NEXT-NUM, :LOC, 'R', 'O', CURRENT TIMESTAMP)
        END-EXEC. MOVE NEXT-NUM TO MASK0. PERFORM HEADER-PROC THRU HEADER-EXIT.
        CREATE-ORDER-EXIT. EXIT.                 Oh, wait! See the same thing all the time in this forum ... not because someone thinks fewer lines = faster code, but simply because people are sloppy.
INSERT INTO PART_ORDER(ORDER_NUM,ORIGIN_LOC,ORDER_TYPE,ORDER_STAT,CREAT_TIME) VALUES (:NEXT-NUM,:LOC, 'R', 'O',CURRENT TIMESTAMP) ;