Merge "Convert serialization of query::result to use db::serializer<>…

…" from Tomasz

Reviewed-by: Nadav Har'El <[email protected]>

bytes_ostream.hh

@@ -33,8 +33,10 @@
  *
  */
 class bytes_ostream {
+public:
     using size_type = bytes::size_type;
     using value_type = bytes::value_type;
+private:
     static_assert(sizeof(value_type) == 1, "value_type is assumed to be one byte long");
     struct chunk {
         // FIXME: group fragment pointers to reduce pointer chasing when packetizing

db/serializer.hh

@@ -26,7 +26,6 @@
 #include "utils/data_output.hh"
 #include "bytes_ostream.hh"
 #include "bytes.hh"
-#include "mutation.hh"
 #include "keys.hh"
 #include "database_fwd.hh"
 #include "frozen_mutation.hh"

frozen_mutation.cc

@@ -21,6 +21,8 @@
 
 #include "db/serializer.hh"
 #include "frozen_mutation.hh"
+#include "mutation_partition.hh"
+#include "mutation.hh"
 #include "partition_builder.hh"
 #include "mutation_partition_serializer.hh"
 #include "utils/UUID.hh"

frozen_mutation.hh

@@ -23,9 +23,9 @@
 
 #include "atomic_cell.hh"
 #include "keys.hh"
-#include "mutation.hh"
 #include "mutation_partition_view.hh"
 
+class mutation;
 
 // Immutable, compact form of mutation.
 //

message/messaging_service.cc

@@ -110,17 +110,11 @@ query::read_command net::serializer::read(Input& in, rpc::type<query::read_comma
 
 template <typename Output>
 void net::serializer::write(Output& out, const query::result& v) const {
-    // FIXME: allow const call to query::result::serialize()
-    uint32_t sz = v.serialized_size();
-    write(out, sz);
-    bytes b(bytes::initialized_later(), sz);
-    auto _out = b.begin();
-    const_cast<query::result&>(v).serialize(_out);
-    out.write(reinterpret_cast<const char*>(b.c_str()), sz);
+    write_serializable(out, v);
 }
 template <typename Input>
 query::result net::serializer::read(Input& in, rpc::type<query::result>) const {
-    return read_gms<query::result>(in);
+    return read_serializable<query::result>(in);
 }
 
 template <typename Output>

mutation_partition_serializer.cc

@@ -21,6 +21,7 @@
  */
 
 #include "mutation_partition_serializer.hh"
+#include "mutation_partition.hh"
 #include "db/serializer.hh"
 
 //

mutation_partition_view.cc

@@ -25,6 +25,7 @@
 #include "db/serializer.hh"
 #include "utils/data_input.hh"
 #include "mutation_partition_serializer.hh"
+#include "mutation_partition.hh"
 
 //
 // See mutation_partition_serializer.cc for representation layout.

query-result.hh

@@ -25,6 +25,7 @@
 #include <cryptopp/md5.h>
 #include "bytes_ostream.hh"
 #include "query-request.hh"
+#include "db/serializer.hh"
 
 namespace query {
 
@@ -139,17 +140,16 @@ public:
         return result_digest(std::move(b));
     }
     sstring pretty_print(schema_ptr, const query::partition_slice&) const;
-    size_t serialized_size() const { return _w.size(); }
-    void serialize(bytes::iterator& out) {
-        auto v = _w.linearize();
-        out = std::copy(v.begin(), v.end(), out);
-    }
-    static result deserialize(bytes_view& in) {
-        bytes_ostream w;
-        w.write(in);
-        in.remove_prefix(in.size());
-        return result(std::move(w));
-    }
 };
 
 }
+
+namespace db {
+
+template<> serializer<query::result>::serializer(const query::result&);
+template<> void serializer<query::result>::write(output&, const query::result&);
+template<> query::result serializer<query::result>::read(input&);
+
+extern template class serializer<query::result>;
+
+}

query.cc

@@ -19,6 +19,7 @@
  * along with Scylla.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <limits>
 #include "db/serializer.hh"
 #include "query-request.hh"
 #include "query-result.hh"
@@ -270,3 +271,34 @@ result::pretty_print(schema_ptr s, const query::partition_slice& slice) const {
 }
 
 }
+
+template class db::serializer<query::result>;
+
+using query_result_size_type = uint32_t;
+
+template<>
+db::serializer<query::result>::serializer(const query::result& v)
+        : _item(v)
+        , _size(sizeof(query_result_size_type) + v.buf().size())
+{
+    static_assert(std::numeric_limits<bytes_ostream::size_type>::max() <=
+                  std::numeric_limits<query_result_size_type>::max(), "query_result_size_type too small");
+}
+
+template<>
+void
+db::serializer<query::result>::write(output& out, const query::result& v) {
+    const bytes_ostream& buf = v.buf();
+    out.write<query_result_size_type>(buf.size());
+    for (bytes_view frag : buf.fragments()) {
+        out.write(frag.begin(), frag.end());
+    }
+}
+
+template<>
+query::result db::serializer<query::result>::read(input& in) {
+    bytes_ostream buf;
+    auto size = in.read<query_result_size_type>();
+    buf.write(in.read_view(size));
+    return query::result(std::move(buf));
+}