amutils.c File Reference

#include "postgres.h"
#include "access/amapi.h"
#include "access/htup_details.h"
#include "catalog/pg_class.h"
#include "catalog/pg_index.h"
#include "utils/builtins.h"
#include "utils/syscache.h"

Include dependency graph for amutils.c:

Go to the source code of this file.

Data Structures
struct	am_propname

Functions
static IndexAMProperty	lookup_prop_name (const char *name)
static bool	test_indoption (HeapTuple tuple, int attno, bool guard, int16 iopt_mask, int16 iopt_expect, bool *res)
static Datum	indexam_property (FunctionCallInfo fcinfo, const char *propname, Oid amoid, Oid index_oid, int attno)
Datum	pg_indexam_has_property (PG_FUNCTION_ARGS)
Datum	pg_index_has_property (PG_FUNCTION_ARGS)
Datum	pg_index_column_has_property (PG_FUNCTION_ARGS)
Datum	pg_indexam_progress_phasename (PG_FUNCTION_ARGS)

Variables
static const struct am_propname	am_propnames []

Function Documentation

indexam_property()

static Datum indexam_property ( FunctionCallInfo  fcinfo, const char *  propname, Oid  amoid, Oid  index_oid, int  attno  )

static

Definition at line 149 of file amutils.c.

