Feedback-ID: i76984098:Fastmail
Message-ID: <368259fb-fd2e-4a05-89e9-a733fae6d964@aklaver.com>
Date: Sat, 5 Oct 2024 09:59:00 -0700
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Repeatable Read Isolation Level "transaction start time"
To: pgsql-general@lists.postgresql.org
References: <CAKAnmmLt2ezcf7-LgJkO_oeqK+Ei+XB6F3pHk2mnyadRq3corQ@mail.gmail.com>
 <e9dba83f-0fba-4113-a13a-58aa2a98f092@aklaver.com>
 <CANzqJaBjwtzLg_bZHkokUJbtA8gy6RpHjirfdBH9OJGfn5=tmw@mail.gmail.com>
 <28109.1727286817@sss.pgh.pa.us>
 <CAKAnmmLDpwgqu071t_Q7Fq349dYAgQim1x46U1DCAiiTcUmU2A@mail.gmail.com>
 <CANzqJaAAQFD_JvK=ChmfdGCRNP0G5gMtVBgF52bZiFjQxH8N_Q@mail.gmail.com>
 <CAKAnmmL05Lt89EOnMW111qdUOau+dYG7u8ff5o+ckKKohnNwGg@mail.gmail.com>
 <DD2C10F3-2A3C-44AB-AAC5-10BB15B15498@thebuild.com>
 <20240925215554.gfg24h5sp5aqesxv@hjp.at> <152525.1727302184@sss.pgh.pa.us>
 <20241005091424.34il2ss4noazgegx@hjp.at>
Content-Language: en-US
From: Adrian Klaver <adrian.klaver@aklaver.com>
In-Reply-To: <20241005091424.34il2ss4noazgegx@hjp.at>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Archived-At: <https://www.postgresql.org/message-id/368259fb-fd2e-4a05-89e9-a733fae6d964%40aklaver.com>
Precedence: bulk

On 10/5/24 02:14, Peter J. Holzer wrote:
> On 2024-09-25 18:09:44 -0400, Tom Lane wrote:
>> "Peter J. Holzer" <hjp-pgsql@hjp.at> writes:


>> Admittedly, that would normally not be a very long interval if BEGIN
>> did both things ... but on a busy system you could lose the CPU for
>> awhile in between.
> 
> Assuming that the system does have a global clock of sufficiently
> fine resolution which returns strictly monotonically increasing
> timestamps[1], I think the following is true:
> 
> Every snapshot divides the set of transactions into two non-overlapping
> subsets: Those which have committed early enough that their effects are
> visible in the snapshot and those which haven't. Let's call the first set
> the "earlier" transactions and the second the "later" transactions. Let's
> call the current transaction c and any transaction in the earlier set e
> (we ignore the later transactions for now).
> 
> Performing a commit and taking a snapshot take some time, but there
> should be a time t_C(e) in each commit and t_S(c) in the snapshot, such
> that t_C(e) < t_S(c) for each "earlier" transaction.

Assuming t_C is time of commit and t_S is time of snapshot, is the above 
not the crux of the matter? Namely when in the current transaction the 
snapshot is actually taken. That would determine what constitutes an 
earlier visible transaction relative to the current transaction. In 
other words I am not seeing how this changes anything?

> 
> Within each transaction each timestamp t which could be visible outside
> of the transaction must have been obtained before the commit,
> so t(e) < t_C(e) < t_S(c).
> 
> If we choose the transaction_timestamp to be >= t_S, then
> transaction_timestamp(e) < t_C(e) < t_S(c) <= transaction_timestamp(c)
> and therefore
> transaction_timestamp(e) < transaction_timestamp(c)
> 
> Such a guarantee might be useful for some applications and it's not
> (IMHO) an entirely unreasonable assumption, but it's not true for
> PostgreSQL. So a programmer should be aware of that.
> 
>          hp


-- 
Adrian Klaver
adrian.klaver@aklaver.com