How long will a 64 bit Transaction-ID last in PostgreSQL? • Hacker News Board

Re: How long will a 64 bit Transaction-ID last in PostgreSQL?

#31

Post by londons_explore » Tue, Feb 05, 2019, 11:39 PM UTC

anarazel wrote: post #22

devit wrote: post #20

Earlier quoted context omitted.

Why write the transaction ids in the tuples at all? In most production cases, transactions in flight are going to affect a small amount of rows overall, so you can just keep the data in memory, and store it to disk in a separate table if it gets large.

You need to access that data from different connections, so it needs to be correctly locked etc. Looking purely at the tuple you need to know where to look for the tuple visibility information. Accessing data stored in some datastructure off to the side will also have drastically worse cache locality then just storing it alongside with the data. E.g. for a sequential scan these checks need to be done for every tuple,…

Except in most usecases, the tuple is old enough that it was committed long ago and visible to everyone.

It's only a tiny fraction of tuples which are recently committed and visibility rules come into play. That can be a special-cased slow-path

Re: How long will a 64 bit Transaction-ID last in PostgreSQL?

#32

Post by anarazel » Wed, Feb 06, 2019, 5:02 AM UTC

jtc331 wrote: post #24

Aeolun wrote: post #18

Earlier quoted context omitted.

Isn’t 64 bit, even duplicated, completely irrelevant to how much data is generally stored in a row?

Any overhead is generally considered irrelevant when you’re on a small database. For example, going from 50GB in a table to 75GB is 50% overhead, but easily handled in a time where you just pay for more GB on RDS. That doesn’t hold true when working on multi-terabyte tables or databases when physical disk space in a chassis is actually a boundary you have to consider.

> Any overhead is generally considered irrelevant when you’re on a small database. For example, going from 50GB in a table to 75GB is 50% overhead, but easily handled in a time where you just pay for more GB on RDS.

Often disk-space is less the issue, and it's more about whether things can fit in memory or not...

Re: How long will a 64 bit Transaction-ID last in PostgreSQL?

#33

Post by anarazel » Wed, Feb 06, 2019, 5:05 AM UTC

londons_explore wrote: post #31

anarazel wrote: post #22

Earlier quoted context omitted.

You need to access that data from different connections, so it needs to be correctly locked etc. Looking purely at the tuple you need to know where to look for the tuple visibility information. Accessing data stored in some datastructure off to the side will also have drastically worse cache locality then just storing it alongside with the data. E.g. for a sequential scan these checks need to be done for every tuple,…

Except in most usecases, the tuple is old enough that it was committed long ago and visible to everyone. It's only a tiny fraction of tuples which are recently committed and visibility rules come into play. That can be a special-cased slow-path

In a system like postgres' current heap you cannot know whether it was committed long ago, without actually looking in that side table (or modifying the page the one time you do, to set a hint bit). You pretty fundamentally need something like the transactionid to do so.

Also, in OLTP workload you often have a set of pretty hotly modified data, where you then actually very commonly access recently modified tuples and thus need to do visibility checks.

There's obviously systems with different visibility architectures (either by reducing the types of concurrency allowed, using page level information about recency of modification + something undo based), but given this post is about postgres, I fail to see what you're arguing about here.