**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. 


total_writes.rows -= block_rows;
        total_writes.bytes -= block_allocated_bytes_delta;
        LOG_DEBUG(log, "Flushing buffer with {} rows (discarded), {} bytes, age {} seconds {}.", rows, bytes, time_passed, (check_thresholds ? "(bg)" : "(direct)"));
        return true;
    }
    /** For simplicity, buffer is locked during write.
        * We could unlock buffer temporary, but it would lead to too many difficulties:
        * - data, that is written, will not be visible for SELECTs;
        * - new data could be appended to buffer, and in case of exception, we must merge it with old data, that has not been written;
        * - this could lead to infinite memory growth.
        */
    Stopwatch watch;
    try
    {
        writeBlockToDestination(block_to_write, getDestinationTable());
    }
    catch (...)
    {
        ProfileEvents::increment(ProfileEvents::StorageBufferErrorOnFlush);
        
        CurrentMetrics::add(CurrentMetrics::StorageBufferRows, block_to_write.rows());
        CurrentMetrics::add(CurrentMetrics::StorageBufferBytes, block_to_write.bytes());
        buffer.data.swap(block_to_write);
        if (!buffer.first_write_time) 
            buffer.first_write_time = current_time;
        
        throw;
    }
    total_writes.rows -= block_rows;
    total_writes.bytes -= block_allocated_bytes_delta;