brin_inclusion.c File Reference

#include "postgres.h"
#include "access/brin_internal.h"
#include "access/brin_tuple.h"
#include "access/genam.h"
#include "access/skey.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_type.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for brin_inclusion.c:

Go to the source code of this file.

Data Structures
struct	InclusionOpaque

Macros
#define	INCLUSION_MAX_PROCNUMS   4 /* maximum support procs we need */
#define	PROCNUM_MERGE   11 /* required */
#define	PROCNUM_MERGEABLE   12 /* optional */
#define	PROCNUM_CONTAINS   13 /* optional */
#define	PROCNUM_EMPTY   14 /* optional */
#define	PROCNUM_BASE   11
#define	INCLUSION_UNION   0
#define	INCLUSION_UNMERGEABLE   1
#define	INCLUSION_CONTAINS_EMPTY   2

Typedefs
typedef struct InclusionOpaque	InclusionOpaque

Functions
static FmgrInfo *	inclusion_get_procinfo (BrinDesc *bdesc, uint16 attno, uint16 procnum)
static FmgrInfo *	inclusion_get_strategy_procinfo (BrinDesc *bdesc, uint16 attno, Oid subtype, uint16 strategynum)
Datum	brin_inclusion_opcinfo (PG_FUNCTION_ARGS)
Datum	brin_inclusion_add_value (PG_FUNCTION_ARGS)
Datum	brin_inclusion_consistent (PG_FUNCTION_ARGS)
Datum	brin_inclusion_union (PG_FUNCTION_ARGS)

Macro Definition Documentation

INCLUSION_CONTAINS_EMPTY

#define INCLUSION_CONTAINS_EMPTY   2

Definition at line 73 of file brin_inclusion.c.

INCLUSION_MAX_PROCNUMS

#define INCLUSION_MAX_PROCNUMS   4 /* maximum support procs we need */

Definition at line 46 of file brin_inclusion.c.

INCLUSION_UNION

#define INCLUSION_UNION   0

Definition at line 71 of file brin_inclusion.c.

INCLUSION_UNMERGEABLE

#define INCLUSION_UNMERGEABLE   1

Definition at line 72 of file brin_inclusion.c.

PROCNUM_BASE

#define PROCNUM_BASE   11

Definition at line 57 of file brin_inclusion.c.

PROCNUM_CONTAINS

#define PROCNUM_CONTAINS   13 /* optional */

Definition at line 49 of file brin_inclusion.c.

PROCNUM_EMPTY

#define PROCNUM_EMPTY   14 /* optional */

Definition at line 50 of file brin_inclusion.c.

PROCNUM_MERGE

#define PROCNUM_MERGE   11 /* required */

Definition at line 47 of file brin_inclusion.c.

PROCNUM_MERGEABLE

#define PROCNUM_MERGEABLE   12 /* optional */

Definition at line 48 of file brin_inclusion.c.

Typedef Documentation

InclusionOpaque

typedef struct InclusionOpaque InclusionOpaque

Function Documentation

brin_inclusion_add_value()

Datum brin_inclusion_add_value

(

PG_FUNCTION_ARGS

)

Definition at line 138 of file brin_inclusion.c.