{
    bool        res = false;
    bool        isnull = false;
    int         natts = 0;
    IndexAMProperty prop;
    const IndexAmRoutine *routine;
 
    /* Try to convert property name to enum (no error if not known) */
    prop = lookup_prop_name(propname);
 
    /* If we have an index OID, look up the AM, and get # of columns too */
    if (OidIsValid(index_oid))
    {
        HeapTuple   tuple;
        Form_pg_class rd_rel;
 
        Assert(!OidIsValid(amoid));
        tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(index_oid));
        if (!HeapTupleIsValid(tuple))
            PG_RETURN_NULL();
        rd_rel = (Form_pg_class) GETSTRUCT(tuple);
        if (rd_rel->relkind != RELKIND_INDEX &&
            rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
        {
            ReleaseSysCache(tuple);
            PG_RETURN_NULL();
        }
        amoid = rd_rel->relam;
        natts = rd_rel->relnatts;
        ReleaseSysCache(tuple);
    }
 
    /*
     * At this point, either index_oid == InvalidOid or it's a valid index
     * OID. Also, after this test and the one below, either attno == 0 for
     * index-wide or AM-wide tests, or it's a valid column number in a valid
     * index.
     */
    if (attno < 0 || attno > natts)
        PG_RETURN_NULL();
 
    /*
     * Get AM information.  If we don't have a valid AM OID, return NULL.
     */
    routine = GetIndexAmRoutineByAmId(amoid, true);
    if (routine == NULL)
        PG_RETURN_NULL();
 
    /*
     * If there's an AM property routine, give it a chance to override the
     * generic logic.  Proceed if it returns false.
     */
    if (routine->amproperty &&
        routine->amproperty(index_oid, attno, prop, propname,
                            &res, &isnull))
    {
        if (isnull)
            PG_RETURN_NULL();
        PG_RETURN_BOOL(res);
    }
 
    if (attno > 0)
    {
        HeapTuple   tuple;
        Form_pg_index rd_index;
        bool        iskey = true;
 
        /*
         * Handle column-level properties. Many of these need the pg_index row
         * (which we also need to use to check for nonkey atts) so we fetch
         * that first.
         */
        tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
        if (!HeapTupleIsValid(tuple))
            PG_RETURN_NULL();
        rd_index = (Form_pg_index) GETSTRUCT(tuple);
 
        Assert(index_oid == rd_index->indexrelid);
        Assert(attno > 0 && attno <= rd_index->indnatts);
 
        isnull = true;
 
        /*
         * If amcaninclude, we might be looking at an attno for a nonkey
         * column, for which we (generically) assume that most properties are
         * null.
         */
        if (routine->amcaninclude
            && attno > rd_index->indnkeyatts)
            iskey = false;
 
        switch (prop)
        {
            case AMPROP_ASC:
                if (iskey &&
                    test_indoption(tuple, attno, routine->amcanorder,
                                   INDOPTION_DESC, 0, &res))
                    isnull = false;
                break;
 
            case AMPROP_DESC:
                if (iskey &&
                    test_indoption(tuple, attno, routine->amcanorder,
                                   INDOPTION_DESC, INDOPTION_DESC, &res))
                    isnull = false;
                break;
 
            case AMPROP_NULLS_FIRST:
                if (iskey &&
                    test_indoption(tuple, attno, routine->amcanorder,
                                   INDOPTION_NULLS_FIRST, INDOPTION_NULLS_FIRST, &res))
                    isnull = false;
                break;
 
            case AMPROP_NULLS_LAST:
                if (iskey &&
                    test_indoption(tuple, attno, routine->amcanorder,
                                   INDOPTION_NULLS_FIRST, 0, &res))
                    isnull = false;
                break;
 
            case AMPROP_ORDERABLE:
 
                /*
                 * generic assumption is that nonkey columns are not orderable
                 */
                res = iskey ? routine->amcanorder : false;
                isnull = false;
                break;
 
            case AMPROP_DISTANCE_ORDERABLE:
 
                /*
                 * The conditions for whether a column is distance-orderable
                 * are really up to the AM (at time of writing, only GiST
                 * supports it at all). The planner has its own idea based on
                 * whether it finds an operator with amoppurpose 'o', but
                 * getting there from just the index column type seems like a
                 * lot of work. So instead we expect the AM to handle this in
                 * its amproperty routine. The generic result is to return
                 * false if the AM says it never supports this, or if this is
                 * a nonkey column, and null otherwise (meaning we don't
                 * know).
                 */
                if (!iskey || !routine->amcanorderbyop)
                {
                    res = false;
                    isnull = false;
                }
                break;
 
            case AMPROP_RETURNABLE:
 
                /* note that we ignore iskey for this property */
 
                isnull = false;
                res = false;
 
                if (routine->amcanreturn)
                {
                    /*
                     * If possible, the AM should handle this test in its
                     * amproperty function without opening the rel. But this
                     * is the generic fallback if it does not.
                     */
                    Relation    indexrel = index_open(index_oid, AccessShareLock);
 
                    res = index_can_return(indexrel, attno);
                    index_close(indexrel, AccessShareLock);
                }
                break;
 
            case AMPROP_SEARCH_ARRAY:
                if (iskey)
                {
                    res = routine->amsearcharray;
                    isnull = false;
                }
                break;
 
            case AMPROP_SEARCH_NULLS:
                if (iskey)
                {
                    res = routine->amsearchnulls;
                    isnull = false;
                }
                break;
 
            default:
                break;
        }
 
        ReleaseSysCache(tuple);
 
        if (!isnull)
            PG_RETURN_BOOL(res);
        PG_RETURN_NULL();
    }
 
    if (OidIsValid(index_oid))
    {
        /*
         * Handle index-level properties.  Currently, these only depend on the
         * AM, but that might not be true forever, so we make users name an
         * index not just an AM.
         */
        switch (prop)
        {
            case AMPROP_CLUSTERABLE:
                PG_RETURN_BOOL(routine->amclusterable);
 
            case AMPROP_INDEX_SCAN:
                PG_RETURN_BOOL(routine->amgettuple ? true : false);
 
            case AMPROP_BITMAP_SCAN:
                PG_RETURN_BOOL(routine->amgetbitmap ? true : false);
 
            case AMPROP_BACKWARD_SCAN:
                PG_RETURN_BOOL(routine->amcanbackward);
 
            default:
                PG_RETURN_NULL();
        }
    }
 
    /*
     * Handle AM-level properties (those that control what you can say in
     * CREATE INDEX).
     */
    switch (prop)
    {
        case AMPROP_CAN_ORDER:
            PG_RETURN_BOOL(routine->amcanorder);
 
        case AMPROP_CAN_UNIQUE:
            PG_RETURN_BOOL(routine->amcanunique);
 
        case AMPROP_CAN_MULTI_COL:
            PG_RETURN_BOOL(routine->amcanmulticol);
 
        case AMPROP_CAN_EXCLUDE:
            PG_RETURN_BOOL(routine->amgettuple ? true : false);
 
        case AMPROP_CAN_INCLUDE:
            PG_RETURN_BOOL(routine->amcaninclude);
 
        default:
            PG_RETURN_NULL();
    }
}

