ClickHouse is using infinite cache for compiled regular expressions.
Hyperscan can use several megabytes per compiled regexp.
It makes infinite memory growth possible:

```
clickhouse-benchmark --query "SELECT multiFuzzyMatchAny('Hello, world', 5, ['(' || (SELECT toString(rand(1))) || '|' || (SELECT toString(rand(2))) || ')+(' || (SELECT toString(rand(3))) || '|' || (SELECT toString(rand(4))) || ')+(' || (SELECT toString(rand(5))) || ')+'])"
```

Possible solutions:
- simply drop cache if its size is 1000 entries;
- replace to LRU cache with 1000 entries.

{
                        res[i] = negate;
                        ++i;
                    }
                    
                    if (pos + required_substring.size() < begin + haystack_offsets[i])
                    {
                        
                        if (is_trivial)
                            res[i] = !negate;
                        else
                        {
                            const char * str_data = reinterpret_cast<const char *>(&haystack_data[haystack_offsets[i - 1]]);
                            size_t str_size = haystack_offsets[i] - haystack_offsets[i - 1] - 1;
                            /** Even in the case of `required_substring_is_prefix` use UNANCHORED check for regexp,
                              *  so that it can match when `required_substring` occurs into the string several times,
                              *  and at the first occurrence, the regexp is not a match.
                              */
                            const size_t start_pos = (required_substring_is_prefix) ? (reinterpret_cast<const char *>(pos) - str_data) : 0;
                            const size_t end_pos = str_size;
                            const bool match = regexp.getRE2()->Match(
                                    {str_data, str_size},
                                    start_pos,
                                    end_pos,
                                    re2_st::RE2::UNANCHORED,
                                    nullptr,
                                    0);
                            res[i] = negate ^ match;
                        }
                    }