static void
compactify_tuples(itemIdCompact itemidbase, int nitems, Page page, bool presorted)
{
    PageHeader  phdr = (PageHeader) page;
    Offset      upper;
    Offset      copy_tail;
    Offset      copy_head;
    itemIdCompact itemidptr;
    int         i;

    /* Code within will not work correctly if nitems == 0 */
    Assert(nitems > 0);

    if (presorted)
    {
        /*
         * 'itemidbase' is already in the optimal order, i.e, lower item
         * pointers have a higher offset.  This allows us to memmove() the
         * tuples up to the end of the page without having to worry about
         * overwriting other tuples that have not been moved yet.
         *
         * There's a good chance that there are tuples already right at the
         * end of the page that we can simply skip over because they're
         * already in the correct location within the page.  We'll do that
         * first...
         */
        upper = phdr->pd_special;
        i = 0;
        do
        {
            itemidptr = &itemidbase[i];
            if (upper != itemidptr->itemoff + itemidptr->alignedlen)
                break;
            upper -= itemidptr->alignedlen;

            i++;
        } while (i < nitems);

        /*
         * Now that we've found the first tuple that needs to be moved, we can
         * do the tuple compactification.  We try and make the least number of
         * memmove() calls and only call memmove() when there's a gap.  When
         * we see a gap we just move all tuples after the gap up until the
         * point of the last move operation.
         */
        copy_tail = copy_head = itemidptr->itemoff + itemidptr->alignedlen;
        for (; i < nitems; i++)
        {
            ItemId      lp;

            itemidptr = &itemidbase[i];
            lp = PageGetItemId(page, itemidptr->offsetindex + 1);

            if (copy_head != itemidptr->itemoff + itemidptr->alignedlen)
            {
                memmove((char *) page + upper,
                        page + copy_head,
                        copy_tail - copy_head);

                /*
                 * We've now moved all tuples already seen, but not the
                 * current tuple, so we set the copy_tail to the end of this
                 * tuple so it can be moved in another iteration of the loop.
                 */
                copy_tail = itemidptr->itemoff + itemidptr->alignedlen;
            }
            /* shift the target offset down by the length of this tuple */
            upper -= itemidptr->alignedlen;
            /* point the copy_head to the start of this tuple */
            copy_head = itemidptr->itemoff;

            /* update the line pointer to reference the new offset */
            lp->lp_off = upper;

        }

        /* move the remaining tuples. */
        memmove((char *) page + upper,
                page + copy_head,
                copy_tail - copy_head);
    }
    else
    {
        PGAlignedBlock scratch;
        char       *scratchptr = scratch.data;

        /*
         * Non-presorted case:  The tuples in the itemidbase array may be in
         * any order.  So, in order to move these to the end of the page we
         * must make a temp copy of each tuple that needs to be moved before
         * we copy them back into the page at the new offset.
         *
         * If a large percentage of tuples have been pruned (>75%) then we'll
         * copy these into the temp buffer tuple-by-tuple, otherwise, we'll
         * just do a single memcpy() for all tuples that need to be moved.
         * When so many tuples have been removed there's likely to be a lot of
         * gaps and it's unlikely that many non-movable tuples remain at the
         * end of the page.
         */
        if (nitems < PageGetMaxOffsetNumber(page) / 4)
        {
            i = 0;
            do
            {
                itemidptr = &itemidbase[i];
                memcpy(scratchptr + itemidptr->itemoff, page + itemidptr->itemoff,
                       itemidptr->alignedlen);
                i++;
            } while (i < nitems);

            /* Set things up for the compactification code below */
            i = 0;
            itemidptr = &itemidbase[0];
            upper = phdr->pd_special;
        }
        else
        {
            upper = phdr->pd_special;

            /*
             * Many tuples are likely to already be in the correct location.
             * There's no need to copy these into the temp buffer.  Instead
             * we'll just skip forward in the itemidbase array to the position
             * that we do need to move tuples from so that the code below just
             * leaves these ones alone.
             */
            i = 0;
            do
            {
                itemidptr = &itemidbase[i];
                if (upper != itemidptr->itemoff + itemidptr->alignedlen)
                    break;
                upper -= itemidptr->alignedlen;

                i++;
            } while (i < nitems);

            /* Copy all tuples that need to be moved into the temp buffer */
            memcpy(scratchptr + phdr->pd_upper,
                   page + phdr->pd_upper,
                   upper - phdr->pd_upper);
        }

        /*
         * Do the tuple compactification.  itemidptr is already pointing to
         * the first tuple that we're going to move.  Here we collapse the
         * memcpy calls for adjacent tuples into a single call.  This is done
         * by delaying the memcpy call until we find a gap that needs to be
         * closed.
         */
        copy_tail = copy_head = itemidptr->itemoff + itemidptr->alignedlen;
        for (; i < nitems; i++)
        {
            ItemId      lp;

            itemidptr = &itemidbase[i];
            lp = PageGetItemId(page, itemidptr->offsetindex + 1);

            /* copy pending tuples when we detect a gap */
            if (copy_head != itemidptr->itemoff + itemidptr->alignedlen)
            {
                memcpy((char *) page + upper,
                       scratchptr + copy_head,
                       copy_tail - copy_head);

                /*
                 * We've now copied all tuples already seen, but not the
                 * current tuple, so we set the copy_tail to the end of this
                 * tuple.
                 */
                copy_tail = itemidptr->itemoff + itemidptr->alignedlen;
            }
            /* shift the target offset down by the length of this tuple */
            upper -= itemidptr->alignedlen;
            /* point the copy_head to the start of this tuple */
            copy_head = itemidptr->itemoff;

            /* update the line pointer to reference the new offset */
            lp->lp_off = upper;

        }

        /* Copy the remaining chunk */
        memcpy((char *) page + upper,
               scratchptr + copy_head,
               copy_tail - copy_head);
    }

    phdr->pd_upper = upper;
}

1. 已经排好序了

'itemidbase'已经处于最优的顺序。这意味着较低的元指针（item pointers）具有较高的偏移量。这样可以使用memmove()函数将元组移动到页面的末尾，而无需担心覆盖尚未移动的其他元组。

此外，很可能存在一些已经位于页面末尾的元组，我们可以简单地跳过它们，因为它们在页面中已经处于正确的位置。

已经找到了需要移动的第一个元组，可以进行元组压缩。我们尽量使memmove()调用的次数最少，并且只在有间隔时调用memmove()。当我们发现间隔时，我们只需将所有位于间隔之后的元组移动到最后一次移动操作之后的位置。

2. 非排序

非排序情况：itemidbase数组中的元组可以是任意顺序。因此，为了将这些元组移动到页面的末尾，我们必须在对它们进行复制并移动到新偏移量之前，将每个需要移动的元组临时复制一份。

如果被修剪的元组占很大比例（>75%），那么我们将逐个将这些元组复制到临时缓冲区中，否则，我们将仅为需要移动的所有元组执行单个memmove()操作。当删除如此多的元组时，很可能存在许多间隙，并且很可能不再有大量不可移动的元组留在页面的末尾。

很可能有许多元组已经位于正确的位置。没有必要将这些元组复制到临时缓冲区中，而是直接在itemidbase数组中跳到需要从其中移动元组的位置，

效果