{
    BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
    BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
    Datum       newval = PG_GETARG_DATUM(2);
    bool        isnull PG_USED_FOR_ASSERTS_ONLY = PG_GETARG_BOOL(3);
    Oid         colloid = PG_GET_COLLATION();
    FmgrInfo   *finfo;
    Datum       result;
    bool        new = false;
    AttrNumber  attno;
    Form_pg_attribute attr;
 
    Assert(!isnull);
 
    attno = column->bv_attno;
    attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
 
    /*
     * If the recorded value is null, copy the new value (which we know to be
     * not null), and we're almost done.
     */
    if (column->bv_allnulls)
    {
        column->bv_values[INCLUSION_UNION] =
            datumCopy(newval, attr->attbyval, attr->attlen);
        column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(false);
        column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(false);
        column->bv_allnulls = false;
        new = true;
    }
 
    /*
     * No need for further processing if the block range is marked as
     * containing unmergeable values.
     */
    if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE]))
        PG_RETURN_BOOL(false);
 
    /*
     * If the opclass supports the concept of empty values, test the passed
     * new value for emptiness; if it returns true, we need to set the
     * "contains empty" flag in the element (unless already set).
     */
    finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_EMPTY);
    if (finfo != NULL && DatumGetBool(FunctionCall1Coll(finfo, colloid, newval)))
    {
        if (!DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]))
        {
            column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true);
            PG_RETURN_BOOL(true);
        }
 
        PG_RETURN_BOOL(false);
    }
 
    if (new)
        PG_RETURN_BOOL(true);
 
    /* Check if the new value is already contained. */
    finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_CONTAINS);
    if (finfo != NULL &&
        DatumGetBool(FunctionCall2Coll(finfo, colloid,
                                       column->bv_values[INCLUSION_UNION],
                                       newval)))
        PG_RETURN_BOOL(false);
 
    /*
     * Check if the new value is mergeable to the existing union.  If it is
     * not, mark the value as containing unmergeable elements and get out.
     *
     * Note: at this point we could remove the value from the union, since
     * it's not going to be used any longer.  However, the BRIN framework
     * doesn't allow for the value not being present.  Improve someday.
     */
    finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGEABLE);
    if (finfo != NULL &&
        !DatumGetBool(FunctionCall2Coll(finfo, colloid,
                                        column->bv_values[INCLUSION_UNION],
                                        newval)))
    {
        column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
        PG_RETURN_BOOL(true);
    }
 
    /* Finally, merge the new value to the existing union. */
    finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGE);
    Assert(finfo != NULL);
    result = FunctionCall2Coll(finfo, colloid,
                               column->bv_values[INCLUSION_UNION], newval);
    if (!attr->attbyval &&
        DatumGetPointer(result) != DatumGetPointer(column->bv_values[INCLUSION_UNION]))
    {
        pfree(DatumGetPointer(column->bv_values[INCLUSION_UNION]));
 
        if (result == newval)
            result = datumCopy(result, attr->attbyval, attr->attlen);
    }
    column->bv_values[INCLUSION_UNION] = result;
 
    PG_RETURN_BOOL(true);
}

References Assert(), BrinDesc::bd_tupdesc, BoolGetDatum(), BrinValues::bv_allnulls, BrinValues::bv_attno, BrinValues::bv_values, datumCopy(), DatumGetBool(), DatumGetPointer(), FunctionCall1Coll(), FunctionCall2Coll(), INCLUSION_CONTAINS_EMPTY, inclusion_get_procinfo(), INCLUSION_UNION, INCLUSION_UNMERGEABLE, newval, pfree(), PG_GET_COLLATION, PG_GETARG_BOOL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_BOOL, PG_USED_FOR_ASSERTS_ONLY, PROCNUM_CONTAINS, PROCNUM_EMPTY, PROCNUM_MERGE, PROCNUM_MERGEABLE, and TupleDescAttr.

brin_inclusion_consistent()

Datum brin_inclusion_consistent

(

PG_FUNCTION_ARGS

)

Definition at line 251 of file brin_inclusion.c.

