**Describe the bug**
Using a `NULL` tuple as a left operand with a chained or operands produce an invalid ClickHouse filtering.

**Does it reproduce on recent release?**
Can be reproduced with `21.2.2.8`

**How to reproduce**
```
SELECT (NULL, NULL) = (8, 0) OR (NULL, NULL) = (3, 2) OR (NULL, NULL) = (0, 0) OR (NULL, NULL) = (3, 1)

Received exception from server (version 21.2.2):
Code: 53. DB::Exception: Received from 127.0.0.1:10000. DB::Exception: Type mismatch in IN or VALUES section. Expected: Nothing. Got: UInt64: While processing (NULL, NULL) IN ((0, 0), (3, 1), (3, 2), (8, 0)). 
```

**Expected behavior**
It should return `NULL`, or at least the same output as `equals(tuple(NULL, NULL), tuple(3, 2))`
return src;
        }
        
    }
    else if (which_type.isStringOrFixedString())
    {
        if (src.getType() == Field::Types::String)
        {
            if (which_type.isFixedString())
            {
                size_t n = assert_cast<const DataTypeFixedString &>(type).getN();
                const auto & src_str = src.get<String>();
                if (src_str.size() < n)
                {
                    String src_str_extended = src_str;
                    src_str_extended.resize(n);
                    return src_str_extended;
                }
            }
            return src;
        }
    }
    else if (const DataTypeArray * type_array = typeid_cast<const DataTypeArray *>(&type))
    {
        if (src.getType() == Field::Types::Array)
        {
            const Array & src_arr = src.get<Array>();
            size_t src_arr_size = src_arr.size();
            const auto & element_type = *(type_array->getNestedType());
            bool have_unconvertible_element = false;