collection_crud.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
#ifndef MYSQLX_COLLECTION_CRUD_H
#define MYSQLX_COLLECTION_CRUD_H
 
#include "common.h"
#include "result.h"
#include "executable.h"
#include "crud.h"
 
 
namespace mysqlx {
MYSQLX_ABI_BEGIN(2,0)
 
class Session;
class Collection;
class Table;
 
template<>
PUBLIC_API common::Value Value::get<common::Value>() const;
 
// ----------------------------------------------------------------------
 
/*
  Adding documents to a collection
  ================================
*/
 
class CollectionAdd;
 
namespace internal {
 
/*
  Note: using empty class instead of alias/typedef to help Doxygen correctly
  expand templates.
*/
 
struct Collection_add_base
  : public Executable<Result, CollectionAdd>
{};
 
}
 
 
class CollectionAdd
  : public internal::Collection_add_base
  , internal::Collection_add_detail
{
public:
 
  CollectionAdd(Collection &coll)
  {
    try {
      reset(internal::Crud_factory::mk_add(coll));
    }
    CATCH_AND_WRAP
  }
 
  CollectionAdd(const internal::Collection_add_base &other)
  {
    internal::Collection_add_base::operator=(other);
  }
 
  CollectionAdd(internal::Collection_add_base &&other)
  {
    internal::Collection_add_base::operator=(std::move(other));
  }
 
  using internal::Collection_add_base::operator=;
 
 
  template <typename It>
  CollectionAdd& add(const It &begin, const It &end)
  {
    try {
      do_add(get_impl(), begin, end);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  template <class Container>
  CollectionAdd& add(const Container &c)
  {
    try {
      do_add(get_impl(), c);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  template <typename... Types>
  CollectionAdd& add(const Types&... docs)
  {
    try {
      do_add(get_impl(), docs...);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Impl = common::Collection_add_if;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Collection_add_base::get_impl());
  }
 
};
 
 
// ----------------------------------------------------------------------
 
 
/*
  Removing documents from a collection
  ====================================
*/
 
class CollectionRemove;
 
namespace internal {
 
struct Collection_remove_cmd
  : public Executable<Result, CollectionRemove>
{};
 
struct Collection_remove_base
  : public Sort< Limit< Bind_parameters< Collection_remove_cmd > > >
{};
 
}  // internal namespace
 
 
class CollectionRemove
  : public internal::Collection_remove_base
{
 
public:
 
  CollectionRemove(Collection &coll, const string &expr)
  {
    try {
      reset(internal::Crud_factory::mk_remove(coll, expr));
    }
    CATCH_AND_WRAP
  }
 
 
  CollectionRemove(const internal::Collection_remove_cmd &other)
  {
    internal::Collection_remove_cmd::operator=(other);
  }
 
  CollectionRemove(internal::Collection_remove_cmd &&other)
  {
    internal::Collection_remove_cmd::operator=(std::move(other));
  }
 
  using internal::Collection_remove_cmd::operator=;
 
};
 
 
// ----------------------------------------------------------------------
 
/*
  Searching for documents in a collection
  =======================================
*/
 
class CollectionFind;
 
namespace internal {
 
struct Collection_find_cmd
  : public Executable<DocResult, CollectionFind>
{};
 
struct Collection_find_base
  : public Group_by< Having< Sort< Limit< Offset< Bind_parameters<
      Set_lock< Collection_find_cmd, common::Collection_find_if >
    > > > > > >
{};
 
}  // internal namespace
 
 
class CollectionFind
  : public internal::Collection_find_base
  , internal::Collection_find_detail
{
 
  using Operation = internal::Collection_find_base;
 
public:
 
  CollectionFind(Collection &coll)
  {
    try {
      reset(internal::Crud_factory::mk_find(coll));
    }
    CATCH_AND_WRAP
  }
 
  CollectionFind(Collection &coll, const string &expr)
  {
    try {
      reset(internal::Crud_factory::mk_find(coll, expr));
    }
    CATCH_AND_WRAP
  }
 
 
  CollectionFind(const internal::Collection_find_cmd &other)
  {
    internal::Collection_find_cmd::operator=(other);
  }
 
  CollectionFind(internal::Collection_find_cmd &&other)
  {
    internal::Collection_find_cmd::operator=(std::move(other));
  }
 
  using internal::Collection_find_cmd::operator=;
 
 
public:
 
  template <typename... Expr>
  Operation& fields(Expr... proj)
  {
    try {
      get_impl()->clear_proj();
      do_fields(get_impl(), proj...);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Impl = common::Collection_find_if;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Collection_find_base::get_impl());
  }
 
};
 
 
// ----------------------------------------------------------------------
 
/*
  Modifying documents in a collection
  ===================================
*/
 
class CollectionModify;
 
 
namespace internal {
 
class CollectionReplace;
 
struct Collection_modify_cmd
  : public Executable<Result, CollectionModify>
{};
 
struct Collection_modify_base
  : public Sort< Limit< Bind_parameters< Collection_modify_cmd > > >
{};
 
}  // internal namespace
 
 
class CollectionModify
  : public internal::Collection_modify_base
{
 
public:
 
  CollectionModify(Collection &coll, const string &expr)
  {
    try {
      reset(internal::Crud_factory::mk_modify(coll, expr));
    }
    CATCH_AND_WRAP
  }
 
 
  CollectionModify(const internal::Collection_modify_cmd &other)
  {
    internal::Collection_modify_cmd::operator=(other);
  }
 
  CollectionModify(internal::Collection_modify_cmd &&other)
  {
    internal::Collection_modify_cmd::operator=(std::move(other));
  }
 
  using internal::Collection_modify_cmd::operator=;
 
  CollectionModify& set(const Field &field, const Value &val)
  {
    try {
      get_impl()->add_operation(Impl::SET, field,
                                val.get<common::Value>());
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  CollectionModify& unset(const Field &field)
  {
    try {
      get_impl()->add_operation(Impl::UNSET, field);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  CollectionModify& arrayInsert(const Field &field, const Value &val)
  {
    try {
      get_impl()->add_operation(Impl::ARRAY_INSERT, field,
                                val.get<common::Value>());
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  CollectionModify& arrayAppend(const Field &field, const Value &val)
  {
    try {
      get_impl()->add_operation(Impl::ARRAY_APPEND, field,
                                val.get<common::Value>());
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  CollectionModify& patch(const string &val)
  {
    try {
      get_impl()->add_operation(
        Impl::MERGE_PATCH, "$", (const common::Value&)expr(val)
      );
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Impl = common::Collection_modify_if;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Collection_modify_base::get_impl());
  }
 
};
 
MYSQLX_ABI_END(2,0)
}  // mysqlx namespace
 
#endif