/*-------------------------------------------------------------------------

 *

 * nbtcompare.c

 *    Comparison functions for btree access method.

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/access/nbtree/nbtcompare.c

 *

 * NOTES

 *

 *  These functions are stored in pg_amproc.  For each operator class

 *  defined on btrees, they compute

 *

 *        compare(a, b):

 *            < 0 if a < b,

 *            = 0 if a == b,

 *            > 0 if a > b.

 *

 *  The result is always an int32 regardless of the input datatype.

 *

 *  Although any negative int32 is acceptable for reporting "<",

 *  and any positive int32 is acceptable for reporting ">", routines

 *  that work on 32-bit or wider datatypes can't just return "a - b".

 *  That could overflow and give the wrong answer.

 *

 *  NOTE: it is critical that the comparison function impose a total order

 *  on all non-NULL values of the data type, and that the datatype's

 *  boolean comparison operators (= < >= etc) yield results consistent

 *  with the comparison routine.  Otherwise bad behavior may ensue.

 *  (For example, the comparison operators must NOT punt when faced with

 *  NAN or other funny values; you must devise some collation sequence for

 *  all such values.)  If the datatype is not trivial, this is most

 *  reliably done by having the boolean operators invoke the same

 *  three-way comparison code that the btree function does.  Therefore,

 *  this file contains only btree support for "trivial" datatypes ---

 *  all others are in the /utils/adt/ files that implement their datatypes.

 *

 *  NOTE: these routines must not leak memory, since memory allocated

 *  during an index access won't be recovered till end of query.  This

 *  primarily affects comparison routines for toastable datatypes;

 *  they have to be careful to free any detoasted copy of an input datum.

 *

 *  NOTE: we used to forbid comparison functions from returning INT_MIN,

 *  but that proves to be too error-prone because some platforms' versions

 *  of memcmp() etc can return INT_MIN.  As a means of stress-testing

 *  callers, this file can be compiled with STRESS_SORT_INT_MIN defined

 *  to cause many of these functions to return INT_MIN or INT_MAX instead of

 *  their customary -1/+1.  For production, though, that's not a good idea

 *  since users or third-party code might expect the traditional results.

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include <limits.h>

#include "utils/builtins.h"

#include "utils/fmgrprotos.h"

#include "utils/skipsupport.h"

#include "utils/sortsupport.h"

#ifdef STRESS_SORT_INT_MIN

#define A_LESS_THAN_B   INT_MIN

#define A_GREATER_THAN_B  INT_MAX

#else

#define A_LESS_THAN_B   (-1)

#define A_GREATER_THAN_B  1

#endif

Datum

btboolcmp(PG_FUNCTION_ARGS)

{

  bool    a = PG_GETARG_BOOL(0);

  bool    b = PG_GETARG_BOOL(1);

  PG_RETURN_INT32((int32) a - (int32) b);

}

static Datum

bool_decrement(Relation rel, Datum existing, bool *underflow)

{

  bool    bexisting = DatumGetBool(existing);

  if (bexisting == false)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return BoolGetDatum(bexisting - 1);

}

static Datum

bool_increment(Relation rel, Datum existing, bool *overflow)

{

  bool    bexisting = DatumGetBool(existing);

  if (bexisting == true)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return BoolGetDatum(bexisting + 1);

}

Datum

btboolskipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = bool_decrement;

  sksup->increment = bool_increment;

  sksup->low_elem = BoolGetDatum(false);

  sksup->high_elem = BoolGetDatum(true);

  PG_RETURN_VOID();

}

Datum

btint2cmp(PG_FUNCTION_ARGS)

{

  int16   a = PG_GETARG_INT16(0);

  int16   b = PG_GETARG_INT16(1);

  PG_RETURN_INT32((int32) a - (int32) b);

}

Datum

btint2sortsupport(PG_FUNCTION_ARGS)

{

  SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

  ssup->comparator = ssup_datum_int32_cmp;

  PG_RETURN_VOID();

}

static Datum

int2_decrement(Relation rel, Datum existing, bool *underflow)

{

  int16   iexisting = DatumGetInt16(existing);

  if (iexisting == PG_INT16_MIN)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return Int16GetDatum(iexisting - 1);

}

static Datum

int2_increment(Relation rel, Datum existing, bool *overflow)

{

  int16   iexisting = DatumGetInt16(existing);

  if (iexisting == PG_INT16_MAX)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return Int16GetDatum(iexisting + 1);

}

Datum

btint2skipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = int2_decrement;

  sksup->increment = int2_increment;

  sksup->low_elem = Int16GetDatum(PG_INT16_MIN);

  sksup->high_elem = Int16GetDatum(PG_INT16_MAX);

  PG_RETURN_VOID();

}

Datum

btint4cmp(PG_FUNCTION_ARGS)

{

  int32   a = PG_GETARG_INT32(0);

  int32   b = PG_GETARG_INT32(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint4sortsupport(PG_FUNCTION_ARGS)

{

  SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

  ssup->comparator = ssup_datum_int32_cmp;

  PG_RETURN_VOID();

}

static Datum

int4_decrement(Relation rel, Datum existing, bool *underflow)

{

  int32   iexisting = DatumGetInt32(existing);

  if (iexisting == PG_INT32_MIN)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return Int32GetDatum(iexisting - 1);

}

static Datum

int4_increment(Relation rel, Datum existing, bool *overflow)

{

  int32   iexisting = DatumGetInt32(existing);

  if (iexisting == PG_INT32_MAX)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return Int32GetDatum(iexisting + 1);

}

Datum

btint4skipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = int4_decrement;

  sksup->increment = int4_increment;

  sksup->low_elem = Int32GetDatum(PG_INT32_MIN);

  sksup->high_elem = Int32GetDatum(PG_INT32_MAX);

  PG_RETURN_VOID();

}

Datum

btint8cmp(PG_FUNCTION_ARGS)

{

  int64   a = PG_GETARG_INT64(0);

  int64   b = PG_GETARG_INT64(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint8sortsupport(PG_FUNCTION_ARGS)

{

  SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

  ssup->comparator = ssup_datum_int64_cmp;

  PG_RETURN_VOID();

}

static Datum

int8_decrement(Relation rel, Datum existing, bool *underflow)

{

  int64   iexisting = DatumGetInt64(existing);

  if (iexisting == PG_INT64_MIN)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return Int64GetDatum(iexisting - 1);

}

static Datum

int8_increment(Relation rel, Datum existing, bool *overflow)

{

  int64   iexisting = DatumGetInt64(existing);

  if (iexisting == PG_INT64_MAX)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return Int64GetDatum(iexisting + 1);

}

Datum

btint8skipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = int8_decrement;

  sksup->increment = int8_increment;

  sksup->low_elem = Int64GetDatum(PG_INT64_MIN);

  sksup->high_elem = Int64GetDatum(PG_INT64_MAX);

  PG_RETURN_VOID();

}

Datum

btint48cmp(PG_FUNCTION_ARGS)

{

  int32   a = PG_GETARG_INT32(0);

  int64   b = PG_GETARG_INT64(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint84cmp(PG_FUNCTION_ARGS)

{

  int64   a = PG_GETARG_INT64(0);

  int32   b = PG_GETARG_INT32(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint24cmp(PG_FUNCTION_ARGS)

{

  int16   a = PG_GETARG_INT16(0);

  int32   b = PG_GETARG_INT32(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint42cmp(PG_FUNCTION_ARGS)

{

  int32   a = PG_GETARG_INT32(0);

  int16   b = PG_GETARG_INT16(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint28cmp(PG_FUNCTION_ARGS)

{

  int16   a = PG_GETARG_INT16(0);

  int64   b = PG_GETARG_INT64(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btint82cmp(PG_FUNCTION_ARGS)

{

  int64   a = PG_GETARG_INT64(0);

  int16   b = PG_GETARG_INT16(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btoidcmp(PG_FUNCTION_ARGS)

{

  Oid     a = PG_GETARG_OID(0);

  Oid     b = PG_GETARG_OID(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btoidsortsupport(PG_FUNCTION_ARGS)

{

  SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

  ssup->comparator = ssup_datum_uint32_cmp;

  PG_RETURN_VOID();

}

static Datum

oid_decrement(Relation rel, Datum existing, bool *underflow)

{

  Oid     oexisting = DatumGetObjectId(existing);

  if (oexisting == InvalidOid)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return ObjectIdGetDatum(oexisting - 1);

}

static Datum

oid_increment(Relation rel, Datum existing, bool *overflow)

{

  Oid     oexisting = DatumGetObjectId(existing);

  if (oexisting == OID_MAX)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return ObjectIdGetDatum(oexisting + 1);

}

Datum

btoidskipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = oid_decrement;

  sksup->increment = oid_increment;

  sksup->low_elem = ObjectIdGetDatum(InvalidOid);

  sksup->high_elem = ObjectIdGetDatum(OID_MAX);

  PG_RETURN_VOID();

}

Datum

btoid8cmp(PG_FUNCTION_ARGS)

{

  Oid8    a = PG_GETARG_OID8(0);

  Oid8    b = PG_GETARG_OID8(1);

  if (a > b)

    PG_RETURN_INT32(A_GREATER_THAN_B);

  else if (a == b)

    PG_RETURN_INT32(0);

  else

    PG_RETURN_INT32(A_LESS_THAN_B);

}

Datum

btoid8sortsupport(PG_FUNCTION_ARGS)

{

  SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

  ssup->comparator = ssup_datum_uint64_cmp;

  PG_RETURN_VOID();

}

static Datum

oid8_decrement(Relation rel, Datum existing, bool *underflow)

{

  Oid8    oexisting = DatumGetObjectId8(existing);

  if (oexisting == InvalidOid8)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return ObjectId8GetDatum(oexisting - 1);

}

static Datum

oid8_increment(Relation rel, Datum existing, bool *overflow)

{

  Oid8    oexisting = DatumGetObjectId8(existing);

  if (oexisting == OID8_MAX)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return ObjectId8GetDatum(oexisting + 1);

}

Datum

btoid8skipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = oid8_decrement;

  sksup->increment = oid8_increment;

  sksup->low_elem = ObjectId8GetDatum(InvalidOid8);

  sksup->high_elem = ObjectId8GetDatum(OID8_MAX);

  PG_RETURN_VOID();

}

Datum

btoidvectorcmp(PG_FUNCTION_ARGS)

{

  oidvector  *a = (oidvector *) PG_GETARG_POINTER(0);

  oidvector  *b = (oidvector *) PG_GETARG_POINTER(1);

  int     i;

  check_valid_oidvector(a);

  check_valid_oidvector(b);

  /* We arbitrarily choose to sort first by vector length */

  if (a->dim1 != b->dim1)

    PG_RETURN_INT32(a->dim1 - b->dim1);

  for (i = 0; i < a->dim1; i++)

  {

    if (a->values[i] != b->values[i])

    {

      if (a->values[i] > b->values[i])

        PG_RETURN_INT32(A_GREATER_THAN_B);

      else

        PG_RETURN_INT32(A_LESS_THAN_B);

    }

  }

  PG_RETURN_INT32(0);

}

Datum

btcharcmp(PG_FUNCTION_ARGS)

{

  char    a = PG_GETARG_CHAR(0);

  char    b = PG_GETARG_CHAR(1);

  /* Be careful to compare chars as unsigned */

  PG_RETURN_INT32((int32) ((uint8) a) - (int32) ((uint8) b));

}

static Datum

char_decrement(Relation rel, Datum existing, bool *underflow)

{

  uint8   cexisting = DatumGetUInt8(existing);

  if (cexisting == 0)

  {

    /* return value is undefined */

    *underflow = true;

    return (Datum) 0;

  }

  *underflow = false;

  return CharGetDatum((uint8) cexisting - 1);

}

static Datum

char_increment(Relation rel, Datum existing, bool *overflow)

{

  uint8   cexisting = DatumGetUInt8(existing);

  if (cexisting == UCHAR_MAX)

  {

    /* return value is undefined */

    *overflow = true;

    return (Datum) 0;

  }

  *overflow = false;

  return CharGetDatum((uint8) cexisting + 1);

}

Datum

btcharskipsupport(PG_FUNCTION_ARGS)

{

  SkipSupport sksup = (SkipSupport) PG_GETARG_POINTER(0);

  sksup->decrement = char_decrement;

  sksup->increment = char_increment;

  /* btcharcmp compares chars as unsigned */

  sksup->low_elem = UInt8GetDatum(0);

  sksup->high_elem = UInt8GetDatum(UCHAR_MAX);

  PG_RETURN_VOID();

}