In order to share the running transaction into a DAO style data management class, I have wrapped the transaction in an Arc<Mutex> and pass it into the DAO.
The issue is, once the transaction is in there I cannot call commit() on it because it cannot be moved out of the Arc<Mutex> anymore, as the commit requires a mut self.
Any ideas on how to work around this?
This screams of XY problem. You’ve gotten a new problem from using this method and you’re asking for help for that, but probably there is an underlying better solution that solves your actual use case without running into this problem at all.
That’s not what I said. Read about the XY problem and then come back and explain what you actually want to achieve, and give some more information like code examples.
Well. I did read up on the “XY” problem and apparently you assume that what I want to do is somehow bad practice.
To elaborate more on the problem: I am writing an axum backend which (like other backends) needs to do stuff in the database. As some endpoints update the database (and sometimes over multiple sql statements) I want to pass around the transaction as this embodies the connection I am using to update the database.
To separate the axum stuff (parameters, urls and whatnot) from the actual database logic, I’ve first pulled out all the database interactions into separate functions. Because those functions are logically groups (e.g. stuff happening with invoices, others with contacts etc), I thought it was a good idea to create a “dao” struct (and agreed: my OO brain kicked in here which might be debatable). This would group the interactions for each logical domain into a short-lived data access struct.
To prevent passing around the transaction/connection, i wanted to pass that along during construction, so the functions in the DAO could just access the connection when needed.
Non “OO” would be fine to be honest (just having all the DAO as functions in a separate package).
Sorry, no code, not at the computer atm.
(And yes, I am aware that rust is not OO, put away the pitchforks please 🙏)
Transactions should be short lived, they block data on the database side from acessing those tables or rows. Best to not jole onto a transaction that long and instead gather your data first or rethink your access patterns to your data base.
But arc does give you a try_unwrap which returns the inner type if there is only one strong copy left. And mutex gives you an into_inner to move out of it. But really transactions should not be held for a long period of time.
Seems like the into_inner is the way (i see other references to it).
And yes, transactions should be short-lived, this is just about delegating it to the responsible component.
Not sure why you need an arc mutex to delegate it to the responsible component. Seems like the type of thing that should not cross thread boundaries nor be cloned multiple times.
Make sure there’s only one strong reference and call Arc::into_inner to move it out of the Arc. Same can be done with Mutex::into_inner to move the transaction out of the mutex
