brin_minmax.c

Go to the documentation of this file.

/*
 * brin_minmax.c
 *      Implementation of Min/Max opclass for BRIN
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/backend/access/brin/brin_minmax.c
 */
#include "postgres.h"
 
#include "access/brin_internal.h"
#include "access/brin_tuple.h"
#include "access/stratnum.h"
#include "catalog/pg_amop.h"
#include "utils/datum.h"
#include "utils/fmgrprotos.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"
 
typedef struct MinmaxOpaque
{
    Oid         cached_subtype;
    FmgrInfo    strategy_procinfos[BTMaxStrategyNumber];
} MinmaxOpaque;
 
static FmgrInfo *minmax_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno,
                                              Oid subtype, uint16 strategynum);
 
 
Datum
brin_minmax_opcinfo(PG_FUNCTION_ARGS)
{
    Oid         typoid = PG_GETARG_OID(0);
    BrinOpcInfo *result;
 
    /*
     * opaque->strategy_procinfos is initialized lazily; here it is set to
     * all-uninitialized by palloc0 which sets fn_oid to InvalidOid.
     */
 
    result = palloc0(MAXALIGN(SizeofBrinOpcInfo(2)) +
                     sizeof(MinmaxOpaque));
    result->oi_nstored = 2;
    result->oi_regular_nulls = true;
    result->oi_opaque = (MinmaxOpaque *)
        MAXALIGN((char *) result + SizeofBrinOpcInfo(2));
    result->oi_typcache[0] = result->oi_typcache[1] =
        lookup_type_cache(typoid, 0);
 
    PG_RETURN_POINTER(result);
}
 
/*
 * Examine the given index tuple (which contains partial status of a certain
 * page range) by comparing it to the given value that comes from another heap
 * tuple.  If the new value is outside the min/max range specified by the
 * existing tuple values, update the index tuple and return true.  Otherwise,
 * return false and do not modify in this case.
 */
Datum
brin_minmax_add_value(PG_FUNCTION_ARGS)
{
    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_DATUM(3);
    Oid         colloid = PG_GET_COLLATION();
    FmgrInfo   *cmpFn;
    Datum       compar;
    bool        updated = false;
    Form_pg_attribute attr;
    AttrNumber  attno;
 
    Assert(!isnull);
 
    attno = column->bv_attno;
    attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
 
    /*
     * If the recorded value is null, store the new value (which we know to be
     * not null) as both minimum and maximum, and we're done.
     */
    if (column->bv_allnulls)
    {
        column->bv_values[0] = datumCopy(newval, attr->attbyval, attr->attlen);
        column->bv_values[1] = datumCopy(newval, attr->attbyval, attr->attlen);
        column->bv_allnulls = false;
        PG_RETURN_BOOL(true);
    }
 
    /*
     * Otherwise, need to compare the new value with the existing boundaries
     * and update them accordingly.  First check if it's less than the
     * existing minimum.
     */
    cmpFn = minmax_get_strategy_procinfo(bdesc, attno, attr->atttypid,
                                         BTLessStrategyNumber);
    compar = FunctionCall2Coll(cmpFn, colloid, newval, column->bv_values[0]);
    if (DatumGetBool(compar))
    {
        if (!attr->attbyval)
            pfree(DatumGetPointer(column->bv_values[0]));
        column->bv_values[0] = datumCopy(newval, attr->attbyval, attr->attlen);
        updated = true;
    }
 
    /*
     * And now compare it to the existing maximum.
     */
    cmpFn = minmax_get_strategy_procinfo(bdesc, attno, attr->atttypid,
                                         BTGreaterStrategyNumber);
    compar = FunctionCall2Coll(cmpFn, colloid, newval, column->bv_values[1]);
    if (DatumGetBool(compar))
    {
        if (!attr->attbyval)
            pfree(DatumGetPointer(column->bv_values[1]));
        column->bv_values[1] = datumCopy(newval, attr->attbyval, attr->attlen);
        updated = true;
    }
 
    PG_RETURN_BOOL(updated);
}
 
