itup.h File Reference

#include "access/tupdesc.h"
#include "access/tupmacs.h"
#include "storage/bufpage.h"
#include "storage/itemptr.h"

Include dependency graph for itup.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	IndexTupleData
struct	IndexAttributeBitMapData

Macros
#define	INDEX_SIZE_MASK   0x1FFF
#define	INDEX_AM_RESERVED_BIT
#define	INDEX_VAR_MASK   0x4000
#define	INDEX_NULL_MASK   0x8000
#define	MaxIndexTuplesPerPage

Typedefs
typedef struct IndexTupleData	IndexTupleData
typedef IndexTupleData *	IndexTuple
typedef struct IndexAttributeBitMapData	IndexAttributeBitMapData
typedef IndexAttributeBitMapData *	IndexAttributeBitMap

Functions
static Size	IndexTupleSize (const IndexTupleData *itup)
static bool	IndexTupleHasNulls (const IndexTupleData *itup)
static bool	IndexTupleHasVarwidths (const IndexTupleData *itup)
IndexTuple	index_form_tuple (TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
IndexTuple	index_form_tuple_context (TupleDesc tupleDescriptor, const Datum *values, const bool *isnull, MemoryContext context)
Datum	nocache_index_getattr (IndexTuple tup, int attnum, TupleDesc tupleDesc)
void	index_deform_tuple (IndexTuple tup, TupleDesc tupleDescriptor, Datum *values, bool *isnull)
void	index_deform_tuple_internal (TupleDesc tupleDescriptor, Datum *values, bool *isnull, char *tp, bits8 *bp, int hasnulls)
IndexTuple	CopyIndexTuple (IndexTuple source)
IndexTuple	index_truncate_tuple (TupleDesc sourceDescriptor, IndexTuple source, int leavenatts)
static Size	IndexInfoFindDataOffset (unsigned short t_info)
static Datum	index_getattr (IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

Macro Definition Documentation

INDEX_AM_RESERVED_BIT

#define INDEX_AM_RESERVED_BIT

Value:

                                         0x2000 /* reserved for index-AM specific
                                         * usage */

Definition at line 66 of file itup.h.

{
    return (itup->t_info & INDEX_SIZE_MASK);
}
 
static inline bool
IndexTupleHasNulls(const IndexTupleData *itup)
{
    return itup->t_info & INDEX_NULL_MASK;
}
 
static inline bool
IndexTupleHasVarwidths(const IndexTupleData *itup)
{
    return itup->t_info & INDEX_VAR_MASK;
}
 
 
/* routines in indextuple.c */
extern IndexTuple index_form_tuple(TupleDesc tupleDescriptor,
                                   const Datum *values, const bool *isnull);
extern IndexTuple index_form_tuple_context(TupleDesc tupleDescriptor,
                                           const Datum *values, const bool *isnull,
                                           MemoryContext context);
extern Datum nocache_index_getattr(IndexTuple tup, int attnum,
                                   TupleDesc tupleDesc);
extern void index_deform_tuple(IndexTuple tup, TupleDesc tupleDescriptor,
                               Datum *values, bool *isnull);
extern void index_deform_tuple_internal(TupleDesc tupleDescriptor,
                                        Datum *values, bool *isnull,
                                        char *tp, bits8 *bp, int hasnulls);
extern IndexTuple CopyIndexTuple(IndexTuple source);
extern IndexTuple index_truncate_tuple(TupleDesc sourceDescriptor,
                                       IndexTuple source, int leavenatts);
 
 
/*
 * Takes an infomask as argument (primarily because this needs to be usable
 * at index_form_tuple time so enough space is allocated).
 */
static inline Size
IndexInfoFindDataOffset(unsigned short t_info)
{
    if (!(t_info & INDEX_NULL_MASK))
        return MAXALIGN(sizeof(IndexTupleData));
    else
        return MAXALIGN(sizeof(IndexTupleData) + sizeof(IndexAttributeBitMapData));
}
 
#ifndef FRONTEND
 
/* ----------------
 *      index_getattr
 *
 *      This gets called many times, so we macro the cacheable and NULL
 *      lookups, and call nocache_index_getattr() for the rest.
 *
 * ----------------
 */
static inline Datum
index_getattr(IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
{
    Assert(isnull);
    Assert(attnum > 0);
 
    *isnull = false;
 
    if (!IndexTupleHasNulls(tup))
    {
        CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum - 1);
 
        if (attr->attcacheoff >= 0)
        {
            return fetchatt(attr,
                            (char *) tup + IndexInfoFindDataOffset(tup->t_info) +
                            attr->attcacheoff);
        }
        else
            return nocache_index_getattr(tup, attnum, tupleDesc);
    }
    else
    {
        if (att_isnull(attnum - 1, (bits8 *) tup + sizeof(IndexTupleData)))
        {
            *isnull = true;
            return (Datum) 0;
        }
        else
            return nocache_index_getattr(tup, attnum, tupleDesc);
    }
}
 
#endif
 
/*
 * MaxIndexTuplesPerPage is an upper bound on the number of tuples that can
 * fit on one index page.  An index tuple must have either data or a null
 * bitmap, so we can safely assume it's at least 1 byte bigger than a bare
 * IndexTupleData struct.  We arrive at the divisor because each tuple
 * must be maxaligned, and it must have an associated line pointer.
 *
 * To be index-type-independent, this does not account for any special space
 * on the page, and is thus conservative.
 *
 * Note: in btree non-leaf pages, the first tuple has no key (it's implicitly
 * minus infinity), thus breaking the "at least 1 byte bigger" assumption.
 * On such a page, N tuples could take one MAXALIGN quantum less space than
 * estimated here, seemingly allowing one more tuple than estimated here.
 * But such a page always has at least MAXALIGN special space, so we're safe.
 */
#define MaxIndexTuplesPerPage   \
    ((int) ((BLCKSZ - SizeOfPageHeaderData) / \
            (MAXALIGN(sizeof(IndexTupleData) + 1) + sizeof(ItemIdData))))
 
#endif                          /* ITUP_H */

INDEX_NULL_MASK

#define INDEX_NULL_MASK   0x8000

Definition at line 68 of file itup.h.

INDEX_SIZE_MASK

#define INDEX_SIZE_MASK   0x1FFF

Definition at line 65 of file itup.h.

INDEX_VAR_MASK

#define INDEX_VAR_MASK   0x4000

Definition at line 67 of file itup.h.

MaxIndexTuplesPerPage

#define MaxIndexTuplesPerPage

Value:

    ((int) ((BLCKSZ - SizeOfPageHeaderData) / \
            (MAXALIGN(sizeof(IndexTupleData) + 1) + sizeof(ItemIdData))))

Definition at line 181 of file itup.h.

Typedef Documentation

IndexAttributeBitMap

typedef IndexAttributeBitMapData* IndexAttributeBitMap

Definition at line 60 of file itup.h.

IndexAttributeBitMapData

typedef struct IndexAttributeBitMapData IndexAttributeBitMapData

IndexTuple

typedef IndexTupleData* IndexTuple

Definition at line 53 of file itup.h.

IndexTupleData

typedef struct IndexTupleData IndexTupleData

Function Documentation

CopyIndexTuple()

IndexTuple CopyIndexTuple ( IndexTuple  source )

extern

Definition at line 479 of file indextuple.c.

{
    IndexTuple  result;
    Size        size;
 
    size = IndexTupleSize(source);
    result = (IndexTuple) palloc(size);
    memcpy(result, source, size);
    return result;
}

References fb(), IndexTupleSize(), palloc(), and source.

Referenced by _bt_buildadd(), _bt_insert_parent(), _bt_insertonpg(), _bt_load(), _bt_newlevel(), _bt_pagedel(), _bt_swap_posting(), _hash_splitbucket(), _hash_squeezebucket(), btree_xlog_insert(), btree_xlog_split(), gin_check_parent_keys_consistency(), gin_refind_parent(), gistformdownlink(), and index_truncate_tuple().

index_deform_tuple()

void index_deform_tuple ( IndexTuple  tup, TupleDesc  tupleDescriptor, Datum *  values, bool *  isnull  )

extern

Definition at line 364 of file indextuple.c.

{
    char       *tp;             /* ptr to tuple data */
    bits8      *bp;             /* ptr to null bitmap in tuple */
 
    /* XXX "knows" t_bits are just after fixed tuple header! */
    bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
 
    tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
 
    index_deform_tuple_internal(tupleDescriptor, values, isnull,
                                tp, bp, IndexTupleHasNulls(tup));
}

References fb(), index_deform_tuple_internal(), IndexInfoFindDataOffset(), IndexTupleHasNulls(), and values.

Referenced by _bt_check_unique(), comparetup_index_btree_tiebreak(), get_actual_variable_endpoint(), gist_page_items(), index_truncate_tuple(), and StoreIndexTuple().

index_deform_tuple_internal()

void index_deform_tuple_internal ( TupleDesc  tupleDescriptor, Datum *  values, bool *  isnull, char *  tp, bits8 *  bp, int  hasnulls  )

extern

Definition at line 387 of file indextuple.c.

{
    CompactAttribute *cattr;
    int         natts = tupleDescriptor->natts; /* number of atts to extract */
    int         attnum = 0;
    uint32      off = 0;        /* offset in tuple data */
    int         firstNonCacheOffsetAttr;
    int         firstNullAttr;
 
    /* Assert to protect callers who allocate fixed-size arrays */
    Assert(natts <= INDEX_MAX_KEYS);
 
    /* Did someone forget to call TupleDescFinalize()? */
    Assert(tupleDescriptor->firstNonCachedOffsetAttr >= 0);
 
    firstNonCacheOffsetAttr = Min(tupleDescriptor->firstNonCachedOffsetAttr, natts);
 
    if (hasnulls)
    {
        firstNullAttr = first_null_attr(bp, natts);
        firstNonCacheOffsetAttr = Min(firstNonCacheOffsetAttr, firstNullAttr);
    }
    else
        firstNullAttr = natts;
 
    if (firstNonCacheOffsetAttr > 0)
    {
#ifdef USE_ASSERT_CHECKING
        /* In Assert enabled builds, verify attcacheoff is correct */
        off = 0;
#endif
 
        do
        {
            isnull[attnum] = false;
            cattr = TupleDescCompactAttr(tupleDescriptor, attnum);
 
#ifdef USE_ASSERT_CHECKING
            off = att_nominal_alignby(off, cattr->attalignby);
            Assert(off == cattr->attcacheoff);
            off += cattr->attlen;
#endif
 
            values[attnum] = fetch_att_noerr(tp + cattr->attcacheoff, cattr->attbyval,
                                             cattr->attlen);
        } while (++attnum < firstNonCacheOffsetAttr);
 
        off = cattr->attcacheoff + cattr->attlen;
    }
 
    for (; attnum < firstNullAttr; attnum++)
    {
        isnull[attnum] = false;
        cattr = TupleDescCompactAttr(tupleDescriptor, attnum);
 
        /* align 'off', fetch the datum, and increment off beyond the datum */
        values[attnum] = align_fetch_then_add(tp,
                                              &off,
                                              cattr->attbyval,
                                              cattr->attlen,
                                              cattr->attalignby);
    }
 
    for (; attnum < natts; attnum++)
    {
        Assert(hasnulls);
 
        if (att_isnull(attnum, bp))
        {
            values[attnum] = (Datum) 0;
            isnull[attnum] = true;
            continue;
        }
 
        isnull[attnum] = false;
        cattr = TupleDescCompactAttr(tupleDescriptor, attnum);
 
        /* align 'off', fetch the attr's value, and increment off beyond it */
        values[attnum] = align_fetch_then_add(tp,
                                              &off,
                                              cattr->attbyval,
                                              cattr->attlen,
                                              cattr->attalignby);
    }
}

References align_fetch_then_add(), Assert, att_isnull(), att_nominal_alignby, attnum, fb(), fetch_att_noerr(), first_null_attr(), INDEX_MAX_KEYS, Min, TupleDescCompactAttr(), and values.

Referenced by index_deform_tuple(), and spgDeformLeafTuple().

index_form_tuple()

IndexTuple index_form_tuple ( TupleDesc  tupleDescriptor, const Datum *  values, const bool *  isnull  )

extern

Definition at line 44 of file indextuple.c.

{
    return index_form_tuple_context(tupleDescriptor, values, isnull,
                                    CurrentMemoryContext);
}

References CurrentMemoryContext, fb(), index_form_tuple_context(), and values.

Referenced by bt_normalize_tuple(), bt_tuple_present_callback(), btinsert(), GinFormTuple(), gistFormTuple(), hashbuildCallback(), hashinsert(), and index_truncate_tuple().

index_form_tuple_context()

IndexTuple index_form_tuple_context ( TupleDesc  tupleDescriptor, const Datum *  values, const bool *  isnull, MemoryContext  context  )

extern

Definition at line 65 of file indextuple.c.

{
    char       *tp;             /* tuple pointer */
    IndexTuple  tuple;          /* return tuple */
    Size        size,
                data_size,
                hoff;
    int         i;
    unsigned short infomask = 0;
    bool        hasnull = false;
    uint16      tupmask = 0;
    int         numberOfAttributes = tupleDescriptor->natts;
 
#ifdef TOAST_INDEX_HACK
    Datum       untoasted_values[INDEX_MAX_KEYS] = {0};
    bool        untoasted_free[INDEX_MAX_KEYS] = {0};
#endif
 
    if (numberOfAttributes > INDEX_MAX_KEYS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("number of index columns (%d) exceeds limit (%d)",
                        numberOfAttributes, INDEX_MAX_KEYS)));
 
#ifdef TOAST_INDEX_HACK
    for (i = 0; i < numberOfAttributes; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupleDescriptor, i);
 
        untoasted_values[i] = values[i];
        untoasted_free[i] = false;
 
        /* Do nothing if value is NULL or not of varlena type */
        if (isnull[i] || att->attlen != -1)
            continue;
 
        /*
         * If value is stored EXTERNAL, must fetch it so we are not depending
         * on outside storage.  This should be improved someday.
         */
        if (VARATT_IS_EXTERNAL(DatumGetPointer(values[i])))
        {
            untoasted_values[i] =
                PointerGetDatum(detoast_external_attr((varlena *)
                                                      DatumGetPointer(values[i])));
            untoasted_free[i] = true;
        }
 
        /*
         * If value is above size target, and is of a compressible datatype,
         * try to compress it in-line.
         */
        if (!VARATT_IS_EXTENDED(DatumGetPointer(untoasted_values[i])) &&
            VARSIZE(DatumGetPointer(untoasted_values[i])) > TOAST_INDEX_TARGET &&
            (att->attstorage == TYPSTORAGE_EXTENDED ||
             att->attstorage == TYPSTORAGE_MAIN))
        {
            Datum       cvalue;
 
            cvalue = toast_compress_datum(untoasted_values[i],
                                          att->attcompression);
 
            if (DatumGetPointer(cvalue) != NULL)
            {
                /* successful compression */
                if (untoasted_free[i])
                    pfree(DatumGetPointer(untoasted_values[i]));
                untoasted_values[i] = cvalue;
                untoasted_free[i] = true;
            }
        }
    }
#endif
 
    for (i = 0; i < numberOfAttributes; i++)
    {
        if (isnull[i])
        {
            hasnull = true;
            break;
        }
    }
 
    if (hasnull)
        infomask |= INDEX_NULL_MASK;
 
    hoff = IndexInfoFindDataOffset(infomask);
#ifdef TOAST_INDEX_HACK
    data_size = heap_compute_data_size(tupleDescriptor,
                                       untoasted_values, isnull);
#else
    data_size = heap_compute_data_size(tupleDescriptor,
                                       values, isnull);
#endif
    size = hoff + data_size;
    size = MAXALIGN(size);      /* be conservative */
 
    tp = (char *) MemoryContextAllocZero(context, size);
    tuple = (IndexTuple) tp;
 
    heap_fill_tuple(tupleDescriptor,
#ifdef TOAST_INDEX_HACK
                    untoasted_values,
#else
                    values,
#endif
                    isnull,
                    tp + hoff,
                    data_size,
                    &tupmask,
                    (hasnull ? (bits8 *) tp + sizeof(IndexTupleData) : NULL));
 
#ifdef TOAST_INDEX_HACK
    for (i = 0; i < numberOfAttributes; i++)
    {
        if (untoasted_free[i])
            pfree(DatumGetPointer(untoasted_values[i]));
    }
#endif
 
    /*
     * We do this because heap_fill_tuple wants to initialize a "tupmask"
     * which is used for HeapTuples, but we want an indextuple infomask. The
     * only relevant info is the "has variable attributes" field. We have
     * already set the hasnull bit above.
     */
    if (tupmask & HEAP_HASVARWIDTH)
        infomask |= INDEX_VAR_MASK;
 
    /* Also assert we got rid of external attributes */
#ifdef TOAST_INDEX_HACK
    Assert((tupmask & HEAP_HASEXTERNAL) == 0);
#endif
 
    /*
     * Here we make sure that the size will fit in the field reserved for it
     * in t_info.
     */
    if ((size & INDEX_SIZE_MASK) != size)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("index row requires %zu bytes, maximum size is %zu",
                        size, (Size) INDEX_SIZE_MASK)));
 
    infomask |= size;
 
    /*
     * initialize metadata
     */
    tuple->t_info = infomask;
    return tuple;
}

