postgres源码解析48 Btree节点分裂点确认流程--1

/*
 *    btsplit() -- split a tree node if necessary when adding a tuple.
 *
 * On entry, tup is the tuple we are attempting to add to the tree,
 * and b is the buffer holding the page to which we will add it.
 *
 * Return value is a new buffer holding the page to which we did add
 * the tuple (this could be the same as b, or different if the tuple
 * cross-linked to a new page).
 */
Buffer
btsplit(Relation rel,
        Buffer b,
        Item tuple,
        int keylen,
        IndexTuple itup,
        OffsetNumber itup_off)
{
    Page        page = BufferGetPage(b);
    BTPageOpaque opaque = (BTPageOpaque) PageGetSpecialPointer(page);
    Buffer        rbuf;
    char       *datapage;
    OffsetNumber itup_index;
    ItemId        itemid;
    IndexTuple    newitem;
    Size        tuplen;
    ItemIdData    hitem;
    Page        rpage;
    BTPageOpaque ropaque;
    OffsetNumber offnum;
    OffsetNumber offnum_min;
    OffsetNumber offnum_max;
    bool        is_root;
    bool        is_only;
    BlockNumber rblkno = InvalidBlockNumber;
 
    /*
     * Check to see if the node needs to be split.  It does if the new tuple
     * won't fit on an empty page.  (An empty page cannot hold a new tuple
     * because of the item pointer linking OFFSET_TO_NO_END_OF_LINE_INDEX_ID
     * item.)
     */
    tuplen = IndexTupleDSize(*itup) + keylen;
    if (PageGetFreeSpace(page) < MAXALIGN(tuplen))
    {
        /*
         * Guess that we'll need a new right sibling with 50% of the current
         * page's space.  This should be the normal case during index population.
         * Note that we are assuming the new tuple is about the same size as
         * other tuples on the page.
         */
        Size        rbytes = (PageGetFreeSpace(page) + tuplen) / 2;
        BlockNumber blkno = BufferGetBlockNumber(b);
        BlockNumber rblkno;
 
        rbytes = Max(rbytes, BLCKSZ / 8); /* guarantee minimum space */
 
        /* Choose the new right sibling as the next physical block */
        rblkno = blkno + 1;
 
        /*
         * If the page we are trying to split is the rightmost page on its
         * level, we create a new right sibling on the next higher level.
         * This is the "top of the tree" case of an index.  This case should
         * occur very rarely, since it requires that there already be a
         * whole heap of leaf-only levels.  The probability of this occurring
         * is approximately 1 in NIndexTuples/BLCKSZ.