{
    BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
    BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
    ScanKey     key = (ScanKey) PG_GETARG_POINTER(2);
    Oid         colloid = PG_GET_COLLATION(),
                subtype;
    Datum       unionval;
    AttrNumber  attno;
    Datum       query;
    FmgrInfo   *finfo;
    Datum       result;
 
    /* This opclass uses the old signature with only three arguments. */
    Assert(PG_NARGS() == 3);
 
    /* Should not be dealing with all-NULL ranges. */
    Assert(!column->bv_allnulls);
 
    /* It has to be checked, if it contains elements that are not mergeable. */
    if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE]))
        PG_RETURN_BOOL(true);
 
    attno = key->sk_attno;
    subtype = key->sk_subtype;
    query = key->sk_argument;
    unionval = column->bv_values[INCLUSION_UNION];
    switch (key->sk_strategy)
    {
            /*
             * Placement strategies
             *
             * These are implemented by logically negating the result of the
             * converse placement operator; for this to work, the converse
             * operator must be part of the opclass.  An error will be thrown
             * by inclusion_get_strategy_procinfo() if the required strategy
             * is not part of the opclass.
             *
             * These all return false if either argument is empty, so there is
             * no need to check for empty elements.
             */
 
        case RTLeftStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTOverRightStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTOverLeftStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTRightStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTOverRightStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTLeftStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTRightStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTOverLeftStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTBelowStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTOverAboveStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTOverBelowStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTAboveStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTOverAboveStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTBelowStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        case RTAboveStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTOverBelowStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
            /*
             * Overlap and contains strategies
             *
             * These strategies are simple enough that we can simply call the
             * operator and return its result.  Empty elements don't change
             * the result.
             */
 
        case RTOverlapStrategyNumber:
        case RTContainsStrategyNumber:
        case RTContainsElemStrategyNumber:
        case RTSubStrategyNumber:
        case RTSubEqualStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    key->sk_strategy);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_DATUM(result);
 
            /*
             * Contained by strategies
             *
             * We cannot just call the original operator for the contained by
             * strategies because some elements can be contained even though
             * the union is not; instead we use the overlap operator.
             *
             * We check for empty elements separately as they are not merged
             * to the union but contained by everything.
             */
 
        case RTContainedByStrategyNumber:
        case RTSuperStrategyNumber:
        case RTSuperEqualStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTOverlapStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            if (DatumGetBool(result))
                PG_RETURN_BOOL(true);
 
            PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
 
            /*
             * Adjacent strategy
             *
             * We test for overlap first but to be safe we need to call the
             * actual adjacent operator also.
             *
             * An empty element cannot be adjacent to any other, so there is
             * no need to check for it.
             */
 
        case RTAdjacentStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTOverlapStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            if (DatumGetBool(result))
                PG_RETURN_BOOL(true);
 
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTAdjacentStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_DATUM(result);
 
            /*
             * Basic comparison strategies
             *
             * It is straightforward to support the equality strategies with
             * the contains operator.  Generally, inequality strategies do not
             * make much sense for the types which will be used with the
             * inclusion BRIN family of opclasses, but it is possible to
             * implement them with logical negation of the left-of and
             * right-of operators.
             *
             * NB: These strategies cannot be used with geometric datatypes
             * that use comparison of areas!  The only exception is the "same"
             * strategy.
             *
             * Empty elements are considered to be less than the others.  We
             * cannot use the empty support function to check the query is an
             * empty element, because the query can be another data type than
             * the empty support function argument.  So we will return true,
             * if there is a possibility that empty elements will change the
             * result.
             */
 
        case RTLessStrategyNumber:
        case RTLessEqualStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTRightStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            if (!DatumGetBool(result))
                PG_RETURN_BOOL(true);
 
            PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
 
        case RTSameStrategyNumber:
        case RTEqualStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTContainsStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            if (DatumGetBool(result))
                PG_RETURN_BOOL(true);
 
            PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
 
        case RTGreaterEqualStrategyNumber:
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTLeftStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            if (!DatumGetBool(result))
                PG_RETURN_BOOL(true);
 
            PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
 
        case RTGreaterStrategyNumber:
            /* no need to check for empty elements */
            finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
                                                    RTLeftStrategyNumber);
            result = FunctionCall2Coll(finfo, colloid, unionval, query);
            PG_RETURN_BOOL(!DatumGetBool(result));
 
        default:
            /* shouldn't happen */
            elog(ERROR, "invalid strategy number %d", key->sk_strategy);
            PG_RETURN_BOOL(false);
    }
}

References Assert(), BrinValues::bv_allnulls, BrinValues::bv_values, DatumGetBool(), elog(), ERROR, FunctionCall2Coll(), INCLUSION_CONTAINS_EMPTY, inclusion_get_strategy_procinfo(), INCLUSION_UNION, INCLUSION_UNMERGEABLE, sort-test::key, PG_GET_COLLATION, PG_GETARG_POINTER, PG_NARGS, PG_RETURN_BOOL, PG_RETURN_DATUM, RTAboveStrategyNumber, RTAdjacentStrategyNumber, RTBelowStrategyNumber, RTContainedByStrategyNumber, RTContainsElemStrategyNumber, RTContainsStrategyNumber, RTEqualStrategyNumber, RTGreaterEqualStrategyNumber, RTGreaterStrategyNumber, RTLeftStrategyNumber, RTLessEqualStrategyNumber, RTLessStrategyNumber, RTOverAboveStrategyNumber, RTOverBelowStrategyNumber, RTOverlapStrategyNumber, RTOverLeftStrategyNumber, RTOverRightStrategyNumber, RTRightStrategyNumber, RTSameStrategyNumber, RTSubEqualStrategyNumber, RTSubStrategyNumber, RTSuperEqualStrategyNumber, and RTSuperStrategyNumber.

brin_inclusion_opcinfo()

Datum brin_inclusion_opcinfo

(

PG_FUNCTION_ARGS

)

Definition at line 94 of file brin_inclusion.c.