References AccessShareLock, IndexAmRoutine::amcanbackward, IndexAmRoutine::amcaninclude, IndexAmRoutine::amcanmulticol, IndexAmRoutine::amcanorder, IndexAmRoutine::amcanorderbyop, IndexAmRoutine::amcanreturn, IndexAmRoutine::amcanunique, IndexAmRoutine::amclusterable, IndexAmRoutine::amgetbitmap, IndexAmRoutine::amgettuple, AMPROP_ASC, AMPROP_BACKWARD_SCAN, AMPROP_BITMAP_SCAN, AMPROP_CAN_EXCLUDE, AMPROP_CAN_INCLUDE, AMPROP_CAN_MULTI_COL, AMPROP_CAN_ORDER, AMPROP_CAN_UNIQUE, AMPROP_CLUSTERABLE, AMPROP_DESC, AMPROP_DISTANCE_ORDERABLE, AMPROP_INDEX_SCAN, AMPROP_NULLS_FIRST, AMPROP_NULLS_LAST, AMPROP_ORDERABLE, AMPROP_RETURNABLE, AMPROP_SEARCH_ARRAY, AMPROP_SEARCH_NULLS, IndexAmRoutine::amproperty, IndexAmRoutine::amsearcharray, IndexAmRoutine::amsearchnulls, Assert, fb(), Form_pg_index, GetIndexAmRoutineByAmId(), GETSTRUCT(), HeapTupleIsValid, index_can_return(), index_close(), index_open(), lookup_prop_name(), ObjectIdGetDatum(), OidIsValid, PG_RETURN_BOOL, PG_RETURN_NULL, am_propname::prop, ReleaseSysCache(), SearchSysCache1(), and test_indoption().

Referenced by pg_index_column_has_property(), pg_index_has_property(), and pg_indexam_has_property().

lookup_prop_name()

static IndexAMProperty lookup_prop_name ( const char *  name )

static

Definition at line 90 of file amutils.c.

{
    for (size_t i = 0; i < lengthof(am_propnames); i++)
    {
        if (pg_strcasecmp(am_propnames[i].name, name) == 0)
            return am_propnames[i].prop;
    }
 
    /* We do not throw an error, so that AMs can define their own properties */
    return AMPROP_UNKNOWN;
}

References am_propnames, AMPROP_UNKNOWN, i, lengthof, name, pg_strcasecmp(), and am_propname::prop.

Referenced by indexam_property().

pg_index_column_has_property()

Datum pg_index_column_has_property

(

PG_FUNCTION_ARGS

)

Definition at line 431 of file amutils.c.

{
    Oid         relid = PG_GETARG_OID(0);
    int32       attno = PG_GETARG_INT32(1);
    char       *propname = text_to_cstring(PG_GETARG_TEXT_PP(2));
 
    /* Reject attno 0 immediately, so that attno > 0 identifies this case */
    if (attno <= 0)
        PG_RETURN_NULL();
 
    return indexam_property(fcinfo, propname, InvalidOid, relid, attno);
}

References fb(), indexam_property(), InvalidOid, PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_NULL, and text_to_cstring().

pg_index_has_property()

Datum pg_index_has_property

(

PG_FUNCTION_ARGS

)

Definition at line 419 of file amutils.c.

