LCOV - code coverage report
Current view: top level - src/backend/access/spgist - spgvalidate.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 73 95 76.8 %
Date: 2019-06-19 16:07:09 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * spgvalidate.c
       4             :  *    Opclass validator for SP-GiST.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *          src/backend/access/spgist/spgvalidate.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "access/amvalidate.h"
      17             : #include "access/htup_details.h"
      18             : #include "access/spgist_private.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/builtins.h"
      25             : #include "utils/lsyscache.h"
      26             : #include "utils/regproc.h"
      27             : #include "utils/syscache.h"
      28             : 
      29             : 
      30             : /*
      31             :  * Validator for an SP-GiST opclass.
      32             :  *
      33             :  * Some of the checks done here cover the whole opfamily, and therefore are
      34             :  * redundant when checking each opclass in a family.  But they don't run long
      35             :  * enough to be much of a problem, so we accept the duplication rather than
      36             :  * complicate the amvalidate API.
      37             :  */
      38             : bool
      39          28 : spgvalidate(Oid opclassoid)
      40             : {
      41          28 :     bool        result = true;
      42             :     HeapTuple   classtup;
      43             :     Form_pg_opclass classform;
      44             :     Oid         opfamilyoid;
      45             :     Oid         opcintype;
      46             :     char       *opclassname;
      47             :     HeapTuple   familytup;
      48             :     Form_pg_opfamily familyform;
      49             :     char       *opfamilyname;
      50             :     CatCList   *proclist,
      51             :                *oprlist;
      52             :     List       *grouplist;
      53             :     OpFamilyOpFuncGroup *opclassgroup;
      54             :     int         i;
      55             :     ListCell   *lc;
      56             :     spgConfigIn configIn;
      57             :     spgConfigOut configOut;
      58          28 :     Oid         configOutLefttype = InvalidOid;
      59          28 :     Oid         configOutRighttype = InvalidOid;
      60             : 
      61             :     /* Fetch opclass information */
      62          28 :     classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
      63          28 :     if (!HeapTupleIsValid(classtup))
      64           0 :         elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
      65          28 :     classform = (Form_pg_opclass) GETSTRUCT(classtup);
      66             : 
      67          28 :     opfamilyoid = classform->opcfamily;
      68          28 :     opcintype = classform->opcintype;
      69          28 :     opclassname = NameStr(classform->opcname);
      70             : 
      71             :     /* Fetch opfamily information */
      72          28 :     familytup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfamilyoid));
      73          28 :     if (!HeapTupleIsValid(familytup))
      74           0 :         elog(ERROR, "cache lookup failed for operator family %u", opfamilyoid);
      75          28 :     familyform = (Form_pg_opfamily) GETSTRUCT(familytup);
      76             : 
      77          28 :     opfamilyname = NameStr(familyform->opfname);
      78             : 
      79             :     /* Fetch all operators and support functions of the opfamily */
      80          28 :     oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
      81          28 :     proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
      82          28 :     grouplist = identify_opfamily_groups(oprlist, proclist);
      83             : 
      84             :     /* Check individual support functions */
      85         172 :     for (i = 0; i < proclist->n_members; i++)
      86             :     {
      87         144 :         HeapTuple   proctup = &proclist->members[i]->tuple;
      88         144 :         Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
      89             :         bool        ok;
      90             : 
      91             :         /*
      92             :          * All SP-GiST support functions should be registered with matching
      93             :          * left/right types
      94             :          */
      95         144 :         if (procform->amproclefttype != procform->amprocrighttype)
      96             :         {
      97           0 :             ereport(INFO,
      98             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
      99             :                      errmsg("operator family \"%s\" of access method %s contains support function %s with different left and right input types",
     100             :                             opfamilyname, "spgist",
     101             :                             format_procedure(procform->amproc))));
     102           0 :             result = false;
     103             :         }
     104             : 
     105             :         /* Check procedure numbers and function signatures */
     106         144 :         switch (procform->amprocnum)
     107             :         {
     108             :             case SPGIST_CONFIG_PROC:
     109          28 :                 ok = check_amproc_signature(procform->amproc, VOIDOID, true,
     110             :                                             2, 2, INTERNALOID, INTERNALOID);
     111          28 :                 configIn.attType = procform->amproclefttype;
     112          28 :                 memset(&configOut, 0, sizeof(configOut));
     113             : 
     114          28 :                 OidFunctionCall2(procform->amproc,
     115             :                                  PointerGetDatum(&configIn),
     116             :                                  PointerGetDatum(&configOut));
     117             : 
     118          28 :                 configOutLefttype = procform->amproclefttype;
     119          28 :                 configOutRighttype = procform->amprocrighttype;
     120             : 
     121             :                 /*
     122             :                  * When leaf and attribute types are the same, compress
     123             :                  * function is not required and we set corresponding bit in
     124             :                  * functionset for later group consistency check.
     125             :                  */
     126          32 :                 if (!OidIsValid(configOut.leafType) ||
     127           4 :                     configOut.leafType == configIn.attType)
     128             :                 {
     129          28 :                     foreach(lc, grouplist)
     130             :                     {
     131          28 :                         OpFamilyOpFuncGroup *group = lfirst(lc);
     132             : 
     133          56 :                         if (group->lefttype == procform->amproclefttype &&
     134          28 :                             group->righttype == procform->amprocrighttype)
     135             :                         {
     136          24 :                             group->functionset |=
     137             :                                 ((uint64) 1) << SPGIST_COMPRESS_PROC;
     138          24 :                             break;
     139             :                         }
     140             :                     }
     141             :                 }
     142          28 :                 break;
     143             :             case SPGIST_CHOOSE_PROC:
     144             :             case SPGIST_PICKSPLIT_PROC:
     145             :             case SPGIST_INNER_CONSISTENT_PROC:
     146          84 :                 ok = check_amproc_signature(procform->amproc, VOIDOID, true,
     147             :                                             2, 2, INTERNALOID, INTERNALOID);
     148          84 :                 break;
     149             :             case SPGIST_LEAF_CONSISTENT_PROC:
     150          28 :                 ok = check_amproc_signature(procform->amproc, BOOLOID, true,
     151             :                                             2, 2, INTERNALOID, INTERNALOID);
     152          28 :                 break;
     153             :             case SPGIST_COMPRESS_PROC:
     154           8 :                 if (configOutLefttype != procform->amproclefttype ||
     155           4 :                     configOutRighttype != procform->amprocrighttype)
     156           0 :                     ok = false;
     157             :                 else
     158           4 :                     ok = check_amproc_signature(procform->amproc,
     159             :                                                 configOut.leafType, true,
     160             :                                                 1, 1, procform->amproclefttype);
     161           4 :                 break;
     162             :             default:
     163           0 :                 ereport(INFO,
     164             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     165             :                          errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
     166             :                                 opfamilyname, "spgist",
     167             :                                 format_procedure(procform->amproc),
     168             :                                 procform->amprocnum)));
     169           0 :                 result = false;
     170           0 :                 continue;       /* don't want additional message */
     171             :         }
     172             : 
     173         144 :         if (!ok)
     174             :         {
     175           0 :             ereport(INFO,
     176             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     177             :                      errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
     178             :                             opfamilyname, "spgist",
     179             :                             format_procedure(procform->amproc),
     180             :                             procform->amprocnum)));
     181           0 :             result = false;
     182             :         }
     183             :     }
     184             : 
     185             :     /* Check individual operators */
     186         308 :     for (i = 0; i < oprlist->n_members; i++)
     187             :     {
     188         280 :         HeapTuple   oprtup = &oprlist->members[i]->tuple;
     189         280 :         Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
     190             :         Oid         op_rettype;
     191             : 
     192             :         /* TODO: Check that only allowed strategy numbers exist */
     193         280 :         if (oprform->amopstrategy < 1 || oprform->amopstrategy > 63)
     194             :         {
     195           0 :             ereport(INFO,
     196             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     197             :                      errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
     198             :                             opfamilyname, "spgist",
     199             :                             format_operator(oprform->amopopr),
     200             :                             oprform->amopstrategy)));
     201           0 :             result = false;
     202             :         }
     203             : 
     204             :         /* spgist supports ORDER BY operators */
     205         280 :         if (oprform->amoppurpose != AMOP_SEARCH)
     206             :         {
     207             :             /* ... and operator result must match the claimed btree opfamily */
     208          12 :             op_rettype = get_op_rettype(oprform->amopopr);
     209          12 :             if (!opfamily_can_sort_type(oprform->amopsortfamily, op_rettype))
     210             :             {
     211           0 :                 ereport(INFO,
     212             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     213             :                          errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
     214             :                                 opfamilyname, "spgist",
     215             :                                 format_operator(oprform->amopopr))));
     216           0 :                 result = false;
     217             :             }
     218             :         }
     219             :         else
     220         268 :             op_rettype = BOOLOID;
     221             : 
     222             :         /* Check operator signature --- same for all spgist strategies */
     223         280 :         if (!check_amop_signature(oprform->amopopr, op_rettype,
     224             :                                   oprform->amoplefttype,
     225             :                                   oprform->amoprighttype))
     226             :         {
     227           0 :             ereport(INFO,
     228             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     229             :                      errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
     230             :                             opfamilyname, "spgist",
     231             :                             format_operator(oprform->amopopr))));
     232           0 :             result = false;
     233             :         }
     234             :     }
     235             : 
     236             :     /* Now check for inconsistent groups of operators/functions */
     237          28 :     opclassgroup = NULL;
     238          72 :     foreach(lc, grouplist)
     239             :     {
     240          44 :         OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
     241             : 
     242             :         /* Remember the group exactly matching the test opclass */
     243          88 :         if (thisgroup->lefttype == opcintype &&
     244          44 :             thisgroup->righttype == opcintype)
     245          28 :             opclassgroup = thisgroup;
     246             : 
     247             :         /*
     248             :          * Complain if there are any datatype pairs with functions but no
     249             :          * operators.  This is about the best we can do for now to detect
     250             :          * missing operators.
     251             :          */
     252          44 :         if (thisgroup->operatorset == 0)
     253             :         {
     254           0 :             ereport(INFO,
     255             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     256             :                      errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
     257             :                             opfamilyname, "spgist",
     258             :                             format_type_be(thisgroup->lefttype),
     259             :                             format_type_be(thisgroup->righttype))));
     260           0 :             result = false;
     261             :         }
     262             : 
     263             :         /*
     264             :          * Complain if we're missing functions for any datatype, remembering
     265             :          * that SP-GiST doesn't use cross-type support functions.
     266             :          */
     267          44 :         if (thisgroup->lefttype != thisgroup->righttype)
     268          16 :             continue;
     269             : 
     270         196 :         for (i = 1; i <= SPGISTNProc; i++)
     271             :         {
     272         168 :             if ((thisgroup->functionset & (((uint64) 1) << i)) != 0)
     273         168 :                 continue;       /* got it */
     274           0 :             ereport(INFO,
     275             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     276             :                      errmsg("operator family \"%s\" of access method %s is missing support function %d for type %s",
     277             :                             opfamilyname, "spgist", i,
     278             :                             format_type_be(thisgroup->lefttype))));
     279           0 :             result = false;
     280             :         }
     281             :     }
     282             : 
     283             :     /* Check that the originally-named opclass is supported */
     284             :     /* (if group is there, we already checked it adequately above) */
     285          28 :     if (!opclassgroup)
     286             :     {
     287           0 :         ereport(INFO,
     288             :                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     289             :                  errmsg("operator class \"%s\" of access method %s is missing operator(s)",
     290             :                         opclassname, "spgist")));
     291           0 :         result = false;
     292             :     }
     293             : 
     294          28 :     ReleaseCatCacheList(proclist);
     295          28 :     ReleaseCatCacheList(oprlist);
     296          28 :     ReleaseSysCache(familytup);
     297          28 :     ReleaseSysCache(classtup);
     298             : 
     299          28 :     return result;
     300             : }

Generated by: LCOV version 1.13