lsyscache.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * lsyscache.c
 *    Convenience routines for common queries in the system catalog cache.
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/backend/utils/cache/lsyscache.c
 *
 * NOTES
 *    Eventually, the index information should go through here, too.
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
 
#include "access/hash.h"
#include "access/htup_details.h"
#include "bootstrap/bootstrap.h"
#include "catalog/namespace.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_class.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_index.h"
#include "catalog/pg_language.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_publication.h"
#include "catalog/pg_range.h"
#include "catalog/pg_statistic.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_transform.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/typcache.h"
 
/* Hook for plugins to get control in get_attavgwidth() */
get_attavgwidth_hook_type get_attavgwidth_hook = NULL;
 
 
/*              ---------- AMOP CACHES ----------                        */
 
/*
 * op_in_opfamily
 *
 *      Return t iff operator 'opno' is in operator family 'opfamily'.
 *
 * This function only considers search operators, not ordering operators.
 */
bool
op_in_opfamily(Oid opno, Oid opfamily)
{
    return SearchSysCacheExists3(AMOPOPID,
                                 ObjectIdGetDatum(opno),
                                 CharGetDatum(AMOP_SEARCH),
                                 ObjectIdGetDatum(opfamily));
}
 
/*
 * get_op_opfamily_strategy
 *
 *      Get the operator's strategy number within the specified opfamily,
 *      or 0 if it's not a member of the opfamily.
 *
 * This function only considers search operators, not ordering operators.
 */
int
get_op_opfamily_strategy(Oid opno, Oid opfamily)
{
    HeapTuple   tp;
    Form_pg_amop amop_tup;
    int         result;
 
    tp = SearchSysCache3(AMOPOPID,
                         ObjectIdGetDatum(opno),
                         CharGetDatum(AMOP_SEARCH),
                         ObjectIdGetDatum(opfamily));
    if (!HeapTupleIsValid(tp))
        return 0;
    amop_tup = (Form_pg_amop) GETSTRUCT(tp);
    result = amop_tup->amopstrategy;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_op_opfamily_sortfamily
 *
 *      If the operator is an ordering operator within the specified opfamily,
 *      return its amopsortfamily OID; else return InvalidOid.
 */
Oid
get_op_opfamily_sortfamily(Oid opno, Oid opfamily)
{
    HeapTuple   tp;
    Form_pg_amop amop_tup;
    Oid         result;
 
    tp = SearchSysCache3(AMOPOPID,
                         ObjectIdGetDatum(opno),
                         CharGetDatum(AMOP_ORDER),
                         ObjectIdGetDatum(opfamily));
    if (!HeapTupleIsValid(tp))
        return InvalidOid;
    amop_tup = (Form_pg_amop) GETSTRUCT(tp);
    result = amop_tup->amopsortfamily;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_op_opfamily_properties
 *
 *      Get the operator's strategy number and declared input data types
 *      within the specified opfamily.
 *
 * Caller should already have verified that opno is a member of opfamily,
 * therefore we raise an error if the tuple is not found.
 */
void
get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op,
                           int *strategy,
                           Oid *lefttype,
                           Oid *righttype)
{
    HeapTuple   tp;
    Form_pg_amop amop_tup;
 
    tp = SearchSysCache3(AMOPOPID,
                         ObjectIdGetDatum(opno),
                         CharGetDatum(ordering_op ? AMOP_ORDER : AMOP_SEARCH),
                         ObjectIdGetDatum(opfamily));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "operator %u is not a member of opfamily %u",
             opno, opfamily);
    amop_tup = (Form_pg_amop) GETSTRUCT(tp);
    *strategy = amop_tup->amopstrategy;
    *lefttype = amop_tup->amoplefttype;
    *righttype = amop_tup->amoprighttype;
    ReleaseSysCache(tp);
}
 
/*
 * get_opfamily_member
 *      Get the OID of the operator that implements the specified strategy
 *      with the specified datatypes for the specified opfamily.
 *
 * Returns InvalidOid if there is no pg_amop entry for the given keys.
 */
