14

I have a php script lets say during execution the scripts throws an exception. I want my PHP to resume from where it left off (where it had thrown the exception).

Should I put the same execution code in the "catch" part of the code?

On example, is lets say connects to mySQL it fails for connection timed out

   function someCode(){
        $pdostmt = $this->prepare($this->sql);
        if($pdostmt->execute($this->bind) !== false) {
            if(preg_match("/^(" . implode("|", array("select", "describe", "pragma")) . ") /i", $this->sql))
                return $pdostmt->fetchAll($this->fetchOption);
            elseif(preg_match("/^(" . implode("|", array("delete", "insert", "update")) . ") /i", $this->sql))
                return $pdostmt->rowCount();
   }
   try {
        someCode();
        }   
    } catch (PDOException $e) {  
        //re-execute same code as within the try clause?
        someCode();
    }
Improve this question
8
  • 2
    Can you give an example on what you try to do? Maybe refactoring it will help. Commented Dec 19, 2012 at 15:19
  • 5
    Code, or it didn't happen. Commented Dec 19, 2012 at 15:19
  • A try block can contain many statements. It's possible to find out which one triggered the exception but it isn't trivial. What are you trying to accomplish? Commented Dec 19, 2012 at 15:20
  • Also .. even if most of the cases it is used it is bad practice ... php.net/manual/en/control-structures.goto.php Commented Dec 19, 2012 at 15:20
  • 1
    You can put same block of code in catch, but than you loose the point of throwing the exception Commented Dec 19, 2012 at 15:21

4 Answers 4

Reset to default
31

First of all one should make clear that an exception is only fatal if it is not caught. Catching an exception does not halt script execution. It merely stops the stack frame in the try block and transfers control to the catch block. From there your script will continue to execute as normal.

By catching the exception here we still resume normal script execution after the exception is caught...

try {
  echo "Try...\n";
  throw new Exception("This is an exception");
} catch(Exception $e) {
  echo "Exception caught with message: " . $e->getMessage() . "\n";
}

echo "Script is still running...";

There's another way to handle uncaught exceptions, using an exception handler. However if you don't use a try and catch statement, execution flow will still be halted. This is the nature of exceptions:

function myExceptionHandler($e) {
  echo "Uncaught exception with message: " , $e->getMessage(), "\n";
}

set_exception_handler('myExceptionHandler'); // Registers the exception handler

throw new Exception("This is Exception 1");
echo "Execution never gets past this point";
throw new Exception("This is Exception 2");
throw new Exception("This is Exception 3");

Edit: After clarifying your question I think that I should state what you want is not an exception handler, but you actually don't want to use Exceptions at all. What you're trying to do does not require throwing Exceptions at all. Don't put PDO into exception mode if what you intend to do is just handle the error like that. Exception should only be used to handle exceptional errors. The whole point of an exception is to make sure you keep your promise. For example, if your function makes the promise that it will always return a PDOStatement object and there is a case where it can not possibly do that, then it makes sense to throw an Exception. This lets the caller know that we have reached a point where we can not keep our promise.

What you want is basic error handling...

function someCode(){
        $pdostmt = $this->prepare($this->sql);
        if($pdostmt->execute($this->bind) !== false) {
            if(preg_match("/^(" . implode("|", array("select", "describe", "pragma")) . ") /i", $this->sql))
                return $pdostmt->fetchAll($this->fetchOption);
            elseif(preg_match("/^(" . implode("|", array("delete", "insert", "update")) . ") /i", $this->sql))
                return $pdostmt->rowCount();
        } else {
           return false;
        }
}

while (someCode() === false) {
  /* Call someCode() until you get what you want */
}
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

So what is the purpose of finally in php 5.5? I always though it was there to ensure after a catch it continue execution and not halt the script.
@MCHam The purpose of finally is to guarantee a codeblock will run despite whether or not an Exception is thrown inside of a try block and whether or not it is handled inside a catch block. ONLY UNCAUGHT EXCEPTIONS ARE FATAL
In PHP 5.5+ if you have a return statement in your try block, it will still execute the finally block before actually returning (whereas if you just have code after the catch block, returning from within the try block will not execute that code). A finally block therefore guarantees your code will be called regardless of whether an exception is handled or not, and regardless of whether your try code returns or carries on.
3

Use php 4/5 register_shutdown_function.

Doc here: http://php.net/manual/en/function.register-shutdown-function.php

Improve this answer

1 Comment

Thanks that's just what I was looking for! Couldn't find it anywhere else. I was looking for a global "finally". Something to execute after an UNCAUGHT exception. Thanks.
3

I am going to assume that you are unable to handle the exception in the function it is being thrown. If you want to resume where your exception was thrown you need to handle the exception there. Anything else is bad coding resulting in confusion for you or anyone else working on the project. We let exception go up the tree because we can't handle them in the function it self because of scope issues.

As to your example which I will expand upon. You say operation can't continue because connection cannot happen. In reality we don't want to blatantly retry the function because we will essentially create a hang point of continuously trying the connection so we use a catch block higher up the tree where we can notify the user and have them decide what we want to do. In so doing we can use catch blocks in the right places to save data so we can restore the data and execute it at a later time. In reality we want to wind-up at a point before the try block.

This will give you a much clearer execution path. Sometimes you have to rethink a function/method so that it does one thing and one thing correctly.

To put the answer to your question simply and bluntly. No, Its a bad idea to call the try(ed) function in the catch block and the simple reason is this you no long have a try block to catch an exception there. Exceptions bring more meaningful error handling then just passing true and false as a return. However, it does mean that you have to go around the full circle in handling them.

Now for an alternate example... Say we have multiple servers that we can connect to and you wanted to run thought the list you would put the try/catch inside a loop and the catch will check for that exception and do any clean up before executing the next loop. If any other exception occurs we will (re)throw the exception. The right way to achieve what your looking for would be like this.

function someCode() {
    $pdostmt = $this->prepare($this->sql);

    while($status == false) {
        try {
            $status = $pdostmt->execute($this->bind)

        } catch (PDOException $e) {
            if($e->getMessage("What ever the error message is") {
                //Fix it here
            } else {
                throw $e;
            }
        }
    }
    //Do other stuff
    return $data; //or true/false
}
Improve this answer

1 Comment

" If you want to resume where your exception was thrown you need to handle the exception there." - For anyone who wants a tl;dr - that's the important part and is 100% the right way to go about it.
0

You might be able to use the finally part of the try catch, if you will not get an exception in execution.

try {
  // some crashing code
} catch (Exception $e) {
  //some catch code
} finally {
  //code that will run anyways.
}
Improve this answer

2 Comments

Isn’t finally a feature from PHP 5.5 (so in practice no-one still has it)?
... and it won't resume from the exact point when exception was thrown. It'll just run a hard-coded set of statements.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.