rollback transaction when code is on a block does not work

[ElectNewt]

I think this is a bug more than a discussion, but let's confirm I am not doing something wrong.

the scenario is the next, I wanted to abstract the Database layer outside of the logic of my application, so basically, I have some repositories like table1_repository and so on.

The problem becomes when I have to add transactions into the logic;

I've been looking at the gem and in the documentation, and it seems that there is no other way to do them than do DB.transaction do ... end.
Note: I know I can use SQL directly to execute that, but it will not take advantage of all the work already done in the gem.

so my idea was to create a transaction_manager which will contain a method that receives a block and it gets executed, and the information gets inserted correctly, but if something goes wrong, it does not roll back.

Simplest Possible Self-Contained Example Showing the Bug

def execute_transaction(&block)
 @db.transaction do
   @table1_repository.create(... <- rolled back
   block <- didn't get rolled back
   intentional error here
 end
end

and block can be any simple piece of code

def insert_example 
 @table1_repository.create(...
end

Am I doing something wrong? or is it a bug?

thanks

[jeremyevans]

Your example isn't self contained and doesn't have valid syntax, so it's hard to see whether or not is a bug in your code. Your example doesn't even execute the block passed.

Sequel will rollback the transaction it creates if the transaction block raises an exception. The main reason code in the block you are passing wouldn't be rolled back is if it didn't execute on the same connection used by the transaction.

Any chance you could post a minimal, self-contained example showing the issue you are having? Note that self-contained means it connects to the database, creates the related tables, and defines all methods used before calling them. It's something I could copy and paste into a file and run on my own system to reproduce the issue.

[ElectNewt]

I will try to create an small example in the morning (EU west time)

[ElectNewt]

Let's see if it is more clear now @jeremyevans; but if you need a working repo it will take me a little bit more time.

I have a repository layer to avoid accessing directly to the DB

class TableRepository
  def initialize(db = nil)
    @db = db
  end

  def create_default(random_id)
    @db[:tablename].insert(random_id:, other_properties: 0)
  end
end



class TransactionManager
  def initialize(db = nill)
    @db = db
  end

  def execute_transaction(&block)
    @db.transaction do
      block
    end
  end
end

Then I have workflows/useCases to execute logic.
It is reduced to the minimum.

class UseCase
  def initialize(table_repository, transaction_manager)
    @table_repository = table_repository
    @transaction_manager = transaction_manager
  end

  def perform(random_id)
    # validations, etc
    @transaction_manager.execute_transaction(inserts_updates_etc())
  end

  private

  def inserts_updates_etc(random_id)
    @table_repository.create_default(random_id)
  end
end

so the code before this does use_case.perform(id)

The issue is that when something goes wrong inside the TransactionManager.execute_transaction; whatever is in the block does not get rolled back.

like if you raise an exception after @table_repository.create_default(random_id) the instruction will not get rolled back. but if you change the transaction manager to:

But If i change the `TransactionManager` to this: 
class TransactionManager
  def initialize(db = nill, table_repository)
    @db = db
    @table_repository = table_repository
  end

  def execute_transaction(&block)
    @db.transaction do
      @table_repository.create_default(1) # any random id
      block
    end
  end
end

and keep the raise inside the block. the @table_repository.create_default(1) will get rolled back, but the one inside the block will not.

are they executed in different connections? I only initialize the @db once, and then I pass it around. Similar of what Dependency injection will do in other languages.

Thanks.

[rgalanakis]

transaction_manager.execute_transaction(inserts_updates_etc())

This is executing the block immediately and passing what the block returns to the method as an argument, not using block. Try this to see the error:

  def execute_transaction(&block)
    raise LocalJumpError unless block_given?
    @db.transaction do
      block
    end
  end

You want something like:

@transaction_manager.execute_transaction { inserts_updates_etc }

Also I didn't run the code but I expect it doesn't work, since execute_transaction is being passed an argument (the result of the block evaluation) but accepts no arguments.

[ElectNewt]

Exaclty this is working. Sorry i'm quite new in ruby.
this is what I changed in the transaction manager to make it working

def execute_transaction(*args, &block)
  @db.transaction do
    block.call(args)
  end
end

Thanks, very much