Oid
get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype,
                    int16 strategy)
{
    HeapTuple   tp;
    Form_pg_amop amop_tup;
    Oid         result;
 
    tp = SearchSysCache4(AMOPSTRATEGY,
                         ObjectIdGetDatum(opfamily),
                         ObjectIdGetDatum(lefttype),
                         ObjectIdGetDatum(righttype),
                         Int16GetDatum(strategy));
    if (!HeapTupleIsValid(tp))
        return InvalidOid;
    amop_tup = (Form_pg_amop) GETSTRUCT(tp);
    result = amop_tup->amopopr;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_opfamily_member_for_cmptype
 *      Get the OID of the operator that implements the specified comparison
 *      type with the specified datatypes for the specified opfamily.
 *
 * Returns InvalidOid if there is no mapping for the comparison type or no
 * pg_amop entry for the given keys.
 */
Oid
get_opfamily_member_for_cmptype(Oid opfamily, Oid lefttype, Oid righttype,
                                CompareType cmptype)
{
    Oid         opmethod;
    StrategyNumber strategy;
 
    opmethod = get_opfamily_method(opfamily);
    strategy = IndexAmTranslateCompareType(cmptype, opmethod, opfamily, true);
    if (!strategy)
        return InvalidOid;
    return get_opfamily_member(opfamily, lefttype, righttype, strategy);
}
 
/*
 * get_opmethod_canorder
 *      Return amcanorder field for given index AM.
 *
 * To speed things up in the common cases, we're hardcoding the results from
 * the built-in index types.  Note that we also need to hardcode the negative
 * results from the built-in non-btree index types, since you'll usually get a
 * few hits for those as well.  It would be nice to organize and cache this a
 * bit differently to avoid the hardcoding.
 */
static bool
get_opmethod_canorder(Oid amoid)
{
    switch (amoid)
    {
        case BTREE_AM_OID:
            return true;
        case HASH_AM_OID:
        case GIST_AM_OID:
        case GIN_AM_OID:
        case SPGIST_AM_OID:
        case BRIN_AM_OID:
            return false;
        default:
            {
                bool        result;
                IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(amoid, false);
 
                result = amroutine->amcanorder;
                pfree(amroutine);
                return result;
            }
    }
}
 
/*
 * get_ordering_op_properties
 *      Given the OID of an ordering operator (a "<" or ">" operator),
 *      determine its opfamily, its declared input datatype, and its
 *      comparison type.
 *
 * Returns true if successful, false if no matching pg_amop entry exists.
 * (This indicates that the operator is not a valid ordering operator.)
 *
 * Note: the operator could be registered in multiple families, for example
 * if someone were to build a "reverse sort" opfamily.  This would result in
 * uncertainty as to whether "ORDER BY USING op" would default to NULLS FIRST
 * or NULLS LAST, as well as inefficient planning due to failure to match up
 * pathkeys that should be the same.  So we want a determinate result here.
 * Because of the way the syscache search works, we'll use the interpretation
 * associated with the opfamily with smallest OID, which is probably
 * determinate enough.  Since there is no longer any particularly good reason
 * to build reverse-sort opfamilies, it doesn't seem worth expending any
 * additional effort on ensuring consistency.
 */
bool
get_ordering_op_properties(Oid opno,
                           Oid *opfamily, Oid *opcintype, CompareType *cmptype)
{
    bool        result = false;
    CatCList   *catlist;
    int         i;
 
    /* ensure outputs are initialized on failure */
    *opfamily = InvalidOid;
    *opcintype = InvalidOid;
    *cmptype = COMPARE_INVALID;
 
    /*
     * Search pg_amop to see if the target operator is registered as the "<"
     * or ">" operator of any btree opfamily.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   tuple = &catlist->members[i]->tuple;
        Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
        CompareType am_cmptype;
 
        /* must be ordering index */
        if (!get_opmethod_canorder(aform->amopmethod))
            continue;
 
        am_cmptype = IndexAmTranslateStrategy(aform->amopstrategy,
                                              aform->amopmethod,
                                              aform->amopfamily,
                                              true);
 
        if (am_cmptype == COMPARE_LT || am_cmptype == COMPARE_GT)
        {
            /* Found it ... should have consistent input types */
            if (aform->amoplefttype == aform->amoprighttype)
            {
                /* Found a suitable opfamily, return info */
                *opfamily = aform->amopfamily;
                *opcintype = aform->amoplefttype;
                *cmptype = am_cmptype;
                result = true;
                break;
            }
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
/*
 * get_equality_op_for_ordering_op
 *      Get the OID of the datatype-specific equality operator
 *      associated with an ordering operator (a "<" or ">" operator).
 *
 * If "reverse" isn't NULL, also set *reverse to false if the operator is "<",
 * true if it's ">"
 *
 * Returns InvalidOid if no matching equality operator can be found.
 * (This indicates that the operator is not a valid ordering operator.)
 */
Oid
get_equality_op_for_ordering_op(Oid opno, bool *reverse)
{
    Oid         result = InvalidOid;
    Oid         opfamily;
    Oid         opcintype;
    CompareType cmptype;
 
    /* Find the operator in pg_amop */
    if (get_ordering_op_properties(opno,
                                   &opfamily, &opcintype, &cmptype))
    {
        /* Found a suitable opfamily, get matching equality operator */
        result = get_opfamily_member_for_cmptype(opfamily,
                                                 opcintype,
                                                 opcintype,
                                                 COMPARE_EQ);
        if (reverse)
            *reverse = (cmptype == COMPARE_GT);
    }
 
    return result;
}
 
/*
 * get_ordering_op_for_equality_op
 *      Get the OID of a datatype-specific "less than" ordering operator
 *      associated with an equality operator.  (If there are multiple
 *      possibilities, assume any one will do.)
 *
 * This function is used when we have to sort data before unique-ifying,
 * and don't much care which sorting op is used as long as it's compatible
 * with the intended equality operator.  Since we need a sorting operator,
 * it should be single-data-type even if the given operator is cross-type.
 * The caller specifies whether to find an op for the LHS or RHS data type.
 *
 * Returns InvalidOid if no matching ordering operator can be found.
 */
Oid
get_ordering_op_for_equality_op(Oid opno, bool use_lhs_type)
{
    Oid         result = InvalidOid;
    CatCList   *catlist;
    int         i;
 
    /*
     * Search pg_amop to see if the target operator is registered as the "="
     * operator of any btree opfamily.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   tuple = &catlist->members[i]->tuple;
        Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
        CompareType cmptype;
 
        /* must be ordering index */
        if (!get_opmethod_canorder(aform->amopmethod))
            continue;
 
        cmptype = IndexAmTranslateStrategy(aform->amopstrategy,
                                           aform->amopmethod,
                                           aform->amopfamily,
                                           true);
        if (cmptype == COMPARE_EQ)
        {
            /* Found a suitable opfamily, get matching ordering operator */
            Oid         typid;
 
            typid = use_lhs_type ? aform->amoplefttype : aform->amoprighttype;
            result = get_opfamily_member_for_cmptype(aform->amopfamily,
                                                     typid, typid,
                                                     COMPARE_LT);
            if (OidIsValid(result))
                break;
            /* failure probably shouldn't happen, but keep looking if so */
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
/*
 * get_mergejoin_opfamilies
 *      Given a putatively mergejoinable operator, return a list of the OIDs
 *      of the amcanorder opfamilies in which it represents equality.
 *
 * It is possible (though at present unusual) for an operator to be equality
 * in more than one opfamily, hence the result is a list.  This also lets us
 * return NIL if the operator is not found in any opfamilies.
 *
 * The planner currently uses simple equal() tests to compare the lists
 * returned by this function, which makes the list order relevant, though
 * strictly speaking it should not be.  Because of the way syscache list
 * searches are handled, in normal operation the result will be sorted by OID
 * so everything works fine.  If running with system index usage disabled,
 * the result ordering is unspecified and hence the planner might fail to
 * recognize optimization opportunities ... but that's hardly a scenario in
 * which performance is good anyway, so there's no point in expending code
 * or cycles here to guarantee the ordering in that case.
 */
List *
get_mergejoin_opfamilies(Oid opno)
{
    List       *result = NIL;
    CatCList   *catlist;
    int         i;
 
    /*
     * Search pg_amop to see if the target operator is registered as the "="
     * operator of any opfamily of an ordering index type.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   tuple = &catlist->members[i]->tuple;
        Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
 
        /* must be ordering index equality */
        if (get_opmethod_canorder(aform->amopmethod) &&
            IndexAmTranslateStrategy(aform->amopstrategy,
                                     aform->amopmethod,
                                     aform->amopfamily,
                                     true) == COMPARE_EQ)
            result = lappend_oid(result, aform->amopfamily);
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
/*
 * get_compatible_hash_operators
 *      Get the OID(s) of hash equality operator(s) compatible with the given
 *      operator, but operating on its LHS and/or RHS datatype.
 *
 * An operator for the LHS type is sought and returned into *lhs_opno if
 * lhs_opno isn't NULL.  Similarly, an operator for the RHS type is sought
 * and returned into *rhs_opno if rhs_opno isn't NULL.
 *
 * If the given operator is not cross-type, the results should be the same
 * operator, but in cross-type situations they will be different.
 *
 * Returns true if able to find the requested operator(s), false if not.
 * (This indicates that the operator should not have been marked oprcanhash.)
 */
bool
get_compatible_hash_operators(Oid opno,
                              Oid *lhs_opno, Oid *rhs_opno)
{
    bool        result = false;
    CatCList   *catlist;
    int         i;
 
    /* Ensure output args are initialized on failure */
    if (lhs_opno)
        *lhs_opno = InvalidOid;
    if (rhs_opno)
        *rhs_opno = InvalidOid;
 
    /*
     * Search pg_amop to see if the target operator is registered as the "="
     * operator of any hash opfamily.  If the operator is registered in
     * multiple opfamilies, assume we can use any one.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   tuple = &catlist->members[i]->tuple;
        Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
 
        if (aform->amopmethod == HASH_AM_OID &&
            aform->amopstrategy == HTEqualStrategyNumber)
        {
            /* No extra lookup needed if given operator is single-type */
            if (aform->amoplefttype == aform->amoprighttype)
            {
                if (lhs_opno)
                    *lhs_opno = opno;
                if (rhs_opno)
                    *rhs_opno = opno;
                result = true;
                break;
            }
 
            /*
             * Get the matching single-type operator(s).  Failure probably
             * shouldn't happen --- it implies a bogus opfamily --- but
             * continue looking if so.
             */
            if (lhs_opno)
            {
                *lhs_opno = get_opfamily_member(aform->amopfamily,
                                                aform->amoplefttype,
                                                aform->amoplefttype,
                                                HTEqualStrategyNumber);
                if (!OidIsValid(*lhs_opno))
                    continue;
                /* Matching LHS found, done if caller doesn't want RHS */
                if (!rhs_opno)
                {
                    result = true;
                    break;
                }
            }
            if (rhs_opno)
            {
                *rhs_opno = get_opfamily_member(aform->amopfamily,
                                                aform->amoprighttype,
                                                aform->amoprighttype,
                                                HTEqualStrategyNumber);
                if (!OidIsValid(*rhs_opno))
                {
                    /* Forget any LHS operator from this opfamily */
                    if (lhs_opno)
                        *lhs_opno = InvalidOid;
                    continue;
                }
                /* Matching RHS found, so done */
                result = true;
                break;
            }
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
/*
 * get_op_hash_functions
 *      Get the OID(s) of the standard hash support function(s) compatible with
 *      the given operator, operating on its LHS and/or RHS datatype as required.
 *
 * A function for the LHS type is sought and returned into *lhs_procno if
 * lhs_procno isn't NULL.  Similarly, a function for the RHS type is sought
 * and returned into *rhs_procno if rhs_procno isn't NULL.
 *
 * If the given operator is not cross-type, the results should be the same
 * function, but in cross-type situations they will be different.
 *
 * Returns true if able to find the requested function(s), false if not.
 * (This indicates that the operator should not have been marked oprcanhash.)
 */
bool
get_op_hash_functions(Oid opno,
                      RegProcedure *lhs_procno, RegProcedure *rhs_procno)
{
    bool        result = false;
    CatCList   *catlist;
    int         i;
 
    /* Ensure output args are initialized on failure */
    if (lhs_procno)
        *lhs_procno = InvalidOid;
    if (rhs_procno)
        *rhs_procno = InvalidOid;
 
    /*
     * Search pg_amop to see if the target operator is registered as the "="
     * operator of any hash opfamily.  If the operator is registered in
     * multiple opfamilies, assume we can use any one.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   tuple = &catlist->members[i]->tuple;
        Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
 
        if (aform->amopmethod == HASH_AM_OID &&
            aform->amopstrategy == HTEqualStrategyNumber)
        {
            /*
             * Get the matching support function(s).  Failure probably
             * shouldn't happen --- it implies a bogus opfamily --- but
             * continue looking if so.
             */
            if (lhs_procno)
            {
                *lhs_procno = get_opfamily_proc(aform->amopfamily,
                                                aform->amoplefttype,
                                                aform->amoplefttype,
                                                HASHSTANDARD_PROC);
                if (!OidIsValid(*lhs_procno))
                    continue;
                /* Matching LHS found, done if caller doesn't want RHS */
                if (!rhs_procno)
                {
                    result = true;
                    break;
                }
                /* Only one lookup needed if given operator is single-type */
                if (aform->amoplefttype == aform->amoprighttype)
                {
                    *rhs_procno = *lhs_procno;
                    result = true;
                    break;
                }
            }
            if (rhs_procno)
            {
                *rhs_procno = get_opfamily_proc(aform->amopfamily,
                                                aform->amoprighttype,
                                                aform->amoprighttype,
                                                HASHSTANDARD_PROC);
                if (!OidIsValid(*rhs_procno))
                {
                    /* Forget any LHS function from this opfamily */
                    if (lhs_procno)
                        *lhs_procno = InvalidOid;
                    continue;
                }
                /* Matching RHS found, so done */
                result = true;
                break;
            }
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
/*
 * get_op_index_interpretation
 *      Given an operator's OID, find out which amcanorder opfamilies it belongs to,
 *      and what properties it has within each one.  The results are returned
 *      as a palloc'd list of OpIndexInterpretation structs.
 *
 * In addition to the normal btree operators, we consider a <> operator to be
 * a "member" of an opfamily if its negator is an equality operator of the
 * opfamily.  COMPARE_NE is returned as the strategy number for this case.
 */
List *
get_op_index_interpretation(Oid opno)
{
    List       *result = NIL;
    OpIndexInterpretation *thisresult;
    CatCList   *catlist;
    int         i;
 
    /*
     * Find all the pg_amop entries containing the operator.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   op_tuple = &catlist->members[i]->tuple;
        Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
        CompareType cmptype;
 
        /* must be ordering index */
        if (!get_opmethod_canorder(op_form->amopmethod))
            continue;
 
        /* Get the operator's comparision type */
        cmptype = IndexAmTranslateStrategy(op_form->amopstrategy,
                                           op_form->amopmethod,
                                           op_form->amopfamily,
                                           true);
 
        /* should not happen */
        if (cmptype == COMPARE_INVALID)
            continue;
 
        thisresult = (OpIndexInterpretation *)
            palloc(sizeof(OpIndexInterpretation));
        thisresult->opfamily_id = op_form->amopfamily;
        thisresult->cmptype = cmptype;
        thisresult->oplefttype = op_form->amoplefttype;
        thisresult->oprighttype = op_form->amoprighttype;
        result = lappend(result, thisresult);
    }
 
    ReleaseSysCacheList(catlist);
 
    /*
     * If we didn't find any btree opfamily containing the operator, perhaps
     * it is a <> operator.  See if it has a negator that is in an opfamily.
     */
    if (result == NIL)
    {
        Oid         op_negator = get_negator(opno);
 
        if (OidIsValid(op_negator))
        {
            catlist = SearchSysCacheList1(AMOPOPID,
                                          ObjectIdGetDatum(op_negator));
 
            for (i = 0; i < catlist->n_members; i++)
            {
                HeapTuple   op_tuple = &catlist->members[i]->tuple;
                Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
                IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(op_form->amopmethod, false);
                CompareType cmptype;
 
                /* must be ordering index */
                if (!amroutine->amcanorder)
                    continue;
 
                /* Get the operator's comparision type */
                cmptype = IndexAmTranslateStrategy(op_form->amopstrategy,
                                                   op_form->amopmethod,
                                                   op_form->amopfamily,
                                                   true);
 
                /* Only consider negators that are = */
                if (cmptype != COMPARE_EQ)
                    continue;
 
                /* OK, report it as COMPARE_NE */
                thisresult = (OpIndexInterpretation *)
                    palloc(sizeof(OpIndexInterpretation));
                thisresult->opfamily_id = op_form->amopfamily;
                thisresult->cmptype = COMPARE_NE;
                thisresult->oplefttype = op_form->amoplefttype;
                thisresult->oprighttype = op_form->amoprighttype;
                result = lappend(result, thisresult);
            }
 
            ReleaseSysCacheList(catlist);
        }
    }
 
    return result;
}
 
/*
 * equality_ops_are_compatible
 *      Return true if the two given equality operators have compatible
 *      semantics.
 *
 * This is trivially true if they are the same operator.  Otherwise,
 * Otherwise, we look to see if they both belong to an opfamily that
 * guarantees compatible semantics for equality.  Either finding allows us to
 * assume that they have compatible notions of equality.  (The reason we need
 * to do these pushups is that one might be a cross-type operator; for
 * instance int24eq vs int4eq.)
 */
bool
equality_ops_are_compatible(Oid opno1, Oid opno2)
{
    bool        result;
    CatCList   *catlist;
    int         i;
 
    /* Easy if they're the same operator */
    if (opno1 == opno2)
        return true;
 
    /*
     * We search through all the pg_amop entries for opno1.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno1));
 
    result = false;
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   op_tuple = &catlist->members[i]->tuple;
        Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
 
        /*
         * op_in_opfamily() is cheaper than GetIndexAmRoutineByAmId(), so
         * check it first
         */
        if (op_in_opfamily(opno2, op_form->amopfamily))
        {
            IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(op_form->amopmethod, false);
 
            if (amroutine->amconsistentequality)
            {
                result = true;
                break;
            }
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
/*
 * comparison_ops_are_compatible
 *      Return true if the two given comparison operators have compatible
 *      semantics.
 *
 * This is trivially true if they are the same operator.  Otherwise, we look
 * to see if they both belong to an opfamily that guarantees compatible
 * semantics for ordering.  (For example, for btree, '<' and '>=' ops match if
 * they belong to the same family.)
 *
 * (This is identical to equality_ops_are_compatible(), except that we check
 * amconsistentordering instead of amconsistentequality.)
 */
bool
comparison_ops_are_compatible(Oid opno1, Oid opno2)
{
    bool        result;
    CatCList   *catlist;
    int         i;
 
    /* Easy if they're the same operator */
    if (opno1 == opno2)
        return true;
 
    /*
     * We search through all the pg_amop entries for opno1.
     */
    catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno1));
 
    result = false;
    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   op_tuple = &catlist->members[i]->tuple;
        Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
 
        /*
         * op_in_opfamily() is cheaper than GetIndexAmRoutineByAmId(), so
         * check it first
         */
        if (op_in_opfamily(opno2, op_form->amopfamily))
        {
            IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(op_form->amopmethod, false);
 
            if (amroutine->amconsistentordering)
            {
                result = true;
                break;
            }
        }
    }
 
    ReleaseSysCacheList(catlist);
 
    return result;
}
 
 
/*              ---------- AMPROC CACHES ----------                      */
 
/*
 * get_opfamily_proc
 *      Get the OID of the specified support function
 *      for the specified opfamily and datatypes.
 *
 * Returns InvalidOid if there is no pg_amproc entry for the given keys.
 */
Oid
get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
{
    HeapTuple   tp;
    Form_pg_amproc amproc_tup;
    RegProcedure result;
 
    tp = SearchSysCache4(AMPROCNUM,
                         ObjectIdGetDatum(opfamily),
                         ObjectIdGetDatum(lefttype),
                         ObjectIdGetDatum(righttype),
                         Int16GetDatum(procnum));
    if (!HeapTupleIsValid(tp))
        return InvalidOid;
    amproc_tup = (Form_pg_amproc) GETSTRUCT(tp);
    result = amproc_tup->amproc;
    ReleaseSysCache(tp);
    return result;
}
 
 
/*              ---------- ATTRIBUTE CACHES ----------                   */
 
/*
 * get_attname
 *      Given the relation id and the attribute number, return the "attname"
 *      field from the attribute relation as a palloc'ed string.
 *
 * If no such attribute exists and missing_ok is true, NULL is returned;
 * otherwise a not-intended-for-user-consumption error is thrown.
 */
char *
get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
{
    HeapTuple   tp;
 
    tp = SearchSysCache2(ATTNUM,
                         ObjectIdGetDatum(relid), Int16GetDatum(attnum));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(att_tup->attname));
        ReleaseSysCache(tp);
        return result;
    }
 
    if (!missing_ok)
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             attnum, relid);
    return NULL;
}
 
/*
 * get_attnum
 *
 *      Given the relation id and the attribute name,
 *      return the "attnum" field from the attribute relation.
 *
 *      Returns InvalidAttrNumber if the attr doesn't exist (or is dropped).
 */
AttrNumber
get_attnum(Oid relid, const char *attname)
{
    HeapTuple   tp;
 
    tp = SearchSysCacheAttName(relid, attname);
    if (HeapTupleIsValid(tp))
    {
        Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
        AttrNumber  result;
 
        result = att_tup->attnum;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidAttrNumber;
}
 
/*
 * get_attgenerated
 *
 *      Given the relation id and the attribute number,
 *      return the "attgenerated" field from the attribute relation.
 *
 *      Errors if not found.
 *
 *      Since not generated is represented by '\0', this can also be used as a
 *      Boolean test.
 */
char
get_attgenerated(Oid relid, AttrNumber attnum)
{
    HeapTuple   tp;
    Form_pg_attribute att_tup;
    char        result;
 
    tp = SearchSysCache2(ATTNUM,
                         ObjectIdGetDatum(relid),
                         Int16GetDatum(attnum));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             attnum, relid);
    att_tup = (Form_pg_attribute) GETSTRUCT(tp);
    result = att_tup->attgenerated;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_atttype
 *
 *      Given the relation OID and the attribute number with the relation,
 *      return the attribute type OID.
 */
Oid
get_atttype(Oid relid, AttrNumber attnum)
{
    HeapTuple   tp;
 
    tp = SearchSysCache2(ATTNUM,
                         ObjectIdGetDatum(relid),
                         Int16GetDatum(attnum));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
        Oid         result;
 
        result = att_tup->atttypid;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_atttypetypmodcoll
 *
 *      A three-fer: given the relation id and the attribute number,
 *      fetch atttypid, atttypmod, and attcollation in a single cache lookup.
 *
 * Unlike the otherwise-similar get_atttype, this routine
 * raises an error if it can't obtain the information.
 */
void
get_atttypetypmodcoll(Oid relid, AttrNumber attnum,
                      Oid *typid, int32 *typmod, Oid *collid)
{
    HeapTuple   tp;
    Form_pg_attribute att_tup;
 
    tp = SearchSysCache2(ATTNUM,
                         ObjectIdGetDatum(relid),
                         Int16GetDatum(attnum));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             attnum, relid);
    att_tup = (Form_pg_attribute) GETSTRUCT(tp);
 
    *typid = att_tup->atttypid;
    *typmod = att_tup->atttypmod;
    *collid = att_tup->attcollation;
    ReleaseSysCache(tp);
}
 
/*
 * get_attoptions
 *
 *      Given the relation id and the attribute number,
 *      return the attribute options text[] datum, if any.
 */
Datum
get_attoptions(Oid relid, int16 attnum)
{
    HeapTuple   tuple;
    Datum       attopts;
    Datum       result;
    bool        isnull;
 
    tuple = SearchSysCache2(ATTNUM,
                            ObjectIdGetDatum(relid),
                            Int16GetDatum(attnum));
 
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             attnum, relid);
 
    attopts = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions,
                              &isnull);
 
    if (isnull)
        result = (Datum) 0;
    else
        result = datumCopy(attopts, false, -1); /* text[] */
 
    ReleaseSysCache(tuple);
 
    return result;
}
 
/*              ---------- PG_CAST CACHE ----------                  */
 
/*
 * get_cast_oid - given two type OIDs, look up a cast OID
 *
 * If missing_ok is false, throw an error if the cast is not found.  If
 * true, just return InvalidOid.
 */
Oid
get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok)
{
    Oid         oid;
 
    oid = GetSysCacheOid2(CASTSOURCETARGET, Anum_pg_cast_oid,
                          ObjectIdGetDatum(sourcetypeid),
                          ObjectIdGetDatum(targettypeid));
    if (!OidIsValid(oid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("cast from type %s to type %s does not exist",
                        format_type_be(sourcetypeid),
                        format_type_be(targettypeid))));
    return oid;
}
 
/*              ---------- COLLATION CACHE ----------                    */
 
/*
 * get_collation_name
 *      Returns the name of a given pg_collation entry.
 *
 * Returns a palloc'd copy of the string, or NULL if no such collation.
 *
 * NOTE: since collation name is not unique, be wary of code that uses this
 * for anything except preparing error messages.
 */
char *
get_collation_name(Oid colloid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(colloid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_collation colltup = (Form_pg_collation) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(colltup->collname));
        ReleaseSysCache(tp);
        return result;
    }
    else
        return NULL;
}
 
