MIME-Version: 1.0
References: <CAMT0RQT_0qVxcTT6ycM20QUN-pEQ6iMLbz6gLWgLpeF0NmNOUA@mail.gmail.com>
 <CAExHW5t54GPKFbW3KLzintJ6jMMRYwb-t2Fjm4JTxEcZbGDomA@mail.gmail.com>
 <CAMT0RQTHoL8S7OonFWC_aDSC-2oX7BGBBLAQ+OOBhRPcxV2eiw@mail.gmail.com>
 <CAMT0RQQAH1a8kY-mx7B07Uzn3T_zeaU9detqFFtW36_k67Su+A@mail.gmail.com>
 <CAMT0RQQr7KtPAY903+F42csiHc1EPHo70Xji-znkxEhwdoKa6w@mail.gmail.com>
 <CAMT0RQSNHFffbCmDNxQogVBD8H5gTDJNwhUR2btCVE+Lq1sGGw@mail.gmail.com>
 <CAMT0RQTEFGctCfgVx3u2XgVRCAj_QURV2tfdzL0HOQi=u0sV2A@mail.gmail.com>
 <CAApHDvr8ay+31Wd0TptDGp8cAg2-NOnWddx8csnUE3R03EbvZw@mail.gmail.com>
 <CAMT0RQShjXPPdXQS-5uzDC3bXt+QEZR5tO02o1NHdXWNu2quvw@mail.gmail.com>
 <CAN4CZFOTOX1nFkPrmM7fQ9qnrccvjwywXPf4Eo7C+DF-h-x96g@mail.gmail.com>
 <CAMT0RQTbQxjdN5nv6M_HhFWiLqdT84=NYBM1ZYQKaAcf8Ufyaw@mail.gmail.com>
 <CAN4CZFOjG2kUciKeVBpxrHJZNkZuzY_Q5ij_qpDZcAS3Ak2GxA@mail.gmail.com>
 <CAMT0RQStjytRrGTe0X03ErC7anwxNRHAULYBsSmdWZV3fr4-Dg@mail.gmail.com>
 <CAMT0RQROPMSPwfxAUCm1gZs9cUr7FmvwX+eO6Wzq_wWdd6eEAQ@mail.gmail.com>
 <CAMT0RQQ8DX+K7OTw3Lg+Yp2ew8TsZduiqtPszfiBixcpxKbz-A@mail.gmail.com>
 <CAApHDvo29-vQz=xV6+x5hU--NZ9qGPXsCNBuOAf88pAHjTpvvQ@mail.gmail.com> <CAMT0RQQT1dQTPj4etRTc0877mirCPVKzjbF_U5KRAyPwhHMr0Q@mail.gmail.com>
In-Reply-To: <CAMT0RQQT1dQTPj4etRTc0877mirCPVKzjbF_U5KRAyPwhHMr0Q@mail.gmail.com>
From: Hannu Krosing <hannuk@google.com>
Date: Wed, 28 Jan 2026 18:29:58 +0100
Message-ID: <CAMT0RQQKWWrYYYQ8QNurs7hXBC5DwBAV6b0JmHKvJk7wZnup0g@mail.gmail.com>
Subject: Re: Patch: dumping tables data in multiple chunks in pg_dump
To: David Rowley <dgrowleyml@gmail.com>
Cc: Zsolt Parragi <zsolt.parragi@percona.com>, 
	Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>, 
	PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>, 
	Nathan Bossart <nathandbossart@gmail.com>
Content-Type: multipart/mixed; boundary="000000000000b8a90406497617e5"
Archived-At: <https://www.postgresql.org/message-id/CAMT0RQQKWWrYYYQ8QNurs7hXBC5DwBAV6b0JmHKvJk7wZnup0g%40mail.gmail.com>
Precedence: bulk

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

v13 has added a proper test comparing original and restored table data


