Ora DN
main resize tbs DN Crea_DB

OPI

  • scaricare lo excel
  • ci interessa la parte DBA Support su sistemi PRE
  • collegarsi al sistema
  • dbset
  • oadhoc
  • mkdir DNXXX
  • copiare il tar (di solito anche .gz quindi gzip -d e poi tar xf)
  • verificare di avere la pwd delle varie utenze da utilizzare per gli script
  • controllo degli oggetti invalidi
  • seguire le istruzioni dello excel
    • Nota: copia le righe istruzione su n++
    • Esegui nella sequenza data
    • NB: se sono tanti script da lanciare utilizza lo scriptche trovi qui
  • controllo oggetti invalidi
  • eventualmente inviare i log

Controllo oggetti invalidi

select 'ALTER '||decode(owner,'PUBLIC','PUBLIC')||' '|| decode(object_type,'PACKAGE BODY','PACKAGE','TYPE BODY','TYPE',object_type)||
' '|| decode(owner,'PUBLIC',NULL,owner||'.')||''||object_name||' COMPILE '||
decode(object_type,'PACKAGE BODY','BODY;','TYPE BODY','BODY;',';') oggetti from dba_objects where status='INVALID' minus
select * from system.oggetti_invalidi_prerilacio;

Drop oggetti_invalidi_prerilacio

drop table system.oggetti_invalidi_prerilacio;

Create oggetti_invalidi_prerilacio

create table system.oggetti_invalidi_prerilacio as select
'ALTER '||decode(owner,'PUBLIC','PUBLIC')||' '|| decode(object_type,'PACKAGE BODY','PACKAGE','TYPE BODY','TYPE',object_type)||
' '|| decode(owner,'PUBLIC',NULL,owner||'.')||''||object_name||' COMPILE '|| decode(object_type,'PACKAGE BODY','BODY;','TYPE BODY','BODY;',';') oggetti from dba_objects where status='INVALID'
order by owner, object_type desc;

lancia_sql.sh: SHELL per eseguire tanti script

#!/usr/bin/ksh

ts_begin=$(date)
secs_begin=$SECONDS

######### GLOBAL VARS #########################
sql_scripts="scripts.txt" #### Puo' diventare parametro
session_out="scripts.out"
ESITO=0
EXIT_ESITO=0
CAN_RUN=0
RET_CODE=0
stars_row=""
ok_rows=6
nok_rows=4
###############################################

help_out()
{
        newline
        newline
        printf "\---------------- lancia_sql.sh -----------------\n"
        newline
        printf "Creare nella directory degli script il file "
        tput bold
        printf "%s" "$sql_scripts"
        tput sgr0
        printf ".\nInserire una riga per ogni script da eseguire.\nEs. di riga: sqlplus utente/password @nomescript\n"
        newline
        printf "N.B. controllare preliminarmente che utente/password si colleghino al DB.\n\n"

        printf "Eseguire gli script lanciando %s\n\n" "$0"

        printf "stdout e stderr verranno reindirizzati nel file script9999.out, con 9999 progressivo: 1 - numero_scripts.\n"

        newline
        newline
        printf "Per ogni script eseguito viene stampata una riga con: progressivo, nome script, numero di righe.\n"
        printf "Per ogni script eseguito viene testato l'esito:\n"
        newline

        printf "\- Se OK, vengono stampate le ultime %d righe di uno degli output generati dallo script, come di seguito:\n" "$ok_rows"
        printf "  1) se presente, dal file di spool\n"
        printf "  2) altrimenti, dallo stdout/stderr rediretto in script999.out\n"
        newline
        printf "  Viene chiesta conferma per proseguire con lo script successivo.\n"
        newline

        printf "\- Se ERRORE, vengono stampate %d righe per ogni ORA- trovato (la riga dello ORA- e le righe precedenti),\n" "$nok_rows"
        printf "  Inoltre viene stampata la coda del file script9999.out\n"
        printf "  N.B. Viene richiesta una doppia conferma per procedere nell'elaborazione degli script\n" 
        newline
        newline

        printf "Al termine, vengono stampati:\n"
        printf "Il numero totale di script eseguiti:, ora inizio/fine, il tempo complessivo di esecuzione in minuti e secondi.\n"
        newline
        printf "%s torna un return code  pari al numero di scripts contenenti almeno un errore.\n" $0
        newline
        newline

        exit 2

}

newline()
{
        printf "\n"
}

crea_stars ()
{
        stars_row=""
        cnt=0
        while [[ $cnt -lt 132 ]]
        do
                ((cnt=$cnt+1))
                stars_row=${stars_row}'*'
        done
}

stars()
{
        printf "%s\n" "${stars_row}"
}

format_msg ()
{
        printf "%s: %s" $(date "+%H:%M:%S") "$1"

}

header_out ()
{
        printf "\n\n%s\n" "${stars_row}" >>$session_out
        printf "%s\n\n" "$header_row" >>$session_out

}

footer_out ()
{
        printf "\n\n%s\n" "$footer_row" >>$session_out
        printf "%s\n" "${stars_row}" >>$session_out

}

is_spool ()
{
        IsSpool="N"

        spoolfile=$(grep -i spool $sqlname | head -1 | awk '{ print $2 }')
        if [[ -f $spoolfile ]]
        then
                IsSpool="Y"
        fi

}

