MIME-Version: 1.0
From: David Rowley <dgrowleyml@gmail.com>
Date: Mon, 13 Apr 2026 16:35:03 +1200
Message-ID: 
 <CAApHDvq=eEdw2Qp+aSzSOtTSe+h0fnVQ55CcTNqBkLDYiRZmxw@mail.gmail.com>
Subject: Add bms_offset_members() function for bitshifting Bitmapsets
To: PostgreSQL Developers <pgsql-hackers@lists.postgresql.org>
Content-Type: multipart/mixed; boundary="000000000000585712064f50023c"
Archived-At: 
 <https://www.postgresql.org/message-id/CAApHDvq%3DeEdw2Qp%2BaSzSOtTSe%2Bh0fnVQ55CcTNqBkLDYiRZmxw%40mail.gmail.com>
Precedence: bulk

--000000000000585712064f50023c
Content-Type: text/plain; charset="UTF-8"

(v20 material)

While working on some new code which required offsetting the members
of a Bitmapset, I decided to go and write a function to do this rather
than copy the various other places where we manually construct a new
set with a bms_next_member() -> bms_add_member() loop. The new use
case I have is from pulling varattnos from a scan's targetlist, which
there could be several hundred Vars in. I considered this might be
noticeably expensive.

The current manual way we have of doing this is a bit laborious since
we're only doing 1 member per bms_next_member() loop, and also, if the
set has multiple words, we may end up doing several repallocs to
expand the set, perhaps as little as 1 word at a time. That's not to
mention the rather repetitive code that we have to do this in various
places that might be nice to consolidate.

I've attached a patch which adds bms_offset_members(), which does
bitshifting to move the members up or down by the given offset. While
working on this I made a few choices which might be worth a revisit:

1) The function modifies the given set in-place rather than making a new set.
2) The function will ERROR if any member would go above INT_MAX. These
would be inaccessible, and that seems weird/wrong.
3) When offsetting by a negative value, members that would go below
zero fall out of the set silently.

For #1; my original use-case that made me write this didn't need a
copy, so I wrote the function to modify the set in-place. After
hunting down and replacing the relevant existing bms_next_member()
loops with the new function, I noticed all these seem to need a copy.
Currently, I have coded the patch to do
bms_offset_members(bms_copy(set), ...), but that's a little
inefficient as it *could* result in a palloc for the copy then a
repalloc in the offset. If bms_offset_members() just created a new
set, then it could palloc() a set to the exact required size.  The
counterargument to that is that I don't really want to copy the set
for my intended use case. I thought about two versions, but thought
that might be overkill. There could be a boolean parameter to define
that, but we don't do that anywhere else in bitmapset.c, or we could
avoid a copy-paste of the code with an always-inlined helper function.
I couldn't decide, so left it as-is.

For #2, I could have equally made these fall off the top of the set,
but I thought we might want to know about it in the unlikely event
that this ever happens.

#3 We commonly want to get rid of system columns from a
pull_varattnos() set which is offset by
FirstLowInvalidHeapAttributeNumber, so those disappearing silently is
what most use cases seem to want. I expect that's not for revisiting,
but I listed this one anyway as it flies in the face of #2.

Patch attached. Comments welcome.

David

--000000000000585712064f50023c
Content-Type: application/octet-stream;
	name="v1-0001-Introduce-bms_offset_members-function.patch"
Content-Disposition: attachment;
	filename="v1-0001-Introduce-bms_offset_members-function.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mnwow55k0>
X-Attachment-Id: f_mnwow55k0
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=
--000000000000585712064f50023c--