[yugabyte#26847] YSQL: Use __thread in regex code

Summary:
PG is designed for use in single-threaded environments, so it often uses static (global) vars. When this code is evaluated as part of expression pushdown, it's executed from a multi-threaded environment, and so the static variables are no longer safe.

`__thread` is a simpler way to denote a thread-local variable in C code. Switching to this format keeps correctness, but makes the changes from PG much smaller.

```
src/lint/diff_file_with_upstream.py src/postgres/src/backend/regex/regc_pg_locale.c | grep -v "yb_switch_fallthrough" | grep -E "<|>"
< /* YB includes */
< #include "pg_yb_utils.h"
<
< static YB_THREAD_LOCAL PG_Locale_Strategy pg_regex_strategy;
< static YB_THREAD_LOCAL pg_locale_t pg_regex_locale;
< static YB_THREAD_LOCAL Oid	pg_regex_collation;
> static PG_Locale_Strategy pg_regex_strategy;
> static pg_locale_t pg_regex_locale;
> static Oid	pg_regex_collation;
< static YB_THREAD_LOCAL pg_ctype_cache *pg_ctype_cache_list = NULL;
> static pg_ctype_cache *pg_ctype_cache_list = NULL;
```

```
src/lint/diff_file_with_upstream.py src/postgres/src/backend/utils/adt/regexp.c | grep -v "yb_switch_fallthrough" | grep -E "<|>"
< /* YB includes */
< #include "pg_yb_utils.h"
<
< static YB_THREAD_LOCAL int	num_res = 0;		/* # of cached re's */
< static YB_THREAD_LOCAL cached_re_str re_array[MAX_CACHED_RES];	/* cached re's */
> static int	num_res = 0;		/* # of cached re's */
> static cached_re_str re_array[MAX_CACHED_RES];	/* cached re's */
```
Jira: DB-16251

Test Plan:
```
./yb_build.sh --cxx-test pgwrapper_pg_mini-test --gtest_filter PgMiniTest.RegexPushdown
./yb_build.sh tsan--cxx-test pgwrapper_pg_mini-test --gtest_filter PgMiniTest.RegexPushdown
```

Reviewers: kfranz

Reviewed By: kfranz

Subscribers: yql, svc_phabricator

Differential Revision: https://phorge.dev.yugabyte.com/D44528

Author: timothy-e

src/postgres/src/backend/regex/regc_pg_locale.c

@@ -39,8 +39,7 @@
 #include "utils/varlena.h"
 
 /* YB includes */
-#include "yb/yql/pggate/ybc_pg_typedefs.h"
-#include "yb/yql/pggate/ybc_pggate.h"
+#include "pg_yb_utils.h"
 
 #define PG_GETARG_TEXT_PP_IF_EXISTS(_n) \
 	(PG_NARGS() > (_n) ? PG_GETARG_TEXT_PP(_n) : NULL)
@@ -110,66 +109,9 @@ typedef struct cached_re_str
 	regex_t		cre_re;			/* the compiled regular expression */
 } cached_re_str;
 
-/*
- * YB: A single static cache works in Postgres, but is not safe in a
- * multi-threaded environment when we pushdown regex filters to the tserver.
- * The following infrastructure is necessary to create a thread local cache
- * for regex compilation.
- */
-typedef struct YbReCacheInfo
-{
-	int		   *num;
-	cached_re_str *array;
-} YbReCacheInfo;
+static YB_THREAD_LOCAL int	num_res = 0;		/* # of cached re's */
+static YB_THREAD_LOCAL cached_re_str re_array[MAX_CACHED_RES];	/* cached re's */
 
