Check that user-specified opclass in CREATE INDEX corresponds to operators

that will actually work on the column datatype.

diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index c1c16a844d4737a93246241b98cac6a54509828f..19ff9597d5297129ce761b5161a77e8214fc4bdc 100644 (file)
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.24 2000/04/23 01:44:55 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.25 2000/04/25 02:45:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -24,6 +24,7 @@
 #include "catalog/pg_database.h"
 #include "catalog/pg_index.h"
 #include "catalog/pg_opclass.h"
+#include "catalog/pg_operator.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_shadow.h"
 #include "catalog/pg_type.h"
@@ -32,6 +33,7 @@
 #include "optimizer/planmain.h"
 #include "optimizer/prep.h"
 #include "parser/parsetree.h"
+#include "parser/parse_coerce.h"
 #include "parser/parse_func.h"
 #include "parser/parse_type.h"
 #include "utils/builtins.h"
@@ -556,7 +558,9 @@ GetAttrOpClass(IndexElem *attribute, Oid attrType,
    HeapScanDesc scan;
    ScanKeyData entry[2];
    HeapTuple   tuple;
-   Oid         opClassId;
+   Oid         opClassId,
+               oprId;
+   bool        doTypeCheck = true;
 
    if (attribute->class == NULL)
    {
@@ -565,6 +569,8 @@ GetAttrOpClass(IndexElem *attribute, Oid attrType,
        if (attribute->class == NULL)
            elog(ERROR, "DefineIndex: type %s has no default operator class",
                 typeidTypeName(attrType));
+       /* assume we need not check type compatibility */
+       doTypeCheck = false;
    }
 
    tuple = SearchSysCacheTuple(CLANAME,
@@ -597,9 +603,42 @@ GetAttrOpClass(IndexElem *attribute, Oid attrType,
             attribute->class, accessMethodName);
    }
 
+   oprId = ((Form_pg_amop) GETSTRUCT(tuple))->amopopr;
+
    heap_endscan(scan);
    heap_close(relation, AccessShareLock);
 
+   /*
+    * Make sure the operators associated with this opclass actually accept
+    * the column data type.  This prevents possible coredumps caused by
+    * user errors like applying text_ops to an int4 column.  We will accept
+    * an opclass as OK if the operator's input datatype is binary-compatible
+    * with the actual column datatype.  Note we assume that all the operators
+    * associated with an opclass accept the same datatypes, so checking the
+    * first one we happened to find in the table is sufficient.
+    *
+    * If the opclass was the default for the datatype, assume we can skip
+    * this check --- that saves a few cycles in the most common case.
+    * If pg_opclass is messed up then we're probably screwed anyway...
+    */
+   if (doTypeCheck)
+   {
+       tuple = SearchSysCacheTuple(OPEROID,
+                                   ObjectIdGetDatum(oprId),
+                                   0, 0, 0);
+       if (HeapTupleIsValid(tuple))
+       {
+           Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tuple);
+           Oid     opInputType = (optup->oprkind == 'l') ?
+               optup->oprright : optup->oprleft;
+
+           if (attrType != opInputType &&
+               ! IS_BINARY_COMPATIBLE(attrType, opInputType))
+               elog(ERROR, "DefineIndex: opclass \"%s\" does not accept datatype \"%s\"",
+                    attribute->class, typeidTypeName(attrType));
+       }
+   }
+
    return opClassId;
 }