Is asynchronous apex either rolled back or not executed if the original transactions fails?

Question

I would like to confirm the behaviour of asynchronous apex when an error occurs on its original/parent transaction.

Imagine we have a synchronous apex transaction (Transaction1-Apex) that launches a apex batch process (Transaction2-Batch).

Can I assume that if there is a uncatched exception in Transaction1-Apex after the executeBatch method has been called, the platform will also rollback or even not execute Transaction2-Batch?

Here is a more "graphical" representation of what I mean:

Transaction1-Apex
-
-
-
Database.executeBatch(...)          Transaction2-Batch
-                                           -
-                                           -
-                                           -
Uncatched exception                         -
-- Automatic rollback                       ... is this transaction also rolled back?

I assumed that was the case, asynchronous apex was always rolled back. However, I could not find confirmation in the official docs, then I found the following article indicating that there are some cases where this might not be true: https://smgoodyear.com/2015/12/04/asynchronous-apex-and-transaction-boundaries/

Has anyone investigated this in depth? If so, could you confirm or deny my hypothesis?

Thanks a lot everyone!

Answer 1

My understanding is that for most asynchronous invocations - including future, Queueable, Batchable, Schedulable - the invocation enqueues the operation but it does not execute until the end of the current synchronous Apex transaction. In case of an unhandled exception, these jobs are rolled back from the queue and don't execute.

However not all features work this way. Notably if you fire a Platform Event from a transaction that subsequently rolls back or has an unhandled exception, the Event (and any triggers on it, executed asynchronously) will continue unaffected.

Answer 2

Looks like things have changed since the time of writing that blog and now. I quickly tried doing it on API 44 Winter 19 org, after exception, the future/queueable don't get triggered.

public class MainClass {
    public static void mainMethod(){

        MainClass.futureMethod();
        MainClass.futureMethod();

        if(true){
            throw new DMLException();
        }
        System.debug('FInished');
    }

    @future
    public static void futureMethod(){
        System.debug('Future Called');
    }
}

In execute anon : MainClass.MainMethod();

When that blog was written, It was old Apex compiler which had few bugs. Starting Spring 18 A new Apex compiler is introduced and that might have potentially fixed this loophole.

That being said, I have been using future/queuable too often for my current project and I never faced the issue of they being called even if the current transaction wasnt committed to the database.

The behaviour you mentioned is actually a feature for platform events.

Answer 3

That blog post shows some lack of understanding of what's going on under the hood. One should not be allowing exceptions to escape a trigger context. Things can get really weird if you allow this happen. At one point the system had a bug that completely cancelled a transaction if an uncaught exception was raised in a trigger.

As long as you always use the appropriate error-handling techniques (e.g. always using addError to report errors), then future/queueable/batchable calls will roll back as expected. Do not use Platform events in a trigger if you have any reason to suspect your trigger may roll back, because those cannot be rolled back. Do not allow exceptions to escape a trigger, ever, because bad things can happen.