Clean up a couple of ad-hoc computations of the maximum number of tuples

on a page, as suggested by ITAGAKI Takahiro.  Also, change a few places
that were using some other estimates of max-items-per-page to consistently
use MaxOffsetNumber.  This is conservatively large --- we could have used
the new MaxHeapTuplesPerPage macro, or a similar one for index tuples ---
but those places are simply declaring a fixed-size buffer and assuming it
will work, rather than actively testing for overrun.  It seems safer to
size these buffers in a way that can't overflow even if the page is
corrupt.

diff --git a/src/backend/access/gist/gistvacuum.c b/src/backend/access/gist/gistvacuum.c
index 239e9e4d7f7e35fe5f51ef2dca790a96bd09cb14..f04ea4cd3efb65f81e1012720f354a51b2188de7 100644 (file)
--- a/src/backend/access/gist/gistvacuum.c
+++ b/src/backend/access/gist/gistvacuum.c
@@ -52,7 +52,7 @@ gistVacuumUpdate( GistVacuum *gv, BlockNumber blkno, bool needunion ) {
        int             lenaddon=4, curlenaddon=0, ntodelete=0;
        IndexTuple      idxtuple, *addon=NULL;
        bool            needwrite=false;
-       OffsetNumber    todelete[ BLCKSZ/SizeOfIptrData ];
+       OffsetNumber    todelete[MaxOffsetNumber];
        ItemPointerData *completed=NULL;
        int             ncompleted=0, lencompleted=16;
 
@@ -439,7 +439,7 @@ gistbulkdelete(PG_FUNCTION_ARGS) {
                page   = (Page) BufferGetPage(buffer);
 
                if ( GistPageIsLeaf(page) ) {
-                       OffsetNumber todelete[BLCKSZ/SizeOfIptrData];
+                       OffsetNumber todelete[MaxOffsetNumber];
                        int ntodelete = 0;
 
                        LockBuffer(buffer, GIST_UNLOCK);

diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index d9eb88247239572c08f2a077a5a815e2fcce92e1..a6dd9d3e93c20a7e015ddfeeb825e196f2576e9a 100644 (file)
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -584,7 +584,7 @@ btbulkdelete(PG_FUNCTION_ARGS)
        IndexBulkDeleteResult *result;
        double          tuples_removed;
        double          num_index_tuples;
-       OffsetNumber deletable[BLCKSZ / sizeof(OffsetNumber)];
+       OffsetNumber deletable[MaxOffsetNumber];
        int                     ndeletable;
        Buffer          buf;
        BlockNumber num_pages;

diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 3db43c4b7a1f1e89912f7103f2b5449fe1f84742..7f31a39d558bb5099f72a2be8efc2a01268fa196 100644 (file)
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -2407,7 +2407,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
                {
                        Buffer          buf;
                        Page            page;
-                       OffsetNumber unused[BLCKSZ / sizeof(OffsetNumber)];
+                       OffsetNumber unused[MaxOffsetNumber];
                        OffsetNumber offnum,
                                                maxoff;
                        int                     uncnt;
@@ -2896,7 +2896,7 @@ vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages)
 static void
 vacuum_page(Relation onerel, Buffer buffer, VacPage vacpage)
 {
-       OffsetNumber unused[BLCKSZ / sizeof(OffsetNumber)];
+       OffsetNumber unused[MaxOffsetNumber];
        int                     uncnt;
        Page            page = BufferGetPage(buffer);
        ItemId          itemid;

diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c
index c2d5f83e06f25453a8925f57e97d2796923954fd..65b01bf1eddccbad27c9073a5f36452dbc1e989a 100644 (file)
--- a/src/backend/commands/vacuumlazy.c
+++ b/src/backend/commands/vacuumlazy.c
@@ -60,9 +60,6 @@
 #define REL_TRUNCATE_MINIMUM   1000
 #define REL_TRUNCATE_FRACTION  16
 
-/* MAX_TUPLES_PER_PAGE can be a conservative upper limit */
-#define MAX_TUPLES_PER_PAGE            ((int) (BLCKSZ / sizeof(HeapTupleHeaderData)))
-
 
 typedef struct LVRelStats
 {
@@ -259,7 +256,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
                 * dead-tuple TIDs, pause and do a cycle of vacuuming before we
                 * tackle this page.
                 */
-               if ((vacrelstats->max_dead_tuples - vacrelstats->num_dead_tuples) < MAX_TUPLES_PER_PAGE &&
+               if ((vacrelstats->max_dead_tuples - vacrelstats->num_dead_tuples) < MaxHeapTuplesPerPage &&
                        vacrelstats->num_dead_tuples > 0)
                {
                        /* Remove index entries */
@@ -554,7 +551,7 @@ static int
 lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
                                 int tupindex, LVRelStats *vacrelstats)
 {
-       OffsetNumber unused[BLCKSZ / sizeof(OffsetNumber)];
+       OffsetNumber unused[MaxOffsetNumber];
        int                     uncnt;
        Page            page = BufferGetPage(buffer);
        ItemId          itemid;
@@ -960,7 +957,7 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)
        maxtuples = (maintenance_work_mem * 1024L) / sizeof(ItemPointerData);
        maxtuples = Min(maxtuples, INT_MAX);
        /* stay sane if small maintenance_work_mem */
-       maxtuples = Max(maxtuples, MAX_TUPLES_PER_PAGE);
+       maxtuples = Max(maxtuples, MaxHeapTuplesPerPage);
 
        vacrelstats->num_dead_tuples = 0;
        vacrelstats->max_dead_tuples = (int) maxtuples;

diff --git a/src/backend/nodes/tidbitmap.c b/src/backend/nodes/tidbitmap.c
index 1064a38c3482e6413cecfaabbdea221f149575ed..aeb8cf3326631223c52a68f736d2ca75ef50c4ce 100644 (file)
--- a/src/backend/nodes/tidbitmap.c
+++ b/src/backend/nodes/tidbitmap.c
@@ -42,7 +42,7 @@
  * the per-page bitmaps variable size.  We just legislate that the size
  * is this:
  */
-#define MAX_TUPLES_PER_PAGE  ((BLCKSZ - 1) / MAXALIGN(offsetof(HeapTupleHeaderData, t_bits) + sizeof(ItemIdData)) + 1)
+#define MAX_TUPLES_PER_PAGE  MaxHeapTuplesPerPage
 
 /*
  * When we have to switch over to lossy storage, we use a data structure

diff --git a/src/include/access/htup.h b/src/include/access/htup.h
index 367bb6994f744ffe19119c93255f81d9f2d19f16..20a73722386c29771adc8e827f835efe367348ad 100644 (file)
--- a/src/include/access/htup.h
+++ b/src/include/access/htup.h
@@ -323,6 +323,16 @@ do { \
 #define MaxTupleSize   \
        (BLCKSZ - MAXALIGN(sizeof(PageHeaderData) + MaxSpecialSpace))
 
+/*
+ * MaxHeapTuplesPerPage is an upper bound on the number of tuples that can
+ * fit on one heap page.  (Note that indexes could have more, because they
+ * use a smaller tuple header.)  We arrive at the divisor because each tuple
+ * must be maxaligned, and it must have an associated item pointer.
+ */
+#define MaxHeapTuplesPerPage   \
+       ((int) ((BLCKSZ - offsetof(PageHeaderData, pd_linp)) / \
+                       (MAXALIGN(offsetof(HeapTupleHeaderData, t_bits)) + sizeof(ItemIdData))))
+
 /*
  * MaxAttrSize is a somewhat arbitrary upper limit on the declared size of
  * data fields of char(n) and similar types.  It need not have anything