bool
get_collation_isdeterministic(Oid colloid)
{
    HeapTuple   tp;
    Form_pg_collation colltup;
    bool        result;
 
    tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(colloid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for collation %u", colloid);
    colltup = (Form_pg_collation) GETSTRUCT(tp);
    result = colltup->collisdeterministic;
    ReleaseSysCache(tp);
    return result;
}
 
/*              ---------- CONSTRAINT CACHE ----------                   */
 
/*
 * get_constraint_name
 *      Returns the name of a given pg_constraint entry.
 *
 * Returns a palloc'd copy of the string, or NULL if no such constraint.
 *
 * NOTE: since constraint name is not unique, be wary of code that uses this
 * for anything except preparing error messages.
 */
char *
get_constraint_name(Oid conoid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(conoid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_constraint contup = (Form_pg_constraint) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(contup->conname));
        ReleaseSysCache(tp);
        return result;
    }
    else
        return NULL;
}
 
/*
 * get_constraint_index
 *      Given the OID of a unique, primary-key, or exclusion constraint,
 *      return the OID of the underlying index.
 *
 * Returns InvalidOid if the constraint could not be found or is of
 * the wrong type.
 *
 * The intent of this function is to return the index "owned" by the
 * specified constraint.  Therefore we must check contype, since some
 * pg_constraint entries (e.g. for foreign-key constraints) store the
 * OID of an index that is referenced but not owned by the constraint.
 */
