mutations.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_MUTATIONS_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_MUTATIONS_H

#include "google/cloud/spanner/keys.h"
#include "google/cloud/spanner/value.h"
#include <google/spanner/v1/mutation.pb.h>
#include <vector>

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

namespace internal {
template <typename Op>
class WriteMutationBuilder;
class DeleteMutationBuilder;
}  // namespace internal

class Mutation {
 public:
  Mutation() = default;

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

  friend bool operator==(Mutation const& lhs, Mutation const& rhs);
  friend bool operator!=(Mutation const& lhs, Mutation const& rhs) {
    return !(lhs == rhs);
  }

  google::spanner::v1::Mutation as_proto() && { return std::move(m_); }
  google::spanner::v1::Mutation as_proto() const& { return m_; }

  friend void PrintTo(Mutation const& m, std::ostream* os);

 private:
  google::spanner::v1::Mutation& proto() & { return m_; }

  template <typename Op>
  friend class internal::WriteMutationBuilder;
  friend class internal::DeleteMutationBuilder;
  explicit Mutation(google::spanner::v1::Mutation m) : m_(std::move(m)) {}

  google::spanner::v1::Mutation m_;
};

using Mutations = std::vector<Mutation>;

// This namespace contains implementation details. It is not part of the public
// API, and subject to change without notice.
namespace internal {

template <typename Op>
class WriteMutationBuilder {
 public:
  WriteMutationBuilder(std::string table_name,
                       std::vector<std::string> column_names) {
    auto& field = Op::mutable_field(m_.proto());
    field.set_table(std::move(table_name));
    field.mutable_columns()->Reserve(static_cast<int>(column_names.size()));
    for (auto& name : column_names) {
      field.add_columns(std::move(name));
    }
  }

  Mutation Build() const& { return m_; }
  Mutation&& Build() && { return std::move(m_); }

  WriteMutationBuilder& AddRow(std::vector<Value> values) & {
    auto& lv = *Op::mutable_field(m_.proto()).add_values();
    for (auto& v : values) {
      std::tie(std::ignore, *lv.add_values()) = internal::ToProto(std::move(v));
    }
    return *this;
  }

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

  template <typename... Ts>
  WriteMutationBuilder& EmplaceRow(Ts&&... values) & {
    return AddRow({Value(std::forward<Ts>(values))...});
  }

  template <typename... Ts>
  WriteMutationBuilder&& EmplaceRow(Ts&&... values) && {
    return std::move(EmplaceRow(std::forward<Ts>(values)...));
  }

 private:
  Mutation m_;
};

struct InsertOp {
  static google::spanner::v1::Mutation::Write& mutable_field(
      google::spanner::v1::Mutation& m) {
    return *m.mutable_insert();
  }
};

struct UpdateOp {
  static google::spanner::v1::Mutation::Write& mutable_field(
      google::spanner::v1::Mutation& m) {
    return *m.mutable_update();
  }
};

struct InsertOrUpdateOp {
  static google::spanner::v1::Mutation::Write& mutable_field(
      google::spanner::v1::Mutation& m) {
    return *m.mutable_insert_or_update();
  }
};

struct ReplaceOp {
  static google::spanner::v1::Mutation::Write& mutable_field(
      google::spanner::v1::Mutation& m) {
    return *m.mutable_replace();
  }
};

class DeleteMutationBuilder {
 public:
  DeleteMutationBuilder(std::string table_name, KeySet keys) {
    auto& field = *m_.proto().mutable_delete_();
    field.set_table(std::move(table_name));
    *field.mutable_key_set() = internal::ToProto(std::move(keys));
  }

  Mutation Build() const& { return m_; }
  Mutation&& Build() && { return std::move(m_); }

 private:
  Mutation m_;
};

}  // namespace internal

using InsertMutationBuilder =
    internal::WriteMutationBuilder<internal::InsertOp>;

template <typename... Ts>
Mutation MakeInsertMutation(std::string table_name,
                            std::vector<std::string> columns, Ts&&... values) {
  return InsertMutationBuilder(std::move(table_name), std::move(columns))
      .EmplaceRow(std::forward<Ts>(values)...)
      .Build();
}

using UpdateMutationBuilder =
    internal::WriteMutationBuilder<internal::UpdateOp>;

template <typename... Ts>
Mutation MakeUpdateMutation(std::string table_name,
                            std::vector<std::string> columns, Ts&&... values) {
  return UpdateMutationBuilder(std::move(table_name), std::move(columns))
      .EmplaceRow(std::forward<Ts>(values)...)
      .Build();
}

using InsertOrUpdateMutationBuilder =
    internal::WriteMutationBuilder<internal::InsertOrUpdateOp>;

template <typename... Ts>
Mutation MakeInsertOrUpdateMutation(std::string table_name,
                                    std::vector<std::string> columns,
                                    Ts&&... values) {
  return InsertOrUpdateMutationBuilder(std::move(table_name),
                                       std::move(columns))
      .EmplaceRow(std::forward<Ts>(values)...)
      .Build();
}

using ReplaceMutationBuilder =
    internal::WriteMutationBuilder<internal::ReplaceOp>;

template <typename... Ts>
Mutation MakeReplaceMutation(std::string table_name,
                             std::vector<std::string> columns, Ts&&... values) {
  return ReplaceMutationBuilder(std::move(table_name), std::move(columns))
      .EmplaceRow(std::forward<Ts>(values)...)
      .Build();
}

using DeleteMutationBuilder = internal::DeleteMutationBuilder;

inline Mutation MakeDeleteMutation(std::string table_name, KeySet keys) {
  return DeleteMutationBuilder(std::move(table_name), std::move(keys)).Build();
}

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

#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_MUTATIONS_H