LCOV - code coverage report
Current view: top level - src/backend/access/gin - ginvalidate.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 89 116 76.7 %
Date: 2024-03-28 15:11:36 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * ginvalidate.c
       4             :  *    Opclass validator for GIN.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *          src/backend/access/gin/ginvalidate.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "access/amvalidate.h"
      17             : #include "access/gin_private.h"
      18             : #include "access/htup_details.h"
      19             : #include "catalog/pg_amop.h"
      20             : #include "catalog/pg_amproc.h"
      21             : #include "catalog/pg_opclass.h"
      22             : #include "catalog/pg_opfamily.h"
      23             : #include "catalog/pg_type.h"
      24             : #include "utils/regproc.h"
      25             : #include "utils/syscache.h"
      26             : 
      27             : /*
      28             :  * Validator for a GIN opclass.
      29             :  */
      30             : bool
      31          88 : ginvalidate(Oid opclassoid)
      32             : {
      33          88 :     bool        result = true;
      34             :     HeapTuple   classtup;
      35             :     Form_pg_opclass classform;
      36             :     Oid         opfamilyoid;
      37             :     Oid         opcintype;
      38             :     Oid         opckeytype;
      39             :     char       *opclassname;
      40             :     HeapTuple   familytup;
      41             :     Form_pg_opfamily familyform;
      42             :     char       *opfamilyname;
      43             :     CatCList   *proclist,
      44             :                *oprlist;
      45             :     List       *grouplist;
      46             :     OpFamilyOpFuncGroup *opclassgroup;
      47             :     int         i;
      48             :     ListCell   *lc;
      49             : 
      50             :     /* Fetch opclass information */
      51          88 :     classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
      52          88 :     if (!HeapTupleIsValid(classtup))
      53           0 :         elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
      54          88 :     classform = (Form_pg_opclass) GETSTRUCT(classtup);
      55             : 
      56          88 :     opfamilyoid = classform->opcfamily;
      57          88 :     opcintype = classform->opcintype;
      58          88 :     opckeytype = classform->opckeytype;
      59          88 :     if (!OidIsValid(opckeytype))
      60          58 :         opckeytype = opcintype;
      61          88 :     opclassname = NameStr(classform->opcname);
      62             : 
      63             :     /* Fetch opfamily information */
      64          88 :     familytup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfamilyoid));
      65          88 :     if (!HeapTupleIsValid(familytup))
      66           0 :         elog(ERROR, "cache lookup failed for operator family %u", opfamilyoid);
      67          88 :     familyform = (Form_pg_opfamily) GETSTRUCT(familytup);
      68             : 
      69          88 :     opfamilyname = NameStr(familyform->opfname);
      70             : 
      71             :     /* Fetch all operators and support functions of the opfamily */
      72          88 :     oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
      73          88 :     proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
      74             : 
      75             :     /* Check individual support functions */
      76         524 :     for (i = 0; i < proclist->n_members; i++)
      77             :     {
      78         436 :         HeapTuple   proctup = &proclist->members[i]->tuple;
      79         436 :         Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
      80             :         bool        ok;
      81             : 
      82             :         /*
      83             :          * All GIN support functions should be registered with matching
      84             :          * left/right types
      85             :          */
      86         436 :         if (procform->amproclefttype != procform->amprocrighttype)
      87             :         {
      88           0 :             ereport(INFO,
      89             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
      90             :                      errmsg("operator family \"%s\" of access method %s contains support function %s with different left and right input types",
      91             :                             opfamilyname, "gin",
      92             :                             format_procedure(procform->amproc))));
      93           0 :             result = false;
      94             :         }
      95             : 
      96             :         /*
      97             :          * We can't check signatures except within the specific opclass, since
      98             :          * we need to know the associated opckeytype in many cases.
      99             :          */
     100         436 :         if (procform->amproclefttype != opcintype)
     101           0 :             continue;
     102             : 
     103             :         /* Check procedure numbers and function signatures */
     104         436 :         switch (procform->amprocnum)
     105             :         {
     106          82 :             case GIN_COMPARE_PROC:
     107          82 :                 ok = check_amproc_signature(procform->amproc, INT4OID, false,
     108             :                                             2, 2, opckeytype, opckeytype);
     109          82 :                 break;
     110          88 :             case GIN_EXTRACTVALUE_PROC:
     111             :                 /* Some opclasses omit nullFlags */
     112          88 :                 ok = check_amproc_signature(procform->amproc, INTERNALOID, false,
     113             :                                             2, 3, opcintype, INTERNALOID,
     114             :                                             INTERNALOID);
     115          88 :                 break;
     116          88 :             case GIN_EXTRACTQUERY_PROC:
     117             :                 /* Some opclasses omit nullFlags and searchMode */
     118          88 :                 ok = check_amproc_signature(procform->amproc, INTERNALOID, false,
     119             :                                             5, 7, opcintype, INTERNALOID,
     120             :                                             INT2OID, INTERNALOID, INTERNALOID,
     121             :                                             INTERNALOID, INTERNALOID);
     122          88 :                 break;
     123          88 :             case GIN_CONSISTENT_PROC:
     124             :                 /* Some opclasses omit queryKeys and nullFlags */
     125          88 :                 ok = check_amproc_signature(procform->amproc, BOOLOID, false,
     126             :                                             6, 8, INTERNALOID, INT2OID,
     127             :                                             opcintype, INT4OID,
     128             :                                             INTERNALOID, INTERNALOID,
     129             :                                             INTERNALOID, INTERNALOID);
     130          88 :                 break;
     131          64 :             case GIN_COMPARE_PARTIAL_PROC:
     132          64 :                 ok = check_amproc_signature(procform->amproc, INT4OID, false,
     133             :                                             4, 4, opckeytype, opckeytype,
     134             :                                             INT2OID, INTERNALOID);
     135          64 :                 break;
     136          26 :             case GIN_TRICONSISTENT_PROC:
     137          26 :                 ok = check_amproc_signature(procform->amproc, CHAROID, false,
     138             :                                             7, 7, INTERNALOID, INT2OID,
     139             :                                             opcintype, INT4OID,
     140             :                                             INTERNALOID, INTERNALOID,
     141             :                                             INTERNALOID);
     142          26 :                 break;
     143           0 :             case GIN_OPTIONS_PROC:
     144           0 :                 ok = check_amoptsproc_signature(procform->amproc);
     145           0 :                 break;
     146           0 :             default:
     147           0 :                 ereport(INFO,
     148             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     149             :                          errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
     150             :                                 opfamilyname, "gin",
     151             :                                 format_procedure(procform->amproc),
     152             :                                 procform->amprocnum)));
     153           0 :                 result = false;
     154           0 :                 continue;       /* don't want additional message */
     155             :         }
     156             : 
     157         436 :         if (!ok)
     158             :         {
     159           0 :             ereport(INFO,
     160             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     161             :                      errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
     162             :                             opfamilyname, "gin",
     163             :                             format_procedure(procform->amproc),
     164             :                             procform->amprocnum)));
     165           0 :             result = false;
     166             :         }
     167             :     }
     168             : 
     169             :     /* Check individual operators */
     170         502 :     for (i = 0; i < oprlist->n_members; i++)
     171             :     {
     172         414 :         HeapTuple   oprtup = &oprlist->members[i]->tuple;
     173         414 :         Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
     174             : 
     175             :         /* TODO: Check that only allowed strategy numbers exist */
     176         414 :         if (oprform->amopstrategy < 1 || oprform->amopstrategy > 63)
     177             :         {
     178           0 :             ereport(INFO,
     179             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     180             :                      errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
     181             :                             opfamilyname, "gin",
     182             :                             format_operator(oprform->amopopr),
     183             :                             oprform->amopstrategy)));
     184           0 :             result = false;
     185             :         }
     186             : 
     187             :         /* gin doesn't support ORDER BY operators */
     188         414 :         if (oprform->amoppurpose != AMOP_SEARCH ||
     189         414 :             OidIsValid(oprform->amopsortfamily))
     190             :         {
     191           0 :             ereport(INFO,
     192             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     193             :                      errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
     194             :                             opfamilyname, "gin",
     195             :                             format_operator(oprform->amopopr))));
     196           0 :             result = false;
     197             :         }
     198             : 
     199             :         /* Check operator signature --- same for all gin strategies */
     200         414 :         if (!check_amop_signature(oprform->amopopr, BOOLOID,
     201             :                                   oprform->amoplefttype,
     202             :                                   oprform->amoprighttype))
     203             :         {
     204           0 :             ereport(INFO,
     205             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     206             :                      errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
     207             :                             opfamilyname, "gin",
     208             :                             format_operator(oprform->amopopr))));
     209           0 :             result = false;
     210             :         }
     211             :     }
     212             : 
     213             :     /* Now check for inconsistent groups of operators/functions */
     214          88 :     grouplist = identify_opfamily_groups(oprlist, proclist);
     215          88 :     opclassgroup = NULL;
     216         218 :     foreach(lc, grouplist)
     217             :     {
     218         130 :         OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
     219             : 
     220             :         /* Remember the group exactly matching the test opclass */
     221         130 :         if (thisgroup->lefttype == opcintype &&
     222         124 :             thisgroup->righttype == opcintype)
     223          88 :             opclassgroup = thisgroup;
     224             : 
     225             :         /*
     226             :          * There is not a lot we can do to check the operator sets, since each
     227             :          * GIN opclass is more or less a law unto itself, and some contain
     228             :          * only operators that are binary-compatible with the opclass datatype
     229             :          * (meaning that empty operator sets can be OK).  That case also means
     230             :          * that we shouldn't insist on nonempty function sets except for the
     231             :          * opclass's own group.
     232             :          */
     233             :     }
     234             : 
     235             :     /* Check that the originally-named opclass is complete */
     236         704 :     for (i = 1; i <= GINNProcs; i++)
     237             :     {
     238         616 :         if (opclassgroup &&
     239         616 :             (opclassgroup->functionset & (((uint64) 1) << i)) != 0)
     240         436 :             continue;           /* got it */
     241         180 :         if (i == GIN_COMPARE_PROC || i == GIN_COMPARE_PARTIAL_PROC ||
     242             :             i == GIN_OPTIONS_PROC)
     243         118 :             continue;           /* optional method */
     244          62 :         if (i == GIN_CONSISTENT_PROC || i == GIN_TRICONSISTENT_PROC)
     245          62 :             continue;           /* don't need both, see check below loop */
     246           0 :         ereport(INFO,
     247             :                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     248             :                  errmsg("operator class \"%s\" of access method %s is missing support function %d",
     249             :                         opclassname, "gin", i)));
     250           0 :         result = false;
     251             :     }
     252          88 :     if (!opclassgroup ||
     253          88 :         ((opclassgroup->functionset & (1 << GIN_CONSISTENT_PROC)) == 0 &&
     254           0 :          (opclassgroup->functionset & (1 << GIN_TRICONSISTENT_PROC)) == 0))
     255             :     {
     256           0 :         ereport(INFO,
     257             :                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     258             :                  errmsg("operator class \"%s\" of access method %s is missing support function %d or %d",
     259             :                         opclassname, "gin",
     260             :                         GIN_CONSISTENT_PROC, GIN_TRICONSISTENT_PROC)));
     261           0 :         result = false;
     262             :     }
     263             : 
     264             : 
     265          88 :     ReleaseCatCacheList(proclist);
     266          88 :     ReleaseCatCacheList(oprlist);
     267          88 :     ReleaseSysCache(familytup);
     268          88 :     ReleaseSysCache(classtup);
     269             : 
     270          88 :     return result;
     271             : }
     272             : 
     273             : /*
     274             :  * Prechecking function for adding operators/functions to a GIN opfamily.
     275             :  */
     276             : void
     277          86 : ginadjustmembers(Oid opfamilyoid,
     278             :                  Oid opclassoid,
     279             :                  List *operators,
     280             :                  List *functions)
     281             : {
     282             :     ListCell   *lc;
     283             : 
     284             :     /*
     285             :      * Operator members of a GIN opfamily should never have hard dependencies,
     286             :      * since their connection to the opfamily depends only on what the support
     287             :      * functions think, and that can be altered.  For consistency, we make all
     288             :      * soft dependencies point to the opfamily, though a soft dependency on
     289             :      * the opclass would work as well in the CREATE OPERATOR CLASS case.
     290             :      */
     291         462 :     foreach(lc, operators)
     292             :     {
     293         376 :         OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
     294             : 
     295         376 :         op->ref_is_hard = false;
     296         376 :         op->ref_is_family = true;
     297         376 :         op->refobjid = opfamilyoid;
     298             :     }
     299             : 
     300             :     /*
     301             :      * Required support functions should have hard dependencies.  Preferably
     302             :      * those are just dependencies on the opclass, but if we're in ALTER
     303             :      * OPERATOR FAMILY, we leave the dependency pointing at the whole
     304             :      * opfamily.  (Given that GIN opclasses generally don't share opfamilies,
     305             :      * it seems unlikely to be worth working harder.)
     306             :      */
     307         450 :     foreach(lc, functions)
     308             :     {
     309         364 :         OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
     310             : 
     311         364 :         switch (op->number)
     312             :         {
     313         152 :             case GIN_EXTRACTVALUE_PROC:
     314             :             case GIN_EXTRACTQUERY_PROC:
     315             :                 /* Required support function */
     316         152 :                 op->ref_is_hard = true;
     317         152 :                 break;
     318         212 :             case GIN_COMPARE_PROC:
     319             :             case GIN_CONSISTENT_PROC:
     320             :             case GIN_COMPARE_PARTIAL_PROC:
     321             :             case GIN_TRICONSISTENT_PROC:
     322             :             case GIN_OPTIONS_PROC:
     323             :                 /* Optional, so force it to be a soft family dependency */
     324         212 :                 op->ref_is_hard = false;
     325         212 :                 op->ref_is_family = true;
     326         212 :                 op->refobjid = opfamilyoid;
     327         212 :                 break;
     328           0 :             default:
     329           0 :                 ereport(ERROR,
     330             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     331             :                          errmsg("support function number %d is invalid for access method %s",
     332             :                                 op->number, "gin")));
     333             :                 break;
     334             :         }
     335             :     }
     336          86 : }

Generated by: LCOV version 1.14