{
    Oid         typoid = PG_GETARG_OID(0);
    BrinOpcInfo *result;
    TypeCacheEntry *bool_typcache = lookup_type_cache(BOOLOID, 0);
 
    /*
     * All members of opaque are initialized lazily; both procinfo arrays
     * start out as non-initialized by having fn_oid be InvalidOid, and
     * "missing" to false, by zeroing here.  strategy_procinfos elements can
     * be invalidated when cached_subtype changes by zeroing fn_oid.
     * extra_procinfo entries are never invalidated, but if a lookup fails
     * (which is expected), extra_proc_missing is set to true, indicating not
     * to look it up again.
     */
    result = palloc0(MAXALIGN(SizeofBrinOpcInfo(3)) + sizeof(InclusionOpaque));
    result->oi_nstored = 3;
    result->oi_regular_nulls = true;
    result->oi_opaque = (InclusionOpaque *)
        MAXALIGN((char *) result + SizeofBrinOpcInfo(3));
 
    /* the union */
    result->oi_typcache[INCLUSION_UNION] =
        lookup_type_cache(typoid, 0);
 
    /* includes elements that are not mergeable */
    result->oi_typcache[INCLUSION_UNMERGEABLE] = bool_typcache;
 
    /* includes the empty element */
    result->oi_typcache[INCLUSION_CONTAINS_EMPTY] = bool_typcache;
 
    PG_RETURN_POINTER(result);
}

References INCLUSION_CONTAINS_EMPTY, INCLUSION_UNION, INCLUSION_UNMERGEABLE, lookup_type_cache(), MAXALIGN, BrinOpcInfo::oi_nstored, BrinOpcInfo::oi_opaque, BrinOpcInfo::oi_regular_nulls, BrinOpcInfo::oi_typcache, palloc0(), PG_GETARG_OID, PG_RETURN_POINTER, and SizeofBrinOpcInfo.

brin_inclusion_union()

Datum brin_inclusion_union

(

PG_FUNCTION_ARGS

)

Definition at line 475 of file brin_inclusion.c.

{
    BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
    BrinValues *col_a = (BrinValues *) PG_GETARG_POINTER(1);
    BrinValues *col_b = (BrinValues *) PG_GETARG_POINTER(2);
    Oid         colloid = PG_GET_COLLATION();
    AttrNumber  attno;
    Form_pg_attribute attr;
    FmgrInfo   *finfo;
    Datum       result;
 
    Assert(col_a->bv_attno == col_b->bv_attno);
    Assert(!col_a->bv_allnulls && !col_b->bv_allnulls);
 
    attno = col_a->bv_attno;
    attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
 
    /* If B includes empty elements, mark A similarly, if needed. */
    if (!DatumGetBool(col_a->bv_values[INCLUSION_CONTAINS_EMPTY]) &&
        DatumGetBool(col_b->bv_values[INCLUSION_CONTAINS_EMPTY]))
        col_a->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true);
 
    /* Check if A includes elements that are not mergeable. */
    if (DatumGetBool(col_a->bv_values[INCLUSION_UNMERGEABLE]))
        PG_RETURN_VOID();
 
    /* If B includes elements that are not mergeable, mark A similarly. */
    if (DatumGetBool(col_b->bv_values[INCLUSION_UNMERGEABLE]))
    {
        col_a->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
        PG_RETURN_VOID();
    }
 
    /* Check if A and B are mergeable; if not, mark A unmergeable. */
    finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGEABLE);
    if (finfo != NULL &&
        !DatumGetBool(FunctionCall2Coll(finfo, colloid,
                                        col_a->bv_values[INCLUSION_UNION],
                                        col_b->bv_values[INCLUSION_UNION])))
    {
        col_a->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
        PG_RETURN_VOID();
    }
 
    /* Finally, merge B to A. */
    finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGE);
    Assert(finfo != NULL);
    result = FunctionCall2Coll(finfo, colloid,
                               col_a->bv_values[INCLUSION_UNION],
                               col_b->bv_values[INCLUSION_UNION]);
    if (!attr->attbyval &&
        DatumGetPointer(result) != DatumGetPointer(col_a->bv_values[INCLUSION_UNION]))
    {
        pfree(DatumGetPointer(col_a->bv_values[INCLUSION_UNION]));
 
        if (result == col_b->bv_values[INCLUSION_UNION])
            result = datumCopy(result, attr->attbyval, attr->attlen);
    }
    col_a->bv_values[INCLUSION_UNION] = result;
 
    PG_RETURN_VOID();
}

References Assert(), BrinDesc::bd_tupdesc, BoolGetDatum(), BrinValues::bv_allnulls, BrinValues::bv_attno, BrinValues::bv_values, datumCopy(), DatumGetBool(), DatumGetPointer(), FunctionCall2Coll(), INCLUSION_CONTAINS_EMPTY, inclusion_get_procinfo(), INCLUSION_UNION, INCLUSION_UNMERGEABLE, pfree(), PG_GET_COLLATION, PG_GETARG_POINTER, PG_RETURN_VOID, PROCNUM_MERGE, PROCNUM_MERGEABLE, and TupleDescAttr.

inclusion_get_procinfo()

