Rename amcancrosscompare

After more discussion about commit ce62f2f2a0, rename the index AM
property amcancrosscompare to two separate properties
amconsistentequality and amconsistentordering.  Also improve the
documentation and update some comments that were previously missed.

Reported-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/flat/E1tngY6-0000UL-2n%40gemulon.postgresql.org

contrib/bloom/blutils.c

@@ -110,7 +110,8 @@ blhandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = false;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = false;
+	amroutine->amconsistentequality = false;
+	amroutine->amconsistentordering = false;
 	amroutine->amcanbackward = false;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = true;

doc/src/sgml/indexam.sgml

@@ -105,8 +105,10 @@ typedef struct IndexAmRoutine
     bool        amcanorderbyop;
     /* does AM support hashing using API consistent with the hash AM? */
     bool        amcanhash;
-    /* does AM support cross-type comparisons? */
+    /* do operators within an opfamily have consistent equality semantics? */
-    bool        amcancrosscompare;
+    bool        amconsistentequality;
+    /* do operators within an opfamily have consistent ordering semantics? */
+    bool        amconsistentordering;
     /* does AM support backward scanning? */
     bool        amcanbackward;
     /* does AM support UNIQUE indexes? */

src/backend/access/brin/brin.c

@@ -257,7 +257,8 @@ brinhandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = false;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = false;
+	amroutine->amconsistentequality = false;
+	amroutine->amconsistentordering = false;
 	amroutine->amcanbackward = false;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = true;

src/backend/access/gin/ginutil.c

@@ -45,7 +45,8 @@ ginhandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = false;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = false;
+	amroutine->amconsistentequality = false;
+	amroutine->amconsistentordering = false;
 	amroutine->amcanbackward = false;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = true;

src/backend/access/gist/gist.c

@@ -66,7 +66,8 @@ gisthandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = true;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = false;
+	amroutine->amconsistentequality = false;
+	amroutine->amconsistentordering = false;
 	amroutine->amcanbackward = false;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = true;

src/backend/access/hash/hash.c

@@ -65,7 +65,8 @@ hashhandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = false;
 	amroutine->amcanhash = true;
-	amroutine->amcancrosscompare = true;
+	amroutine->amconsistentequality = true;
+	amroutine->amconsistentequality = false;
 	amroutine->amcanbackward = true;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = false;

src/backend/access/nbtree/nbtree.c

@@ -108,7 +108,8 @@ bthandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = true;
 	amroutine->amcanorderbyop = false;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = true;
+	amroutine->amconsistentequality = true;
+	amroutine->amconsistentordering = true;
 	amroutine->amcanbackward = true;
 	amroutine->amcanunique = true;
 	amroutine->amcanmulticol = true;

src/backend/access/spgist/spgutils.c

@@ -51,7 +51,8 @@ spghandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = true;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = false;
+	amroutine->amconsistentequality = false;
+	amroutine->amconsistentordering = false;
 	amroutine->amcanbackward = false;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = false;

src/backend/optimizer/plan/analyzejoins.c

@@ -1083,9 +1083,10 @@ query_supports_distinctness(Query *query)
  * the values are distinct.  (Note: the opids entries could be cross-type
  * operators, and thus not exactly the equality operators that the subquery
  * would use itself.  We use equality_ops_are_compatible() to check
- * compatibility.  That looks at btree or hash opfamily membership, and so
+ * compatibility.  That looks at opfamily membership for index AMs that have
- * should give trustworthy answers for all operators that we might need
+ * declared that they support consistent equality semantics within an
- * to deal with here.)
+ * opfamily, and so should give trustworthy answers for all operators that we
+ * might need to deal with here.)
  */
 bool
 query_is_distinct_for(Query *query, List *colnos, List *opids)

src/backend/utils/cache/lsyscache.c

@@ -690,10 +690,11 @@ get_op_btree_interpretation(Oid opno)
  *		semantics.
  *
  * This is trivially true if they are the same operator.  Otherwise,
- * we look to see if they can be found in the same btree or hash opfamily.
+ * Otherwise, we look to see if they both belong to an opfamily that
- * Either finding allows us to assume that they have compatible notions
+ * guarantees compatible semantics for equality.  Either finding allows us to
- * of equality.  (The reason we need to do these pushups is that one might
+ * assume that they have compatible notions of equality.  (The reason we need
- * be a cross-type operator; for instance int24eq vs int4eq.)
+ * to do these pushups is that one might be a cross-type operator; for
+ * instance int24eq vs int4eq.)
  */
 bool
 equality_ops_are_compatible(Oid opno1, Oid opno2)
@@ -718,7 +719,7 @@ equality_ops_are_compatible(Oid opno1, Oid opno2)
 		Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
 		IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(op_form->amopmethod, false);
 
-		if (amroutine->amcancrosscompare)
+		if (amroutine->amconsistentequality)
 		{
 			if (op_in_opfamily(opno2, op_form->amopfamily))
 			{
@@ -738,12 +739,13 @@ equality_ops_are_compatible(Oid opno1, Oid opno2)
  *		Return true if the two given comparison operators have compatible
  *		semantics.
  *
- * This is trivially true if they are the same operator.  Otherwise,
+ * This is trivially true if they are the same operator.  Otherwise, we look
- * we look to see if they can be found in the same btree opfamily.
+ * to see if they both belong to an opfamily that guarantees compatible
- * For example, '<' and '>=' ops match if they belong to the same family.
+ * semantics for ordering.  (For example, for btree, '<' and '>=' ops match if
+ * they belong to the same family.)
  *
- * (This is identical to equality_ops_are_compatible(), except that we
+ * (This is identical to equality_ops_are_compatible(), except that we check
- * don't bother to examine hash opclasses.)
+ * amcanorder plus amconsistentordering instead of amconsistentequality.)
  */
 bool
 comparison_ops_are_compatible(Oid opno1, Oid opno2)
@@ -768,7 +770,7 @@ comparison_ops_are_compatible(Oid opno1, Oid opno2)
 		Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
 		IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(op_form->amopmethod, false);
 
-		if (amroutine->amcanorder && amroutine->amcancrosscompare)
+		if (amroutine->amcanorder && amroutine->amconsistentordering)
 		{
 			if (op_in_opfamily(opno2, op_form->amopfamily))
 			{

src/include/access/amapi.h

@@ -245,8 +245,10 @@ typedef struct IndexAmRoutine
 	bool		amcanorderbyop;
 	/* does AM support hashing using API consistent with the hash AM? */
 	bool		amcanhash;
-	/* does AM support cross-type comparisons? */
+	/* do operators within an opfamily have consistent equality semantics? */
-	bool		amcancrosscompare;
+	bool		amconsistentequality;
+	/* do operators within an opfamily have consistent ordering semantics? */
+	bool		amconsistentordering;
 	/* does AM support backward scanning? */
 	bool		amcanbackward;
 	/* does AM support UNIQUE indexes? */

src/test/modules/dummy_index_am/dummy_index_am.c

@@ -283,7 +283,8 @@ dihandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = false;
 	amroutine->amcanhash = false;
-	amroutine->amcancrosscompare = false;
+	amroutine->amconsistentequality = false;
+	amroutine->amconsistentordering = false;
 	amroutine->amcanbackward = false;
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = false;