#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:

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

#define INCLUSION_CONTAINS_EMPTY 2

Definition at line 69 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value(), brin_inclusion_consistent(), brin_inclusion_opcinfo(), and brin_inclusion_union().

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

Definition at line 46 of file brin_inclusion.c.

#define INCLUSION_UNION 0

Definition at line 67 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value(), brin_inclusion_consistent(), brin_inclusion_opcinfo(), and brin_inclusion_union().

#define INCLUSION_UNMERGEABLE 1

Definition at line 68 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value(), brin_inclusion_consistent(), brin_inclusion_opcinfo(), and brin_inclusion_union().

#define PROCNUM_BASE 11

Definition at line 57 of file brin_inclusion.c.

Referenced by inclusion_get_procinfo().

#define PROCNUM_CONTAINS 13 /* optional */

Definition at line 49 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value().

#define PROCNUM_EMPTY 14 /* optional */

Definition at line 50 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value().

#define PROCNUM_MERGE 11 /* required */

Definition at line 47 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value(), and brin_inclusion_union().

#define PROCNUM_MERGEABLE 12 /* optional */

Definition at line 48 of file brin_inclusion.c.

Referenced by brin_inclusion_add_value(), and brin_inclusion_union().

Typedef Documentation

typedef struct InclusionOpaque InclusionOpaque

Function Documentation

Datum brin_inclusion_add_value ( PG_FUNCTION_ARGS )

Definition at line 133 of file brin_inclusion.c.

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

 {
     BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
     BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
     Datum       newval = PG_GETARG_DATUM(2);
     bool        isnull = PG_GETARG_BOOL(3);
     Oid         colloid = PG_GET_COLLATION();
     FmgrInfo   *finfo;
     Datum       result;
     bool        new = false;
     AttrNumber  attno;
     Form_pg_attribute attr;
 
     /*
      * If the new value is null, we record that we saw it if it's the first
      * one; otherwise, there's nothing to do.
      */
     if (isnull)
     {
         if (column->bv_hasnulls)
             PG_RETURN_BOOL(false);
 
         column->bv_hasnulls = true;
         PG_RETURN_BOOL(true);
     }
 
     attno = column->bv_attno;
     attr = bdesc->bd_tupdesc->attrs[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)
         pfree(DatumGetPointer(column->bv_values[INCLUSION_UNION]));
     column->bv_values[INCLUSION_UNION] = result;
 
     PG_RETURN_BOOL(true);
 }

Datum brin_inclusion_consistent ( PG_FUNCTION_ARGS )

Definition at line 247 of file brin_inclusion.c.

