[PHP] identificare errori

[Swalke]

Ciao a tutti.
Come si può fare per identificare un errore (di qualsiasi tipo esso sia) in PHP?

Mi spiego meglio con un esempio:

Ho una pagina PHP che:
- esegue una connessione al db,
- esegue delle query di selezione,
- esegue delle operazioni sui dati
- esegue una serie di insert e update

Ad eseguire un rollback non ci vuole nulla ma come si fa ad identificare quando farlo?
Dovrei fare il rollback ogni volta che va storto qualcosa in una query ma anche se si verifica un qualsiasi errore durante la "manipolazione dei dati".

Spero io non debba "contornare" ogni mia singola operazione con un if-else per vedere se è andata a buon fine!

In java basta racchiudere tutto in un try catch ed eseguire il rollback nel blocco catch.
Anche in PHP 5 ho visto si possono usare i blocchi try catch ma non fanno al caso mio
(ho provato a mettere tutto il codice in un try e a mettere dei parametri sbagliati nella connessione al db)...
...il blocco catch non è mai stato eseguito, ho avuto una serie di Notice e fatal error come se il mio try catch non esistesse.

Qualcuno mi sa aiutare?

[demos88]

Originariamente inviato da Swalke

Ciao a tutti.
In java basta racchiudere tutto in un try catch ed eseguire il rollback nel blocco catch.
Anche in PHP 5 ho visto si possono usare i blocchi try catch ma non fanno al caso mio
(ho provato a mettere tutto il codice in un try e a mettere dei parametri sbagliati nella connessione al db)...
...il blocco catch non è mai stato eseguito, ho avuto una serie di Notice e fatal error come se il mio try catch non esistesse.

Qualcuno mi sa aiutare?

Non capisco cosa intendi fare... cioè... su 100 righe, se alla 50° c'è un errore (anche mysql) vuoi che tutte le 49 righe precedenti (comprese operazioni mysql) vengano annullate?
Il costrutto try catch non mi risulta faccia nessun rollback su operazioni php eseguite... te la puoi cavare con il mysql, ma allora devi usare costrutti propri del mysql e non il php. Mia idea:
-All'inizio della pagina esegui la connessione al db e la query "START TRANSACTION;"
-poi esegui tutte le modifiche che vuoi racchiuse in un try
-nella clausola catch inserisci l'istruzione per eseguire la query "ROLLBACK;" e exit(); per bloccare lo script
-alla fine di tutto (dopo il catch) esegui la query "COMMIT;".

in pratica START TRANSACTION fa partire una transazione del database e tutte le operazioni sul db da quel momento in poi saranno depositate in una tabella a parte. Quando esegui la query "COMMIT" le operazioni verranno scritte e rese definitive, se invece esegui la query "ROLLBACK" esse verranno scartate e il db non avrà subito nessuna modifica.
Prova così... rimembranze di database di un annetto fa asd

edit della sera (importante): vagamente mi ricordavo che fosse così, poi ho cercato e ne ho avuto conferma:
funzioni delle libreria mysql e mysqli NON lanciano eccezioni ma solo errori testuali. Ad ogni istruzione di query o connessione dovresti controllare che la funzione sia andata a buon fine e se non lo fosse, lanciare una eccezione che faccia partire il blocco catch e quindi il rollback. Ovviamente, se è fallita la connessione, anche la query di rollback fallirà.

[kk3z]

prova con set_error_handler

[Leo_SR]

In un caso "classico" (usando le funzioni mysql_connect() e mysql_query() e compagnia) ogni funzione restituisce un risultato che, nel caso qualcosa non sia andato come doveva, sarà uguale a false.

Quindi per esempio:

$connection = mysql_connect( /* parametri connessione */);
if(!$connection) { /* Codice di gestione dell'errore */ }

Se vuoi evitare di "contornare" il codice di if-else puoi creare una classe wrapper che ti gestisca la connessione al DB.

Spero di essere stato chiaro ed utile

[demos88]

asd si effettivamente con le eccezioni ci si infogna parecchio... ci sono sicuramente vie più semplici.

prima prova queste altre soluzioni proposte

[Swalke]

Innanzitutto grazie per le risposte, cercherò di spiegare meglio il mio problema rispondendo a ognuno di voi:

Non capisco cosa intendi fare... cioè... su 100 righe, se alla 50° c'è un errore (anche mysql) vuoi che tutte le 49 righe precedenti (comprese operazioni mysql) vengano annullate?

Assolutamente no. L'unica cosa che mi serve annullare sono le modifiche al db eseguendo un rolback. Certo è che il mio rolback deve essere invocato quando una delle 100 righe causa un errore. Quindi appunto mi chiedevo: devo fare un "if else" su ognuna delle 100 istruzioni per vedere se causa un errore?
Esempio (in pseudocodice):

