**Use case**
A friend wants to show me a set of queries, but is afraid to reveal the names of columns (domain area) and the values of constants.

**Describe the solution you'd like**
A simple ad-hoc solution that will be mostly acceptable.

Use Lexer to tokenize query and replace tokens. Use a list of english nouns or similar words for replacements. The user will specify a salt in command line to make deterministic pseudorandom unpredictable replacement.

Split identifiers to words according to their style (snake_case, CamelCase, ALL_CAPS). If identifier is too complex, treat it as a single word. These words will be replaced with english nouns selected by the value of a SipHash from the word and the salt. Save all replacements in a map to track collisions. In case of collision, add 1 to the salt and repeat to select another noun. Keep the style of replaced identifiers for convenience. Keep some words like `id`, `num`, `value` unreplaced.

For literals in a query: for numbers, dates, datetimes, apply a model similar to clickhouse-obfuscator. For string literals, keep punctuation charaters as is to keep the meaning of LIKE and regexp. Replace alphanumeric parts to a gibberish of similar length (maybe keeping alpha and numerics). Replace valid UTF-8 to another valid UTF-8 while keeping the number of leading zeros in bytes.

Keep the keywords in the query as is. (Lexer does not know about keywords, so we have to list them explicitly).
++pos;
        }
        else
        {
            const uint8_t * upos = reinterpret_cast<const uint8_t *>(pos);
            if (pos + 1 < end && upos[0] == 0xC2 && (upos[1] == 0x85 || upos[1] == 0xA0))
            {
                pos += 2;
            }
            else if (pos + 2 < end
                &&    ((upos[0] == 0xE1 && upos[1] == 0xA0 && upos[2] == 0x8E)
                    || (upos[0] == 0xE2
                        &&    ((upos[1] == 0x80
                            &&    ((upos[2] >= 0x80 && upos[2] <= 0x8A)
                                || (upos[2] >= 0xA8 && upos[2] <= 0xA9)
                                || (upos[2] >= 0x8B && upos[2] <= 0x8D)
                                || (upos[2] == 0xAF)))
                            || (upos[1] == 0x81 && (upos[2] == 0x9F || upos[2] == 0xA0))))
                    || (upos[0] == 0xE3 && upos[1] == 0x80 && upos[2] == 0x80)
                    || (upos[0] == 0xEF && upos[1] == 0xBB && upos[2] == 0xBF)))
            {
                pos += 3;
            }
            else
                break;
        }
    }
    return pos;
}
inline bool equalsCaseInsensitive(char a, char b)