Row values decoding performance optimisation (#510)

* - optimise row decoding, just update decoder for every column

* - fix null rows decoding

* - a bit of code cleanup

* - remove semicolon

* - apply formatting

* - reduce branching

* - fix typo

* - address review comment, handle tuple & udt cases

* - fix typos

* - add new line to trigger CI

Co-authored-by: Alex Revetchi <alex.revetchi@synchronoss.com>

Author: zakalibit

src/decoder.cpp

@@ -158,6 +158,21 @@ Value Decoder::decode_value(const DataType::ConstPtr& data_type) {
   return Value(data_type);
 }
 
+bool Decoder::update_value(Value& value) {
+  int32_t size = 0;
+  if (decode_int32(size)) {
+    if (size >= 0) {
+      Decoder decoder(input_, size, protocol_version_);
+      input_ += size;
+      remaining_ -= size;
+      return value.update(decoder);
+    }
+    Decoder decoder;
+    return value.update(decoder);
+  }
+  return false;
+}
+
 void Decoder::notify_error(const char* detail, size_t bytes) const {
   if (strlen(type_) == 0) {
     LOG_ERROR("Expected at least %u byte%s to decode %s value", static_cast<unsigned int>(bytes),

src/decoder.hpp

@@ -559,6 +559,9 @@ class Decoder {
   bool decode_warnings(WarningVec& output);
 
   Value decode_value(const DataType::ConstPtr& data_type);
+  bool update_value(Value& value);
+
+  bool is_null() const { return input_ == NULL; }
 
 protected:
   // Testing only

src/result_iterator.hpp

@@ -31,30 +31,17 @@ class ResultIterator : public Iterator {
       , index_(-1)
       , row_(result) {
     decoder_ = (const_cast<ResultResponse*>(result))->row_decoder();
-    row_.values.reserve(result->column_count());
+    row_.values = result_->first_row().values;
   }
 
   virtual bool next() {
-    if (index_ + 1 >= result_->row_count()) {
-      return false;
-    }
-
-    ++index_;
-
-    if (index_ > 0) {
-      return decode_row(decoder_, result_, row_.values);
-    }
-
-    return true;
+    return (index_ + 1 < result_->row_count()) &&
+           (++index_ < 1 || decode_next_row(decoder_, row_.values));
   }
 
   const Row* row() const {
     assert(index_ >= 0 && index_ < result_->row_count());
-    if (index_ > 0) {
-      return &row_;
-    } else {
-      return &result_->first_row();
-    }
+    return &row_;
   }
 
 private:

src/row.cpp

@@ -51,18 +51,21 @@ namespace datastax { namespace internal { namespace core {
 
 bool decode_row(Decoder& decoder, const ResultResponse* result, OutputValueVec& output) {
   output.clear();
-  const int column_count = result->column_count();
-  if (column_count > 0) {
-    output.reserve(column_count);
-    const SharedRefPtr<ResultMetadata>& metadata = result->metadata();
-    for (int i = 0; i < column_count; ++i) {
-      const ColumnDefinition& def = metadata->get_column_definition(i);
-      Value value = decoder.decode_value(def.data_type);
-      if (value.is_valid()) {
-        output.push_back(value);
-      } else
-        return false;
-    }
+  for (int i = 0; i < result->column_count(); ++i) {
+    const ColumnDefinition& def = result->metadata()->get_column_definition(i);
+    Value value = decoder.decode_value(def.data_type);
+    if (value.is_valid()) {
+      output.push_back(value);
+    } else
+      return false;
+  }
+  return true;
+}
+
+bool decode_next_row(Decoder& decoder, OutputValueVec& output) {
+  const size_t column_count = output.size();
+  for (size_t i = 0; i < column_count; ++i) {
+    if (!decoder.update_value(output[i])) return false;
   }
   return true;
 }

src/row.hpp

@@ -51,6 +51,7 @@ class Row {
 };
 
 bool decode_row(Decoder& decoder, const ResultResponse* result, OutputValueVec& output);
+bool decode_next_row(Decoder& decoder, OutputValueVec& output);
 
 }}} // namespace datastax::internal::core
 

src/value.cpp

@@ -209,6 +209,26 @@ Value::Value(const DataType::ConstPtr& data_type, Decoder decoder)
   }
 }
 
+bool Value::update(const Decoder& decoder) {
+  decoder_ = decoder;
+  if (!decoder_.is_null()) {
+    if (data_type_->is_collection()) {
+      return decoder_.decode_int32(count_);
+    } else if (data_type_->is_tuple()) {
+      const CompositeType& composite_type = static_cast<const CompositeType&>(*data_type_);
+      count_ = composite_type.types().size();
+    } else if (data_type_->is_user_type()) {
+      const UserType& user_type = static_cast<const UserType&>(*data_type_);
+      count_ = user_type.fields().size();
+    }
+  } else {
+    count_ = 0;
+    is_null_ = true;
+  }
+
+  return true;
+}
+
 bool Value::as_bool() const {
   assert(!is_null() && value_type() == CASS_VALUE_TYPE_BOOLEAN);
   bool value = false;

src/value.hpp

@@ -136,6 +136,10 @@ class Value {
   CassUuid as_uuid() const;
   StringVec as_stringlist() const;
 
+private:
+  friend class Decoder;
+  bool update(const Decoder& decoder);
+
 private:
   DataType::ConstPtr data_type_;
   int32_t count_;