xdevapi.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 MYSQL_DEVAPI_H
#define MYSQL_DEVAPI_H
 
#ifndef __cplusplus
#error This header can be only used with C++ code
#endif
 
/*
  X DevAPI public classes are declared in this and other headers included from
  devapi/ folder. The main public API classes, such as Session below, contain
  declarations of public interface methods. Any obscure details of the public
  API, which must be defined in the public header, are factored out
  to Session_detail class from which the main Session class inherits.
  Among other things, Session_detail declares the implementation class for
  Session. This implementation class is opaque and its details are not defined
  in the public headers - only in the implementation part. Definitions of
  XXX_detail classes can be found in devapi/detail/ sub-folder.
*/
 
#include "devapi/common.h"
#include "devapi/result.h"
#include "devapi/collection_crud.h"
#include "devapi/table_crud.h"
#include "devapi/settings.h"
#include "devapi/detail/session.h"
 
namespace mysqlx {
MYSQLX_ABI_BEGIN(2,0)
 
class Session;
 
namespace internal {
 
template <class Base> class Sch_object;
 
}  // internal
 
 
 
class CollectionOptions;
 
class CollectionValidation
{
public:
 
#define COLLECTION_VALIDATION_ENUM(x,y) x=y,
 
 
  enum Level
  {
    COLLECTION_VALIDATION_LEVEL(COLLECTION_VALIDATION_ENUM)
  };
 
 
  enum Option
  {
    COLLECTION_VALIDATION_OPTION(COLLECTION_VALIDATION_ENUM)
    LAST
  };
 
private:
 
  struct Data
  {
    std::string validation_level;
    DbDoc validation_schema;
    std::bitset<LAST> used;
  };
 
public:
 
  CollectionValidation()
  {}
 
  CollectionValidation(const char* json_doc)
    : CollectionValidation(DbDoc(json_doc))
  {}
 
  CollectionValidation(DbDoc doc)
  {
    for(auto el : doc)
    {
      if(el == "level")
      {
        try {
          _set(LEVEL, doc[el].get<std::string>());
        } catch (const Error& e)
        {
          std::string err("Unexpected level type: ");
          err+=e.what();
          throw Error(err.c_str());
        }
      }
      else if(el == "schema")
      {
        _set(SCHEMA,doc[el].get<DbDoc>());
      }
      else {
        std::string err("Unexpected schema validation field ");
        err+=el;
        throw Error(err.c_str());
      }
    }
  }
 
  template<typename... Rest>
  CollectionValidation(Option opt, Rest&&... rest)
  {
    set(opt, std::forward<Rest>(rest)...);
  }
 
  template<typename... Rest>
  void set(Rest&&... options)
  {
    Data tmp_data(m_data);
    try {
      _set(std::forward<Rest>(options)...);
    } catch (...) {
      m_data = tmp_data;
      throw;
    }
  }
 
protected:
 
  // Note: Doxygen gets confused here and renders docs incorrectly.
  template<typename T,typename... Rest>
  void _set(Option opt, T&& v, Rest&&... options)
  {
#define SCHEMA_VALIDATION_SET(x,y) case CollectionValidation::x:\
    do_set<CollectionValidation::x>(std::forward<T>(v)); break;
 
    switch (opt)
    {
      COLLECTION_VALIDATION_OPTION(SCHEMA_VALIDATION_SET)
      case CollectionValidation::LAST: throw_error("Invalid option."); ; break;
    }
 
    _set(std::forward<Rest>(options)...);
  }
 
  void _set() {}
 
  template<CollectionValidation::Option, typename T>
  void do_set(T)
  {
    throw_error("Invalid option value type.");
  }
 
  Data m_data;
 
  friend CollectionOptions;
  friend Schema;
  friend mysqlx::internal::Schema_detail;
};
 
 
class CollectionOptions
{
  public:
 
#define COLLECTION_OPTIONS_ENUM(x,y) x=y,
 
  enum Option
  {
    COLLECTION_OPTIONS_OPTION(COLLECTION_OPTIONS_ENUM)
    LAST
  };
 
private:
 
