BEGIN{
OS    = "AIX";
QUERIES    = ENVIRON[ "QUERIES"     ];
DISPLAY_SQL = ENVIRON[ "DISPLAY_SQL" ];
SAVE_SQL    = ENVIRON[ "SAVE_SQL"    ];
SQL_ONLY    = ENVIRON[ "SQL_ONLY"    ];
NO_TIMING   = ENVIRON[ "NO_TIMING"   ];
NO_ROWS     = ENVIRON[ "NO_ROWS"     ];
LAST_QUERY  = ENVIRON[ "LAST_QUERY"  ];
TMP_SQL     = ENVIRON[ "TMP_SQL"     ];
WINCOLS     = ENVIRON[ "WINCOLS"     ];
header    = 0;
COLLECTED   = 1;
STMT_NUM    = 0;
MIL         = 1000000;

#printQUERIES    "=QUERIES"     ;
#printDISPLAY_SQL "=DISPLAY_SQL" ;
#printSAVE_SQL    "=SAVE_SQL"    ;
#printSQL_ONLY    "=SQL_ONLY"    ;
#printNO_TIMING   "=NO_TIMING"   ;
#printNO_ROWS     "=NO_ROWS"     ;
#printLAST_QUERY  "=LAST_QUERY"  ;
#printTMP_SQL     "=TMP_SQL"     ;
#printWINCOLS     "=WINCOLS"     ;
}

/SQL1611W/{ print }

/ Number of executions/{
  N_EXECUTIONS= "";
  N_COMPILES= "";
  T_W_PREP= "";
  T_B_PREP= "";
  R_DELETED= "";
  R_INSERTED= "";
  R_READ= "";
  R_UPDATED= "";
  R_WRITTEN= "";
  S_SORTS= "";
  T_T_EXECUTION= "";
  T_T_USER= "";
  T_T_SYSTEM= "";
}
/ Number of executions/{ N_EXECUTIONS=$NF}
/ Number of compilations/{ N_COMPILES=$NF}
/ Worst preparation time \(ms\)/{ T_W_PREP=$NF}
/ Best preparation time \(ms\)/{ T_B_PREP=$NF}
/ Rows deleted/{ R_DELETED=$NF}
/ Rows inserted/{ R_INSERTED=$NF}
/ Rows read/{ R_READ=$NF}
/ Rows updated/{ R_UPDATED=$NF}
/ Rows written/{ R_WRITTEN=$NF}
/ Statement sorts/{ S_SORTS=$NF}
/ Total execution time \(sec.ms\)/{ T_T_EXECUTION=$NF}
/ Total user cpu time \(sec.ms\)/{ T_T_USER=$NF}
/ Total system cpu time \(sec.ms\)/{ T_T_SYSTEM=$NF}

/ Statement text/{  # Begin Display

STMT_NUM=STMT_NUM + 1;
S_TEXT=substr( $0, index( $0, "=")+2 );
SQL_OUT="";

if (R_READ == "Collected")
COLLECTED=0;

if (DISPLAY_SQL == -1)
SQL_LEN = length( S_TEXT);
else
SQL_LEN = DISPLAY_SQL;

# Save SQL Text to a file, or get name of existing (duplicate) file
if ( SAVE_SQL )  Save_Sql();

headline = "";
dataline = "";

if ( SQL_ONLY )
{
if (SAVE_SQL)S_Save_Info();
}
else
{
T_A_EXEC= T_T_EXECUTION / N_EXECUTIONS;
T_A_USER= T_T_USER/ N_EXECUTIONS;
T_A_SYSTEM= T_T_SYSTEM / N_EXECUTIONS;
A_R_READ= R_READ/ N_EXECUTIONS;
A_R_WRITTEN= R_WRITTEN/ N_EXECUTIONS;
A_R_INSERTED= R_INSERTED/ N_EXECUTIONS;
A_R_UPDATED= R_UPDATED/ N_EXECUTIONS;
A_R_DELETED= R_DELETED/ N_EXECUTIONS;

N_EXECUTIONS= round_MIL( N_EXECUTIONS );
N_COMPILES= round_MIL( N_COMPILES   );
A_R_READ= round_MIL( A_R_READ     );
A_R_WRITTEN= round_MIL( A_R_WRITTEN  );
A_R_INSERTED= round_MIL( A_R_INSERTED );
A_R_UPDATED= round_MIL( A_R_UPDATED  );
A_R_DELETED= round_MIL( A_R_DELETED  );

S_Exec_Info();

if (COLLECTED && ! NO_TIMING) S_Timing_Info();

#if ( SAVE_SQL ||
#     ((! SAVE_SQL) && ! (NO_TIMING || NO_ROWS || ! COLLECTED)) )
if ( SAVE_SQL )
S_Save_Info();

if (COLLECTED && ! NO_ROWS) S_Rows_Info();
}

S_SQL_Text();

rm_Trailing();

if ( headline && ! header)
{
for (i=1; i<=length( headline); i++)
underline = underline "-";

print headline;
print underline;
header = 1;
}

if (dataline) print dataline;
}