testa_esito ()
{
        ESITO=0

        [[ $1 -eq 0 ]] || { ESITO=1 ; break; }

        is_spool

        if [[ $IsSpool == "Y" ]]
        then
                [[ $(grep "ORA-" $spoolfile | wc -l) -eq 0 ]] || { ESITO=1 ; break ; }
        fi

        # grep out 
        [[ $(grep "ORA-" $script_out | wc -l) -eq 0 ]] || { ESITO=1 ; break ; }
}

ask_ok ()
{

        while [[ $answer != 'y' && $answer != 'n' ]]
        do
                printf "[y/n]? "
                read myansw

                case $myansw in
                        [yY] ) CAN_RUN=0 ;  break ;;
                        [nN] ) CAN_RUN=1 ;  break ;;
                esac
        done

}

ask_superok ()
{
        CAN_RUN=0
        printf "Inserisci [si] (minuscolo) per proseguire, ogni altra scritta abortira' l'esecuzione: "
        read myansw

        [[ $myansw != "si" ]] && CAN_RUN=1 
}

# ####################################################################
# START
# ####################################################################

### Check scripts.txt
[[ ! -f "$sql_scripts" || -n "$1" ]] && { help_out ; } 

newline
tput bold
printf "Hai fatto il controllo degli oggetti invalidi "
tput sgr0

CAN_RUN=1
while [[ $CAN_RUN -ne 0 ]]
do
        ask_ok
done

crea_stars

newline

rm -f $session_out
seriale=0
can_run=0

# MAIN LOOP
while IFS='' read -r sql <&3 || [[ -n "$sql" ]]
do

        ((seriale=$seriale+1))
        script_out=orascript$(printf "%4.4d" ${seriale}).out

        #parse nome script 
        oifs=$IFS
        IFS="@"
        set -A elem $sql
        sqlname=${elem[1]}
        IFS=$oifs

        if [[ -f $sqlname ]]
        then
                sqlrows=$(wc -l $sqlname | awk '{print $1}')

                header_row=$(printf "Eseguo script #%4.4d: %s. Righe script: %d." $seriale "$sqlname" $sqlrows)

                newline
                stars
                format_msg "$header_row"
                newline
                newline

                header_out 

                $($sql >$script_out 2>&1)

                testa_esito $?

                cat $script_out >>$session_out

                [[ $ESITO -eq 0 ]] && okmsg="OK" || okmsg="ERRORE!"

                footer_row=$(printf "ESITO: %.-7s         Fine script #%4.4d: %s\n" "$okmsg" $seriale "$sqlname" )

                is_spool
                [[ $IsSpool == "Y" ]] && outfile=$spoolfile || outfile=$script_out

                printf "Estratto del file" "$outfile"
                tput bold
                printf " %s:\n\n" "$outfile"
                tput sgr0

                if [[ $ESITO -eq 0 ]]
                then
                        tail -$ok_rows $outfile
                else

                        errnum=$(grep -c "ORA-" $outfile)

                        if [[ $errnum -gt 0 ]]
                        then

                                for idx in $(grep -n "ORA-"  "$outfile" | awk '{print $1}' "FS=:")
                                do
                                        firstrow=$(($idx - $nok_rows ))
                                        [[ $firstrow -lt 1 ]] && firstrow=1
                                        tput bold
                                        grep -n "" $outfile | sed -n "$firstrow,${idx}p"
                                        tput sgr0
                                        printf "-----------------\n"
                                done

                        else
                                tput bold
                                tail -$nok_rows $outfile
                                tput sgr0
                        fi

                        # if [[ $outfile != $script_out ]]
                        # then

                                printf "-----------------\n"
                                printf "Coda del file"
                                tput bold
                                printf " %s:\n\n" "$script_out"
                                tput sgr0

                                tail -10 $script_out

                                printf "-----------------\n"
                        # fi

                fi

                newline

                printf "========================\n"
                format_msg "$footer_row"
                newline
                stars
                newline
                newline

                footer_out 

        else
                newline
                stars
                tput bold
                format_msg "ERRORE! script #${seriale}: [$sqlname] non trovato."
                tput sgr0
                newline
                stars
                newline

                ((seriale=$seriale-1))

                ESITO=1
        fi

        printf "Continuare col prossimo script "
        ask_ok

        if [[ $ESITO -ne 0  ]]
        then
                ((RET_CODE=$RET_CODE+1))
                [[ $CAN_RUN -eq 0 ]] && ask_superok
        fi

        [[ $CAN_RUN -ne 0 ]] && break

done  3<$sql_scripts

[[ $RET_CODE -eq 0 ]] && esito_msg="OK" || esito_msg="$RET_CODE script(s) con ERRORE(I) !"

newline
newline

printf "--------------------------------------------------------------\n"
printf "%s: FINE. ESITO: " "$(basename $0)"
tput bold
printf "%s" "$esito_msg" 
tput sgr0
printf "\n--------------------------------------------------------------\n"
printf "Scripts Eseguiti: %d\n" "$seriale"
printf "Data Inizio     : %s\n" "$ts_begin"
printf "Data Fine       : %s\n" "$(date)"

newline

printf "Tempo complessivo esecuzione: "
tput bold
printf "%dm %ds" "$(($SECONDS / 60))" "$(($SECONDS % 60))"
tput sgr0

newline
newline
newline

[[ $CAN_RUN -eq 0 ]] && printf "Ricorda di fare il controllo degli oggetti invalidi!\n\n"

exit $RET_CODE
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License