-static void
-YbFreeRe(cached_re_str *re)
-{
-	pg_regfree(&re->cre_re);
-	free(re->cre_pat);
-}
-
-static void
-YbFreeReCache(YbcPgThreadLocalRegexpCache *cache)
-{
-	Assert(cache && cache->array);
-	cached_re_str *re = cache->array;
-
-	for (cached_re_str *re_end = re + cache->num; re != re_end; ++re)
-		YbFreeRe(re);
-}
-
-static YbReCacheInfo
-YbGetReCacheInfo()
-{
-	if (IsMultiThreadedMode())
-	{
-		YbcPgThreadLocalRegexpCache *cache = YBCPgGetThreadLocalRegexpCache();
-
-		if (!cache)
-		{
-			cache = YBCPgInitThreadLocalRegexpCache((sizeof(cached_re_str) *
-													 MAX_CACHED_RES),
-													&YbFreeReCache);
-			Assert(cache && cache->array);
-		}
-
-		return (YbReCacheInfo)
-		{
-			.num = &cache->num,
-				.array = (cached_re_str *) cache->array,
-		};
-	}
-
-	static int	num_res = 0;	/* # of cached re's */
-	static cached_re_str re_array[MAX_CACHED_RES];	/* cached re's */
-
-	return (YbReCacheInfo)
-	{
-		.num = &num_res,
-			.array = re_array,
-	};
-}
 
 /* Local functions */
 static regexp_matches_ctx *setup_regexp_matches(text *orig_str, text *pattern,
@@ -207,16 +149,12 @@ RE_compile_and_cache(text *text_re, int cflags, Oid collation)
 	cached_re_str re_temp;
 	char		errMsg[100];
 
-	YbReCacheInfo yb_re_cache_info = YbGetReCacheInfo();
-	int		   *num_res = yb_re_cache_info.num;
-	cached_re_str *re_array = yb_re_cache_info.array;
-
 	/*
 	 * Look for a match among previously compiled REs.  Since the data
 	 * structure is self-organizing with most-used entries at the front, our
 	 * search strategy can just be to scan from the front.
 	 */
-	for (i = 0; i < *num_res; i++)
+	for (i = 0; i < num_res; i++)
 	{
 		if (re_array[i].cre_pat_len == text_re_len &&
 			re_array[i].cre_flags == cflags &&
@@ -297,18 +235,19 @@ RE_compile_and_cache(text *text_re, int cflags, Oid collation)
 	 * Okay, we have a valid new item in re_temp; insert it into the storage
 	 * array.  Discard last entry if needed.
 	 */
-	if (*num_res >= MAX_CACHED_RES)
+	if (num_res >= MAX_CACHED_RES)
 	{
-		--*num_res;
-		Assert(*num_res < MAX_CACHED_RES);
-		YbFreeRe(&re_array[*num_res]);
+		--num_res;
+		Assert(num_res < MAX_CACHED_RES);
+		pg_regfree(&re_array[num_res].cre_re);
+		free(re_array[num_res].cre_pat);
 	}
 
-	if (*num_res > 0)
-		memmove(&re_array[1], &re_array[0], *num_res * sizeof(cached_re_str));
+	if (num_res > 0)
+		memmove(&re_array[1], &re_array[0], num_res * sizeof(cached_re_str));
 
 	re_array[0] = re_temp;
-	(*num_res)++;
+	num_res++;
 
 	return &re_array[0].cre_re;
 }

src/postgres/src/backend/utils/adt/regexp.c

@@ -152,7 +152,6 @@ YbQueryDiagnosticsParams
 YbQueryDiagnosticsPgss
 YbQueryDiagnosticsStatusType
 YbRange
-YbReCacheInfo
 YbRegisterOuterMatchFn_t
 YbRelationAttrsProcessingState
 YbResetBatchFn_t
@@ -271,9 +270,6 @@ YbcPgSysColumns
 YbcPgSysTablePrefetcherCacheMode
 YbcPgTableDesc
 YbcPgTabletsDescriptor
-YbcPgThreadLocalRegexpCache
-YbcPgThreadLocalRegexpCacheCleanup
-YbcPgThreadLocalRegexpMetadata
 YbcPgTransactionSetting
 YbcPgTxnSnapshot
 YbcPgTypeAttrs

src/postgres/src/tools/pgindent/yb_typedefs.list

@@ -21,24 +21,6 @@
 #include "yb/yql/pggate/ybc_pg_typedefs.h"
 #include "yb/util/logging.h"
 
-class CachedRegexpHolder {
- public:
-  CachedRegexpHolder(size_t buffer_size,
-                     YbcPgThreadLocalRegexpCacheCleanup cleanup)
-      : buffer_(buffer_size, 0), cleanup_(cleanup), cache_{.num = 0, .array = buffer_.data()} {}
-
-  ~CachedRegexpHolder() {
-    cleanup_(&cache_);
-  }
-
-  YbcPgThreadLocalRegexpCache& cache() { return cache_; }
-
- private:
-  std::vector<char> buffer_;
-  const YbcPgThreadLocalRegexpCacheCleanup cleanup_;
-  YbcPgThreadLocalRegexpCache cache_ = {};
-};
-
 namespace yb::pggate {
 
 /*
@@ -50,8 +32,6 @@ thread_local void* pg_strtok_ptr = nullptr;
 thread_local int yb_expression_version = 0;
 thread_local void* jump_buffer = nullptr;
 thread_local void* err_status = nullptr;
-thread_local std::optional<CachedRegexpHolder> re_cache;
-thread_local YbcPgThreadLocalRegexpMetadata re_metadata;
 
 //-----------------------------------------------------------------------------
 // Memory context.
@@ -117,19 +97,4 @@ void PgSetThreadLocalYbExpressionVersion(int yb_expr_version) {
   yb_expression_version = yb_expr_version;
 }
 
-YbcPgThreadLocalRegexpCache* PgGetThreadLocalRegexpCache() {
-  return re_cache ? &re_cache->cache() : nullptr;
-}
-
-YbcPgThreadLocalRegexpCache* PgInitThreadLocalRegexpCache(
-    size_t buffer_size, YbcPgThreadLocalRegexpCacheCleanup cleanup) {
-  DCHECK(!re_cache);
-  re_cache.emplace(buffer_size, cleanup);
-  return &re_cache->cache();
-}
-
-YbcPgThreadLocalRegexpMetadata* PgGetThreadLocalRegexpMetadata() {
-  return &re_metadata;
-}
-
 }  // namespace yb::pggate

src/yb/yql/pggate/pggate_thread_local_vars.cc

@@ -77,19 +77,4 @@ void PgSetThreadLocalStrTokPtr(char *new_pg_strtok_ptr);
 int PgGetThreadLocalYbExpressionVersion();
 void PgSetThreadLocalYbExpressionVersion(int yb_expr_version);
 
-/*
- * CachedRegexpHolder (from regex/regex.c)
- * These are used to cache the compiled regexes
- */
-YbcPgThreadLocalRegexpCache* PgGetThreadLocalRegexpCache();
-YbcPgThreadLocalRegexpCache* PgInitThreadLocalRegexpCache(
-    size_t buffer_size, YbcPgThreadLocalRegexpCacheCleanup cleanup);
-
-/*
- * Regular Expression Metadata (from regc_pg_locale.c)
- * These are used to cache the collation and locale information for regular
- * expression processing.
- */
-YbcPgThreadLocalRegexpMetadata* PgGetThreadLocalRegexpMetadata();
-
 } // namespace yb::pggate

src/yb/yql/pggate/pggate_thread_local_vars.h

@@ -905,21 +905,6 @@ typedef struct {
   const char* tgt_owner;
 } YbcCloneInfo;
 
-// A thread-safe way to cache compiled regexes.
-typedef struct {
-  int num;
-  void* array;
-} YbcPgThreadLocalRegexpCache;
-
-typedef void (*YbcPgThreadLocalRegexpCacheCleanup)(YbcPgThreadLocalRegexpCache*);
-
-// A thread-safe way to control the behavior of regex matching.
-typedef struct {
-  int pg_regex_strategy; // PG_Locale_Strategy
-  void* pg_regex_locale; // struct pg_locale_t
-  YbcPgOid pg_regex_collation;
-} YbcPgThreadLocalRegexpMetadata;
-
 typedef struct {
   void *slot;
 } YbcPgInsertOnConflictKeyInfo;

src/yb/yql/pggate/ybc_pg_typedefs.h

@@ -2399,19 +2399,6 @@ void YBCPgSetThreadLocalYbExpressionVersion(int yb_expr_version) {
   PgSetThreadLocalYbExpressionVersion(yb_expr_version);
 }
 
-YbcPgThreadLocalRegexpCache* YBCPgGetThreadLocalRegexpCache() {
-  return PgGetThreadLocalRegexpCache();
-}
-
-YbcPgThreadLocalRegexpCache* YBCPgInitThreadLocalRegexpCache(
-    size_t buffer_size, YbcPgThreadLocalRegexpCacheCleanup cleanup) {
-  return PgInitThreadLocalRegexpCache(buffer_size, cleanup);
-}
-
-YbcPgThreadLocalRegexpMetadata* YBCPgGetThreadLocalRegexpMetadata() {
-  return PgGetThreadLocalRegexpMetadata();
-}
-
 void* YBCPgSetThreadLocalJumpBuffer(void* new_buffer) {
   return PgSetThreadLocalJumpBuffer(new_buffer);
 }

src/yb/yql/pggate/ybc_pggate.cc

@@ -870,13 +870,6 @@ void* YBCPgSetThreadLocalErrStatus(void* new_status);
 
 void* YBCPgGetThreadLocalErrStatus();
 
-YbcPgThreadLocalRegexpCache* YBCPgGetThreadLocalRegexpCache();
-
-YbcPgThreadLocalRegexpCache* YBCPgInitThreadLocalRegexpCache(
-    size_t buffer_size, YbcPgThreadLocalRegexpCacheCleanup cleanup);
-
-YbcPgThreadLocalRegexpMetadata* YBCPgGetThreadLocalRegexpMetadata();
-
 void YBCPgResetCatalogReadTime();
 
 YbcStatus YBCNewGetLockStatusDataSRF(YbcPgFunction *handle);