if(n!=0)
{
    x=y/n;
}
else
{
    rolback;
    redirect;
}

...mi sembra assurdo dovere fare sta cosa su ogni istruzione che può causare eccezione. In JAVA è molto più semplice basta fare:

try {
   tutte le 100 istruzioni
}
catch {
   rollback;
   redirect;
}

...su come fare gestire il commit e rollback siamo d'accordo invece ma non era quello il mio problema

mysql e mysqli NON lanciano eccezioni ma solo errori testuali. Ad ogni istruzione di query o connessione dovresti controllare che la funzione sia andata a buon fine e se non lo fosse, lanciare una eccezione che faccia partire il blocco catch e quindi il rollback. Ovviamente, se è fallita la connessione, anche la query di rollback fallirà.

Hai ragione infatti. Quello che faccio io è controllare semplicemente se restituisce errore. Se lo fa rolbacko e redirigo (non serve neanche fare il try catch). Però vedi dobbiamo sempre usare un if else per ogni istruzione SQL per verificare se ritorna degli errori. E similmnete dovremmo fare anche per le altre 100 istruzioni di cui sopra?
Non c'è un modo per vedere se durante tutta l'esecuzione ci son stati errori?
In modo che solo alla fine posso fare un controllo e fare il mio eventuale rollback?

Se vuoi evitare di "contornare" il codice di if-else puoi creare una classe wrapper che ti gestisca la connessione al DB.

Ma così risolverei la questione solo relativamente alla connessione al db no?

prova con set_error_handler

Ho dato un occhiata. se ho capito bene dovrei comunque fare un if else su ogni istruzione per capire se devo lanciare l'error hendler no?

...si effettivamente con le eccezioni ci si infogna parecchio

Anche perchè come dicevi giustamente tu le funzioni mysql non lanciano eccezioni ma ritornano solo errori testuali.

Insomma non c'è un modo per eseguire solo una volta il controllo solo alla fine?

...
100 istruzioni + istruzioni sql
...
if(siSonoVerificatiErrori)
{
   rollback;
   redirect;
}

Così avremmo una soluzione molto più efficiente e simile all'esempio java. E eviteremmo di fare un mare di if else che rilevano i singoli errori.
Tutto sta nel capire come si può ottenere quel "siSonoVerificatiErrori".
Dopotutto PHP da qualche parte li memorizzerà quegli errori (notice, warning, error, ecc...) che stampa quando qualcosa va male no?

Spero di essere riuscito a darvi informazioni e mi scuso per la lunghezza del post.

[Leo_SR]

Originariamente inviato da Swalke

Ma così risolverei la questione solo relativamente alla connessione al db no?

No, per connessione intendevo qualsiasi interazione con il DB una cosa del genere:

class MySQL {
   private $connection;
   
   public function __construct() {/* Costruttore */}

   public function connect() {
       $this->connection = @mysql_connection(/* Dati connessione */);
       if(!$this->connection) {
           throw new Exception(mysql_error());
       }
   }

   public function query($sql) {
      $q = mysql_query();
      if(!$q) {
         throw new Exception(mysql_error());
      }
      else return $q;
   }

//...
}

In modo da controllare il DB con una classe.

[Swalke]

Si scusa, però ancora stai contornando ogni operazione con una istruzione di if else che controlla se è il caso o meno di lanciare un'eccezione.

...io dovrei fare quell oche dici tu, più una serie di if else analoghi per ogni istruzione che opera sui dati estratti.

Quello che volevo io era appunto un modo per fare solo un controllo alla fine e rollbackare se era il caso.
A me non interessa quale errore è avvenuto. Mi interessa solo sapere se è avvenuto.
In java chiudendo tutte le istruzioni in un blocco try, qualsiasi eccezione si verifichi (senza che debba essere tu a eseguire un throw) viene eseguito il blocco catch (dove è posizionato il tuo rollback).

Insomma in php sono costretto a fare 1000 if else per controllare se ogni singola cosa genera un errore?
...mi pare assurdo.

[Leo_SR]

Se hai una classe l'if-else lo fai solo dentro la classe. Per intenderci, dopo aver sviluppato (per bene...) quella classe, nel tuo codice avrai una cosa del tipo:

try {
   $db = new MySQL();
   $db->connect(/*blablabla*/);

   $db->begin();

   $sql = "SELECT * FROM tabella WHERE condizione_astrusa";
   $q = $db->query($sql);
   $res = $db->result($q);

   //...
   $sql = "INSERT INTO altra_tabella(id, nome, cognome) VALUES (null, 'Pippo', 'La Coca')";
   $db->query($sql);

   //...
   $sql = "UPDATE ennesima_tabella SET campo = 10";
   $db->query($sql);

   //...
   $db->commit();
} catch(Exception $ex) {
   //Rollback
   $db->rollback();
}