On Tue, Jan 27, 2026 at 11:43=E2=80=AFPM Hannu Krosing <hannuk@google.com> =
wrote:
>
> Hi David
>
> Thanks for reviewing.
>
> Please hold back reviewing this v12 patch until I have verified that
> it passes CfBot and until I have finished my testing with 17TB table.
>
> I would appreciate pointers or help on adding the data correctness
> tests to the tap tests as real tests.
> For now I put them as DO$$ ... $$ blocks in the parallel test .pl and
> I check manually that the table data checksums match
> If we add them we should add them to other places in pg_dump tests as
> well. Currently we just test that dump and restore do not fail, not
> that the restored data is correct.
>
> On Fri, Jan 23, 2026 at 3:15=E2=80=AFAM David Rowley <dgrowleyml@gmail.co=
m> wrote:
> >
> > On Fri, 23 Jan 2026 at 06:05, Hannu Krosing <hannuk@google.com> wrote:
> > >
> > > Fixing all the warnings
> >
> > I think overall this needs significantly more care and precision than
> > what you've given it so far. For example, you have:
> >
> > +    if(dopt->max_table_segment_pages !=3D InvalidBlockNumber)
> > +        appendPQExpBufferStr(query,
> > "pg_relation_size(c.oid)/current_setting('block_size')::int AS
> > relpages, ");
> > +    else
> > +        appendPQExpBufferStr(query, "c.relpages, ");
> >
> > Note that pg_class.relpages is "int". Later the code in master does:
> >
> > tblinfo[i].relpages =3D atoi(PQgetvalue(res, i, i_relpages));
>
> I have now fixed the base issue by changing the data type of
> TableInfo.relpages to BlockNumber, and also changed the way we get it
> by
>
> 1. converting it to unsigned int ( c.relpages::oid ) in the query
> 2. reading it from the result using strtoul()
>
> (technically it should have been enough to just use strtoul() as it
> already wraps signed ints to unsigned ones, but having it converted in
> the query seems cleaner)
>
> This allowed removing casts to (BlockNumber) everywhere where
> .relpages was used.
>
> Functionally value was ever only used for ordering and even this
> loosley, which explains why patch v10 did not break anything.
>
> I also changed the data type of TocEntry.dataLength from pgoff_t to
> uint64. The current clearly had an overflow in case when off_t was 32
> bit and sum of relpages from heap and toast was larger than allowed
> for it.
>
> > If you look in vacuum.c, you'll see "pgcform->relpages =3D (int32)
> > num_pages;" that the value stored in relpages will be negative when
> > the table is >=3D 16TB (assuming 8k pages). Your pg_relation_size
> > expression is not going to produce an INT. It'll produce a BIGINT, per
> > "select pg_typeof(pg_relation_size('pg_class') /
> > current_setting('block_size')::int);". So the atoi() can receive a
> > string of digits representing an integer larger than INT_MAX in this
> > case. Looking at [1], I see:
>
> As said above this should be fixed now by using correct type in struch
> and strtoul().
> To be sure  I have now created a 17TB  table and running some tests on
> this as well.
> Will let you know here when done.
>
> > "7.22.1 Numeric conversion functions 1 The functions atof, atoi, atol,
> > and atoll need not affect the value of the integer expression errno on
> > an error. If the value of the result cannot be represented, *the
> > behavior is undefined.*"
> >
> > And testing locally, I see that my Microsoft compiler will just return
> > INT_MAX on overflow, whereas I see gcc does nothing to prevent
> > overflows and just continues to multiply by 10 regardless of what
> > overflows occur, which I think would just make the code work by
> > accident.
>
> As .relpages was only ever used for ordering parallel copies it does
> work just not optimally.
>
> The old code has similar overflow/wraparound for case when off_t is 32
> bit int and the sum of relpages from heap and toast table is above
> INT_MAX
>
> I have removed the whole part where this was partially fixed for the
> case when one of them was > 0x7fffffff (i.e. negative) by pinning the
> dataLength to INT_MAX in that case
>
> > Aside from that, nothing in the documentation mentions that this is
> > for "heap" tables only. That should be mentioned as it'll just result
> > in people posting questions about why it's not working for some other
> > table access method. There's also not much care for white space.
> > You've introduced a bunch of whitespace changes unrelated to code
> > changes you've made, plus there's not much regard for following
> > project standard. For example, you commonly do "if(" and don't
> > consistently follow the bracing rules, e.g:
> >
> > + for(chkptr =3D optarg; *chkptr !=3D '\0'; chkptr++)
> > +     if(*chkptr =3D=3D '-')
>
> I assumed that it is the classical "single statemet -- no braces.
>
> Do we have a writeup of our coding standards somewhere ?
>
> Now this specific case is rewritten using while() so shoud be ok.
>
> > Things like the following help convey the level of care that's gone int=
o this:
> >
> > +/*
> > + * option_parse_int
> > + *
> > + * Parse integer value for an option.  If the parsing is successful, r=
eturns
> > + * true and stores the result in *result if that's given; if parsing f=
ails,
> > + * returns false.
> > + */
> > +bool
> > +option_parse_uint32(const char *optarg, const char *optname,
> >
> > i.e zero effort gone in to modify the comments after pasting them from
> > option_parse_int().
> >
> > Another example:
> >
> > + pg_log_error("%s musst be in range %lu..%lu",
> >
> > Also, I have no comprehension of why you'd use uint64 for the valid
> > range when the function is for processing uint32 types in:
>
> The uint64 there I picked up from the referenced long unsigned usage
> in pg_resetval after I managed to get pg_log_warning to print out -1
> for format %u and did not want to go to debug why that happens.
>
> I have now made all the arguments uint32
>
> > +bool
> > +option_parse_uint32(const char *optarg, const char *optname,
> > + uint64 min_range, uint64 max_range,
> > + uint32 *result)
> >
> > In its current state, it's quite hard to take this patch seriously.
> > Please spend longer self-reviewing it before posting. You could
> > temporarily hard-code something for testing which makes at least 1
> > table appear to be larger than 16TB and ensure your code works. What
> > you have is visually broken and depends on whatever the atoi
> > implementation opts to do in the overflow case. These are all things
> > diligent commiters will be testing and it's sad to see how little
> > effort you're putting into this. How do you expect this community to
> > scale with this quality level of patch submissions? You've been around
> > long enough and should know and do better.  Are you just expecting the
> > committer to fix these things for you? That work does not get done via
> > magic wand. Being on v10 already, I'd have expected the patch to be
> > far beyond proof of concept grade. If you're withholding investing
> > time on this until you see more community buy-in, then I'd suggest you
> > write that and withhold further revisions until you're happy with the
> > level of buy-in.
>
> > I'm also still not liking your de-normalised TableInfo representation
> > for "is_segment".
> > IMO, InvalidBlockNumber should be used to represent
> > open bounded ranges, and if there's no chunking, then startPage and
> > endPage will both be InvalidBlockNumber.
>
> That's what I ended up doing
>
> I switched to using startPage =3D InvalidBlockNumber to indicate that no
> chunking is in effect.
>
> This is safe because when chunking is in use I always try to set both
> chunk end pages, and lower bound I can always set the lower bound.
>
> Only for the last page is the endPage left to InvalidBlockNumber.
>
> > IMO, what you have now
> > needlessly allows invalid states where is_segment =3D=3D true and
> > startPage, endPage are not set correctly. If you want to keep the code
> > simple, hide the complexity in a macro or an inline function. There's
> > just no performance reason to materialise the more complex condition
> > into a dedicated boolean flag.

--000000000000b8a90406497617e5
Content-Type: application/x-patch; 
	name="v13-0001-changed-flag-name-to-max-table-segment-pages.patch"
Content-Disposition: attachment; 
	filename="v13-0001-changed-flag-name-to-max-table-segment-pages.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkyatksk0>
X-Attachment-Id: f_mkyatksk0
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--000000000000b8a90406497617e5--