Add reversed options when query the partition

query-request.hh

@@ -157,7 +157,9 @@ public:
     void set_partition_row_limit(uint32_t limit) {
         _partition_row_limit = limit;
     }
-
+    void set_reversed() {
+        options.set<query::partition_slice::option::reversed>();
+    }
     friend std::ostream& operator<<(std::ostream& out, const partition_slice& ps);
     friend std::ostream& operator<<(std::ostream& out, const specific_ranges& ps);
 };

redis/commands/lindex.cc

@@ -25,7 +25,7 @@ shared_ptr<abstract_command> lindex::prepare(service::storage_proxy& proxy, requ
 future<reply> lindex::execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::values, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::values, false, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
         if (pd && pd->has_data()) {
             auto& data = pd->data();
             if (static_cast<size_t>(_index) < data.size()) {

redis/commands/llen.cc

@@ -25,7 +25,7 @@ shared_ptr<abstract_command> llen::prepare(service::storage_proxy& proxy, reques
 future<reply> llen::execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::values, cl, timeout, cs).then([] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::values, false, cl, timeout, cs).then([] (auto pd) {
         if (pd && pd->has_data()) {
             return reply_builder::build<number_tag>(static_cast<size_t>(pd->data().size()));
         }

redis/commands/lpop.cc

@@ -45,9 +45,9 @@ future<reply> rpop::execute(service::storage_proxy& proxy, db::consistency_level
 future<reply> pop::do_execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs, bool left)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::all, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs, left] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::all, !left, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs, left] (auto pd) {
         if (pd && pd->has_data()) {
-            auto removed = [left, &pd] () { return left ? pd->data().front() : pd->data().back(); } ();
+            auto removed = pd->data().front();
             return [this, removed_cell_key = removed.first, &proxy, &cs, timeout, cl, pd] () {
                 // The last cell, delete this partition.
                 if (pd->data_size() == 1) {

redis/commands/lrange.cc

@@ -25,7 +25,7 @@ shared_ptr<abstract_command> lrange::prepare(service::storage_proxy& proxy, requ
 future<reply> lrange::execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::values, cl, timeout, cs).then([] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::values, false, cl, timeout, cs).then([] (auto pd) {
         if (pd && pd->has_data()) {
             auto&& vals = boost::copy_range<std::vector<std::optional<bytes>>> (pd->data() | boost::adaptors::transformed([] (auto& data) {
                 return std::move(data.first); 

redis/commands/lrem.cc

@@ -33,7 +33,7 @@ shared_ptr<abstract_command> lrem::prepare(service::storage_proxy& proxy, reques
 future<reply> lrem::execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::all, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::all, false, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
         if (pd && pd->has_data()) {
             std::vector<std::optional<bytes>> removed;
             auto& data = pd->data();

redis/commands/lset.cc

@@ -27,7 +27,7 @@ shared_ptr<abstract_command> lset::prepare(service::storage_proxy& proxy, reques
 future<reply> lset::execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::keys, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::keys, false, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
         if (pd && pd->has_data()) {
             auto& e = pd->data().front();
             std::vector<std::pair<std::optional<bytes>, std::optional<bytes>>> new_cells { { std::move(e.first), std::move(e.second) } };

redis/commands/ltrim.cc

@@ -38,7 +38,7 @@ shared_ptr<abstract_command> ltrim::prepare(service::storage_proxy& proxy, reque
 future<reply> ltrim::execute(service::storage_proxy& proxy, db::consistency_level cl, db::timeout_clock::time_point now, const timeout_config& tc, service::client_state& cs)
 {
     auto timeout = now + tc.read_timeout;
-    return prefetch_list(proxy, _schema, _key, fetch_options::all, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
+    return prefetch_list(proxy, _schema, _key, fetch_options::all, false, cl, timeout, cs).then([this, &proxy, cl, timeout, &cs] (auto pd) {
         if (pd && pd->has_data()) {
             std::vector<std::optional<bytes>> removed;
             auto& data = pd->data();