References Assert, BrinValues::bv_allnulls, BrinValues::bv_attno, BrinValues::bv_hasnulls, BrinValues::bv_values, DatumGetBool, elog, ERROR, FunctionCall2Coll(), INCLUSION_CONTAINS_EMPTY, inclusion_get_strategy_procinfo(), INCLUSION_UNION, INCLUSION_UNMERGEABLE, PG_GET_COLLATION, PG_GETARG_POINTER, PG_RETURN_BOOL, PG_RETURN_DATUM, result, RTAboveStrategyNumber, RTAdjacentStrategyNumber, RTBelowStrategyNumber, RTContainedByStrategyNumber, RTContainsElemStrategyNumber, RTContainsStrategyNumber, RTEqualStrategyNumber, RTGreaterEqualStrategyNumber, RTGreaterStrategyNumber, RTLeftStrategyNumber, RTLessEqualStrategyNumber, RTLessStrategyNumber, RTOldContainedByStrategyNumber, RTOldContainsStrategyNumber, RTOverAboveStrategyNumber, RTOverBelowStrategyNumber, RTOverlapStrategyNumber, RTOverLeftStrategyNumber, RTOverRightStrategyNumber, RTRightStrategyNumber, RTSameStrategyNumber, RTSubEqualStrategyNumber, RTSubStrategyNumber, RTSuperEqualStrategyNumber, RTSuperStrategyNumber, ScanKeyData::sk_argument, ScanKeyData::sk_attno, ScanKeyData::sk_flags, SK_ISNULL, SK_SEARCHNOTNULL, SK_SEARCHNULL, ScanKeyData::sk_strategy, and ScanKeyData::sk_subtype.

 {
     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;
 
     Assert(key->sk_attno == column->bv_attno);
 
     /* Handle IS NULL/IS NOT NULL tests. */
     if (key->sk_flags & SK_ISNULL)
     {
         if (key->sk_flags & SK_SEARCHNULL)
         {
             if (column->bv_allnulls || column->bv_hasnulls)
                 PG_RETURN_BOOL(true);
             PG_RETURN_BOOL(false);
         }
 
         /*
          * For IS NOT NULL, we can only skip ranges that are known to have
          * only nulls.
          */
         if (key->sk_flags & SK_SEARCHNOTNULL)
             PG_RETURN_BOOL(!column->bv_allnulls);
 
         /*
          * Neither IS NULL nor IS NOT NULL was used; assume all indexable
          * operators are strict and return false.
          */
         PG_RETURN_BOOL(false);
     }
 
     /* If it is all nulls, it cannot possibly be consistent. */
     if (column->bv_allnulls)
         PG_RETURN_BOOL(false);
 
     /* 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 RTOldContainsStrategyNumber:
         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 RTOldContainedByStrategyNumber:
         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 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);
     }
 }

Datum brin_inclusion_opcinfo ( PG_FUNCTION_ARGS )

Definition at line 90 of file brin_inclusion.c.

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

 {
     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_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);
 }

Datum brin_inclusion_union ( PG_FUNCTION_ARGS )

Definition at line 497 of file brin_inclusion.c.

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

 {
     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);
 
     /* Adjust "hasnulls". */
     if (!col_a->bv_hasnulls && col_b->bv_hasnulls)
         col_a->bv_hasnulls = true;
 
     /* If there are no values in B, there's nothing left to do. */
     if (col_b->bv_allnulls)
         PG_RETURN_VOID();
 
     attno = col_a->bv_attno;
     attr = bdesc->bd_tupdesc->attrs[attno - 1];
 
     /*
      * Adjust "allnulls".  If A doesn't have values, just copy the values from
      * B into A, and we're done.  We cannot run the operators in this case,
      * because values in A might contain garbage.  Note we already established
      * that B contains values.
      */
     if (col_a->bv_allnulls)
     {
         col_a->bv_allnulls = false;
         col_a->bv_values[INCLUSION_UNION] =
             datumCopy(col_b->bv_values[INCLUSION_UNION],
                       attr->attbyval, attr->attlen);
         col_a->bv_values[INCLUSION_UNMERGEABLE] =
             col_b->bv_values[INCLUSION_UNMERGEABLE];
         col_a->bv_values[INCLUSION_CONTAINS_EMPTY] =
             col_b->bv_values[INCLUSION_CONTAINS_EMPTY];
         PG_RETURN_VOID();
     }
 
     /* 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)
         pfree(DatumGetPointer(col_a->bv_values[INCLUSION_UNION]));
     col_a->bv_values[INCLUSION_UNION] = result;
 
     PG_RETURN_VOID();
 }

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

static

Definition at line 587 of file brin_inclusion.c.

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

Referenced by brin_inclusion_add_value(), and brin_inclusion_union().

 {
     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];
 }

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

static

Definition at line 645 of file brin_inclusion.c.

References AMOPSTRATEGY, Anum_pg_amop_amopopr, Assert, tupleDesc::attrs, 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, Int16GetDatum, InvalidOid, ObjectIdGetDatum, BrinOpcInfo::oi_opaque, oprid(), RelationData::rd_opfamily, RegProcedureIsValid, ReleaseSysCache(), RTMaxStrategyNumber, SearchSysCache4, InclusionOpaque::strategy_procinfos, and SysCacheGetAttr().

Referenced by brin_inclusion_consistent().

 {
     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;
         bool        isNull;
 
         opfamily = bdesc->bd_index->rd_opfamily[attno - 1];
         attr = bdesc->bd_tupdesc->attrs[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(SysCacheGetAttr(AMOPSTRATEGY, tuple,
                                                  Anum_pg_amop_amopopr, &isNull));
         ReleaseSysCache(tuple);
         Assert(!isNull && RegProcedureIsValid(oprid));
 
         fmgr_info_cxt(get_opcode(oprid),
                       &opaque->strategy_procinfos[strategynum - 1],
                       bdesc->bd_context);
     }
 
     return &opaque->strategy_procinfos[strategynum - 1];
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation