table_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_TABLE_CRUD_H
#define MYSQLX_TABLE_CRUD_H
 
#include "common.h"
#include "result.h"
#include "executable.h"
#include "crud.h"
 
 
namespace mysqlx {
MYSQLX_ABI_BEGIN(2,0)
 
class Table;
 
// ---------------------------------------------------------------------------
 
class TableInsert;
 
namespace internal {
 
  struct Table_insert_base
    : public Executable<Result, TableInsert>
  {};
 
}
 
class TableInsert
  : public internal::Table_insert_base
  , internal::Table_insert_detail
{
 
protected:
 
  template <class... Cols>
  TableInsert(Table &table, const Cols&... cols)
    : TableInsert(table)
  {
    add_columns(get_impl(), cols...);
  }
 
public:
 
  // Create operation which inserts rows into given table.
 
  TableInsert(Table &table)
  {
    try {
      reset(internal::Crud_factory::mk_insert(table));
    }
    CATCH_AND_WRAP
  }
 
  TableInsert(const internal::Table_insert_base &other)
  {
    internal::Table_insert_base::operator=(other);
  }
 
  TableInsert(internal::Table_insert_base &&other)
  {
    internal::Table_insert_base::operator=(std::move(other));
  }
 
  using internal::Table_insert_base::operator=;
 
 
  virtual TableInsert& values(const Row &row)
  {
    try {
      add_rows(get_impl(), row);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  template<typename... Types>
  TableInsert& values(Types... rest)
  {
    try {
      add_values(get_impl(), rest...);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  template<typename Container>
  TableInsert& rows(const Container &cont)
  {
    try {
      add_rows(get_impl(), cont);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  template<typename It>
  TableInsert& rows(const It &begin, const It &end)
  {
    try {
      add_rows(get_impl(), begin, end);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  template<typename... Types>
  TableInsert& rows(const Row &first, Types... rest)
  {
    try {
      add_rows(get_impl(), first, rest...);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Table_insert_detail::Impl;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Table_insert_base::get_impl());
  }
 
  friend Table;
};
 
 
// ---------------------------------------------------------------------------
 
class TableSelect;
 
namespace internal {
 
  class Op_view_create_alter;
 
  struct Table_select_cmd
    : public Executable<RowResult, TableSelect>
  {};
 
  struct Table_select_base
    : public Group_by < Having < Order_by < Limit < Offset< Bind_parameters<
        Set_lock< Table_select_cmd, common::Table_select_if >
      > > > > > >
  {};
 
}
 
 
class TableSelect
  : public internal::Table_select_base
  , internal::Table_select_detail
{
 
  using Operation = Table_select_base;
 
public:
 
  TableSelect(Table &table)
  {
    try {
      reset(internal::Crud_factory::mk_select(table));
    }
    CATCH_AND_WRAP
  }
 
  template <typename...PROJ>
  TableSelect(Table &table, const PROJ&... proj)
    : TableSelect(table)
  {
    try {
      add_proj(get_impl(), proj...);
    }
    CATCH_AND_WRAP
  }
 
  TableSelect(const internal::Table_select_cmd &other)
  {
    internal::Table_select_cmd::operator=(other);
  }
 
  TableSelect(internal::Table_select_cmd &&other)
  {
    internal::Table_select_cmd::operator=(std::move(other));
  }
 
  using internal::Table_select_cmd::operator=;
 
  Operation& where(const string& expr)
  {
    try {
      get_impl()->set_where(expr);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Impl = common::Table_select_if;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Table_select_base::get_impl());
  }
 
  friend Table;
  friend internal::Op_view_create_alter;
};
 
 
// ---------------------------------------------------------------------------
 
class TableUpdate;
 
namespace internal {
 
  struct Table_update_cmd
    : public Executable<Result, TableUpdate>
  {};
 
  struct Table_update_base
    : public Order_by< Limit< Bind_parameters< Table_update_cmd > > >
  {};
 
}
 
 
class TableUpdate
  : public internal::Table_update_base
{
  using Operation = internal::Table_update_base;
 
  TableUpdate(Table& table)
  {
    try {
      reset(internal::Crud_factory::mk_update(table));
    }
    CATCH_AND_WRAP
  }
 
public:
 
  TableUpdate(Table &table, const string &expr)
    : TableUpdate(table)
  {
    where(expr);
  }
 
  TableUpdate(const internal::Table_update_cmd &other)
  {
    internal::Table_update_cmd::operator=(other);
  }
 
  TableUpdate(internal::Table_update_cmd &&other)
  {
    internal::Table_update_cmd::operator=(std::move(other));
  }
 
  using internal::Table_update_cmd::operator=;
 
  TableUpdate& set(const string& field, const Value &val)
  {
    try {
      get_impl()->add_set(field, (const common::Value&)val);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
  Operation& where(const string& expr)
  {
    try {
      get_impl()->set_where(expr);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Impl = common::Table_update_if;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Table_update_base::get_impl());
  }
 
  friend Table;
};
 
 
// ---------------------------------------------------------------------------
 
class TableRemove;
 
namespace internal {
 
  struct Table_remove_cmd
    : public Executable<Result, TableRemove>
  {};
 
  struct Table_remove_base
    : Order_by< Limit< Bind_parameters< Table_remove_cmd > > >
  {};
 
}
 
 
class TableRemove
  : public internal::Table_remove_base
{
  using Operation = internal::Table_remove_base;
 
  TableRemove(Table& table)
  {
    try {
      reset(internal::Crud_factory::mk_remove(table));
    }
    CATCH_AND_WRAP
  }
 
public:
 
  TableRemove(Table &table, const string &expr)
    : TableRemove(table)
  {
    where(expr);
  }
 
  TableRemove(const internal::Table_remove_cmd &other)
  {
    internal::Table_remove_cmd::operator=(other);
  }
 
  TableRemove(internal::Table_remove_cmd &&other)
  {
    internal::Table_remove_cmd::operator=(std::move(other));
  }
 
  using internal::Table_remove_cmd::operator=;
 
  Operation& where(const string &expr)
  {
    try {
      get_impl()->set_where(expr);
      return *this;
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using Impl = common::Table_remove_if;
 
  Impl* get_impl()
  {
    return static_cast<Impl*>(internal::Table_remove_base::get_impl());
  }
 
  friend Table;
};
 
 
MYSQLX_ABI_END(2,0)
}  // mysqlx
 
#endif