row.h

Go to the documentation of this file.

// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_ROW_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_ROW_H

#include "google/cloud/spanner/internal/tuple_utils.h"
#include "google/cloud/spanner/value.h"
#include "google/cloud/spanner/version.h"
#include "google/cloud/status.h"
#include "google/cloud/status_or.h"
#include <functional>
#include <iterator>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

namespace google {
namespace cloud {
namespace spanner {
inline namespace SPANNER_CLIENT_NS {

class Row;
namespace internal {
Row MakeRow(std::vector<Value>,
            std::shared_ptr<const std::vector<std::string>>);
}  // namespace internal

class Row {
 public:
  Row();

  Row(Row const&) = default;
  Row& operator=(Row const&) = default;
  Row(Row&&) = default;
  Row& operator=(Row&&) = default;

  std::size_t size() const { return columns_->size(); }

  std::vector<std::string> const& columns() const { return *columns_; }

  std::vector<Value> const& values() const& { return values_; }

  std::vector<Value>&& values() && { return std::move(values_); }

  StatusOr<Value> get(std::size_t pos) const;

  StatusOr<Value> get(std::string const& name) const;

  template <typename T, typename Arg>
  StatusOr<T> get(Arg&& arg) const {
    auto v = get(std::forward<Arg>(arg));
    if (v) return v->template get<T>();
    return v.status();
  }

  template <typename Tuple>
  StatusOr<Tuple> get() const& {
    if (size() != std::tuple_size<Tuple>::value) {
      auto const msg = "Tuple has the wrong number of elements";
      return Status(StatusCode::kInvalidArgument, msg);
    }
    Tuple tup;
    auto it = values_.begin();
    Status status;
    internal::ForEach(tup, ExtractValue{status}, it);
    if (!status.ok()) return status;
    return tup;
  }

  template <typename Tuple>
  StatusOr<Tuple> get() && {
    if (size() != std::tuple_size<Tuple>::value) {
      auto const msg = "Tuple has the wrong number of elements";
      return Status(StatusCode::kInvalidArgument, msg);
    }
    Tuple tup;
    auto it = std::make_move_iterator(values_.begin());
    Status status;
    internal::ForEach(tup, ExtractValue{status}, it);
    if (!status.ok()) return status;
    return tup;
  }

  friend bool operator==(Row const& a, Row const& b);
  friend bool operator!=(Row const& a, Row const& b) { return !(a == b); }

 private:
  friend Row internal::MakeRow(std::vector<Value>,
                               std::shared_ptr<const std::vector<std::string>>);
  struct ExtractValue {
    Status& status;
    template <typename T, typename It>
    void operator()(T& t, It& it) const {
      auto x = it++->template get<T>();
      if (!x) {
        status = std::move(x).status();
      } else {
        t = *std::move(x);
      }
    }
  };

  Row(std::vector<Value> values,
      std::shared_ptr<const std::vector<std::string>> columns);

  std::vector<Value> values_;
  std::shared_ptr<const std::vector<std::string>> columns_;
};

Row MakeTestRow(std::vector<std::pair<std::string, Value>> pairs);

template <typename... Ts>
Row MakeTestRow(Ts&&... ts) {
  auto columns = std::make_shared<std::vector<std::string>>();
  for (std::size_t i = 0; i < sizeof...(ts); ++i) {
    columns->emplace_back(std::to_string(i));
  }
  std::vector<Value> v{Value(std::forward<Ts>(ts))...};
  return internal::MakeRow(std::move(v), std::move(columns));
}

class RowStreamIterator {
 public:
  using Source = std::function<StatusOr<Row>()>;

  using iterator_category = std::input_iterator_tag;
  using value_type = StatusOr<Row>;
  using difference_type = std::ptrdiff_t;
  using pointer = value_type*;
  using reference = value_type&;
  using const_pointer = value_type const*;
  using const_reference = value_type const&;

  RowStreamIterator();

  explicit RowStreamIterator(Source source);

  reference operator*() { return row_; }
  pointer operator->() { return &row_; }

  const_reference operator*() const { return row_; }
  const_pointer operator->() const { return &row_; }

  RowStreamIterator& operator++();
  RowStreamIterator operator++(int);

  friend bool operator==(RowStreamIterator const&, RowStreamIterator const&);
  friend bool operator!=(RowStreamIterator const&, RowStreamIterator const&);

 private:
  value_type row_;
  Source source_;  // nullptr means "end"
};

template <typename Tuple>
class TupleStreamIterator {
 public:
  using iterator_category = std::input_iterator_tag;
  using value_type = StatusOr<Tuple>;
  using difference_type = std::ptrdiff_t;
  using pointer = value_type*;
  using reference = value_type&;
  using const_pointer = value_type const*;
  using const_reference = value_type const&;

  TupleStreamIterator() = default;

  TupleStreamIterator(RowStreamIterator begin, RowStreamIterator end)
      : it_(std::move(begin)), end_(std::move(end)) {
    ParseTuple();
  }

  reference operator*() { return tup_; }
  pointer operator->() { return &tup_; }

  const_reference operator*() const { return tup_; }
  const_pointer operator->() const { return &tup_; }

  TupleStreamIterator& operator++() {
    if (!tup_) {
      it_ = end_;
      return *this;
    }
    ++it_;
    ParseTuple();
    return *this;
  }

  TupleStreamIterator operator++(int) {
    auto const old = *this;
    ++*this;
    return old;
  }

  friend bool operator==(TupleStreamIterator const& a,
                         TupleStreamIterator const& b) {
    return a.it_ == b.it_;
  }

  friend bool operator!=(TupleStreamIterator const& a,
                         TupleStreamIterator const& b) {
    return !(a == b);
  }

 private:
  void ParseTuple() {
    if (it_ == end_) return;
    tup_ = *it_ ? std::move(*it_)->template get<Tuple>() : it_->status();
  }

  value_type tup_;
  RowStreamIterator it_;
  RowStreamIterator end_;
};

template <typename Tuple>
class TupleStream {
 public:
  using iterator = TupleStreamIterator<Tuple>;
  static_assert(internal::IsTuple<Tuple>::value,
                "TupleStream<T> requires a std::tuple parameter");

  iterator begin() const { return begin_; }
  iterator end() const { return end_; }

 private:
  template <typename T, typename RowRange>
  friend TupleStream<T> StreamOf(RowRange&& range);

  template <typename It>
  explicit TupleStream(It&& start, It&& end)
      : begin_(std::forward<It>(start), std::forward<It>(end)) {}

  iterator begin_;
  iterator end_;
};

template <typename Tuple, typename RowRange>
TupleStream<Tuple> StreamOf(RowRange&& range) {
  static_assert(std::is_lvalue_reference<decltype(range)>::value,
                "range must be an lvalue since it must outlive StreamOf");
  return TupleStream<Tuple>(std::begin(std::forward<RowRange>(range)),
                            std::end(std::forward<RowRange>(range)));
}

template <typename RowRange>
auto GetSingularRow(RowRange&& range) -> typename std::decay<
    decltype(*std::forward<RowRange>(range).begin())>::type {
  auto const e = std::forward<RowRange>(range).end();
  auto it = std::forward<RowRange>(range).begin();
  if (it == e) return Status(StatusCode::kInvalidArgument, "no rows");
  auto row = std::move(*it);
  if (++it != e) return Status(StatusCode::kInvalidArgument, "too many rows");
  return row;
}

}  // namespace SPANNER_CLIENT_NS
}  // namespace spanner
}  // namespace cloud
}  // namespace google

#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_ROW_H