References Assert, DatumGetPointer(), detoast_external_attr(), ereport, errcode(), errmsg, ERROR, fb(), heap_compute_data_size(), heap_fill_tuple(), HEAP_HASEXTERNAL, HEAP_HASVARWIDTH, i, INDEX_MAX_KEYS, INDEX_NULL_MASK, INDEX_SIZE_MASK, INDEX_VAR_MASK, IndexInfoFindDataOffset(), MAXALIGN, MemoryContextAllocZero(), pfree(), PointerGetDatum(), IndexTupleData::t_info, toast_compress_datum(), TOAST_INDEX_HACK, TOAST_INDEX_TARGET, TupleDescAttr(), values, VARATT_IS_EXTENDED(), VARATT_IS_EXTERNAL(), and VARSIZE().

Referenced by index_form_tuple(), and tuplesort_putindextuplevalues().

index_getattr()

static Datum index_getattr ( IndexTuple  tup, int  attnum, TupleDesc  tupleDesc, bool *  isnull  )

inlinestatic

Definition at line 131 of file itup.h.

{
    Assert(isnull);
    Assert(attnum > 0);
 
    *isnull = false;
 
    if (!IndexTupleHasNulls(tup))
    {
        CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum - 1);
 
        if (attr->attcacheoff >= 0)
        {
            return fetchatt(attr,
                            (char *) tup + IndexInfoFindDataOffset(tup->t_info) +
                            attr->attcacheoff);
        }
        else
            return nocache_index_getattr(tup, attnum, tupleDesc);
    }
    else
    {
        if (att_isnull(attnum - 1, (bits8 *) tup + sizeof(IndexTupleData)))
        {
            *isnull = true;
            return (Datum) 0;
        }
        else
            return nocache_index_getattr(tup, attnum, tupleDesc);
    }

