LCOV - code coverage report
Current view: top level - src/backend/access/brin - brin_inclusion.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 162 205 79.0 %
Date: 2021-05-13 09:07:15 Functions: 5 6 83.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * brin_inclusion.c
       3             :  *      Implementation of inclusion opclasses for BRIN
       4             :  *
       5             :  * This module provides framework BRIN support functions for the "inclusion"
       6             :  * operator classes.  A few SQL-level support functions are also required for
       7             :  * each opclass.
       8             :  *
       9             :  * The "inclusion" BRIN strategy is useful for types that support R-Tree
      10             :  * operations.  This implementation is a straight mapping of those operations
      11             :  * to the block-range nature of BRIN, with two exceptions: (a) we explicitly
      12             :  * support "empty" elements: at least with range types, we need to consider
      13             :  * emptiness separately from regular R-Tree strategies; and (b) we need to
      14             :  * consider "unmergeable" elements, that is, a set of elements for whose union
      15             :  * no representation exists.  The only case where that happens as of this
      16             :  * writing is the INET type, where IPv6 values cannot be merged with IPv4
      17             :  * values.
      18             :  *
      19             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
      20             :  * Portions Copyright (c) 1994, Regents of the University of California
      21             :  *
      22             :  * IDENTIFICATION
      23             :  *    src/backend/access/brin/brin_inclusion.c
      24             :  */
      25             : #include "postgres.h"
      26             : 
      27             : #include "access/brin_internal.h"
      28             : #include "access/brin_tuple.h"
      29             : #include "access/genam.h"
      30             : #include "access/skey.h"
      31             : #include "catalog/pg_amop.h"
      32             : #include "catalog/pg_type.h"
      33             : #include "utils/builtins.h"
      34             : #include "utils/datum.h"
      35             : #include "utils/lsyscache.h"
      36             : #include "utils/rel.h"
      37             : #include "utils/syscache.h"
      38             : 
      39             : 
      40             : /*
      41             :  * Additional SQL level support functions
      42             :  *
      43             :  * Procedure numbers must not use values reserved for BRIN itself; see
      44             :  * brin_internal.h.
      45             :  */
      46             : #define     INCLUSION_MAX_PROCNUMS  4   /* maximum support procs we need */
      47             : #define     PROCNUM_MERGE           11  /* required */
      48             : #define     PROCNUM_MERGEABLE       12  /* optional */
      49             : #define     PROCNUM_CONTAINS        13  /* optional */
      50             : #define     PROCNUM_EMPTY           14  /* optional */
      51             : 
      52             : 
      53             : /*
      54             :  * Subtract this from procnum to obtain index in InclusionOpaque arrays
      55             :  * (Must be equal to minimum of private procnums).
      56             :  */
      57             : #define     PROCNUM_BASE            11
      58             : 
      59             : /*-
      60             :  * The values stored in the bv_values arrays correspond to:
      61             :  *
      62             :  * INCLUSION_UNION
      63             :  *      the union of the values in the block range
      64             :  * INCLUSION_UNMERGEABLE
      65             :  *      whether the values in the block range cannot be merged
      66             :  *      (e.g. an IPv6 address amidst IPv4 addresses)
      67             :  * INCLUSION_CONTAINS_EMPTY
      68             :  *      whether an empty value is present in any tuple
      69             :  *      in the block range
      70             :  */
      71             : #define INCLUSION_UNION             0
      72             : #define INCLUSION_UNMERGEABLE       1
      73             : #define INCLUSION_CONTAINS_EMPTY    2
      74             : 
      75             : 
      76             : typedef struct InclusionOpaque
      77             : {
      78             :     FmgrInfo    extra_procinfos[INCLUSION_MAX_PROCNUMS];
      79             :     bool        extra_proc_missing[INCLUSION_MAX_PROCNUMS];
      80             :     Oid         cached_subtype;
      81             :     FmgrInfo    strategy_procinfos[RTMaxStrategyNumber];
      82             : } InclusionOpaque;
      83             : 
      84             : static FmgrInfo *inclusion_get_procinfo(BrinDesc *bdesc, uint16 attno,
      85             :                                         uint16 procnum);
      86             : static FmgrInfo *inclusion_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno,
      87             :                                                  Oid subtype, uint16 strategynum);
      88             : 
      89             : 
      90             : /*
      91             :  * BRIN inclusion OpcInfo function
      92             :  */
      93             : Datum
      94        4072 : brin_inclusion_opcinfo(PG_FUNCTION_ARGS)
      95             : {
      96        4072 :     Oid         typoid = PG_GETARG_OID(0);
      97             :     BrinOpcInfo *result;
      98        4072 :     TypeCacheEntry *bool_typcache = lookup_type_cache(BOOLOID, 0);
      99             : 
     100             :     /*
     101             :      * All members of opaque are initialized lazily; both procinfo arrays
     102             :      * start out as non-initialized by having fn_oid be InvalidOid, and
     103             :      * "missing" to false, by zeroing here.  strategy_procinfos elements can
     104             :      * be invalidated when cached_subtype changes by zeroing fn_oid.
     105             :      * extra_procinfo entries are never invalidated, but if a lookup fails
     106             :      * (which is expected), extra_proc_missing is set to true, indicating not
     107             :      * to look it up again.
     108             :      */
     109        4072 :     result = palloc0(MAXALIGN(SizeofBrinOpcInfo(3)) + sizeof(InclusionOpaque));
     110        4072 :     result->oi_nstored = 3;
     111        4072 :     result->oi_regular_nulls = true;
     112        4072 :     result->oi_opaque = (InclusionOpaque *)
     113        4072 :         MAXALIGN((char *) result + SizeofBrinOpcInfo(3));
     114             : 
     115             :     /* the union */
     116        4072 :     result->oi_typcache[INCLUSION_UNION] =
     117        4072 :         lookup_type_cache(typoid, 0);
     118             : 
     119             :     /* includes elements that are not mergeable */
     120        4072 :     result->oi_typcache[INCLUSION_UNMERGEABLE] = bool_typcache;
     121             : 
     122             :     /* includes the empty element */
     123        4072 :     result->oi_typcache[INCLUSION_CONTAINS_EMPTY] = bool_typcache;
     124             : 
     125        4072 :     PG_RETURN_POINTER(result);
     126             : }
     127             : 
     128             : /*
     129             :  * BRIN inclusion add value function
     130             :  *
     131             :  * Examine the given index tuple (which contains partial status of a certain
     132             :  * page range) by comparing it to the given value that comes from another heap
     133             :  * tuple.  If the new value is outside the union specified by the existing
     134             :  * tuple values, update the index tuple and return true.  Otherwise, return
     135             :  * false and do not modify in this case.
     136             :  */
     137             : Datum
     138        5512 : brin_inclusion_add_value(PG_FUNCTION_ARGS)
     139             : {
     140        5512 :     BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
     141        5512 :     BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
     142        5512 :     Datum       newval = PG_GETARG_DATUM(2);
     143        5512 :     bool        isnull PG_USED_FOR_ASSERTS_ONLY = PG_GETARG_BOOL(3);
     144        5512 :     Oid         colloid = PG_GET_COLLATION();
     145             :     FmgrInfo   *finfo;
     146             :     Datum       result;
     147        5512 :     bool        new = false;
     148             :     AttrNumber  attno;
     149             :     Form_pg_attribute attr;
     150             : 
     151             :     Assert(!isnull);
     152             : 
     153        5512 :     attno = column->bv_attno;
     154        5512 :     attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
     155             : 
     156             :     /*
     157             :      * If the recorded value is null, copy the new value (which we know to be
     158             :      * not null), and we're almost done.
     159             :      */
     160        5512 :     if (column->bv_allnulls)
     161             :     {
     162        3432 :         column->bv_values[INCLUSION_UNION] =
     163        1716 :             datumCopy(newval, attr->attbyval, attr->attlen);
     164        1716 :         column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(false);
     165        1716 :         column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(false);
     166        1716 :         column->bv_allnulls = false;
     167        1716 :         new = true;
     168             :     }
     169             : 
     170             :     /*
     171             :      * No need for further processing if the block range is marked as
     172             :      * containing unmergeable values.
     173             :      */
     174        5512 :     if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE]))
     175         312 :         PG_RETURN_BOOL(false);
     176             : 
     177             :     /*
     178             :      * If the opclass supports the concept of empty values, test the passed
     179             :      * new value for emptiness; if it returns true, we need to set the
     180             :      * "contains empty" flag in the element (unless already set).
     181             :      */
     182        5200 :     finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_EMPTY);
     183        5200 :     if (finfo != NULL && DatumGetBool(FunctionCall1Coll(finfo, colloid, newval)))
     184             :     {
     185         752 :         if (!DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]))
     186             :         {
     187         232 :             column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true);
     188         232 :             PG_RETURN_BOOL(true);
     189             :         }
     190             : 
     191         520 :         PG_RETURN_BOOL(false);
     192             :     }
     193             : 
     194        4448 :     if (new)
     195        1504 :         PG_RETURN_BOOL(true);
     196             : 
     197             :     /* Check if the new value is already contained. */
     198        2944 :     finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_CONTAINS);
     199        5888 :     if (finfo != NULL &&
     200        2944 :         DatumGetBool(FunctionCall2Coll(finfo, colloid,
     201             :                                        column->bv_values[INCLUSION_UNION],
     202             :                                        newval)))
     203        2864 :         PG_RETURN_BOOL(false);
     204             : 
     205             :     /*
     206             :      * Check if the new value is mergeable to the existing union.  If it is
     207             :      * not, mark the value as containing unmergeable elements and get out.
     208             :      *
     209             :      * Note: at this point we could remove the value from the union, since
     210             :      * it's not going to be used any longer.  However, the BRIN framework
     211             :      * doesn't allow for the value not being present.  Improve someday.
     212             :      */
     213          80 :     finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGEABLE);
     214         152 :     if (finfo != NULL &&
     215          72 :         !DatumGetBool(FunctionCall2Coll(finfo, colloid,
     216             :                                         column->bv_values[INCLUSION_UNION],
     217             :                                         newval)))
     218             :     {
     219          72 :         column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
     220          72 :         PG_RETURN_BOOL(true);
     221             :     }
     222             : 
     223             :     /* Finally, merge the new value to the existing union. */
     224           8 :     finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGE);
     225             :     Assert(finfo != NULL);
     226           8 :     result = FunctionCall2Coll(finfo, colloid,
     227           8 :                                column->bv_values[INCLUSION_UNION], newval);
     228           8 :     if (!attr->attbyval &&
     229           8 :         DatumGetPointer(result) != DatumGetPointer(column->bv_values[INCLUSION_UNION]))
     230             :     {
     231           8 :         pfree(DatumGetPointer(column->bv_values[INCLUSION_UNION]));
     232             : 
     233           8 :         if (result == newval)
     234           4 :             result = datumCopy(result, attr->attbyval, attr->attlen);
     235             :     }
     236           8 :     column->bv_values[INCLUSION_UNION] = result;
     237             : 
     238           8 :     PG_RETURN_BOOL(true);
     239             : }
     240             : 
     241             : /*
     242             :  * BRIN inclusion consistent function
     243             :  *
     244             :  * We're no longer dealing with NULL keys in the consistent function, that is
     245             :  * now handled by the AM code. That means we should not get any all-NULL ranges
     246             :  * either, because those can't be consistent with regular (not [IS] NULL) keys.
     247             :  *
     248             :  * All of the strategies are optional.
     249             :  */
     250             : Datum
     251       28400 : brin_inclusion_consistent(PG_FUNCTION_ARGS)
     252             : {
     253       28400 :     BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
     254       28400 :     BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
     255       28400 :     ScanKey     key = (ScanKey) PG_GETARG_POINTER(2);
     256       28400 :     Oid         colloid = PG_GET_COLLATION(),
     257             :                 subtype;
     258             :     Datum       unionval;
     259             :     AttrNumber  attno;
     260             :     Datum       query;
     261             :     FmgrInfo   *finfo;
     262             :     Datum       result;
     263             : 
     264             :     /* This opclass uses the old signature with only three arguments. */
     265             :     Assert(PG_NARGS() == 3);
     266             : 
     267             :     /* Should not be dealing with all-NULL ranges. */
     268             :     Assert(!column->bv_allnulls);
     269             : 
     270             :     /* It has to be checked, if it contains elements that are not mergeable. */
     271       28400 :     if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE]))
     272        1092 :         PG_RETURN_BOOL(true);
     273             : 
     274       27308 :     attno = key->sk_attno;
     275       27308 :     subtype = key->sk_subtype;
     276       27308 :     query = key->sk_argument;
     277       27308 :     unionval = column->bv_values[INCLUSION_UNION];
     278       27308 :     switch (key->sk_strategy)
     279             :     {
     280             :             /*
     281             :              * Placement strategies
     282             :              *
     283             :              * These are implemented by logically negating the result of the
     284             :              * converse placement operator; for this to work, the converse
     285             :              * operator must be part of the opclass.  An error will be thrown
     286             :              * by inclusion_get_strategy_procinfo() if the required strategy
     287             :              * is not part of the opclass.
     288             :              *
     289             :              * These all return false if either argument is empty, so there is
     290             :              * no need to check for empty elements.
     291             :              */
     292             : 
     293         800 :         case RTLeftStrategyNumber:
     294         800 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     295             :                                                     RTOverRightStrategyNumber);
     296         800 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     297         800 :             PG_RETURN_BOOL(!DatumGetBool(result));
     298             : 
     299         800 :         case RTOverLeftStrategyNumber:
     300         800 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     301             :                                                     RTRightStrategyNumber);
     302         800 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     303         800 :             PG_RETURN_BOOL(!DatumGetBool(result));
     304             : 
     305         800 :         case RTOverRightStrategyNumber:
     306         800 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     307             :                                                     RTLeftStrategyNumber);
     308         800 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     309         800 :             PG_RETURN_BOOL(!DatumGetBool(result));
     310             : 
     311         800 :         case RTRightStrategyNumber:
     312         800 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     313             :                                                     RTOverLeftStrategyNumber);
     314         800 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     315         800 :             PG_RETURN_BOOL(!DatumGetBool(result));
     316             : 
     317         400 :         case RTBelowStrategyNumber:
     318         400 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     319             :                                                     RTOverAboveStrategyNumber);
     320         400 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     321         400 :             PG_RETURN_BOOL(!DatumGetBool(result));
     322             : 
     323         400 :         case RTOverBelowStrategyNumber:
     324         400 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     325             :                                                     RTAboveStrategyNumber);
     326         400 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     327         400 :             PG_RETURN_BOOL(!DatumGetBool(result));
     328             : 
     329         400 :         case RTOverAboveStrategyNumber:
     330         400 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     331             :                                                     RTBelowStrategyNumber);
     332         400 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     333         400 :             PG_RETURN_BOOL(!DatumGetBool(result));
     334             : 
     335         400 :         case RTAboveStrategyNumber:
     336         400 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     337             :                                                     RTOverBelowStrategyNumber);
     338         400 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     339         400 :             PG_RETURN_BOOL(!DatumGetBool(result));
     340             : 
     341             :             /*
     342             :              * Overlap and contains strategies
     343             :              *
     344             :              * These strategies are simple enough that we can simply call the
     345             :              * operator and return its result.  Empty elements don't change
     346             :              * the result.
     347             :              */
     348             : 
     349       10240 :         case RTOverlapStrategyNumber:
     350             :         case RTContainsStrategyNumber:
     351             :         case RTContainsElemStrategyNumber:
     352             :         case RTSubStrategyNumber:
     353             :         case RTSubEqualStrategyNumber:
     354       10240 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     355       10240 :                                                     key->sk_strategy);
     356       10240 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     357       10240 :             PG_RETURN_DATUM(result);
     358             : 
     359             :             /*
     360             :              * Contained by strategies
     361             :              *
     362             :              * We cannot just call the original operator for the contained by
     363             :              * strategies because some elements can be contained even though
     364             :              * the union is not; instead we use the overlap operator.
     365             :              *
     366             :              * We check for empty elements separately as they are not merged
     367             :              * to the union but contained by everything.
     368             :              */
     369             : 
     370        5664 :         case RTContainedByStrategyNumber:
     371             :         case RTSuperStrategyNumber:
     372             :         case RTSuperEqualStrategyNumber:
     373        5664 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     374             :                                                     RTOverlapStrategyNumber);
     375        5664 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     376        5664 :             if (DatumGetBool(result))
     377        3376 :                 PG_RETURN_BOOL(true);
     378             : 
     379        2288 :             PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
     380             : 
     381             :             /*
     382             :              * Adjacent strategy
     383             :              *
     384             :              * We test for overlap first but to be safe we need to call the
     385             :              * actual adjacent operator also.
     386             :              *
     387             :              * An empty element cannot be adjacent to any other, so there is
     388             :              * no need to check for it.
     389             :              */
     390             : 
     391           0 :         case RTAdjacentStrategyNumber:
     392           0 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     393             :                                                     RTOverlapStrategyNumber);
     394           0 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     395           0 :             if (DatumGetBool(result))
     396           0 :                 PG_RETURN_BOOL(true);
     397             : 
     398           0 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     399             :                                                     RTAdjacentStrategyNumber);
     400           0 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     401           0 :             PG_RETURN_DATUM(result);
     402             : 
     403             :             /*
     404             :              * Basic comparison strategies
     405             :              *
     406             :              * It is straightforward to support the equality strategies with
     407             :              * the contains operator.  Generally, inequality strategies do not
     408             :              * make much sense for the types which will be used with the
     409             :              * inclusion BRIN family of opclasses, but it is possible to
     410             :              * implement them with logical negation of the left-of and
     411             :              * right-of operators.
     412             :              *
     413             :              * NB: These strategies cannot be used with geometric datatypes
     414             :              * that use comparison of areas!  The only exception is the "same"
     415             :              * strategy.
     416             :              *
     417             :              * Empty elements are considered to be less than the others.  We
     418             :              * cannot use the empty support function to check the query is an
     419             :              * empty element, because the query can be another data type than
     420             :              * the empty support function argument.  So we will return true,
     421             :              * if there is a possibility that empty elements will change the
     422             :              * result.
     423             :              */
     424             : 
     425        1200 :         case RTLessStrategyNumber:
     426             :         case RTLessEqualStrategyNumber:
     427        1200 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     428             :                                                     RTRightStrategyNumber);
     429        1200 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     430        1200 :             if (!DatumGetBool(result))
     431        1000 :                 PG_RETURN_BOOL(true);
     432             : 
     433         200 :             PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
     434             : 
     435        3804 :         case RTSameStrategyNumber:
     436             :         case RTEqualStrategyNumber:
     437        3804 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     438             :                                                     RTContainsStrategyNumber);
     439        3804 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     440        3804 :             if (DatumGetBool(result))
     441         468 :                 PG_RETURN_BOOL(true);
     442             : 
     443        3336 :             PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
     444             : 
     445         800 :         case RTGreaterEqualStrategyNumber:
     446         800 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     447             :                                                     RTLeftStrategyNumber);
     448         800 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     449         800 :             if (!DatumGetBool(result))
     450         800 :                 PG_RETURN_BOOL(true);
     451             : 
     452           0 :             PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]);
     453             : 
     454         800 :         case RTGreaterStrategyNumber:
     455             :             /* no need to check for empty elements */
     456         800 :             finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype,
     457             :                                                     RTLeftStrategyNumber);
     458         800 :             result = FunctionCall2Coll(finfo, colloid, unionval, query);
     459         800 :             PG_RETURN_BOOL(!DatumGetBool(result));
     460             : 
     461           0 :         default:
     462             :             /* shouldn't happen */
     463           0 :             elog(ERROR, "invalid strategy number %d", key->sk_strategy);
     464             :             PG_RETURN_BOOL(false);
     465             :     }
     466             : }
     467             : 
     468             : /*
     469             :  * BRIN inclusion union function
     470             :  *
     471             :  * Given two BrinValues, update the first of them as a union of the summary
     472             :  * values contained in both.  The second one is untouched.
     473             :  */
     474             : Datum
     475           0 : brin_inclusion_union(PG_FUNCTION_ARGS)
     476             : {
     477           0 :     BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
     478           0 :     BrinValues *col_a = (BrinValues *) PG_GETARG_POINTER(1);
     479           0 :     BrinValues *col_b = (BrinValues *) PG_GETARG_POINTER(2);
     480           0 :     Oid         colloid = PG_GET_COLLATION();
     481             :     AttrNumber  attno;
     482             :     Form_pg_attribute attr;
     483             :     FmgrInfo   *finfo;
     484             :     Datum       result;
     485             : 
     486             :     Assert(col_a->bv_attno == col_b->bv_attno);
     487             :     Assert(!col_a->bv_allnulls && !col_b->bv_allnulls);
     488             : 
     489           0 :     attno = col_a->bv_attno;
     490           0 :     attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
     491             : 
     492             :     /* If B includes empty elements, mark A similarly, if needed. */
     493           0 :     if (!DatumGetBool(col_a->bv_values[INCLUSION_CONTAINS_EMPTY]) &&
     494           0 :         DatumGetBool(col_b->bv_values[INCLUSION_CONTAINS_EMPTY]))
     495           0 :         col_a->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true);
     496             : 
     497             :     /* Check if A includes elements that are not mergeable. */
     498           0 :     if (DatumGetBool(col_a->bv_values[INCLUSION_UNMERGEABLE]))
     499           0 :         PG_RETURN_VOID();
     500             : 
     501             :     /* If B includes elements that are not mergeable, mark A similarly. */
     502           0 :     if (DatumGetBool(col_b->bv_values[INCLUSION_UNMERGEABLE]))
     503             :     {
     504           0 :         col_a->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
     505           0 :         PG_RETURN_VOID();
     506             :     }
     507             : 
     508             :     /* Check if A and B are mergeable; if not, mark A unmergeable. */
     509           0 :     finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGEABLE);
     510           0 :     if (finfo != NULL &&
     511           0 :         !DatumGetBool(FunctionCall2Coll(finfo, colloid,
     512             :                                         col_a->bv_values[INCLUSION_UNION],
     513             :                                         col_b->bv_values[INCLUSION_UNION])))
     514             :     {
     515           0 :         col_a->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true);
     516           0 :         PG_RETURN_VOID();
     517             :     }
     518             : 
     519             :     /* Finally, merge B to A. */
     520           0 :     finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGE);
     521             :     Assert(finfo != NULL);
     522           0 :     result = FunctionCall2Coll(finfo, colloid,
     523           0 :                                col_a->bv_values[INCLUSION_UNION],
     524           0 :                                col_b->bv_values[INCLUSION_UNION]);
     525           0 :     if (!attr->attbyval &&
     526           0 :         DatumGetPointer(result) != DatumGetPointer(col_a->bv_values[INCLUSION_UNION]))
     527             :     {
     528           0 :         pfree(DatumGetPointer(col_a->bv_values[INCLUSION_UNION]));
     529             : 
     530           0 :         if (result == col_b->bv_values[INCLUSION_UNION])
     531           0 :             result = datumCopy(result, attr->attbyval, attr->attlen);
     532             :     }
     533           0 :     col_a->bv_values[INCLUSION_UNION] = result;
     534             : 
     535           0 :     PG_RETURN_VOID();
     536             : }
     537             : 
     538             : /*
     539             :  * Cache and return inclusion opclass support procedure
     540             :  *
     541             :  * Return the procedure corresponding to the given function support number
     542             :  * or null if it is not exists.
     543             :  */
     544             : static FmgrInfo *
     545        8232 : inclusion_get_procinfo(BrinDesc *bdesc, uint16 attno, uint16 procnum)
     546             : {
     547             :     InclusionOpaque *opaque;
     548        8232 :     uint16      basenum = procnum - PROCNUM_BASE;
     549             : 
     550             :     /*
     551             :      * We cache these in the opaque struct, to avoid repetitive syscache
     552             :      * lookups.
     553             :      */
     554        8232 :     opaque = (InclusionOpaque *) bdesc->bd_info[attno - 1]->oi_opaque;
     555             : 
     556             :     /*
     557             :      * If we already searched for this proc and didn't find it, don't bother
     558             :      * searching again.
     559             :      */
     560        8232 :     if (opaque->extra_proc_missing[basenum])
     561        3720 :         return NULL;
     562             : 
     563        4512 :     if (opaque->extra_procinfos[basenum].fn_oid == InvalidOid)
     564             :     {
     565         200 :         if (RegProcedureIsValid(index_getprocid(bdesc->bd_index, attno,
     566             :                                                 procnum)))
     567             :         {
     568         132 :             fmgr_info_copy(&opaque->extra_procinfos[basenum],
     569             :                            index_getprocinfo(bdesc->bd_index, attno, procnum),
     570             :                            bdesc->bd_context);
     571             :         }
     572             :         else
     573             :         {
     574          68 :             opaque->extra_proc_missing[basenum] = true;
     575          68 :             return NULL;
     576             :         }
     577             :     }
     578             : 
     579        4444 :     return &opaque->extra_procinfos[basenum];
     580             : }
     581             : 
     582             : /*
     583             :  * Cache and return the procedure of the given strategy
     584             :  *
     585             :  * Return the procedure corresponding to the given sub-type and strategy
     586             :  * number.  The data type of the index will be used as the left hand side of
     587             :  * the operator and the given sub-type will be used as the right hand side.
     588             :  * Throws an error if the pg_amop row does not exist, but that should not
     589             :  * happen with a properly configured opclass.
     590             :  *
     591             :  * It always throws an error when the data type of the opclass is different
     592             :  * from the data type of the column or the expression.  That happens when the
     593             :  * column data type has implicit cast to the opclass data type.  We don't
     594             :  * bother casting types, because this situation can easily be avoided by
     595             :  * setting storage data type to that of the opclass.  The same problem does not
     596             :  * apply to the data type of the right hand side, because the type in the
     597             :  * ScanKey always matches the opclass' one.
     598             :  *
     599             :  * Note: this function mirrors minmax_get_strategy_procinfo; if changes are
     600             :  * made here, see that function too.
     601             :  */
     602             : static FmgrInfo *
     603       27308 : inclusion_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, Oid subtype,
     604             :                                 uint16 strategynum)
     605             : {
     606             :     InclusionOpaque *opaque;
     607             : 
     608             :     Assert(strategynum >= 1 &&
     609             :            strategynum <= RTMaxStrategyNumber);
     610             : 
     611       27308 :     opaque = (InclusionOpaque *) bdesc->bd_info[attno - 1]->oi_opaque;
     612             : 
     613             :     /*
     614             :      * We cache the procedures for the last sub-type in the opaque struct, to
     615             :      * avoid repetitive syscache lookups.  If the sub-type is changed,
     616             :      * invalidate all the cached entries.
     617             :      */
     618       27308 :     if (opaque->cached_subtype != subtype)
     619             :     {
     620             :         uint16      i;
     621             : 
     622        8804 :         for (i = 1; i <= RTMaxStrategyNumber; i++)
     623        8520 :             opaque->strategy_procinfos[i - 1].fn_oid = InvalidOid;
     624         284 :         opaque->cached_subtype = subtype;
     625             :     }
     626             : 
     627       27308 :     if (opaque->strategy_procinfos[strategynum - 1].fn_oid == InvalidOid)
     628             :     {
     629             :         Form_pg_attribute attr;
     630             :         HeapTuple   tuple;
     631             :         Oid         opfamily,
     632             :                     oprid;
     633             :         bool        isNull;
     634             : 
     635         284 :         opfamily = bdesc->bd_index->rd_opfamily[attno - 1];
     636         284 :         attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
     637         568 :         tuple = SearchSysCache4(AMOPSTRATEGY, ObjectIdGetDatum(opfamily),
     638         284 :                                 ObjectIdGetDatum(attr->atttypid),
     639             :                                 ObjectIdGetDatum(subtype),
     640             :                                 Int16GetDatum(strategynum));
     641             : 
     642         284 :         if (!HeapTupleIsValid(tuple))
     643           0 :             elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
     644             :                  strategynum, attr->atttypid, subtype, opfamily);
     645             : 
     646         284 :         oprid = DatumGetObjectId(SysCacheGetAttr(AMOPSTRATEGY, tuple,
     647             :                                                  Anum_pg_amop_amopopr, &isNull));
     648         284 :         ReleaseSysCache(tuple);
     649             :         Assert(!isNull && RegProcedureIsValid(oprid));
     650             : 
     651         284 :         fmgr_info_cxt(get_opcode(oprid),
     652         284 :                       &opaque->strategy_procinfos[strategynum - 1],
     653             :                       bdesc->bd_context);
     654             :     }
     655             : 
     656       27308 :     return &opaque->strategy_procinfos[strategynum - 1];
     657             : }

Generated by: LCOV version 1.13