Minor refactoring of jsonb_util.c

The only caller of compareJsonbScalarValue that needed locale-sensitive
comparison of strings was also the only caller that didn't just check for
equality. Separate the two cases for clarity: compareJsonbScalarValue now
does locale-sensitive comparison, and a new function,
equalsJsonbScalarValue, just checks for equality.

diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index 434c68bd24ea62d2d8fda18ebc39a51121489406..93bb148232e140d357c0fb60aac04beddc03d43c 100644 (file)
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -34,8 +34,8 @@
 
 static void fillJsonbValue(JEntry *array, int index, char *base_addr,
                           JsonbValue *result);
+static bool    equalsJsonbScalarValue(JsonbValue *a, JsonbValue *b);
 static int     compareJsonbScalarValue(JsonbValue *a, JsonbValue *b);
-static int     lexicalCompareJsonbStringValue(const void *a, const void *b);
 static Jsonb *convertToJsonb(JsonbValue *val);
 static void convertJsonbValue(StringInfo buffer, JEntry *header, JsonbValue *val, int level);
 static void convertJsonbArray(StringInfo buffer, JEntry *header, JsonbValue *val, int level);
@@ -161,8 +161,6 @@ compareJsonbContainers(JsonbContainer *a, JsonbContainer *b)
                                switch (va.type)
                                {
                                        case jbvString:
-                                               res = lexicalCompareJsonbStringValue(&va, &vb);
-                                               break;
                                        case jbvNull:
                                        case jbvNumeric:
                                        case jbvBool:
@@ -289,7 +287,7 @@ findJsonbValueFromContainer(JsonbContainer *container, uint32 flags,
 
                        if (key->type == result->type)
                        {
-                               if (compareJsonbScalarValue(key, result) == 0)
+                               if (equalsJsonbScalarValue(key, result))
                                        return result;
                        }
                }
@@ -917,7 +915,7 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
                        }
                        else if (IsAJsonbScalar(lhsVal))
                        {
-                               if (compareJsonbScalarValue(lhsVal, &vcontained) != 0)
+                               if (!equalsJsonbScalarValue(lhsVal, &vcontained))
                                        return false;
                        }
                        else
@@ -1118,31 +1116,25 @@ JsonbHashScalarValue(const JsonbValue *scalarVal, uint32 *hash)
 
 /*
  * Are two scalar JsonbValues of the same type a and b equal?
- *
- * Does not use lexical comparisons.  Therefore, it is essentially that this
- * never be used against Strings for anything other than searching for values
- * within a single jsonb.
  */
-static int
-compareJsonbScalarValue(JsonbValue *aScalar, JsonbValue *bScalar)
+static bool
+equalsJsonbScalarValue(JsonbValue *aScalar, JsonbValue *bScalar)
 {
        if (aScalar->type == bScalar->type)
        {
                switch (aScalar->type)
                {
                        case jbvNull:
-                               return 0;
+                               return true;
                        case jbvString:
-                               return lengthCompareJsonbStringValue(aScalar, bScalar);
+                               return lengthCompareJsonbStringValue(aScalar, bScalar) == 0;
                        case jbvNumeric:
-                               return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
+                               return DatumGetBool(DirectFunctionCall2(numeric_eq,
                                                                           PointerGetDatum(aScalar->val.numeric),
                                                                         PointerGetDatum(bScalar->val.numeric)));
                        case jbvBool:
-                               if (aScalar->val.boolean != bScalar->val.boolean)
-                                       return (aScalar->val.boolean > bScalar->val.boolean) ? 1 : -1;
-                               else
-                                       return 0;
+                               return aScalar->val.boolean == bScalar->val.boolean;
+
                        default:
                                elog(ERROR, "invalid jsonb scalar type");
                }
@@ -1152,22 +1144,43 @@ compareJsonbScalarValue(JsonbValue *aScalar, JsonbValue *bScalar)
 }
 
 /*
- * Standard lexical qsort() comparator of jsonb strings.
+ * Compare two scalar JsonbValues, returning -1, 0, or 1.
  *
- * Sorts strings lexically, using the default database collation.  Used by
- * B-Tree operators, where a lexical sort order is generally expected.
+ * Strings are compared using the default collation.  Used by B-tree
+ * operators, where a lexical sort order is generally expected.
  */
 static int
-lexicalCompareJsonbStringValue(const void *a, const void *b)
+compareJsonbScalarValue(JsonbValue *aScalar, JsonbValue *bScalar)
 {
-       const JsonbValue *va = (const JsonbValue *) a;
-       const JsonbValue *vb = (const JsonbValue *) b;
-
-       Assert(va->type == jbvString);
-       Assert(vb->type == jbvString);
-
-       return varstr_cmp(va->val.string.val, va->val.string.len, vb->val.string.val,
-                                         vb->val.string.len, DEFAULT_COLLATION_OID);
+       if (aScalar->type == bScalar->type)
+       {
+               switch (aScalar->type)
+               {
+                       case jbvNull:
+                               return 0;
+                       case jbvString:
+                               return varstr_cmp(aScalar->val.string.val,
+                                                                 aScalar->val.string.len,
+                                                                 bScalar->val.string.val,
+                                                                 bScalar->val.string.len,
+                                                                 DEFAULT_COLLATION_OID);
+                       case jbvNumeric:
+                               return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
+                                                                          PointerGetDatum(aScalar->val.numeric),
+                                                                        PointerGetDatum(bScalar->val.numeric)));
+                       case jbvBool:
+                               if (aScalar->val.boolean == bScalar->val.boolean)
+                                       return 0;
+                               else if (aScalar->val.boolean > bScalar->val.boolean)
+                                       return 1;
+                               else
+                                       return -1;
+                       default:
+                               elog(ERROR, "invalid jsonb scalar type");
+               }
+       }
+       elog(ERROR, "jsonb scalar type mismatch");
+       return -1;
 }