Oid
get_constraint_index(Oid conoid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(conoid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_constraint contup = (Form_pg_constraint) GETSTRUCT(tp);
        Oid         result;
 
        if (contup->contype == CONSTRAINT_UNIQUE ||
            contup->contype == CONSTRAINT_PRIMARY ||
            contup->contype == CONSTRAINT_EXCLUSION)
            result = contup->conindid;
        else
            result = InvalidOid;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_constraint_type
 *      Return the pg_constraint.contype value for the given constraint.
 *
 * No frills.
 */
char
get_constraint_type(Oid conoid)
{
    HeapTuple   tp;
    char        contype;
 
    tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(conoid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for constraint %u", conoid);
 
    contype = ((Form_pg_constraint) GETSTRUCT(tp))->contype;
    ReleaseSysCache(tp);
 
    return contype;
}
 
/*              ---------- LANGUAGE CACHE ----------                     */
 
char *
get_language_name(Oid langoid, bool missing_ok)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(LANGOID, ObjectIdGetDatum(langoid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_language lantup = (Form_pg_language) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(lantup->lanname));
        ReleaseSysCache(tp);
        return result;
    }
 
    if (!missing_ok)
        elog(ERROR, "cache lookup failed for language %u",
             langoid);
    return NULL;
}
 
/*              ---------- OPCLASS CACHE ----------                      */
 
/*
 * get_opclass_family
 *
 *      Returns the OID of the operator family the opclass belongs to.
 */
Oid
get_opclass_family(Oid opclass)
{
    HeapTuple   tp;
    Form_pg_opclass cla_tup;
    Oid         result;
 
    tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for opclass %u", opclass);
    cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
 
    result = cla_tup->opcfamily;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_opclass_input_type
 *
 *      Returns the OID of the datatype the opclass indexes.
 */
Oid
get_opclass_input_type(Oid opclass)
{
    HeapTuple   tp;
    Form_pg_opclass cla_tup;
    Oid         result;
 
    tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for opclass %u", opclass);
    cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
 
    result = cla_tup->opcintype;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_opclass_opfamily_and_input_type
 *
 *      Returns the OID of the operator family the opclass belongs to,
 *              the OID of the datatype the opclass indexes
 */
bool
get_opclass_opfamily_and_input_type(Oid opclass, Oid *opfamily, Oid *opcintype)
{
    HeapTuple   tp;
    Form_pg_opclass cla_tup;
 
    tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
    if (!HeapTupleIsValid(tp))
        return false;
 
    cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
 
    *opfamily = cla_tup->opcfamily;
    *opcintype = cla_tup->opcintype;
 
    ReleaseSysCache(tp);
 
    return true;
}
 
/*
 * get_opclass_method
 *
 *      Returns the OID of the index access method the opclass belongs to.
 */
Oid
get_opclass_method(Oid opclass)
{
    HeapTuple   tp;
    Form_pg_opclass cla_tup;
    Oid         result;
 
    tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for opclass %u", opclass);
    cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
 
    result = cla_tup->opcmethod;
    ReleaseSysCache(tp);
    return result;
}
 
/*              ---------- OPFAMILY CACHE ----------                     */
 
/*
 * get_opfamily_method
 *
 *      Returns the OID of the index access method the opfamily is for.
 */
Oid
get_opfamily_method(Oid opfid)
{
    HeapTuple   tp;
    Form_pg_opfamily opfform;
    Oid         result;
 
    tp = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for operator family %u", opfid);
    opfform = (Form_pg_opfamily) GETSTRUCT(tp);
 
    result = opfform->opfmethod;
    ReleaseSysCache(tp);
    return result;
}
 
char *
get_opfamily_name(Oid opfid, bool missing_ok)
{
    HeapTuple   tup;
    char       *opfname;
    Form_pg_opfamily opfform;
 
    tup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
 
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for operator family %u", opfid);
        return NULL;
    }
 
    opfform = (Form_pg_opfamily) GETSTRUCT(tup);
    opfname = pstrdup(NameStr(opfform->opfname));
 
    ReleaseSysCache(tup);
 
    return opfname;
}
 
/*              ---------- OPERATOR CACHE ----------                     */
 
/*
 * get_opcode
 *
 *      Returns the regproc id of the routine used to implement an
 *      operator given the operator oid.
 */
RegProcedure
get_opcode(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        RegProcedure result;
 
        result = optup->oprcode;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return (RegProcedure) InvalidOid;
}
 
/*
 * get_opname
 *    returns the name of the operator with the given opno
 *
 * Note: returns a palloc'd copy of the string, or NULL if no such operator.
 */
char *
get_opname(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(optup->oprname));
        ReleaseSysCache(tp);
        return result;
    }
    else
        return NULL;
}
 
/*
 * get_op_rettype
 *      Given operator oid, return the operator's result type.
 */
Oid
get_op_rettype(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        Oid         result;
 
        result = optup->oprresult;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * op_input_types
 *
 *      Returns the left and right input datatypes for an operator
 *      (InvalidOid if not relevant).
 */
void
op_input_types(Oid opno, Oid *lefttype, Oid *righttype)
{
    HeapTuple   tp;
    Form_pg_operator optup;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (!HeapTupleIsValid(tp))  /* shouldn't happen */
        elog(ERROR, "cache lookup failed for operator %u", opno);
    optup = (Form_pg_operator) GETSTRUCT(tp);
    *lefttype = optup->oprleft;
    *righttype = optup->oprright;
    ReleaseSysCache(tp);
}
 
/*
 * op_mergejoinable
 *
 * Returns true if the operator is potentially mergejoinable.  (The planner
 * will fail to find any mergejoin plans unless there are suitable btree
 * opfamily entries for this operator and associated sortops.  The pg_operator
 * flag is just a hint to tell the planner whether to bother looking.)
 *
 * In some cases (currently only array_eq and record_eq), mergejoinability
 * depends on the specific input data type the operator is invoked for, so
 * that must be passed as well. We currently assume that only one input's type
 * is needed to check this --- by convention, pass the left input's data type.
 */
bool
op_mergejoinable(Oid opno, Oid inputtype)
{
    bool        result = false;
    HeapTuple   tp;
    TypeCacheEntry *typentry;
 
    /*
     * For array_eq or record_eq, we can sort if the element or field types
     * are all sortable.  We could implement all the checks for that here, but
     * the typcache already does that and caches the results too, so let's
     * rely on the typcache.
     */
    if (opno == ARRAY_EQ_OP)
    {
        typentry = lookup_type_cache(inputtype, TYPECACHE_CMP_PROC);
        if (typentry->cmp_proc == F_BTARRAYCMP)
            result = true;
    }
    else if (opno == RECORD_EQ_OP)
    {
        typentry = lookup_type_cache(inputtype, TYPECACHE_CMP_PROC);
        if (typentry->cmp_proc == F_BTRECORDCMP)
            result = true;
    }
    else
    {
        /* For all other operators, rely on pg_operator.oprcanmerge */
        tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
        if (HeapTupleIsValid(tp))
        {
            Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
 
            result = optup->oprcanmerge;
            ReleaseSysCache(tp);
        }
    }
    return result;
}
 
/*
 * op_hashjoinable
 *
 * Returns true if the operator is hashjoinable.  (There must be a suitable
 * hash opfamily entry for this operator if it is so marked.)
 *
 * In some cases (currently only array_eq), hashjoinability depends on the
 * specific input data type the operator is invoked for, so that must be
 * passed as well.  We currently assume that only one input's type is needed
 * to check this --- by convention, pass the left input's data type.
 */
bool
op_hashjoinable(Oid opno, Oid inputtype)
{
    bool        result = false;
    HeapTuple   tp;
    TypeCacheEntry *typentry;
 
    /* As in op_mergejoinable, let the typcache handle the hard cases */
    if (opno == ARRAY_EQ_OP)
    {
        typentry = lookup_type_cache(inputtype, TYPECACHE_HASH_PROC);
        if (typentry->hash_proc == F_HASH_ARRAY)
            result = true;
    }
    else if (opno == RECORD_EQ_OP)
    {
        typentry = lookup_type_cache(inputtype, TYPECACHE_HASH_PROC);
        if (typentry->hash_proc == F_HASH_RECORD)
            result = true;
    }
    else
    {
        /* For all other operators, rely on pg_operator.oprcanhash */
        tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
        if (HeapTupleIsValid(tp))
        {
            Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
 
            result = optup->oprcanhash;
            ReleaseSysCache(tp);
        }
    }
    return result;
}
 
/*
 * op_strict
 *
 * Get the proisstrict flag for the operator's underlying function.
 */
bool
op_strict(Oid opno)
{
    RegProcedure funcid = get_opcode(opno);
 
    if (funcid == (RegProcedure) InvalidOid)
        elog(ERROR, "operator %u does not exist", opno);
 
    return func_strict((Oid) funcid);
}
 
/*
 * op_volatile
 *
 * Get the provolatile flag for the operator's underlying function.
 */
char
op_volatile(Oid opno)
{
    RegProcedure funcid = get_opcode(opno);
 
    if (funcid == (RegProcedure) InvalidOid)
        elog(ERROR, "operator %u does not exist", opno);
 
    return func_volatile((Oid) funcid);
}
 
/*
 * get_commutator
 *
 *      Returns the corresponding commutator of an operator.
 */
Oid
get_commutator(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        Oid         result;
 
        result = optup->oprcom;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_negator
 *
 *      Returns the corresponding negator of an operator.
 */
Oid
get_negator(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        Oid         result;
 
        result = optup->oprnegate;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_oprrest
 *
 *      Returns procedure id for computing selectivity of an operator.
 */
RegProcedure
get_oprrest(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        RegProcedure result;
 
        result = optup->oprrest;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return (RegProcedure) InvalidOid;
}
 
/*
 * get_oprjoin
 *
 *      Returns procedure id for computing selectivity of a join.
 */
RegProcedure
get_oprjoin(Oid opno)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
        RegProcedure result;
 
        result = optup->oprjoin;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return (RegProcedure) InvalidOid;
}
 
/*              ---------- FUNCTION CACHE ----------                     */
 
/*
 * get_func_name
 *    returns the name of the function with the given funcid
 *
 * Note: returns a palloc'd copy of the string, or NULL if no such function.
 */
char *
get_func_name(Oid funcid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(functup->proname));
        ReleaseSysCache(tp);
        return result;
    }
    else
        return NULL;
}
 
/*
 * get_func_namespace
 *
 *      Returns the pg_namespace OID associated with a given function.
 */
Oid
get_func_namespace(Oid funcid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp);
        Oid         result;
 
        result = functup->pronamespace;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_func_rettype
 *      Given procedure id, return the function's result type.
 */
Oid
get_func_rettype(Oid funcid)
{
    HeapTuple   tp;
    Oid         result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->prorettype;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_nargs
 *      Given procedure id, return the number of arguments.
 */
int
get_func_nargs(Oid funcid)
{
    HeapTuple   tp;
    int         result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->pronargs;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_signature
 *      Given procedure id, return the function's argument and result types.
 *      (The return value is the result type.)
 *
 * The arguments are returned as a palloc'd array.
 */
Oid
get_func_signature(Oid funcid, Oid **argtypes, int *nargs)
{
    HeapTuple   tp;
    Form_pg_proc procstruct;
    Oid         result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    procstruct = (Form_pg_proc) GETSTRUCT(tp);
 
    result = procstruct->prorettype;
    *nargs = (int) procstruct->pronargs;
    Assert(*nargs == procstruct->proargtypes.dim1);
    *argtypes = (Oid *) palloc(*nargs * sizeof(Oid));
    memcpy(*argtypes, procstruct->proargtypes.values, *nargs * sizeof(Oid));
 
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_variadictype
 *      Given procedure id, return the function's provariadic field.
 */
Oid
get_func_variadictype(Oid funcid)
{
    HeapTuple   tp;
    Oid         result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->provariadic;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_retset
 *      Given procedure id, return the function's proretset flag.
 */
bool
get_func_retset(Oid funcid)
{
    HeapTuple   tp;
    bool        result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->proretset;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * func_strict
 *      Given procedure id, return the function's proisstrict flag.
 */
bool
func_strict(Oid funcid)
{
    HeapTuple   tp;
    bool        result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->proisstrict;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * func_volatile
 *      Given procedure id, return the function's provolatile flag.
 */
char
func_volatile(Oid funcid)
{
    HeapTuple   tp;
    char        result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->provolatile;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * func_parallel
 *      Given procedure id, return the function's proparallel flag.
 */
char
func_parallel(Oid funcid)
{
    HeapTuple   tp;
    char        result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->proparallel;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_prokind
 *     Given procedure id, return the routine kind.
 */
char
get_func_prokind(Oid funcid)
{
    HeapTuple   tp;
    char        result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->prokind;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_leakproof
 *     Given procedure id, return the function's leakproof field.
 */
bool
get_func_leakproof(Oid funcid)
{
    HeapTuple   tp;
    bool        result;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", funcid);
 
    result = ((Form_pg_proc) GETSTRUCT(tp))->proleakproof;
    ReleaseSysCache(tp);
    return result;
}
 
/*
 * get_func_support
 *
 *      Returns the support function OID associated with a given function,
 *      or InvalidOid if there is none.
 */
RegProcedure
get_func_support(Oid funcid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp);
        RegProcedure result;
 
        result = functup->prosupport;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return (RegProcedure) InvalidOid;
}
 
/*              ---------- RELATION CACHE ----------                     */
 
/*
 * get_relname_relid
 *      Given name and namespace of a relation, look up the OID.
 *
 * Returns InvalidOid if there is no such relation.
 */
Oid
get_relname_relid(const char *relname, Oid relnamespace)
{
    return GetSysCacheOid2(RELNAMENSP, Anum_pg_class_oid,
                           PointerGetDatum(relname),
                           ObjectIdGetDatum(relnamespace));
}
 
#ifdef NOT_USED
/*
 * get_relnatts
 *
 *      Returns the number of attributes for a given relation.
 */
int
get_relnatts(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        int         result;
 
        result = reltup->relnatts;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidAttrNumber;
}
#endif
 
/*
 * get_rel_name
 *      Returns the name of a given relation.
 *
 * Returns a palloc'd copy of the string, or NULL if no such relation.
 *
 * NOTE: since relation name is not unique, be wary of code that uses this
 * for anything except preparing error messages.
 */
char *
get_rel_name(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(reltup->relname));
        ReleaseSysCache(tp);
        return result;
    }
    else
        return NULL;
}
 
/*
 * get_rel_namespace
 *
 *      Returns the pg_namespace OID associated with a given relation.
 */
Oid
get_rel_namespace(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        Oid         result;
 
        result = reltup->relnamespace;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_rel_type_id
 *
 *      Returns the pg_type OID associated with a given relation.
 *
 * Note: not all pg_class entries have associated pg_type OIDs; so be
 * careful to check for InvalidOid result.
 */
Oid
get_rel_type_id(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        Oid         result;
 
        result = reltup->reltype;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_rel_relkind
 *
 *      Returns the relkind associated with a given relation.
 */
char
get_rel_relkind(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        char        result;
 
        result = reltup->relkind;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return '\0';
}
 
/*
 * get_rel_relispartition
 *
 *      Returns the relispartition flag associated with a given relation.
 */
bool
get_rel_relispartition(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        bool        result;
 
        result = reltup->relispartition;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return false;
}
 
/*
 * get_rel_tablespace
 *
 *      Returns the pg_tablespace OID associated with a given relation.
 *
 * Note: InvalidOid might mean either that we couldn't find the relation,
 * or that it is in the database's default tablespace.
 */
Oid
get_rel_tablespace(Oid relid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
        Oid         result;
 
        result = reltup->reltablespace;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_rel_persistence
 *
 *      Returns the relpersistence associated with a given relation.
 */
char
get_rel_persistence(Oid relid)
{
    HeapTuple   tp;
    Form_pg_class reltup;
    char        result;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    reltup = (Form_pg_class) GETSTRUCT(tp);
    result = reltup->relpersistence;
    ReleaseSysCache(tp);
 
    return result;
}
 
/*
 * get_rel_relam
 *
 *      Returns the relam associated with a given relation.
 */
Oid
get_rel_relam(Oid relid)
{
    HeapTuple   tp;
    Form_pg_class reltup;
    Oid         result;
 
    tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    reltup = (Form_pg_class) GETSTRUCT(tp);
    result = reltup->relam;
    ReleaseSysCache(tp);
 
    return result;
}
 
 
/*              ---------- TRANSFORM CACHE ----------                        */
 
Oid
get_transform_fromsql(Oid typid, Oid langid, List *trftypes)
{
    HeapTuple   tup;
 
    if (!list_member_oid(trftypes, typid))
        return InvalidOid;
 
    tup = SearchSysCache2(TRFTYPELANG, ObjectIdGetDatum(typid),
                          ObjectIdGetDatum(langid));
    if (HeapTupleIsValid(tup))
    {
        Oid         funcid;
 
        funcid = ((Form_pg_transform) GETSTRUCT(tup))->trffromsql;
        ReleaseSysCache(tup);
        return funcid;
    }
    else
        return InvalidOid;
}
 
Oid
get_transform_tosql(Oid typid, Oid langid, List *trftypes)
{
    HeapTuple   tup;
 
    if (!list_member_oid(trftypes, typid))
        return InvalidOid;
 
    tup = SearchSysCache2(TRFTYPELANG, ObjectIdGetDatum(typid),
                          ObjectIdGetDatum(langid));
    if (HeapTupleIsValid(tup))
    {
        Oid         funcid;
 
        funcid = ((Form_pg_transform) GETSTRUCT(tup))->trftosql;
        ReleaseSysCache(tup);
        return funcid;
    }
    else
        return InvalidOid;
}
 
 
/*              ---------- TYPE CACHE ----------                         */
 
/*
 * get_typisdefined
 *
 *      Given the type OID, determine whether the type is defined
 *      (if not, it's only a shell).
 */
bool
get_typisdefined(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        bool        result;
 
        result = typtup->typisdefined;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return false;
}
 
/*
 * get_typlen
 *
 *      Given the type OID, return the length of the type.
 */
int16
get_typlen(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        int16       result;
 
        result = typtup->typlen;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return 0;
}
 
/*
 * get_typbyval
 *
 *      Given the type OID, determine whether the type is returned by value or
 *      not.  Returns true if by value, false if by reference.
 */
bool
get_typbyval(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        bool        result;
 
        result = typtup->typbyval;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return false;
}
 
/*
 * get_typlenbyval
 *
 *      A two-fer: given the type OID, return both typlen and typbyval.
 *
 *      Since both pieces of info are needed to know how to copy a Datum,
 *      many places need both.  Might as well get them with one cache lookup
 *      instead of two.  Also, this routine raises an error instead of
 *      returning a bogus value when given a bad type OID.
 */
void
get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
{
    HeapTuple   tp;
    Form_pg_type typtup;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typtup = (Form_pg_type) GETSTRUCT(tp);
    *typlen = typtup->typlen;
    *typbyval = typtup->typbyval;
    ReleaseSysCache(tp);
}
 
/*
 * get_typlenbyvalalign
 *
 *      A three-fer: given the type OID, return typlen, typbyval, typalign.
 */
void
get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval,
                     char *typalign)
{
    HeapTuple   tp;
    Form_pg_type typtup;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typtup = (Form_pg_type) GETSTRUCT(tp);
    *typlen = typtup->typlen;
    *typbyval = typtup->typbyval;
    *typalign = typtup->typalign;
    ReleaseSysCache(tp);
}
 
/*
 * getTypeIOParam
 *      Given a pg_type row, select the type OID to pass to I/O functions
 *
 * Formerly, all I/O functions were passed pg_type.typelem as their second
 * parameter, but we now have a more complex rule about what to pass.
 * This knowledge is intended to be centralized here --- direct references
 * to typelem elsewhere in the code are wrong, if they are associated with
 * I/O calls and not with actual subscripting operations!  (But see
 * bootstrap.c's boot_get_type_io_data() if you need to change this.)
 *
 * As of PostgreSQL 8.1, output functions receive only the value itself
 * and not any auxiliary parameters, so the name of this routine is now
 * a bit of a misnomer ... it should be getTypeInputParam.
 */
Oid
getTypeIOParam(HeapTuple typeTuple)
{
    Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
 
    /*
     * Array types get their typelem as parameter; everybody else gets their
     * own type OID as parameter.
     */
    if (OidIsValid(typeStruct->typelem))
        return typeStruct->typelem;
    else
        return typeStruct->oid;
}
 
/*
 * get_type_io_data
 *
 *      A six-fer:  given the type OID, return typlen, typbyval, typalign,
 *                  typdelim, typioparam, and IO function OID. The IO function
 *                  returned is controlled by IOFuncSelector
 */
void
get_type_io_data(Oid typid,
                 IOFuncSelector which_func,
                 int16 *typlen,
                 bool *typbyval,
                 char *typalign,
                 char *typdelim,
                 Oid *typioparam,
                 Oid *func)
{
    HeapTuple   typeTuple;
    Form_pg_type typeStruct;
 
    /*
     * In bootstrap mode, pass it off to bootstrap.c.  This hack allows us to
     * use array_in and array_out during bootstrap.
     */
    if (IsBootstrapProcessingMode())
    {
        Oid         typinput;
        Oid         typoutput;
 
        boot_get_type_io_data(typid,
                              typlen,
                              typbyval,
                              typalign,
                              typdelim,
                              typioparam,
                              &typinput,
                              &typoutput);
        switch (which_func)
        {
            case IOFunc_input:
                *func = typinput;
                break;
            case IOFunc_output:
                *func = typoutput;
                break;
            default:
                elog(ERROR, "binary I/O not supported during bootstrap");
                break;
        }
        return;
    }
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
 
    *typlen = typeStruct->typlen;
    *typbyval = typeStruct->typbyval;
    *typalign = typeStruct->typalign;
    *typdelim = typeStruct->typdelim;
    *typioparam = getTypeIOParam(typeTuple);
    switch (which_func)
    {
        case IOFunc_input:
            *func = typeStruct->typinput;
            break;
        case IOFunc_output:
            *func = typeStruct->typoutput;
            break;
        case IOFunc_receive:
            *func = typeStruct->typreceive;
            break;
        case IOFunc_send:
            *func = typeStruct->typsend;
            break;
    }
    ReleaseSysCache(typeTuple);
}
 
#ifdef NOT_USED
char
get_typalign(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        char        result;
 
        result = typtup->typalign;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return TYPALIGN_INT;
}
#endif
 
char
get_typstorage(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        char        result;
 
        result = typtup->typstorage;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return TYPSTORAGE_PLAIN;
}
 
/*
 * get_typdefault
 *    Given a type OID, return the type's default value, if any.
 *
 *    The result is a palloc'd expression node tree, or NULL if there
 *    is no defined default for the datatype.
 *
 * NB: caller should be prepared to coerce result to correct datatype;
 * the returned expression tree might produce something of the wrong type.
 */
Node *
get_typdefault(Oid typid)
{
    HeapTuple   typeTuple;
    Form_pg_type type;
    Datum       datum;
    bool        isNull;
    Node       *expr;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", typid);
    type = (Form_pg_type) GETSTRUCT(typeTuple);
 
    /*
     * typdefault and typdefaultbin are potentially null, so don't try to
     * access 'em as struct fields. Must do it the hard way with
     * SysCacheGetAttr.
     */
    datum = SysCacheGetAttr(TYPEOID,
                            typeTuple,
                            Anum_pg_type_typdefaultbin,
                            &isNull);
 
    if (!isNull)
    {
        /* We have an expression default */
        expr = stringToNode(TextDatumGetCString(datum));
    }
    else
    {
        /* Perhaps we have a plain literal default */
        datum = SysCacheGetAttr(TYPEOID,
                                typeTuple,
                                Anum_pg_type_typdefault,
                                &isNull);
 
        if (!isNull)
        {
            char       *strDefaultVal;
 
            /* Convert text datum to C string */
            strDefaultVal = TextDatumGetCString(datum);
            /* Convert C string to a value of the given type */
            datum = OidInputFunctionCall(type->typinput, strDefaultVal,
                                         getTypeIOParam(typeTuple), -1);
            /* Build a Const node containing the value */
            expr = (Node *) makeConst(typid,
                                      -1,
                                      type->typcollation,
                                      type->typlen,
                                      datum,
                                      false,
                                      type->typbyval);
            pfree(strDefaultVal);
        }
        else
        {
            /* No default */
            expr = NULL;
        }
    }
 
    ReleaseSysCache(typeTuple);
 
    return expr;
}
 
/*
 * getBaseType
 *      If the given type is a domain, return its base type;
 *      otherwise return the type's own OID.
 */
Oid
getBaseType(Oid typid)
{
    int32       typmod = -1;
 
    return getBaseTypeAndTypmod(typid, &typmod);
}
 
/*
 * getBaseTypeAndTypmod
 *      If the given type is a domain, return its base type and typmod;
 *      otherwise return the type's own OID, and leave *typmod unchanged.
 *
 * Note that the "applied typmod" should be -1 for every domain level
 * above the bottommost; therefore, if the passed-in typid is indeed
 * a domain, *typmod should be -1.
 */
Oid
getBaseTypeAndTypmod(Oid typid, int32 *typmod)
{
    /*
     * We loop to find the bottom base type in a stack of domains.
     */
    for (;;)
    {
        HeapTuple   tup;
        Form_pg_type typTup;
 
        tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for type %u", typid);
        typTup = (Form_pg_type) GETSTRUCT(tup);
        if (typTup->typtype != TYPTYPE_DOMAIN)
        {
            /* Not a domain, so done */
            ReleaseSysCache(tup);
            break;
        }
 
        Assert(*typmod == -1);
        typid = typTup->typbasetype;
        *typmod = typTup->typtypmod;
 
        ReleaseSysCache(tup);
    }
 
    return typid;
}
 
/*
 * get_typavgwidth
 *
 *    Given a type OID and a typmod value (pass -1 if typmod is unknown),
 *    estimate the average width of values of the type.  This is used by
 *    the planner, which doesn't require absolutely correct results;
 *    it's OK (and expected) to guess if we don't know for sure.
 */
int32
get_typavgwidth(Oid typid, int32 typmod)
{
    int         typlen = get_typlen(typid);
    int32       maxwidth;
 
    /*
     * Easy if it's a fixed-width type
     */
    if (typlen > 0)
        return typlen;
 
    /*
     * type_maximum_size knows the encoding of typmod for some datatypes;
     * don't duplicate that knowledge here.
     */
    maxwidth = type_maximum_size(typid, typmod);
    if (maxwidth > 0)
    {
        /*
         * For BPCHAR, the max width is also the only width.  Otherwise we
         * need to guess about the typical data width given the max. A sliding
         * scale for percentage of max width seems reasonable.
         */
        if (typid == BPCHAROID)
            return maxwidth;
        if (maxwidth <= 32)
            return maxwidth;    /* assume full width */
        if (maxwidth < 1000)
            return 32 + (maxwidth - 32) / 2;    /* assume 50% */
 
        /*
         * Beyond 1000, assume we're looking at something like
         * "varchar(10000)" where the limit isn't actually reached often, and
         * use a fixed estimate.
         */
        return 32 + (1000 - 32) / 2;
    }
 
    /*
     * Oops, we have no idea ... wild guess time.
     */
    return 32;
}
 
/*
 * get_typtype
 *
 *      Given the type OID, find if it is a basic type, a complex type, etc.
 *      It returns the null char if the cache lookup fails...
 */
char
get_typtype(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        char        result;
 
        result = typtup->typtype;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return '\0';
}
 
/*
 * type_is_rowtype
 *
 *      Convenience function to determine whether a type OID represents
 *      a "rowtype" type --- either RECORD or a named composite type
 *      (including a domain over a named composite type).
 */
bool
type_is_rowtype(Oid typid)
{
    if (typid == RECORDOID)
        return true;            /* easy case */
    switch (get_typtype(typid))
    {
        case TYPTYPE_COMPOSITE:
            return true;
        case TYPTYPE_DOMAIN:
            if (get_typtype(getBaseType(typid)) == TYPTYPE_COMPOSITE)
                return true;
            break;
        default:
            break;
    }
    return false;
}
 
/*
 * type_is_enum
 *    Returns true if the given type is an enum type.
 */
bool
type_is_enum(Oid typid)
{
    return (get_typtype(typid) == TYPTYPE_ENUM);
}
 
/*
 * type_is_range
 *    Returns true if the given type is a range type.
 */
bool
type_is_range(Oid typid)
{
    return (get_typtype(typid) == TYPTYPE_RANGE);
}
 
/*
 * type_is_multirange
 *    Returns true if the given type is a multirange type.
 */
bool
type_is_multirange(Oid typid)
{
    return (get_typtype(typid) == TYPTYPE_MULTIRANGE);
}
 
/*
 * get_type_category_preferred
 *
 *      Given the type OID, fetch its category and preferred-type status.
 *      Throws error on failure.
 */
void
get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
{
    HeapTuple   tp;
    Form_pg_type typtup;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typtup = (Form_pg_type) GETSTRUCT(tp);
    *typcategory = typtup->typcategory;
    *typispreferred = typtup->typispreferred;
    ReleaseSysCache(tp);
}
 
/*
 * get_typ_typrelid
 *
 *      Given the type OID, get the typrelid (InvalidOid if not a complex
 *      type).
 */
Oid
get_typ_typrelid(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        Oid         result;
 
        result = typtup->typrelid;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_element_type
 *
 *      Given the type OID, get the typelem (InvalidOid if not an array type).
 *
 * NB: this only succeeds for "true" arrays having array_subscript_handler
 * as typsubscript.  For other types, InvalidOid is returned independently
 * of whether they have typelem or typsubscript set.
 */
Oid
get_element_type(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        Oid         result;
 
        if (IsTrueArrayType(typtup))
            result = typtup->typelem;
        else
            result = InvalidOid;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_array_type
 *
 *      Given the type OID, get the corresponding "true" array type.
 *      Returns InvalidOid if no array type can be found.
 */
Oid
get_array_type(Oid typid)
{
    HeapTuple   tp;
    Oid         result = InvalidOid;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        result = ((Form_pg_type) GETSTRUCT(tp))->typarray;
        ReleaseSysCache(tp);
    }
    return result;
}
 
/*
 * get_promoted_array_type
 *
 *      The "promoted" type is what you'd get from an ARRAY(SELECT ...)
 *      construct, that is, either the corresponding "true" array type
 *      if the input is a scalar type that has such an array type,
 *      or the same type if the input is already a "true" array type.
 *      Returns InvalidOid if neither rule is satisfied.
 */
Oid
get_promoted_array_type(Oid typid)
{
    Oid         array_type = get_array_type(typid);
 
    if (OidIsValid(array_type))
        return array_type;
    if (OidIsValid(get_element_type(typid)))
        return typid;
    return InvalidOid;
}
 
/*
 * get_base_element_type
 *      Given the type OID, get the typelem, looking "through" any domain
 *      to its underlying array type.
 *
 * This is equivalent to get_element_type(getBaseType(typid)), but avoids
 * an extra cache lookup.  Note that it fails to provide any information
 * about the typmod of the array.
 */
Oid
get_base_element_type(Oid typid)
{
    /*
     * We loop to find the bottom base type in a stack of domains.
     */
    for (;;)
    {
        HeapTuple   tup;
        Form_pg_type typTup;
 
        tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
        if (!HeapTupleIsValid(tup))
            break;
        typTup = (Form_pg_type) GETSTRUCT(tup);
        if (typTup->typtype != TYPTYPE_DOMAIN)
        {
            /* Not a domain, so stop descending */
            Oid         result;
 
            /* This test must match get_element_type */
            if (IsTrueArrayType(typTup))
                result = typTup->typelem;
            else
                result = InvalidOid;
            ReleaseSysCache(tup);
            return result;
        }
 
        typid = typTup->typbasetype;
        ReleaseSysCache(tup);
    }
 
    /* Like get_element_type, silently return InvalidOid for bogus input */
    return InvalidOid;
}
 
/*
 * getTypeInputInfo
 *
 *      Get info needed for converting values of a type to internal form
 */
void
getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
{
    HeapTuple   typeTuple;
    Form_pg_type pt;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", type);
    pt = (Form_pg_type) GETSTRUCT(typeTuple);
 
    if (!pt->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type %s is only a shell",
                        format_type_be(type))));
    if (!OidIsValid(pt->typinput))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("no input function available for type %s",
                        format_type_be(type))));
 
    *typInput = pt->typinput;
    *typIOParam = getTypeIOParam(typeTuple);
 
    ReleaseSysCache(typeTuple);
}
 
/*
 * getTypeOutputInfo
 *
 *      Get info needed for printing values of a type
 */
void
getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
{
    HeapTuple   typeTuple;
    Form_pg_type pt;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", type);
    pt = (Form_pg_type) GETSTRUCT(typeTuple);
 
    if (!pt->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type %s is only a shell",
                        format_type_be(type))));
    if (!OidIsValid(pt->typoutput))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("no output function available for type %s",
                        format_type_be(type))));
 
    *typOutput = pt->typoutput;
    *typIsVarlena = (!pt->typbyval) && (pt->typlen == -1);
 
    ReleaseSysCache(typeTuple);
}
 
/*
 * getTypeBinaryInputInfo
 *
 *      Get info needed for binary input of values of a type
 */
void
getTypeBinaryInputInfo(Oid type, Oid *typReceive, Oid *typIOParam)
{
    HeapTuple   typeTuple;
    Form_pg_type pt;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", type);
    pt = (Form_pg_type) GETSTRUCT(typeTuple);
 
    if (!pt->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type %s is only a shell",
                        format_type_be(type))));
    if (!OidIsValid(pt->typreceive))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("no binary input function available for type %s",
                        format_type_be(type))));
 
    *typReceive = pt->typreceive;
    *typIOParam = getTypeIOParam(typeTuple);
 
    ReleaseSysCache(typeTuple);
}
 