/*
 * Given an index tuple corresponding to a certain page range and a scan key,
 * return whether the scan key is consistent with the index tuple's min/max
 * values.  Return true if so, false otherwise.
 *
 * We're no longer dealing with NULL keys in the consistent function, that is
 * now handled by the AM code. That means we should not get any all-NULL ranges
 * either, because those can't be consistent with regular (not [IS] NULL) keys.
 */
Datum
brin_minmax_consistent(PG_FUNCTION_ARGS)
{
    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;
    AttrNumber  attno;
    Datum       value;
    Datum       matches;
    FmgrInfo   *finfo;
 
    /* 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);
 
    attno = key->sk_attno;
    subtype = key->sk_subtype;
    value = key->sk_argument;
    switch (key->sk_strategy)
    {
        case BTLessStrategyNumber:
        case BTLessEqualStrategyNumber:
            finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype,
                                                 key->sk_strategy);
            matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0],
                                        value);
            break;
        case BTEqualStrategyNumber:
 
            /*
             * In the equality case (WHERE col = someval), we want to return
             * the current page range if the minimum value in the range <=
             * scan key, and the maximum value >= scan key.
             */
            finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype,
                                                 BTLessEqualStrategyNumber);
            matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0],
                                        value);
            if (!DatumGetBool(matches))
                break;
            /* max() >= scankey */
            finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype,
                                                 BTGreaterEqualStrategyNumber);
            matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1],
                                        value);
            break;
        case BTGreaterEqualStrategyNumber:
        case BTGreaterStrategyNumber:
            finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype,
                                                 key->sk_strategy);
            matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1],
                                        value);
            break;
        default:
            /* shouldn't happen */
            elog(ERROR, "invalid strategy number %d", key->sk_strategy);
            matches = 0;
            break;
    }
 
    PG_RETURN_DATUM(matches);
}
 
/*
 * Given two BrinValues, update the first of them as a union of the summary
 * values contained in both.  The second one is untouched.
 */
Datum
brin_minmax_union(PG_FUNCTION_ARGS)
{
    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;
    bool        needsadj;
 
    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);
 
    /* Adjust minimum, if B's min is less than A's min */
    finfo = minmax_get_strategy_procinfo(bdesc, attno, attr->atttypid,
                                         BTLessStrategyNumber);
    needsadj = FunctionCall2Coll(finfo, colloid, col_b->bv_values[0],
                                 col_a->bv_values[0]);
    if (needsadj)
    {
        if (!attr->attbyval)
            pfree(DatumGetPointer(col_a->bv_values[0]));
        col_a->bv_values[0] = datumCopy(col_b->bv_values[0],
                                        attr->attbyval, attr->attlen);
    }
 
    /* Adjust maximum, if B's max is greater than A's max */
    finfo = minmax_get_strategy_procinfo(bdesc, attno, attr->atttypid,
                                         BTGreaterStrategyNumber);
    needsadj = FunctionCall2Coll(finfo, colloid, col_b->bv_values[1],
                                 col_a->bv_values[1]);
    if (needsadj)
    {
        if (!attr->attbyval)
            pfree(DatumGetPointer(col_a->bv_values[1]));
        col_a->bv_values[1] = datumCopy(col_b->bv_values[1],
                                        attr->attbyval, attr->attlen);
    }
 
    PG_RETURN_VOID();
}
 
/*
 * Cache and return the procedure for the given strategy.
 *
 * Note: this function mirrors inclusion_get_strategy_procinfo; see notes
 * there.  If changes are made here, see that function too.
 */
static FmgrInfo *
minmax_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, Oid subtype,
                             uint16 strategynum)
{
    MinmaxOpaque *opaque;
 
    Assert(strategynum >= 1 &&
           strategynum <= BTMaxStrategyNumber);
 
    opaque = (MinmaxOpaque *) bdesc->bd_info[attno - 1]->oi_opaque;
 
    /*
     * We cache the procedures for the previous subtype in the opaque struct,
     * to avoid repetitive syscache lookups.  If the subtype changed,
     * invalidate all the cached entries.
     */
    if (opaque->cached_subtype != subtype)
    {
        uint16      i;
 
        for (i = 1; i <= BTMaxStrategyNumber; 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];
}