20.7
```
SELECT indexOf(['a', 'b', 'c'], toLowCardinality('a'))

┌─indexOf(['a', 'b', 'c'], toLowCardinality('a'))─┐
│                                               1 │
└─────────────────────────────────────────────────┘
```

20.8
```
SELECT indexOf(['a', 'b', 'c'], toLowCardinality('a'))


Received exception from server (version 20.8.3):
Code: 43. DB::Exception: Received from localhost:9000. DB::Exception: Types of array and 2nd argument of function "indexOf" must be identical up to nullability, cardinality, numeric types, or Enum and numeric type. Passed: Array(String) and LowCardinality(String).. 
```

https://github.com/ClickHouse/ClickHouse/pull/12550

/cc @myrrc 

/**
     * The Array's internal data type may be quite tricky (containing a Nullable type somewhere). To process the
     * Nullable types correctly, for each data type specialisation we provide two null maps (one for the data and one
     * for the items). By convention they are passed as the third and the fourth argument, respectively
     * (counting from 1).
     *
     * @return {nullptr, nullptr} if there are less than 3 arguments.
     * @return {null_map_data, nullptr} if there are three arguments
     * @return {nullptr, null_map_item} if there are four arguments but the third is missing.
     * @return {null_map_data, null_map_item} if there are four arguments.
     */
    static NullMaps getNullMaps(const ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments) noexcept
    {
        if (arguments.size() < 3)
            return {nullptr, nullptr};
        const NullMap * null_map_data = nullptr;
        const NullMap * null_map_item = nullptr;
        if (const auto & data_map = columns[arguments[2]].column; data_map)
            null_map_data = &assert_cast<const ColumnUInt8 &>(*data_map).getData();
        if (const auto & item_map = columns[arguments[3]].column; item_map)
            null_map_item = &assert_cast<const ColumnUInt8 &>(*item_map).getData();
        return {null_map_data, null_map_item};
    }
    /**
     * Given a variadic pack #Integral, apply executeIntegralExpanded with such parameters:
     * Integral s = {s1, s2, ...}
     * (s1, s1, s2, ...), (s2, s1, s2, ...), (s3, s1, s2, ...)
     */
    template <class ...Integral>
    static inline bool executeIntegral(ColumnsWithTypeAndName & columns, const ColumnNumbers & arguments, size_t result_pos)