Performance improvement in Decoder::decode_value (#505)

* - decode_row() performance improvement
* - reduce branching


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

Author: zakalibit

src/collection_iterator.cpp

@@ -35,13 +35,16 @@ bool CollectionIterator::decode_value() {
     data_type = collection_->primary_data_type();
   }
 
-  return decoder_.decode_value(data_type, value_, true);
+  value_ = decoder_.decode_value(data_type);
+  return value_.is_valid();
 }
 
 bool TupleIterator::next() {
   if (next_ == end_) {
     return false;
   }
   current_ = next_++;
-  return decoder_.decode_value(*current_, value_);
+
+  value_ = decoder_.decode_value(*current_);
+  return value_.is_valid();
 }

src/decoder.cpp

@@ -138,33 +138,22 @@ bool Decoder::decode_warnings(WarningVec& output) {
   return true;
 }
 
-bool Decoder::decode_value(const DataType::ConstPtr& data_type, Value& output,
-                           bool is_inside_collection /*= false*/) {
-  const char* buffer = NULL;
+Value Decoder::decode_value(const DataType::ConstPtr& data_type) {
   int32_t size = 0;
-
-  if (!decode_int32(size)) {
-    return false;
-  }
+  if (!decode_int32(size)) return Value();
 
   if (size >= 0) {
-    buffer = input_;
+    Decoder decoder(input_, size, protocol_version_);
     input_ += size;
     remaining_ -= size;
-    Decoder decoder(buffer, size, protocol_version_);
-
-    if (data_type->is_collection()) {
-      int32_t count;
-      if (!decoder.decode_int32(count)) return false;
-      output = Value(data_type, count, decoder);
-    } else {
-      output = Value(data_type, decoder);
+
+    int32_t count = 0;
+    if (data_type->is_collection() && !decoder.decode_int32(count)) {
+      return Value();
     }
-  } else { // null value
-    output = Value(data_type);
+    return Value(data_type, count, decoder);
   }
-
-  return true;
+  return Value(data_type);
 }
 
 void Decoder::notify_error(const char* detail, size_t bytes) const {

src/decoder.hpp

@@ -558,8 +558,7 @@ class Decoder {
   bool decode_write_type(CassWriteType& output);
   bool decode_warnings(WarningVec& output);
 
-  bool decode_value(const DataType::ConstPtr& data_type, Value& output,
-                    bool is_inside_collection = false);
+  Value decode_value(const DataType::ConstPtr& data_type);
 
 protected:
   // Testing only

src/map_iterator.cpp

@@ -19,8 +19,12 @@
 using namespace datastax::internal::core;
 
 bool MapIterator::decode_pair() {
-  if (!decoder_.decode_value(map_->primary_data_type(), key_, true)) return false;
-  return decoder_.decode_value(map_->secondary_data_type(), value_, true);
+  key_ = decoder_.decode_value(map_->primary_data_type());
+  if (key_.data_type()) {
+    value_ = decoder_.decode_value(map_->secondary_data_type());
+    return value_.is_valid();
+  }
+  return false;
 }
 
 bool MapIterator::next() {

src/row.cpp

@@ -51,14 +51,19 @@ namespace datastax { namespace internal { namespace core {
 
 bool decode_row(Decoder& decoder, const ResultResponse* result, OutputValueVec& output) {
   output.clear();
-  output.reserve(result->column_count());
-  for (int i = 0; i < result->column_count(); ++i) {
-    Value value;
-    const ColumnDefinition& def = result->metadata()->get_column_definition(i);
-    CHECK_RESULT(decoder.decode_value(def.data_type, value));
-    output.push_back(value);
+  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;
+    }
   }
-
   return true;
 }
 

src/user_type_field_iterator.cpp

@@ -25,5 +25,6 @@ bool UserTypeFieldIterator::next() {
     return false;
   }
   current_ = next_++;
-  return decoder_.decode_value(current_->type, value_);
+  value_ = decoder_.decode_value(current_->type);
+  return value_.is_valid();
 }

src/value.hpp

@@ -51,6 +51,8 @@ class Value {
   ProtocolVersion protocol_version() const { return decoder_.protocol_version(); }
   int64_t size() const { return (is_null_ ? -1 : decoder_.remaining()); }
 
+  bool is_valid() const { return !!data_type_; }
+
   CassValueType value_type() const {
     if (!data_type_) {
       return CASS_VALUE_TYPE_UNKNOWN;