Ovviamente i metodi me li sono invetati, ma dovrebbero essere più o meno quelli

[Hiskrtapps]

Originariamente inviato da kk3z

prova con set_error_handler

la soluzione è esattamente questa che ti è stata data.
non entry nel blocco catch perchè probabilmente è stato sollevato un errore e non un eccezione..
se vuoi gestire tutto con eccezioni devi farti un error handler che intercetta gli errori e lancia delle eccezioni e tutto funzionerà come sei abituato in java

[malocchio]

Originariamente inviato da Hiskrtapps

la soluzione è esattamente questa che ti è stata data.
non entry nel blocco catch perchè probabilmente è stato sollevato un errore e non un eccezione..
se vuoi gestire tutto con eccezioni devi farti un error handler che intercetta gli errori e lancia delle eccezioni e tutto funzionerà come sei abituato in java

Confermo, l'error_handler è quello che fa per te.

Puoi scegliere tu se far lanciare una eccezione oppure integrare direttamente nel codice della funzione handler il tuo rollback+redirect.

Se fai lanciare un'eccezione allora devi mettere un try/catch alle istruzioni e, inserire il rollback nel catch.

[Swalke]

ok ragazzi ho capito.

Vi ringrazio infinitamente dell'aiuto e mi metto all'opera!

[malocchio]

Originariamente inviato da Swalke

ok ragazzi ho capito.

Vi ringrazio infinitamente dell'aiuto e mi metto all'opera!

Magari quando hai finito posta il risultato... così il 3d è completo e si può chiudere.

Ciauuuuu

[Swalke]

In realtà postare il mio codice credo confonderebbe solo le idee perchè è suddiviso in più file e contiene anche cose che non centrano con l'argomento.
Fatto sta che quella che segue è la soluzione al problema ed è ciò su cui mi sono basato:

<?php

// ridefinisce la costante dell'errore utente - solo PHP 4
define (FATAL,E_USER_ERROR);
define (ERROR,E_USER_WARNING);
define (WARNING,E_USER_NOTICE);

// configura il livello di restituzione errore per questo script
error_reporting (FATAL | ERROR | WARNING);

// funzione di gestione dell'errore
function myErrorHandler ($errno, $errstr, $errfile, $errline) {
switch ($errno) {
case FATAL:
echo "<b>FATAL</b> [$errno] $errstr<br>\n";
echo " Fatal error in line ".$errline." of file ".$errfile;
echo ", PHP ".PHP_VERSION." (".PHP_OS.")<br>\n";
echo "Aborting...<br>\n";
exit 1;
break;
case ERROR:
echo "<b>ERROR</b> [$errno] $errstr<br>\n";
break;
case WARNING:
echo "<b>WARNING</b> [$errno] $errstr<br>\n";
break;
default:
echo "Unkown error type: [$errno] $errstr<br>\n";
break;
}
}

// funzione di prova del gestore di errore
function scale_by_log ($vect, $scale) {
if ( !is_numeric($scale) || $scale <= 0 )
trigger_error("log(x) for x <= 0 is undefined, you used: scale = $scale",
FATAL);
if (!is_array($vect)) {
trigger_error("Incorrect input vector, array of values expected", ERROR);
return null;
}
for ($i=0; $i<count($vect); $i++) {
if (!is_numeric($vect[$i]))
trigger_error("Value at position $i is not a number, using 0 (zero)",
WARNING);
$temp[$i] = log($scale) * $vect[$i];
}
return $temp;
}

// configura il gestore dell'errore definito dall'utente
$old_error_handler = set_error_handler("myErrorHandler");

// attiva alcuni errori, definendo prima un array misto con elementi non numerici
echo "vector a\n";
$a = array(2,3,"foo",5.5,43.3,21.11);
print_r($a);

// genera il secondo array, generando un avviso
echo "----\nvector b - a warning (b = log(PI) * a)\n";
$b = scale_by_log($a, M_PI);
print_r($b);

// questo è il problema, passiamo una stringa al posto di un array
echo "----\nvector c - an error\n";
$c = scale_by_log("not array",2.3);
var_dump($c);

// errore critico, il log di zero o di un numero negativo non è definito
echo "----\nvector d - fatal error\n";
$d = scale_by_log($a, -2.5);

?>

Trovate il codice e commenti vari all'argomento a questo indirizzo:
http://it2.php.net/set-error-handler