{
    Oid         relid = PG_GETARG_OID(0);
    char       *propname = text_to_cstring(PG_GETARG_TEXT_PP(1));
 
    return indexam_property(fcinfo, propname, InvalidOid, relid, 0);
}

References fb(), indexam_property(), InvalidOid, PG_GETARG_OID, PG_GETARG_TEXT_PP, and text_to_cstring().

pg_indexam_has_property()

Datum pg_indexam_has_property

(

PG_FUNCTION_ARGS

)

Definition at line 407 of file amutils.c.

{
    Oid         amoid = PG_GETARG_OID(0);
    char       *propname = text_to_cstring(PG_GETARG_TEXT_PP(1));
 
    return indexam_property(fcinfo, propname, amoid, InvalidOid, 0);
}

References fb(), indexam_property(), InvalidOid, PG_GETARG_OID, PG_GETARG_TEXT_PP, and text_to_cstring().

pg_indexam_progress_phasename()

Datum pg_indexam_progress_phasename

(

PG_FUNCTION_ARGS

)

Definition at line 449 of file amutils.c.

{
    Oid         amoid = PG_GETARG_OID(0);
    int32       phasenum = PG_GETARG_INT32(1);
    const IndexAmRoutine *routine;
    char       *name;
 
    routine = GetIndexAmRoutineByAmId(amoid, true);
    if (routine == NULL || !routine->ambuildphasename)
        PG_RETURN_NULL();
 
    name = routine->ambuildphasename(phasenum);
    if (!name)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(CStringGetTextDatum(name));
}

References IndexAmRoutine::ambuildphasename, CStringGetTextDatum, fb(), GetIndexAmRoutineByAmId(), name, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_DATUM, and PG_RETURN_NULL.

test_indoption()

static bool test_indoption ( HeapTuple  tuple, int  attno, bool  guard, int16  iopt_mask, int16  iopt_expect, bool *  res  )

static

Definition at line 115 of file amutils.c.

{
    Datum       datum;
    int2vector *indoption;
    int16       indoption_val;
 
    if (!guard)
    {
        *res = false;
        return true;
    }
 
    datum = SysCacheGetAttrNotNull(INDEXRELID, tuple, Anum_pg_index_indoption);
 
    indoption = ((int2vector *) DatumGetPointer(datum));
    indoption_val = indoption->values[attno - 1];
 
    *res = (indoption_val & iopt_mask) == iopt_expect;
 
    return true;
}

References DatumGetPointer(), fb(), and SysCacheGetAttrNotNull().

Referenced by indexam_property().

Variable Documentation

am_propnames

const struct am_propname am_propnames[]

static

Definition at line 31 of file amutils.c.

{
    {
        "asc", AMPROP_ASC
    },
    {
        "desc", AMPROP_DESC
    },
    {
        "nulls_first", AMPROP_NULLS_FIRST
    },
    {
        "nulls_last", AMPROP_NULLS_LAST
    },
    {
        "orderable", AMPROP_ORDERABLE
    },
    {
        "distance_orderable", AMPROP_DISTANCE_ORDERABLE
    },
    {
        "returnable", AMPROP_RETURNABLE
    },
    {
        "search_array", AMPROP_SEARCH_ARRAY
    },
    {
        "search_nulls", AMPROP_SEARCH_NULLS
    },
    {
        "clusterable", AMPROP_CLUSTERABLE
    },
    {
        "index_scan", AMPROP_INDEX_SCAN
    },
    {
        "bitmap_scan", AMPROP_BITMAP_SCAN
    },
    {
        "backward_scan", AMPROP_BACKWARD_SCAN
    },
    {
        "can_order", AMPROP_CAN_ORDER
    },
    {
        "can_unique", AMPROP_CAN_UNIQUE
    },
    {
        "can_multi_col", AMPROP_CAN_MULTI_COL
    },
    {
        "can_exclude", AMPROP_CAN_EXCLUDE
    },
    {
        "can_include", AMPROP_CAN_INCLUDE
    },
};

Referenced by lookup_prop_name().