/*
 * getTypeBinaryOutputInfo
 *
 *      Get info needed for binary output of values of a type
 */
void
getTypeBinaryOutputInfo(Oid type, Oid *typSend, bool *typIsVarlena)
{
    HeapTuple   typeTuple;
    Form_pg_type pt;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
    if (!HeapTupleIsValid(typeTuple))
        elog(ERROR, "cache lookup failed for type %u", type);
    pt = (Form_pg_type) GETSTRUCT(typeTuple);
 
    if (!pt->typisdefined)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type %s is only a shell",
                        format_type_be(type))));
    if (!OidIsValid(pt->typsend))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("no binary output function available for type %s",
                        format_type_be(type))));
 
    *typSend = pt->typsend;
    *typIsVarlena = (!pt->typbyval) && (pt->typlen == -1);
 
    ReleaseSysCache(typeTuple);
}
 
/*
 * get_typmodin
 *
 *      Given the type OID, return the type's typmodin procedure, if any.
 */
Oid
get_typmodin(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        Oid         result;
 
        result = typtup->typmodin;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
#ifdef NOT_USED
/*
 * get_typmodout
 *
 *      Given the type OID, return the type's typmodout procedure, if any.
 */
Oid
get_typmodout(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        Oid         result;
 
        result = typtup->typmodout;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
#endif                          /* NOT_USED */
 
/*
 * get_typcollation
 *
 *      Given the type OID, return the type's typcollation attribute.
 */
Oid
get_typcollation(Oid typid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
        Oid         result;
 
        result = typtup->typcollation;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
 
/*
 * type_is_collatable
 *
 *      Return whether the type cares about collations
 */
bool
type_is_collatable(Oid typid)
{
    return OidIsValid(get_typcollation(typid));
}
 
 
/*
 * get_typsubscript
 *
 *      Given the type OID, return the type's subscripting handler's OID,
 *      if it has one.
 *
 * If typelemp isn't NULL, we also store the type's typelem value there.
 * This saves some callers an extra catalog lookup.
 */
RegProcedure
get_typsubscript(Oid typid, Oid *typelemp)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_type typform = (Form_pg_type) GETSTRUCT(tp);
        RegProcedure handler = typform->typsubscript;
 
        if (typelemp)
            *typelemp = typform->typelem;
        ReleaseSysCache(tp);
        return handler;
    }
    else
    {
        if (typelemp)
            *typelemp = InvalidOid;
        return InvalidOid;
    }
}
 
/*
 * getSubscriptingRoutines
 *
 *      Given the type OID, fetch the type's subscripting methods struct.
 *      Return NULL if type is not subscriptable.
 *
 * If typelemp isn't NULL, we also store the type's typelem value there.
 * This saves some callers an extra catalog lookup.
 */
const struct SubscriptRoutines *
getSubscriptingRoutines(Oid typid, Oid *typelemp)
{
    RegProcedure typsubscript = get_typsubscript(typid, typelemp);
 
    if (!OidIsValid(typsubscript))
        return NULL;
 
    return (const struct SubscriptRoutines *)
        DatumGetPointer(OidFunctionCall0(typsubscript));
}
 
 
/*              ---------- STATISTICS CACHE ----------                   */
 
/*
 * get_attavgwidth
 *
 *    Given the table and attribute number of a column, get the average
 *    width of entries in the column.  Return zero if no data available.
 *
 * Currently this is only consulted for individual tables, not for inheritance
 * trees, so we don't need an "inh" parameter.
 *
 * Calling a hook at this point looks somewhat strange, but is required
 * because the optimizer calls this function without any other way for
 * plug-ins to control the result.
 */
int32
get_attavgwidth(Oid relid, AttrNumber attnum)
{
    HeapTuple   tp;
    int32       stawidth;
 
    if (get_attavgwidth_hook)
    {
        stawidth = (*get_attavgwidth_hook) (relid, attnum);
        if (stawidth > 0)
            return stawidth;
    }
    tp = SearchSysCache3(STATRELATTINH,
                         ObjectIdGetDatum(relid),
                         Int16GetDatum(attnum),
                         BoolGetDatum(false));
    if (HeapTupleIsValid(tp))
    {
        stawidth = ((Form_pg_statistic) GETSTRUCT(tp))->stawidth;
        ReleaseSysCache(tp);
        if (stawidth > 0)
            return stawidth;
    }
    return 0;
}
 
/*
 * get_attstatsslot
 *
 *      Extract the contents of a "slot" of a pg_statistic tuple.
 *      Returns true if requested slot type was found, else false.
 *
 * Unlike other routines in this file, this takes a pointer to an
 * already-looked-up tuple in the pg_statistic cache.  We do this since
 * most callers will want to extract more than one value from the cache
 * entry, and we don't want to repeat the cache lookup unnecessarily.
 * Also, this API allows this routine to be used with statistics tuples
 * that have been provided by a stats hook and didn't really come from
 * pg_statistic.
 *
 * sslot: pointer to output area (typically, a local variable in the caller).
 * statstuple: pg_statistic tuple to be examined.
 * reqkind: STAKIND code for desired statistics slot kind.
 * reqop: STAOP value wanted, or InvalidOid if don't care.
 * flags: bitmask of ATTSTATSSLOT_VALUES and/or ATTSTATSSLOT_NUMBERS.
 *
 * If a matching slot is found, true is returned, and *sslot is filled thus:
 * staop: receives the actual STAOP value.
 * stacoll: receives the actual STACOLL value.
 * valuetype: receives actual datatype of the elements of stavalues.
 * values: receives pointer to an array of the slot's stavalues.
 * nvalues: receives number of stavalues.
 * numbers: receives pointer to an array of the slot's stanumbers (as float4).
 * nnumbers: receives number of stanumbers.
 *
 * valuetype/values/nvalues are InvalidOid/NULL/0 if ATTSTATSSLOT_VALUES
 * wasn't specified.  Likewise, numbers/nnumbers are NULL/0 if
 * ATTSTATSSLOT_NUMBERS wasn't specified.
 *
 * If no matching slot is found, false is returned, and *sslot is zeroed.
 *
 * Note that the current API doesn't allow for searching for a slot with
 * a particular collation.  If we ever actually support recording more than
 * one collation, we'll have to extend the API, but for now simple is good.
 *
 * The data referred to by the fields of sslot is locally palloc'd and
 * is independent of the original pg_statistic tuple.  When the caller
 * is done with it, call free_attstatsslot to release the palloc'd data.
 *
 * If it's desirable to call free_attstatsslot when get_attstatsslot might
 * not have been called, memset'ing sslot to zeroes will allow that.
 *
 * Passing flags=0 can be useful to quickly check if the requested slot type
 * exists.  In this case no arrays are extracted, so free_attstatsslot need
 * not be called.
 */
bool
get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple,
                 int reqkind, Oid reqop, int flags)
{
    Form_pg_statistic stats = (Form_pg_statistic) GETSTRUCT(statstuple);
    int         i;
    Datum       val;
    ArrayType  *statarray;
    Oid         arrayelemtype;
    int         narrayelem;
    HeapTuple   typeTuple;
    Form_pg_type typeForm;
 
    /* initialize *sslot properly */
    memset(sslot, 0, sizeof(AttStatsSlot));
 
    for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
    {
        if ((&stats->stakind1)[i] == reqkind &&
            (reqop == InvalidOid || (&stats->staop1)[i] == reqop))
            break;
    }
    if (i >= STATISTIC_NUM_SLOTS)
        return false;           /* not there */
 
    sslot->staop = (&stats->staop1)[i];
    sslot->stacoll = (&stats->stacoll1)[i];
 
    if (flags & ATTSTATSSLOT_VALUES)
    {
        val = SysCacheGetAttrNotNull(STATRELATTINH, statstuple,
                                     Anum_pg_statistic_stavalues1 + i);
 
        /*
         * Detoast the array if needed, and in any case make a copy that's
         * under control of this AttStatsSlot.
         */
        statarray = DatumGetArrayTypePCopy(val);
 
        /*
         * Extract the actual array element type, and pass it back in case the
         * caller needs it.
         */
        sslot->valuetype = arrayelemtype = ARR_ELEMTYPE(statarray);
 
        /* Need info about element type */
        typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(arrayelemtype));
        if (!HeapTupleIsValid(typeTuple))
            elog(ERROR, "cache lookup failed for type %u", arrayelemtype);
        typeForm = (Form_pg_type) GETSTRUCT(typeTuple);
 
        /* Deconstruct array into Datum elements; NULLs not expected */
        deconstruct_array(statarray,
                          arrayelemtype,
                          typeForm->typlen,
                          typeForm->typbyval,
                          typeForm->typalign,
                          &sslot->values, NULL, &sslot->nvalues);
 
        /*
         * If the element type is pass-by-reference, we now have a bunch of
         * Datums that are pointers into the statarray, so we need to keep
         * that until free_attstatsslot.  Otherwise, all the useful info is in
         * sslot->values[], so we can free the array object immediately.
         */
        if (!typeForm->typbyval)
            sslot->values_arr = statarray;
        else
            pfree(statarray);
 
        ReleaseSysCache(typeTuple);
    }
 
    if (flags & ATTSTATSSLOT_NUMBERS)
    {
        val = SysCacheGetAttrNotNull(STATRELATTINH, statstuple,
                                     Anum_pg_statistic_stanumbers1 + i);
 
        /*
         * Detoast the array if needed, and in any case make a copy that's
         * under control of this AttStatsSlot.
         */
        statarray = DatumGetArrayTypePCopy(val);
 
        /*
         * We expect the array to be a 1-D float4 array; verify that. We don't
         * need to use deconstruct_array() since the array data is just going
         * to look like a C array of float4 values.
         */
        narrayelem = ARR_DIMS(statarray)[0];
        if (ARR_NDIM(statarray) != 1 || narrayelem <= 0 ||
            ARR_HASNULL(statarray) ||
            ARR_ELEMTYPE(statarray) != FLOAT4OID)
            elog(ERROR, "stanumbers is not a 1-D float4 array");
 
        /* Give caller a pointer directly into the statarray */
        sslot->numbers = (float4 *) ARR_DATA_PTR(statarray);
        sslot->nnumbers = narrayelem;
 
        /* We'll free the statarray in free_attstatsslot */
        sslot->numbers_arr = statarray;
    }
 
    return true;
}
 