  struct Data{
    CollectionValidation validation;
    std::bitset<LAST> used;
    bool reuse = false;
  };
 
  public:
 
 
  CollectionOptions()
  {}
 
  CollectionOptions(const char* options)
    : CollectionOptions(DbDoc(options))
  {}
 
  CollectionOptions(const std::string& options)
    : CollectionOptions(DbDoc(options))
  {}
 
  CollectionOptions(DbDoc options)
  {
    for(auto el : options)
    {
      if(el == "reuseExisting")
      {
        try {
          _set(REUSE, options["reuseExisting"].get<bool>());
        } catch (const Error& e)
        {
          std::string err("Wrong value for reuseExisting option: ");
          err+=e.what();
          throw Error(err.c_str());
        }
      }
      else if(el == "validation")
      {
        _set(VALIDATION, CollectionValidation(options["validation"].get<DbDoc>()));
      }
      else {
        std::string err("Unexpected collection option ");
        err+=el;
        throw Error(err.c_str());
      }
    }
  }
 
  CollectionOptions(CollectionValidation validation)
  {
    set(VALIDATION, validation);
  }
 
  template<typename... Rest>
  CollectionOptions(Option opt, Rest&&... rest)
  {
   set(opt, std::forward<Rest>(rest)...);
  }
 
 
  template<typename... Rest>
  CollectionOptions(CollectionValidation::Option opt, Rest&&... rest)
  {
   set(opt, std::forward<Rest>(rest)...);
  }
 
 
  template<typename... Rest>
  void set(Rest&&... rest)
  {
    Data tmp_data(m_data);
    try {
      _set(std::forward<Rest>(rest)...);
    } catch (...) {
      m_data = std::move(tmp_data);
      throw;
    }
  }
 
 
 
protected:
 
  // Note: Doxygen gets confused here and renders docs incorrectly.
  template<typename T,typename... Rest>
  void _set(Option opt, T&& v, Rest&&... rest)
  {
#define COLLECTION_OPTIONS_SET(x,y) case x:\
    do_set<x>(std::forward<T>(v)); break;
 
    switch (opt)
    {
      COLLECTION_OPTIONS_OPTION(COLLECTION_OPTIONS_SET)
      case LAST: throw_error("Invalid option."); ; break;
    }
 
    _set(std::forward<Rest>(rest)...);
  }
 
  template<typename T,typename... Rest>
  void _set(CollectionValidation::Option opt, T&& v, Rest&&... rest)
  {
    m_data.validation._set(opt, std::forward<T>(v));
    _set(std::forward<Rest>(rest)...);
  }
 
  void _set(){}
 
  template<CollectionOptions::Option O,typename T>
  void do_set(T)
  {
    throw_error("Invalid option value type.");
  }
 
  Data m_data;
 
