How do I do an atomic transactions to a database?

[orchid ridge]

Hi everyone! How do I do an atomic transaction to a database? Say I need to send, from the client side, two requests, one create and one update. And I want them to either fail or succeed together. How do I do it?

E.g. Firebase has it: https://firebase.google.com/docs/firestore/manage-data/transactions

[hybrid grail]

Transactions aren't supported yet. You might want to 👍 this issue: https://github.com/appwrite/appwrite/issues/2788

[viral wasp]

May i know when it will be implemented?

We have a live app running...but randomly some query fails and data integrity is lost.Please let me know soon abt this

[green sedge]

For now you can use appwrite functions to ensure data integrity in those cases

[viral wasp]

When using for loop in appwrite functions...some requests randomly doesnt get executed

[green sedge]

Why would you need a loop?

Also, I think that got solved in the latest versions

[viral wasp]

To execute multiple operations

[viral wasp]

I think it is reduced...recently i got one or two randomly not being executed...but far better from previous versions though as u mentioned rightly here

[green sedge]

I recommend creating a separated post with your function code. That should not be happening

[viral wasp]

Ok sure...if this time any one operation fails...I will create a post...thank u...

But is there any timeline for transactions feature to be implemented in future?

[terse pendant]

I'm also waiting for this feature in the Appwrite Cloud.

[green sedge]

Upvote this: https://github.com/appwrite/appwrite/issues/2788

[terse pendant]

I've already developed a production level project and almost ready to deploy it. But my major concern is the transactions feature. My project deals with in-app currencies and in case of any failure, users could get free money or lose their money for nothing. This is a big issue.

[green sedge]

As mentioned previously, you can achieve consistency with functions to avoid that for now

[terse pendant]

Will consider it.. but do you have an idea when Appwrite will bring this feature? Or they are already working on it?

[green sedge]

No idea unfortunately

[terse pendant]

Could you provide me a link to a code snippet or tutorial where transactions have been implemented using Cloud functions?

[naive field]

Atomic transactions can not be solved with functions. It's error prone and not reliable at all. We need transaction feature built in Appwrite there is no way around it

[viral wasp]

Transactions are not implemented yet.Not using cloud functions also.But according to apprwrite team sending a single request to cloud function and then doing multiple operations would be safest at present.

[naive field]

Just remember that the function must be running in sync and not in async.

[viral wasp]

Yes....forgot to mention abt for loop with one request at a time...instead of sending multiple async requests at a single time from that function

[sick terrace]

I was also requiring that feature but got a logic to do it by ourselves,
create a collection "transactions" then add a document to this collection to increament,
and create another function with cron timings set by you that checks for any docs present in transactions and do the process you asked and then delete the document in transactions when the operation is done,
For multi purpose operations use the same transaction document with type:"increment","collection","document" values set while creating makes it useable across whole project

[naive field]

Oh yeah. I did that as well, but it only works for incrementing and decrements.

[sick terrace]

also don't foget to add a document that takes care of the current cron running status avoiding the race condition

[naive field]

Creating document in a collection is a good solution because it does not depends on previous data

[sick terrace]

ya true

is there a way too get the number of documents present in a collection if there were in lakhs for a query?

[naive field]

lakhs? You can use listDocuments and set Query.limit to a high number

[latent fable]

this is really not recommended imo, use pagination for quick results from backend. but feel free to use Query.limit as @naive field mentioned if you still need to get results in lakhs.

[pseudo wagon]

Do you have an example of one of these transaction functions? Can't seem to find any

[lyric pasture]

@pseudo wagon To ensure atomic operations and prevent concurrent updates on documents in Appwrite, you can use cloud funcitons using the following concepts:

1. Locking Documents
   Use an additional collection to create "lock documents." For every document you want to lock, create a document with the same ID in the lock collection. If this succeeds, the lock is confirmed.
   Add a timestamp to the lock to handle potential failures in releasing the lock. If the timestamp is older than X seconds, you can safely overwrite the lock.
   Release the lock by deleting the corresponding lock document after the operation is complete.

2. Rollback Mechanism
   Implement a rollback method for each individual document update. This allows you to revert all successful operations if one fails.
   Execute all operations, check their success, and roll back if needed.

3. Retry Wrapper
   Wrap each individual method in a retry mechanism with exponential backoff. This greatly reduces the likelihood of failure for transient issues.

4. Transaction Documents
   Create a transaction document before triggering a cloud function with a pending = true flag. If the function succeeds, update the transaction document to pending = false and add a success = true field.
   This approach ensures client feedback, even if the client loses internet during execution.

This method isn't perfect but significantly reduces errors and ensures more reliable operations.

Let me know if i missed something 😉

[green sedge]

You can't lock the documents. You need to rollback in the functions the changes manually if something fails

Hmmm yes, the 4th could be a good way to solve that