MIME-Version: 1.0
References: <CAPqV3pRO=u1Mno06WLCFxoyxbzkYTetiqTs7WaW=_fkjRPgYhw@mail.gmail.com>
In-Reply-To: <CAPqV3pRO=u1Mno06WLCFxoyxbzkYTetiqTs7WaW=_fkjRPgYhw@mail.gmail.com>
From: Siddharth Jain <siddhsql@gmail.com>
Date: Fri, 3 May 2024 20:02:49 -0700
Message-ID: <CAPqV3pQquw63Fv_fCJzAAnUWk86qHfg1cH=+mJ2N=4LGdDyrNw@mail.gmail.com>
Subject: Re: Question regarding how databases support atomicity
To: pgsql-general@lists.postgresql.org
Content-Type: multipart/alternative; boundary="000000000000e8c02306179812c9"
Archived-At: <https://www.postgresql.org/message-id/CAPqV3pQquw63Fv_fCJzAAnUWk86qHfg1cH%3D%2BmJ2N%3D4LGdDyrNw%40mail.gmail.com>
Precedence: bulk

--000000000000e8c02306179812c9
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Fri, May 3, 2024 at 8:00=E2=80=AFPM Siddharth Jain <siddhsql@gmail.com> =
wrote:

> I am trying to sharpen my understanding of databases. Let's say there is
> an operation foo as part of the public API that internally translates to
> more than 1 operation - I am sure there are examples like this in postgre=
s.
> So to do foo we have to do following in order in all or none fashion:
>
> 1. Step 1
> 2. Step 2
> 3. Step 3
>
> The way I understand this is that if there is a failure in-between, we
> start undoing and reverting the previous operations one by one. But what =
if
> there is a failure and we are not able to revert an operation. How is tha=
t
> situation handled? e.g., something failed when we tried to do Step 3. now
> we revert Step 2 and succeed. but when we try to revert step 1 we fail.
> what happens now? To me, it seems its impossible to guarantee true
> atomicity in general.
>
> S.
>

--000000000000e8c02306179812c9
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><br></div><br><div class=3D"gmail_quote"><div dir=3D"ltr" =
class=3D"gmail_attr">On Fri, May 3, 2024 at 8:00=E2=80=AFPM Siddharth Jain =
&lt;<a href=3D"mailto:siddhsql@gmail.com">siddhsql@gmail.com</a>&gt; wrote:=
<br></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8=
ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr=
">I am trying to sharpen my understanding of databases. Let&#39;s say there=
 is an operation foo as part of the public API that internally translates t=
o more than 1 operation - I am sure there are examples like this in postgre=
s. So to do foo we have to do following in order in all or none fashion:<di=
v><br></div><div>1. Step 1</div><div>2. Step 2</div><div>3. Step 3</div><di=
v><br></div><div>The way I understand this is that if there is a failure in=
-between, we start undoing and reverting the previous operations one by one=
. But what if there is a failure and we are not able to revert an operation=
. How is that situation handled? e.g., something failed when we tried to do=
 Step 3. now we revert Step 2 and succeed. but when we try to revert step 1=
 we fail. what happens now? To me, it seems its impossible to guarantee tru=
e atomicity in general.</div><div><br></div><div>S.</div></div>
</blockquote></div>

--000000000000e8c02306179812c9--