  friend mysqlx::internal::Schema_detail;
};
 
 
class Schema
  : protected internal::Schema_detail
{
  Session *m_sess;
 
public:
 
  Schema(Session &sess, const string &name);
 
  Schema(Session&);
 
 
  const string& getName() const
  {
    return m_name;
  }
 
  Session& getSession()
  {
    return *m_sess;
  }
 
  const Session& getSession() const
  {
    return const_cast<Schema*>(this)->getSession();
  }
 
  bool existsInDatabase() const
  {
    try {
      /*
        Note: We get from server a list of schemata filtered by the name of
        this schema - if the schema exists the list should not be empty.
      */
      internal::Session_detail::Name_src list(*m_sess, m_name);
      list.iterator_start();
      return list.iterator_next();
    }
    CATCH_AND_WRAP
  }
 
 
  Collection createCollection(const string &name);
  Collection createCollection(const string &name, bool);
 
  template<typename... Rest>
  Collection createCollection(const string &name,
                              Rest&&... rest);
 
  template<typename... Rest>
  void modifyCollection(const string &name, Rest&&... options);
 
 
  Collection getCollection(const string &name, bool check_exists = false);
 
  Table getTable(const string &name, bool check_exists = false);
 
  CollectionList getCollections()
  {
    try {
      return Collection_src(*this, "%");
    }
    CATCH_AND_WRAP
  }
 
  StringList getCollectionNames()
  {
    try {
      return Name_src(*this, COLLECTION, "%");
    }
    CATCH_AND_WRAP
  }
 
  TableList getTables()
  {
    try {
      return Table_src(*this, "%");
    }
    CATCH_AND_WRAP
  }
 
  StringList getTableNames()
  {
    try {
      return Name_src(*this, TABLE, "%");
    }
    CATCH_AND_WRAP
  }
 
  Table getCollectionAsTable(const string &name, bool check_exists = true);
 
 
  void dropCollection(const mysqlx::string& name)
  {
    try {
      Schema_detail::drop_collection(name);
    }
    CATCH_AND_WRAP
  }
 
 
  friend Collection;
  friend Table;
 
  friend internal::Schema_detail::Name_src;
  template <class Base> friend class internal::Sch_object;
};
 
 
/*
  Database objects that belong to some schema
  ===========================================
*/
 
 
namespace internal {
 
// Common base for schema objects defining the common API methods.
 
template <class Base = Db_obj_base>
class Sch_object
  : public Base
{
protected:
 
  Schema m_schema;
 
  Sch_object(const Schema &sch, const string &name);
 
public:
 
  using string = mysqlx::string;
 
  const string& getName() const
  {
    return Base::m_name;
  }
 
  Session& getSession()
  {
    return m_schema.getSession();
  }
 
  const Schema& getSchema() const
  {
    return m_schema;
  }
 
protected:
 
  std::shared_ptr<common::Session_impl> get_session();
 
  Schema_detail& get_schema()
  {
    return m_schema;
  }
};
 
}  // internal
 
 
 
 
 
 
 
class Collection
  : protected internal::Sch_object<internal::Collection_detail>
{
public:
 
  Collection(const Schema &sch, const string &name)
  try
    : Sch_object(sch, name)
  {}
  CATCH_AND_WRAP
 
 
  using Sch_object::getName;
  using Sch_object::getSession;
  using Sch_object::getSchema;
 
  bool existsInDatabase() const
  {
    try {
      Schema::StringList list(m_schema, Schema::COLLECTION, m_name);
      return list.begin() != list.end();
    }
    CATCH_AND_WRAP
  }
 
  uint64_t count();
 
  /*
    CRUD operations on a collection
    -------------------------------
  */
 
  CollectionFind find()
  {
    try {
      return CollectionFind(*this);
    }
    CATCH_AND_WRAP;
  }
 
  CollectionFind find(const string &cond)
  {
    try {
      return CollectionFind(*this, cond);
    }
    CATCH_AND_WRAP;
  }
 
  template <typename... Types>
  CollectionAdd add(Types... args)
  {
    try {
 
      CollectionAdd add(*this);
      return add.add(args...);
    }
    CATCH_AND_WRAP;
  }
 
  CollectionRemove remove(const string &cond)
  {
    try {
      return CollectionRemove(*this, cond);
    }
    CATCH_AND_WRAP;
  }
 
  CollectionModify modify(const string &expr)
  {
    try {
      return CollectionModify(*this, expr);
    }
    CATCH_AND_WRAP;
  }
 
  DbDoc getOne(const string &id)
  {
    return find("_id = :id").bind("id", id).execute().fetchOne();
  }
 
  Result removeOne(const string &id)
  {
    return remove("_id = :id").bind("id", id).execute();
  }
 
  Result replaceOne(const string &id, Value &&document)
  {
    try {
      return
        Collection_detail::add_or_replace_one(id, std::move(document), true);
    }
    CATCH_AND_WRAP
  }
 
  Result addOrReplaceOne(const string &id, Value &&document)
  {
    try {
      return
        Collection_detail::add_or_replace_one(id, std::move(document), false);
    }
    CATCH_AND_WRAP
  }
 
  void createIndex(const string &name, const string &idx_spec)
  {
    try {
      Collection_detail::index_create(name, idx_spec);
    }
    CATCH_AND_WRAP
  }
 
  void dropIndex(const string &name)
  {
    try {
      Collection_detail::index_drop(name);
    }
    CATCH_AND_WRAP
  }
 
 
  friend CollectionFind;
  friend CollectionAdd;
  friend CollectionRemove;
  friend CollectionModify;
 
  friend internal::Crud_factory;
};
 
//------------------------------------------------------------------------------
 
 
template<>
inline
void CollectionValidation::do_set<CollectionValidation::SCHEMA>(DbDoc schema)
{
  if(m_data.used.test(CollectionValidation::SCHEMA))
    throw_error("Validation schema already set.");
  m_data.used.set(CollectionValidation::SCHEMA);
  m_data.validation_schema = schema;
}
 
template<>
inline
void CollectionValidation::do_set<CollectionValidation::SCHEMA>(const char* schema)
{
  do_set<CollectionValidation::SCHEMA>(DbDoc(schema));
}
 
template<>
inline
void CollectionValidation::do_set<CollectionValidation::SCHEMA>(std::string schema)
{
  do_set<CollectionValidation::SCHEMA>(DbDoc(schema));
}
 
 
template<>
inline
void CollectionValidation::do_set<CollectionValidation::LEVEL>(Level level)
{
  if(m_data.used.test(CollectionValidation::LEVEL))
    throw_error("Validation level already set.");
  m_data.used.set(CollectionValidation::LEVEL);
 
#define SCHEMA_VALIDATION_CASE(x,y) case Level::x: m_data.validation_level = #x; break;
 
  switch (level) {
  COLLECTION_VALIDATION_LEVEL(SCHEMA_VALIDATION_CASE)
  }
}
 
template<>
inline
void CollectionValidation::do_set<CollectionValidation::LEVEL>(std::string level)
{
  if(m_data.used.test(CollectionValidation::LEVEL))
    throw_error("Validation level already set.");
  m_data.used.set(CollectionValidation::LEVEL);
 
  m_data.validation_level = level;
 
}
 
template<>
inline
void CollectionOptions::do_set<CollectionOptions::REUSE>(bool reuse)
{
  if(m_data.used[CollectionOptions::REUSE])
    throw_error("Option reuse already set.");
  m_data.used.set(CollectionOptions::REUSE);
  m_data.reuse = reuse;
}
 
template<>
inline
void CollectionOptions::do_set<CollectionOptions::VALIDATION>(CollectionValidation validation)
{
  if(m_data.used.test(CollectionOptions::VALIDATION) ||
     m_data.validation.m_data.used.test(CollectionValidation::LEVEL) ||
     m_data.validation.m_data.used.test(CollectionValidation::SCHEMA))
    throw_error("Validation already set.");
 
  m_data.used.set(CollectionOptions::VALIDATION);
  m_data.validation.m_data.used.set(CollectionValidation::LEVEL);
  m_data.validation.m_data.used.set(CollectionValidation::SCHEMA);
 
  m_data.validation = validation;
}
 
 
inline
Collection Schema::createCollection(const string &name)
{
  try {
    Schema_detail::create_collection(
          name,
          CollectionOptions() );
 
    return Collection(*this, name);
  }
  CATCH_AND_WRAP
}
 
inline
Collection Schema::createCollection(const string &name, bool reuse)
{
  try {
    Schema_detail::create_collection(
          name,
          CollectionOptions(
            CollectionOptions::REUSE, reuse)
          );
 
    return Collection(*this, name);
  }
  CATCH_AND_WRAP
}
 
 
template<typename... Rest>
inline
Collection Schema::createCollection(const string &name, Rest&&... rest)
{
  try {
    Schema_detail::create_collection(name, CollectionOptions(std::forward<Rest>(rest)...));
    return Collection(*this, name);
  }
  CATCH_AND_WRAP
}
 
 
template <typename... Opt>
inline
void Schema::modifyCollection(const string &name, Opt&&... options)
{
  try {
    Schema_detail::modify_collection(name, CollectionOptions(std::forward<Opt>(options)...));
  }
  CATCH_AND_WRAP
}
 
 
 
inline
Collection Schema::getCollection(const string &name, bool check_exists)
{
  Collection coll(*this, name);
  if (check_exists && !coll.existsInDatabase())
    throw_error("Collection does not exist");
  return coll;
}
 
 
 
/*
  Table object
  ============
*/
 
class Table
  : protected internal::Sch_object<>
{
public:
 
  Table(const Schema &sch, const string &name)
    : Sch_object(sch, name)
  {}
 
  Table(const Schema &sch, const string &name, bool is_view)
    : Sch_object(sch, name)
  {
    m_type = is_view ? VIEW : TABLE;
  }
 
 
  using Sch_object::getName;
  using Sch_object::getSession;
  using Sch_object::getSchema;
 
 
  bool existsInDatabase() const;
 
 
  bool isView();
 
 
  uint64_t count()
  {
    try {
      RowResult cnt = select("count(*)").execute();
      return cnt.fetchOne()[0].get<uint64_t>();
    }
    CATCH_AND_WRAP
  }
 
 
  /*
    CRUD operations
    ---------------
  */
 
  TableInsert insert()
  {
    try {
      return TableInsert(*this);
    }
    CATCH_AND_WRAP;
  }
 
  template <class... T>
  TableInsert insert(const T&... t)
  {
    try {
      return TableInsert(*this, t...);
    }
    CATCH_AND_WRAP;
  }
 
  template<typename ...PROJ>
  TableSelect select(const PROJ&...proj)
  {
    try {
      return TableSelect(*this, proj...);
    }
    CATCH_AND_WRAP;
  }
 
  TableRemove remove()
  {
    try {
      return TableRemove(*this);
    }
    CATCH_AND_WRAP;
  }
 
  TableUpdate update()
  {
    try {
      return TableUpdate(*this);
    }
    CATCH_AND_WRAP;
  }
 
private:
 
  enum { TABLE, VIEW, UNKNOWN } m_type = UNKNOWN;
 
  friend TableSelect;
  friend TableInsert;
  friend TableRemove;
  friend TableUpdate;
 
  friend internal::Crud_factory;
};
 
 
inline
bool Table::existsInDatabase() const
{
  try {
    /*
      Note: When checking existence, we also determine if this is a view or
      a plain table because this information is fetched from the server when
      querying for a list of tables.
    */
    Schema::TableList list(m_schema, m_name);
    auto it = list.begin();
 
    if (!(it != list.end()))
      return false;
 
    const_cast<Table*>(this)->m_type = (*it).isView() ? VIEW : TABLE;
    return true;
  }
  CATCH_AND_WRAP
}
 
 
inline
bool Table::isView()
{
  try {
    /*
      If view status was not determined yet, do existence check which
      determines it as a side effect.
    */
    if (UNKNOWN == m_type)
      if (!existsInDatabase())
        throw_error("Table does not exist");
    return VIEW == m_type;
  }
  CATCH_AND_WRAP
}
 
 
inline
Table Schema::getTable(const string &name, bool check_exists)
{
  Table tbl(*this, name);
  if (check_exists && !tbl.existsInDatabase())
    throw_error("Table does not exist");
  return tbl;
}
 
 
inline
Table Schema::getCollectionAsTable(const string &name, bool check_exists)
{
  if (check_exists && !getCollection(name).existsInDatabase())
    throw_error("Collection does not exist");
  return { *this, name };
}
 
 
inline
uint64_t Collection::count()
{
  return m_schema.getCollectionAsTable(m_name).count();
}
 
 
using SqlStatement = internal::SQL_statement;
 
 
class Session
  : private internal::Session_detail
{
public:
 
 
  Session(SessionSettings settings)
  try
    : Session_detail(settings)
  {}
  CATCH_AND_WRAP
 
 
  template<typename...T>
  Session(T...options)
  try
    : Session(SessionSettings(options...))
  {}CATCH_AND_WRAP
 
 
  Session(Session &&other)
  try
    : internal::Session_detail(std::move(other))
  {}CATCH_AND_WRAP
 
 
  Session(Client &client);
 
  Schema createSchema(const string &name, bool reuse = false)
  {
    try {
      Session_detail::create_schema(name, reuse);
      return Schema(*this, name);
    }
    CATCH_AND_WRAP
  }
 
  Schema getSchema(const string &name, bool check_exists = false)
  {
    Schema sch(*this, name);
    if (check_exists && !sch.existsInDatabase())
      throw_error("Schema does not exist");
    return sch;
  }
 
  Schema getDefaultSchema()
  {
    return Schema(*this, getDefaultSchemaName());
  }
 
  string getDefaultSchemaName()
  {
    try {
      return Session_detail::get_default_schema_name();
    }
    CATCH_AND_WRAP
  }
 
  SchemaList getSchemas()
  {
    try {
      return Schema_src(*this, "%");
    }
    CATCH_AND_WRAP
  }
 
  // TODO: Should we have getSchemaNames() too?
 
  void dropSchema(const string &name)
  {
    try {
      Session_detail::drop_schema(name);
    }
    CATCH_AND_WRAP
  }
 
 
  SqlStatement sql(const string &query)
  {
    try {
      return SqlStatement(this, query);
    }
    CATCH_AND_WRAP
  }
 
  void startTransaction()
  {
    try {
      Session_detail::start_transaction();
    }
    CATCH_AND_WRAP
  }
 
  void commit()
  {
    try {
      Session_detail::commit();
    }
    CATCH_AND_WRAP
  }
 
  void rollback()
  {
    try {
      Session_detail::rollback();
    }
    CATCH_AND_WRAP
  }
 
  void rollbackTo(const string &savepoint)
  {
    try {
      if (savepoint.empty())
        throw_error("Invalid empty save point name");
      Session_detail::rollback(savepoint);
    }
    CATCH_AND_WRAP
  }
 
 
  string setSavepoint(const string &savepoint)
  {
    try {
      if (savepoint.empty())
        throw_error("Invalid empty save point name");
      return Session_detail::savepoint_set(savepoint);
    }
    CATCH_AND_WRAP
  }
 
 
  string setSavepoint()
  {
    try {
      return Session_detail::savepoint_set();
    }
    CATCH_AND_WRAP
  }
 
 
  void releaseSavepoint(const string &savepoint)
  {
    try {
      if (savepoint.empty())
        throw_error("Invalid empty save point name");
      Session_detail::savepoint_remove(savepoint);
    }
    CATCH_AND_WRAP
  }
 
 
  void close()
  {
    try {
      Session_detail::close();
    }
    CATCH_AND_WRAP
  }
 
protected:
 
  using internal::Session_detail::m_impl;
 
public:
 
  friend Schema;
  friend Collection;
  friend Table;
  friend Result;
  friend RowResult;
 
  friend internal::Session_detail;
  friend internal::Crud_factory;
  friend internal::Result_detail;
  template <class Base> friend class internal::Sch_object;
};
 
 
class Client : public internal::Client_detail
{
public:
 
