Doctrine 2 - ORM

Transactions should sent in group not chunked

Details

  • Type: Bug Bug
  • Status: Closed Closed
  • Priority: Critical Critical
  • Resolution: Invalid
  • Affects Version/s: 2.2, 2.3, Git Master
  • Fix Version/s: None
  • Component/s: Mapping Drivers
  • Security Level: All
  • Labels:
  • Environment:
    MySQL 5.5 / Percona

Description

In UnitOfWork::commit() it seems that a transaction is done like this:

  • will send separate queries for transaction start
  • compute the queries/send them to the db driver
  • execute the commit statement
  • optionally execute rollback

The question would be, should my webserver have some issues with resources, wouldn't this part of the code be a pain for the DB?

I don't know how mysql, for example, handles sending the transaction in chunks as opposed to sending it in 2/3 statements ( begin + ops and commit / + revert in case of failure) or in mySQL,l the transaction is evaluated on COMMIT statement only?

If my assumption about how MySQL works, locking everything as soon as the statement is on the server, then shouldn't Doctrine use a internal buffer for sending transactions to the DB driver in order to avoid all sorts of problems that appear in high concurency scenarios?

Best regards.

Activity

Ascending order - Click to sort in descending order
Hide
Permalink
Marco Pivetta added a comment -

Invalid IMO. This is an over-complication that (in such high load scenarios) is handled by clustering/load balancing. Not a problem of the ORM, since smashing all statements together will just make it impossible to trap any problems.

Show
Marco Pivetta added a comment - Invalid IMO. This is an over-complication that (in such high load scenarios) is handled by clustering/load balancing. Not a problem of the ORM, since smashing all statements together will just make it impossible to trap any problems.
Hide
Permalink
Marco Pivetta added a comment -

This performance improvement has been discussed directly on IRC.

The original problem is related to deadlocks and small transactions, which is not anyway solved by this issue.

Otherwise, this improvement requires a PoC that shows that it is possible to have exceptions still showing the query that caused the failure.

Show
Marco Pivetta added a comment - This performance improvement has been discussed directly on IRC. The original problem is related to deadlocks and small transactions, which is not anyway solved by this issue. Otherwise, this improvement requires a PoC that shows that it is possible to have exceptions still showing the query that caused the failure.
Hide
Permalink
Marco Pivetta added a comment -

Sorry, was unclear. I basically mean that any approach squashing the queries into a single chunk sent to the DB should also allow us to get computed insert IDs and eventual exceptions should bubble up with the query that caused them.

Show
Marco Pivetta added a comment - Sorry, was unclear. I basically mean that any approach squashing the queries into a single chunk sent to the DB should also allow us to get computed insert IDs and eventual exceptions should bubble up with the query that caused them.

People

  • Assignee:
    Marco Pivetta
    Reporter:
    Florin Patan
Vote (0)
Watch (2)

Dates

  • Created:
    Updated:
    Resolved: