From e0b3074e894496b41b57fd1c96ede68803cf3df8 Mon Sep 17 00:00:00 2001 From: Jeff Davis Date: Thu, 23 Feb 2023 11:20:00 -0800 Subject: [PATCH] Remove unnecessary #ifdef USE_ICU and branch. Now that the provider-independent API pg_strnxfrm() is available, we no longer need the special cases for ICU in hashfunc.c and varchar.c. Reviewed-by: Peter Eisentraut, Peter Geoghegan Discussion: https://postgr.es/m/a581136455c940d7bd0ff482d3a2bd51af25a94f.camel%40j-davis.com --- src/backend/access/hash/hashfunc.c | 83 ++++++++++++------------------ src/backend/utils/adt/varchar.c | 74 +++++++++++--------------- 2 files changed, 63 insertions(+), 94 deletions(-) diff --git a/src/backend/access/hash/hashfunc.c b/src/backend/access/hash/hashfunc.c index 2e2fd5566e..d850edd1d5 100644 --- a/src/backend/access/hash/hashfunc.c +++ b/src/backend/access/hash/hashfunc.c @@ -289,34 +289,27 @@ hashtext(PG_FUNCTION_ARGS) } else { -#ifdef USE_ICU - if (mylocale->provider == COLLPROVIDER_ICU) - { - Size bsize, rsize; - char *buf; - const char *keydata = VARDATA_ANY(key); - size_t keylen = VARSIZE_ANY_EXHDR(key); + Size bsize, rsize; + char *buf; + const char *keydata = VARDATA_ANY(key); + size_t keylen = VARSIZE_ANY_EXHDR(key); - bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); - buf = palloc(bsize + 1); - rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); - if (rsize != bsize) - elog(ERROR, "pg_strnxfrm() returned unexpected result"); + bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); + buf = palloc(bsize + 1); - /* - * In principle, there's no reason to include the terminating NUL - * character in the hash, but it was done before and the behavior - * must be preserved. - */ - result = hash_any((uint8_t *) buf, bsize + 1); + rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); + if (rsize != bsize) + elog(ERROR, "pg_strnxfrm() returned unexpected result"); - pfree(buf); - } - else -#endif - /* shouldn't happen */ - elog(ERROR, "unsupported collprovider: %c", mylocale->provider); + /* + * In principle, there's no reason to include the terminating NUL + * character in the hash, but it was done before and the behavior + * must be preserved. + */ + result = hash_any((uint8_t *) buf, bsize + 1); + + pfree(buf); } /* Avoid leaking memory for toasted inputs */ @@ -350,35 +343,27 @@ hashtextextended(PG_FUNCTION_ARGS) } else { -#ifdef USE_ICU - if (mylocale->provider == COLLPROVIDER_ICU) - { - Size bsize, rsize; - char *buf; - const char *keydata = VARDATA_ANY(key); - size_t keylen = VARSIZE_ANY_EXHDR(key); + Size bsize, rsize; + char *buf; + const char *keydata = VARDATA_ANY(key); + size_t keylen = VARSIZE_ANY_EXHDR(key); - bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); - buf = palloc(bsize + 1); + bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); + buf = palloc(bsize + 1); - rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); - if (rsize != bsize) - elog(ERROR, "pg_strnxfrm() returned unexpected result"); + rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); + if (rsize != bsize) + elog(ERROR, "pg_strnxfrm() returned unexpected result"); - /* - * In principle, there's no reason to include the terminating NUL - * character in the hash, but it was done before and the behavior - * must be preserved. - */ - result = hash_any_extended((uint8_t *) buf, bsize + 1, - PG_GETARG_INT64(1)); + /* + * In principle, there's no reason to include the terminating NUL + * character in the hash, but it was done before and the behavior + * must be preserved. + */ + result = hash_any_extended((uint8_t *) buf, bsize + 1, + PG_GETARG_INT64(1)); - pfree(buf); - } - else -#endif - /* shouldn't happen */ - elog(ERROR, "unsupported collprovider: %c", mylocale->provider); + pfree(buf); } PG_FREE_IF_COPY(key, 0); diff --git a/src/backend/utils/adt/varchar.c b/src/backend/utils/adt/varchar.c index 99a4ca7cd0..592afc18ec 100644 --- a/src/backend/utils/adt/varchar.c +++ b/src/backend/utils/adt/varchar.c @@ -1021,32 +1021,24 @@ hashbpchar(PG_FUNCTION_ARGS) } else { -#ifdef USE_ICU - if (mylocale->provider == COLLPROVIDER_ICU) - { - Size bsize, rsize; - char *buf; + Size bsize, rsize; + char *buf; - bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); - buf = palloc(bsize + 1); + bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); + buf = palloc(bsize + 1); - rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); - if (rsize != bsize) - elog(ERROR, "pg_strnxfrm() returned unexpected result"); + rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); + if (rsize != bsize) + elog(ERROR, "pg_strnxfrm() returned unexpected result"); - /* - * In principle, there's no reason to include the terminating NUL - * character in the hash, but it was done before and the behavior - * must be preserved. - */ - result = hash_any((uint8_t *) buf, bsize + 1); + /* + * In principle, there's no reason to include the terminating NUL + * character in the hash, but it was done before and the behavior + * must be preserved. + */ + result = hash_any((uint8_t *) buf, bsize + 1); - pfree(buf); - } - else -#endif - /* shouldn't happen */ - elog(ERROR, "unsupported collprovider: %c", mylocale->provider); + pfree(buf); } /* Avoid leaking memory for toasted inputs */ @@ -1084,33 +1076,25 @@ hashbpcharextended(PG_FUNCTION_ARGS) } else { -#ifdef USE_ICU - if (mylocale->provider == COLLPROVIDER_ICU) - { - Size bsize, rsize; - char *buf; + Size bsize, rsize; + char *buf; - bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); - buf = palloc(bsize + 1); + bsize = pg_strnxfrm(NULL, 0, keydata, keylen, mylocale); + buf = palloc(bsize + 1); - rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); - if (rsize != bsize) - elog(ERROR, "pg_strnxfrm() returned unexpected result"); + rsize = pg_strnxfrm(buf, bsize + 1, keydata, keylen, mylocale); + if (rsize != bsize) + elog(ERROR, "pg_strnxfrm() returned unexpected result"); - /* - * In principle, there's no reason to include the terminating NUL - * character in the hash, but it was done before and the behavior - * must be preserved. - */ - result = hash_any_extended((uint8_t *) buf, bsize + 1, - PG_GETARG_INT64(1)); + /* + * In principle, there's no reason to include the terminating NUL + * character in the hash, but it was done before and the behavior + * must be preserved. + */ + result = hash_any_extended((uint8_t *) buf, bsize + 1, + PG_GETARG_INT64(1)); - pfree(buf); - } - else -#endif - /* shouldn't happen */ - elog(ERROR, "unsupported collprovider: %c", mylocale->provider); + pfree(buf); } PG_FREE_IF_COPY(key, 0);