  Client(ClientSettings settings)
  try
    : Client_detail(settings)
  {}
  CATCH_AND_WRAP
 
  Client(SessionSettings &settings)
  try
    : Client_detail(settings)
  {}
  CATCH_AND_WRAP
 
  template<typename...T>
  Client(T...options)
    : Client(ClientSettings(options...))
  {}
 
 
  Session getSession()
  {
    return *this;
  }
 
};
 
 
/*
  Session
*/
 
inline
Session::Session(Client &client)
try
  : internal::Session_detail(client.get_session_pool())
{}CATCH_AND_WRAP
 
template<class ...P>
Session getSession(P...p)
{
  return Session(p...);
}
 
template<class ...P>
Client getClient(P...p)
{
  return Client(p...);
}
 
 
/*
   Schema class implementation
*/
 
inline
Schema::Schema(Session &sess, const string &name)
  : Schema_detail(sess.m_impl, name)
  , m_sess(&sess)
{}
 
 
template <class Base>
inline
internal::Sch_object<Base>::Sch_object(const Schema &sch, const string &name)
  : Base(sch.getSession().m_impl, name)
  , m_schema(sch)
{}
 
 
template <class Base>
inline
std::shared_ptr<common::Session_impl>
internal::Sch_object<Base>::get_session()
{
  assert(m_schema.m_sess);
  return m_schema.m_sess->m_impl;
}
 
 
MYSQLX_ABI_END(2,0)
}  // mysqlx
 
#endif