References Assert, att_isnull(), CompactAttribute::attcacheoff, attnum, fb(), fetchatt, IndexInfoFindDataOffset(), IndexTupleHasNulls(), nocache_index_getattr(), and TupleDescCompactAttr().

Referenced by _bt_advance_array_keys(), _bt_check_compare(), _bt_check_rowcompare(), _bt_compare(), _bt_keep_natts(), _bt_keep_natts_fast(), _bt_load(), _bt_mkscankey(), _bt_set_startikey(), _bt_tuple_before_array_skeys(), _hash_checkqual(), bt_normalize_tuple(), comparetup_index_btree_tiebreak(), gintuple_get_attrnum(), gintuple_get_key(), gistchoose(), gistDeCompressAtt(), gistFetchTuple(), gistindex_keytest(), gistMakeUnionItVec(), gistSplitByKey(), readtup_index(), removeabbrev_index(), and tuplesort_putindextuplevalues().

index_truncate_tuple()

IndexTuple index_truncate_tuple ( TupleDesc  sourceDescriptor, IndexTuple  source, int  leavenatts  )

extern

Definition at line 508 of file indextuple.c.

{
    TupleDesc   truncdesc;
    Datum       values[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
    IndexTuple  truncated;
 
    Assert(leavenatts <= sourceDescriptor->natts);
 
    /* Easy case: no truncation actually required */
    if (leavenatts == sourceDescriptor->natts)
        return CopyIndexTuple(source);
 
    /* Create temporary truncated tuple descriptor */
    truncdesc = CreateTupleDescTruncatedCopy(sourceDescriptor, leavenatts);
 
    /* Deform, form copy of tuple with fewer attributes */
    index_deform_tuple(source, truncdesc, values, isnull);
    truncated = index_form_tuple(truncdesc, values, isnull);
    truncated->t_tid = source->t_tid;
    Assert(IndexTupleSize(truncated) <= IndexTupleSize(source));
 
    /*
     * Cannot leak memory here, TupleDescCopy() doesn't allocate any inner
     * structure, so, plain pfree() should clean all allocated memory
     */
    pfree(truncdesc);
 
    return truncated;
}

References Assert, CopyIndexTuple(), CreateTupleDescTruncatedCopy(), fb(), index_deform_tuple(), index_form_tuple(), INDEX_MAX_KEYS, IndexTupleSize(), pfree(), source, IndexTupleData::t_tid, and values.

Referenced by _bt_truncate().

IndexInfoFindDataOffset()

static Size IndexInfoFindDataOffset ( unsigned short  t_info )

inlinestatic

Definition at line 112 of file itup.h.

{
    if (!(t_info & INDEX_NULL_MASK))
        return MAXALIGN(sizeof(IndexTupleData));
    else
        return MAXALIGN(sizeof(IndexTupleData) + sizeof(IndexAttributeBitMapData));

References INDEX_NULL_MASK, and MAXALIGN.

Referenced by _hash_get_indextuple_hashkey(), bt_page_print_tuples(), index_deform_tuple(), index_form_tuple_context(), index_getattr(), and nocache_index_getattr().

IndexTupleHasNulls()

static bool IndexTupleHasNulls ( const IndexTupleData *  itup )

inlinestatic

Definition at line 77 of file itup.h.

{
    return itup->t_info & INDEX_NULL_MASK;

References INDEX_NULL_MASK, and IndexTupleData::t_info.

Referenced by bt_page_print_tuples(), GinFormTuple(), index_deform_tuple(), index_getattr(), nocache_index_getattr(), and spgExtractNodeLabels().

IndexTupleHasVarwidths()

static bool IndexTupleHasVarwidths ( const IndexTupleData *  itup )

inlinestatic

Definition at line 83 of file itup.h.

{
    return itup->t_info & INDEX_VAR_MASK;

References INDEX_VAR_MASK, and IndexTupleData::t_info.

Referenced by bt_normalize_tuple(), bt_page_print_tuples(), and nocache_index_getattr().

IndexTupleSize()

static Size IndexTupleSize ( const IndexTupleData *  itup )

inlinestatic

Definition at line 71 of file itup.h.

{
    return (itup->t_info & INDEX_SIZE_MASK);

References INDEX_SIZE_MASK, and IndexTupleData::t_info.

Referenced by _bt_buildadd(), _bt_check_third_page(), _bt_dedup_finish_pending(), _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_delitems_delete(), _bt_delitems_vacuum(), _bt_doinsert(), _bt_form_posting(), _bt_insert_parent(), _bt_insertonpg(), _bt_mark_page_halfdead(), _bt_recsplitloc(), _bt_restore_page(), _bt_saveitem(), _bt_sort_dedup_finish_pending(), _bt_split(), _bt_truncate(), _hash_doinsert(), _hash_pgaddmultitup(), _hash_splitbucket(), _hash_squeezebucket(), bt_check_level_from_leftmost(), bt_page_print_tuples(), bt_pivot_tuple_identical(), bt_rootdescend(), bt_target_page_check(), bt_tuple_present_callback(), btree_xlog_insert(), btree_xlog_split(), btree_xlog_updates(), BTreeTupleGetHeapTID(), CopyIndexTuple(), decodePageSplitRecord(), entryExecPlaceToPage(), entryIsEnoughSpace(), entrySplitPage(), GetBTPageStatistics(), gin_check_parent_keys_consistency(), ginEntryFillRoot(), GinFormInteriorTuple(), GinFormTuple(), ginHeapTupleFastCollect(), ginHeapTupleFastInsert(), ginRedoInsertEntry(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), ginVacuumEntryPage(), gist_indexsortbuild_levelstate_add(), gist_indexsortbuild_levelstate_flush(), gist_page_items(), gist_page_items_bytea(), gistBuildCallback(), gistfillbuffer(), gistfillitupvec(), gistfitpage(), gistGetItupFromPage(), gistnospace(), gistPlaceItupToPage(), gistplacetopage(), gistRedoPageUpdateRecord(), gistSplit(), gistXLogUpdate(), hash_xlog_move_page_contents(), hash_xlog_squeeze_page(), index_truncate_tuple(), makeSublist(), spgFormInnerTuple(), writeListPage(), and writetup_index().

nocache_index_getattr()

Datum nocache_index_getattr ( IndexTuple  tup, int  attnum, TupleDesc  tupleDesc  )

extern

Definition at line 229 of file indextuple.c.

{
    CompactAttribute *cattr;
    char       *tp;             /* ptr to data part of tuple */
    bits8      *bp = NULL;      /* ptr to null bitmap in tuple */
    int         data_off;       /* tuple data offset */
    int         off;            /* current offset within data */
    int         startAttr;
    int         firstNullAttr;
    bool        hasnulls = IndexTupleHasNulls(tup);
    int         i;
 
    /* Did someone forget to call TupleDescFinalize()? */
    Assert(tupleDesc->firstNonCachedOffsetAttr >= 0);
 
    attnum--;
 
    data_off = IndexInfoFindDataOffset(tup->t_info);
    tp = (char *) tup + data_off;
 
    /*
     * To minimize the number of attributes we need to look at, start walking
     * the tuple at the attribute with the highest attcacheoff prior to attnum
     * or the first NULL attribute prior to attnum, whichever comes first.
     */
    if (hasnulls)
    {
        bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
        firstNullAttr = first_null_attr(bp, attnum);
    }
    else
        firstNullAttr = attnum;
 
    if (tupleDesc->firstNonCachedOffsetAttr > 0 && firstNullAttr > 0)
    {
        /*
         * Try to start with the highest attribute with an attcacheoff that's
         * prior to the one we're looking for, or with the attribute prior to
         * the first NULL attribute, if there is one.
         */
        startAttr = Min(tupleDesc->firstNonCachedOffsetAttr - 1, firstNullAttr - 1);
        off = TupleDescCompactAttr(tupleDesc, startAttr)->attcacheoff;
    }
    else
    {
        /* Otherwise, start at the beginning... */
        startAttr = 0;
        off = 0;
    }
 
    /*
     * Calculate 'off' up to the first NULL attr.  We use two cheaper loops
     * when the tuple has no variable-width columns.  When variable-width
     * columns exists, we use att_addlength_pointer() to move the offset
     * beyond the current attribute.
     */
    if (IndexTupleHasVarwidths(tup))
    {
        /* Calculate the offset up until the first NULL */
        for (i = startAttr; i < firstNullAttr; i++)
        {
            cattr = TupleDescCompactAttr(tupleDesc, i);
 
            off = att_pointer_alignby(off,
                                      cattr->attalignby,
                                      cattr->attlen,
                                      tp + off);
            off = att_addlength_pointer(off, cattr->attlen, tp + off);
        }
 
        /* Calculate the offset for any remaining columns. */
        for (; i < attnum; i++)
        {
            Assert(hasnulls);
 
            if (att_isnull(i, bp))
                continue;
 
            cattr = TupleDescCompactAttr(tupleDesc, i);
 
            off = att_pointer_alignby(off,
                                      cattr->attalignby,
                                      cattr->attlen,
                                      tp + off);
            off = att_addlength_pointer(off, cattr->attlen, tp + off);
        }
    }
    else
    {
        /* Handle tuples with only fixed-width attributes */
 
        /* Calculate the offset up until the first NULL */
        for (i = startAttr; i < firstNullAttr; i++)
        {
            cattr = TupleDescCompactAttr(tupleDesc, i);
 
            Assert(cattr->attlen > 0);
            off = att_nominal_alignby(off, cattr->attalignby);
            off += cattr->attlen;
        }
 
        /* Calculate the offset for any remaining columns. */
        for (; i < attnum; i++)
        {
            Assert(hasnulls);
 
            if (att_isnull(i, bp))
                continue;
 
            cattr = TupleDescCompactAttr(tupleDesc, i);
 
            Assert(cattr->attlen > 0);
            off = att_nominal_alignby(off, cattr->attalignby);
            off += cattr->attlen;
        }
    }
 
    cattr = TupleDescCompactAttr(tupleDesc, attnum);
    off = att_pointer_alignby(off, cattr->attalignby,
                              cattr->attlen, tp + off);
    return fetchatt(cattr, tp + off);
}

References Assert, att_addlength_pointer, att_isnull(), att_nominal_alignby, att_pointer_alignby, CompactAttribute::attcacheoff, attnum, fb(), fetchatt, first_null_attr(), i, IndexInfoFindDataOffset(), IndexTupleHasNulls(), IndexTupleHasVarwidths(), Min, and TupleDescCompactAttr().

Referenced by index_getattr().