**Describe what's wrong**

Selecting from a Buffer table with ORDER BY <col> DESC clause returns wrong rows, and the returned rows are not ordered.

**Does it reproduce on recent release?**

Tested version: 22.7.2.15

**How to reproduce**

* Which ClickHouse server version to use
22.7.2.15
* `CREATE TABLE` statements for all tables involved

        CREATE TABLE mydb.mytable_stored
        (
            `a` UInt8
        )
        ENGINE = MergeTree
        ORDER BY a;

        CREATE TABLE mydb.mytable
        (
            `a` UInt8
        )
        ENGINE = Buffer('mydb', 'mytable_stored', 4, 600, 3600, 10, 100, 10000, 10000000);

* Sample data for all these tables
Note: rows must be inserted one-by-one:

        INSERT INTO mydb.mytable VALUES (0);
        INSERT INTO mydb.mytable VALUES (1);
        INSERT INTO mydb.mytable VALUES (2);
        INSERT INTO mydb.mytable VALUES (3);
        INSERT INTO mydb.mytable VALUES (4);
        INSERT INTO mydb.mytable VALUES (5);
        INSERT INTO mydb.mytable VALUES (6);
        INSERT INTO mydb.mytable VALUES (7);
        INSERT INTO mydb.mytable VALUES (8);
        INSERT INTO mydb.mytable VALUES (9);

* Queries to run that lead to unexpected result

        SELECT a FROM mydb.mytable ORDER BY a DESC LIMIT 5;
        ┌─a─┐
        │ 3 │
        │ 7 │
        └───┘
        ┌─a─┐
        │ 2 │
        │ 6 │
        └───┘
        ┌─a─┐
        │ 1 │
        └───┘
        5 rows in set. Elapsed: 0.007 sec.

(Interestingly, ascending order *seems* to work, did not test it thoroughly though.)

**Expected behavior**

Get the results in descending order, ie. `9, 8, 7, 6, 5`.

**Additional context**

Selecting the maximal value works:

        SELECT max(a) FROM mydb.mytable;
        ┌─max(a)─┐
        │      9 │
        └────────┘
        1 row in set. Elapsed: 0.007 sec.

After the rows are flushed to the backing MergeTree table, the results are good.

        OPTIMIZE TABLE mydb.mytable;
        SELECT a FROM mydb.mytable ORDER BY a DESC LIMIT 5;
        ┌─a─┐
        │ 9 │
        │ 8 │
        │ 7 │
        │ 6 │
        │ 5 │
        └───┘
        5 rows in set. Elapsed: 0.008 sec. 


return;
        }
        
        const auto start_shard_num = getThreadId() % storage.num_shards;
        
        auto shard_num = start_shard_num;
        StorageBuffer::Buffer * least_busy_buffer = nullptr;
        std::unique_lock<std::mutex> least_busy_lock;
        size_t least_busy_shard_rows = 0;
        for (size_t try_no = 0; try_no < storage.num_shards; ++try_no)
        {
            std::unique_lock lock(storage.buffers[shard_num].tryLock());
            if (lock.owns_lock())
            {
                size_t num_rows = storage.buffers[shard_num].data.rows();
                if (!least_busy_buffer || num_rows < least_busy_shard_rows)
                {
                    least_busy_buffer = &storage.buffers[shard_num];
                    least_busy_lock = std::move(lock);
                    least_busy_shard_rows = num_rows;
                }
            }
            shard_num = (shard_num + 1) % storage.num_shards;
        }
        
        if (!least_busy_buffer)
        {
            least_busy_buffer = &storage.buffers[start_shard_num];
            least_busy_lock = least_busy_buffer->lockForWriting();
        }