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.

{
                    size_t prev_offset = 0;
                    for (size_t i = 0; i < haystack_size; ++i)
                    {
                        const bool match = regexp.getRE2()->Match(
                                {reinterpret_cast<const char *>(&haystack_data[prev_offset]), haystack_offsets[i] - prev_offset - 1},
                                0,
                                haystack_offsets[i] - prev_offset - 1,
                                re2_st::RE2::UNANCHORED,
                                nullptr,
                                0);
                        res[i] = negate ^ match;
                        prev_offset = haystack_offsets[i];
                    }
                }
            }
            else
            {
                
                const UInt8 * const begin = haystack_data.data();
                const UInt8 * const end = haystack_data.begin() + haystack_data.size();
                const UInt8 * pos = begin;
                
                size_t i = 0;
                Searcher searcher(required_substring.data(), required_substring.size(), end - pos);
                
                while (pos < end && end != (pos = searcher.search(pos, end - pos)))
                {
                    
                    while (begin + haystack_offsets[i] <= pos)