/*
 * free_attstatsslot
 *      Free data allocated by get_attstatsslot
 */
void
free_attstatsslot(AttStatsSlot *sslot)
{
    /* The values[] array was separately palloc'd by deconstruct_array */
    if (sslot->values)
        pfree(sslot->values);
    /* The numbers[] array points into numbers_arr, do not pfree it */
    /* Free the detoasted array objects, if any */
    if (sslot->values_arr)
        pfree(sslot->values_arr);
    if (sslot->numbers_arr)
        pfree(sslot->numbers_arr);
}
 
/*              ---------- PG_NAMESPACE CACHE ----------                 */
 
/*
 * get_namespace_name
 *      Returns the name of a given namespace
 *
 * Returns a palloc'd copy of the string, or NULL if no such namespace.
 */
char *
get_namespace_name(Oid nspid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(NAMESPACEOID, ObjectIdGetDatum(nspid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_namespace nsptup = (Form_pg_namespace) GETSTRUCT(tp);
        char       *result;
 
        result = pstrdup(NameStr(nsptup->nspname));
        ReleaseSysCache(tp);
        return result;
    }
    else
        return NULL;
}
 
/*
 * get_namespace_name_or_temp
 *      As above, but if it is this backend's temporary namespace, return
 *      "pg_temp" instead.
 */
char *
get_namespace_name_or_temp(Oid nspid)
{
    if (isTempNamespace(nspid))
        return pstrdup("pg_temp");
    else
        return get_namespace_name(nspid);
}
 
/*              ---------- PG_RANGE CACHES ----------                */
 
/*
 * get_range_subtype
 *      Returns the subtype of a given range type
 *
 * Returns InvalidOid if the type is not a range type.
 */
Oid
get_range_subtype(Oid rangeOid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(rangeOid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
        Oid         result;
 
        result = rngtup->rngsubtype;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_range_collation
 *      Returns the collation of a given range type
 *
 * Returns InvalidOid if the type is not a range type,
 * or if its subtype is not collatable.
 */
Oid
get_range_collation(Oid rangeOid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(rangeOid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
        Oid         result;
 
        result = rngtup->rngcollation;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_range_multirange
 *      Returns the multirange type of a given range type
 *
 * Returns InvalidOid if the type is not a range type.
 */
Oid
get_range_multirange(Oid rangeOid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(rangeOid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
        Oid         result;
 
        result = rngtup->rngmultitypid;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*
 * get_multirange_range
 *      Returns the range type of a given multirange
 *
 * Returns InvalidOid if the type is not a multirange.
 */
Oid
get_multirange_range(Oid multirangeOid)
{
    HeapTuple   tp;
 
    tp = SearchSysCache1(RANGEMULTIRANGE, ObjectIdGetDatum(multirangeOid));
    if (HeapTupleIsValid(tp))
    {
        Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
        Oid         result;
 
        result = rngtup->rngtypid;
        ReleaseSysCache(tp);
        return result;
    }
    else
        return InvalidOid;
}
 
/*              ---------- PG_INDEX CACHE ----------                 */
 
/*
 * get_index_column_opclass
 *
 *      Given the index OID and column number,
 *      return opclass of the index column
 *          or InvalidOid if the index was not found
 *              or column is non-key one.
 */
Oid
get_index_column_opclass(Oid index_oid, int attno)
{
    HeapTuple   tuple;
    Form_pg_index rd_index;
    Datum       datum;
    oidvector  *indclass;
    Oid         opclass;
 
    /* First we need to know the column's opclass. */
 
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
    if (!HeapTupleIsValid(tuple))
        return InvalidOid;
 
    rd_index = (Form_pg_index) GETSTRUCT(tuple);
 
    /* caller is supposed to guarantee this */
    Assert(attno > 0 && attno <= rd_index->indnatts);
 
    /* Non-key attributes don't have an opclass */
    if (attno > rd_index->indnkeyatts)
    {
        ReleaseSysCache(tuple);
        return InvalidOid;
    }
 
    datum = SysCacheGetAttrNotNull(INDEXRELID, tuple, Anum_pg_index_indclass);
    indclass = ((oidvector *) DatumGetPointer(datum));
 
    Assert(attno <= indclass->dim1);
    opclass = indclass->values[attno - 1];
 
    ReleaseSysCache(tuple);
 
    return opclass;
}
 
/*
 * get_index_isreplident
 *
 *      Given the index OID, return pg_index.indisreplident.
 */
bool
get_index_isreplident(Oid index_oid)
{
    HeapTuple   tuple;
    Form_pg_index rd_index;
    bool        result;
 
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
    if (!HeapTupleIsValid(tuple))
        return false;
 
    rd_index = (Form_pg_index) GETSTRUCT(tuple);
    result = rd_index->indisreplident;
    ReleaseSysCache(tuple);
 
    return result;
}
 
/*
 * get_index_isvalid
 *
 *      Given the index OID, return pg_index.indisvalid.
 */
bool
get_index_isvalid(Oid index_oid)
{
    bool        isvalid;
    HeapTuple   tuple;
    Form_pg_index rd_index;
 
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for index %u", index_oid);
 
    rd_index = (Form_pg_index) GETSTRUCT(tuple);
    isvalid = rd_index->indisvalid;
    ReleaseSysCache(tuple);
 
    return isvalid;
}
 
/*
 * get_index_isclustered
 *
 *      Given the index OID, return pg_index.indisclustered.
 */
bool
get_index_isclustered(Oid index_oid)
{
    bool        isclustered;
    HeapTuple   tuple;
    Form_pg_index rd_index;
 
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for index %u", index_oid);
 
    rd_index = (Form_pg_index) GETSTRUCT(tuple);
    isclustered = rd_index->indisclustered;
    ReleaseSysCache(tuple);
 
    return isclustered;
}
 
/*
 * get_publication_oid - given a publication name, look up the OID
 *
 * If missing_ok is false, throw an error if name not found.  If true, just
 * return InvalidOid.
 */
Oid
get_publication_oid(const char *pubname, bool missing_ok)
{
    Oid         oid;
 
    oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
                          CStringGetDatum(pubname));
    if (!OidIsValid(oid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("publication \"%s\" does not exist", pubname)));
    return oid;
}
 
/*
 * get_publication_name - given a publication Oid, look up the name
 *
 * If missing_ok is false, throw an error if name not found.  If true, just
 * return NULL.
 */
char *
get_publication_name(Oid pubid, bool missing_ok)
{
    HeapTuple   tup;
    char       *pubname;
    Form_pg_publication pubform;
 
    tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
 
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for publication %u", pubid);
        return NULL;
    }
 
    pubform = (Form_pg_publication) GETSTRUCT(tup);
    pubname = pstrdup(NameStr(pubform->pubname));
 
    ReleaseSysCache(tup);
 
    return pubname;
}
 
/*
 * get_subscription_oid - given a subscription name, look up the OID
 *
 * If missing_ok is false, throw an error if name not found.  If true, just
 * return InvalidOid.
 */
Oid
get_subscription_oid(const char *subname, bool missing_ok)
{
    Oid         oid;
 
    oid = GetSysCacheOid2(SUBSCRIPTIONNAME, Anum_pg_subscription_oid,
                          MyDatabaseId, CStringGetDatum(subname));
    if (!OidIsValid(oid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("subscription \"%s\" does not exist", subname)));
    return oid;
}
 
/*
 * get_subscription_name - given a subscription OID, look up the name
 *
 * If missing_ok is false, throw an error if name not found.  If true, just
 * return NULL.
 */
char *
get_subscription_name(Oid subid, bool missing_ok)
{
    HeapTuple   tup;
    char       *subname;
    Form_pg_subscription subform;
 
    tup = SearchSysCache1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
 
    if (!HeapTupleIsValid(tup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for subscription %u", subid);
        return NULL;
    }
 
    subform = (Form_pg_subscription) GETSTRUCT(tup);
    subname = pstrdup(NameStr(subform->subname));
 
    ReleaseSysCache(tup);
 
    return subname;
}