static FmgrInfo * inclusion_get_procinfo ( BrinDesc *  bdesc, uint16  attno, uint16  procnum  )

static

Definition at line 545 of file brin_inclusion.c.

{
    InclusionOpaque *opaque;
    uint16      basenum = procnum - PROCNUM_BASE;
 
    /*
     * We cache these in the opaque struct, to avoid repetitive syscache
     * lookups.
     */
    opaque = (InclusionOpaque *) bdesc->bd_info[attno - 1]->oi_opaque;
 
    /*
     * If we already searched for this proc and didn't find it, don't bother
     * searching again.
     */
    if (opaque->extra_proc_missing[basenum])
        return NULL;
 
    if (opaque->extra_procinfos[basenum].fn_oid == InvalidOid)
    {
        if (RegProcedureIsValid(index_getprocid(bdesc->bd_index, attno,
                                                procnum)))
        {
            fmgr_info_copy(&opaque->extra_procinfos[basenum],
                           index_getprocinfo(bdesc->bd_index, attno, procnum),
                           bdesc->bd_context);
        }
        else
        {
            opaque->extra_proc_missing[basenum] = true;
            return NULL;
        }
    }
 
    return &opaque->extra_procinfos[basenum];
}

References BrinDesc::bd_context, BrinDesc::bd_index, BrinDesc::bd_info, InclusionOpaque::extra_proc_missing, InclusionOpaque::extra_procinfos, fmgr_info_copy(), FmgrInfo::fn_oid, if(), index_getprocid(), index_getprocinfo(), InvalidOid, BrinOpcInfo::oi_opaque, PROCNUM_BASE, and RegProcedureIsValid.

Referenced by brin_inclusion_add_value(), and brin_inclusion_union().

inclusion_get_strategy_procinfo()

static FmgrInfo * inclusion_get_strategy_procinfo ( BrinDesc *  bdesc, uint16  attno, Oid  subtype, uint16  strategynum  )

static

Definition at line 603 of file brin_inclusion.c.

{
    InclusionOpaque *opaque;
 
    Assert(strategynum >= 1 &&
           strategynum <= RTMaxStrategyNumber);
 
    opaque = (InclusionOpaque *) bdesc->bd_info[attno - 1]->oi_opaque;
 
    /*
     * We cache the procedures for the last sub-type in the opaque struct, to
     * avoid repetitive syscache lookups.  If the sub-type is changed,
     * invalidate all the cached entries.
     */
    if (opaque->cached_subtype != subtype)
    {
        uint16      i;
 
        for (i = 1; i <= RTMaxStrategyNumber; i++)
            opaque->strategy_procinfos[i - 1].fn_oid = InvalidOid;
        opaque->cached_subtype = subtype;
    }
 
    if (opaque->strategy_procinfos[strategynum - 1].fn_oid == InvalidOid)
    {
        Form_pg_attribute attr;
        HeapTuple   tuple;
        Oid         opfamily,
                    oprid;
 
        opfamily = bdesc->bd_index->rd_opfamily[attno - 1];
        attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
        tuple = SearchSysCache4(AMOPSTRATEGY, ObjectIdGetDatum(opfamily),
                                ObjectIdGetDatum(attr->atttypid),
                                ObjectIdGetDatum(subtype),
                                Int16GetDatum(strategynum));
 
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                 strategynum, attr->atttypid, subtype, opfamily);
 
        oprid = DatumGetObjectId(SysCacheGetAttrNotNull(AMOPSTRATEGY, tuple,
                                                        Anum_pg_amop_amopopr));
        ReleaseSysCache(tuple);
        Assert(RegProcedureIsValid(oprid));
 
        fmgr_info_cxt(get_opcode(oprid),
                      &opaque->strategy_procinfos[strategynum - 1],
                      bdesc->bd_context);
    }
 
    return &opaque->strategy_procinfos[strategynum - 1];
}

References AMOPSTRATEGY, Assert(), BrinDesc::bd_context, BrinDesc::bd_index, BrinDesc::bd_info, BrinDesc::bd_tupdesc, InclusionOpaque::cached_subtype, DatumGetObjectId(), elog(), ERROR, fmgr_info_cxt(), FmgrInfo::fn_oid, get_opcode(), HeapTupleIsValid, i, if(), Int16GetDatum(), InvalidOid, ObjectIdGetDatum(), BrinOpcInfo::oi_opaque, oprid(), RelationData::rd_opfamily, RegProcedureIsValid, ReleaseSysCache(), RTMaxStrategyNumber, SearchSysCache4(), InclusionOpaque::strategy_procinfos, SysCacheGetAttrNotNull(), and TupleDescAttr.

Referenced by brin_inclusion_consistent().