**Describe the bug**
When using ORDER BY with multiple expressions on a MergeTree table, the ordering is not correct.


**How to reproduce**
` yandex/clickhouse-server:20.5.2.7`

Create the table:
```sql
create table order_test
(
    timestamp DateTime64(3),
    color     LowCardinality(Nullable(String))
) engine = MergeTree()
      PARTITION BY toYYYYMM(timestamp)
      ORDER BY timestamp
      SETTINGS index_granularity = 8192;
```

Fill the table (run a few time times to get a range of timestamps):
```sql
insert into order_test
select now64(),
       arrayElement(['red', 'green', 'blue', null], modulo(number, 4) + 1) as color
from (select number from system.numbers limit 1000000);
```

Query:
```sql
SELECT count(),
       color,
       toStartOfSecond(timestamp) AS `second`
FROM order_test AS i
GROUP BY color, `second`
ORDER BY color, `second` desc
LIMIT 500;
```


See out of order results:
```
500000,blue,2020-08-21 18:30:06.000
500000,blue,2020-08-21 18:30:09.000
250000,blue,2020-08-21 18:30:03.000
250000,blue,2020-08-21 18:30:08.000
250000,blue,2020-08-21 18:30:07.000
```

**Expected behavior**
See results in order by descending second:
```
500000,blue,2020-08-21 18:30:09.000
250000,blue,2020-08-21 18:30:08.000
250000,blue,2020-08-21 18:30:07.000
500000,blue,2020-08-21 18:30:06.000
250000,blue,2020-08-21 18:30:03.000
```

Notes:

It appears when I take out `LowCardinality` from the color column, the order works as expected. 



{
    if (limit == 0)
        limit = size();
    size_t unique_limit = getDictionary().size();
    Permutation unique_perm;
    getDictionary().getNestedColumn()->getPermutation(reverse, unique_limit, nan_direction_hint, unique_perm);
    
    
    std::vector<std::vector<size_t>> indexes_per_row(getDictionary().size());
    size_t indexes_size = getIndexes().size();
    for (size_t row = 0; row < indexes_size; ++row)
        indexes_per_row[getIndexes().getUInt(row)].push_back(row);
    
    size_t perm_size = std::min(indexes_size, limit);
    res.resize(perm_size);
    size_t perm_index = 0;
    for (size_t row = 0; row < unique_perm.size() && perm_index < perm_size; ++row)
    {
        const auto & row_indexes = indexes_per_row[unique_perm[row]];
        for (auto row_index : row_indexes)
        {
            res[perm_index] = row_index;
            ++perm_index;
            if (perm_index == perm_size)
                break;
        }
    }
}
void ColumnLowCardinality::updatePermutation(bool reverse, size_t limit, int nan_direction_hint, IColumn::Permutation & res, EqualRanges & equal_range) const