################################################################################
function round_MIL( val ) {

if ( val > MIL ) val = int( val / MIL ) "M";
return val;
}

################################################################################
function S_Exec_Info() {

headline = headline sprintf( \
"%4.4s | %6.6s %6.6s | %10.10s | ",
"Qnum",
"Exec's",
"Comp's",
"BestPrepMS");
dataline = dataline sprintf( \
"|%3s | %6s %6s | %10s | ",
STMT_NUM,
N_EXECUTIONS,
N_COMPILES,
T_B_PREP);
}

################################################################################
function S_Timing_Info() {

headline = headline sprintf( \
"%10.10s %10.10s %10.10s | ",
"ExecSEC.MS",
"UserSEC.MS",
"SystSEC.MS");
dataline = dataline sprintf( \
"%10.10s %10.10s %10.10s | ",
T_A_EXEC,
T_A_USER,
T_A_SYSTEM);
}

################################################################################
function S_Rows_Info() {

SPACERHEAD="";
SPACER="";
WINCOL_Spacing();

headline = headline sprintf( \
"%6.6s %6.6s %s%10.10s   %10.10s %10.10s | ",
"R_Read",
"Writtn",
SPACERHEAD,
"Inserted",
"Updated",
"Deleted");
dataline = dataline sprintf( \
"%6.6s %6.6s %s%10.10s   %10.10s %10.10s | ",
A_R_READ,
A_R_WRITTEN,
SPACER,
A_R_INSERTED,
A_R_UPDATED,
A_R_DELETED);
}

################################################################################
function S_Save_Info() {

headline = headline sprintf( \
"%8.8s | ",
"SQL-File");
#if ( ( ! SQL_ONLY ) || ( SQL_ONLY && S_TEXT ) )
dataline = dataline sprintf( \
"%8s | ",
SQL_OUT);
}

################################################################################
function S_SQL_Text() {

if ( DISPLAY_SQL )
headline = headline sprintf( \
"%-*s | ",
SQL_LEN, "SQL-Text");
if (S_TEXT && SQL_LEN)
dataline = dataline sprintf( \
"%-*.*s | ",
SQL_LEN, SQL_LEN, S_TEXT);
}

################################################################################
function WINCOL_Spacing() {

if ( COLLECTED && ! ( NO_TIMING || NO_ROWS ) )
{
if (SAVE_SQL)
{
if (WINCOLS == 80)
{
headline = headline "   | ";
dataline = dataline "   | ";
SPACERHEAD="| ";
SPACER="| ";
}
else if (WINCOLS == 132)
{
SPACERHEAD="|";
SPACER="|";
}
}
else # No SAVE_SQL info
{
if (WINCOLS == 80)
{
headline = headline "         |    | ";
dataline = dataline "         |    | ";
SPACERHEAD="| ";
SPACER="| ";
}
else if (WINCOLS == 132)
{
headline = headline "        | ";
dataline = dataline "        | ";
SPACERHEAD="| ";
SPACER="| ";
}
}
}
}

################################################################################
function rm_Trailing() {
# Get rid of trailing separator

if ( substr( headline, (len=length( headline))-2) == " | " )
{
headline = substr( headline, 1, (len - 3) );
dataline = substr( dataline, 1, (len - 3) );
}
}

################################################################################
function Save_Sql() {
# Save SQL Text to a file, or get name of existing (duplicate) file

DUPFILE="";
print S_TEXT > TMP_SQL;
close( TMP_SQL);

# Check if a duplicate SQL file exists
if ( OS == "AIX" )
{
# Get filesize of TMP_SQL
"ls -l " TMP_SQL | getline DIRLINE;
close( "ls -l " TMP_SQL );
DFN=split( DIRLINE, DIRARRAY);
FILESIZE=DIRARRAY[5];

# Loop thru sql files in reverse creation order
# Compare only if same filesize
while ( (DUPFILE == "") &&
("ls -lt " QUERIES "/[0-9]*.sql" | getline DIRLINE ) )
{
DFN=split( DIRLINE, DIRARRAY);
if ((DIRARRAY[5] == FILESIZE) &&
    (TMP_SQL != DIRARRAY[DFN])  )
{
"diff " TMP_SQL " " DIRARRAY[DFN]   \
" >/dev/null 2>&1 && "              \
"basename "  DIRARRAY[DFN] | \
getline DUPFILE;
close(  "diff " TMP_SQL " " DIRARRAY[DFN]   \
" >/dev/null 2>&1 && "              \
"basename "  DIRARRAY[DFN] );
}
}
close( "ls -lt " QUERIES "/[0-9]*.sql" );

system( "rm " TMP_SQL);
}
else# Untested
{
# delete TMP_SQL
}

if ( DUPFILE != "" )
{  # A duplicate SQL file was found
SQL_OUT = DUPFILE;
}
else
{  # Create SQL file
LAST_QUERY=LAST_QUERY + 1;
SQL_OUT=LAST_QUERY ".sql";
print S_TEXT > QUERIES "/" SQL_OUT;
}
}