Repository.h

#pragma once
#include <datamappercpp/sql/Transaction.h>
#include <datamappercpp/sql/db.h>
#include <datamappercpp/sql/exceptions.h>

#include <datamappercpp/sql/detail/SqlStatementBuilder.h>

#include <dbccpp/dbccpp.h>

#include <utilcpp/disable_copy.h>

#include <vector>

#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus > 199711L)
  #include <functional>
  namespace dm
  {
      namespace stdutil = std;
  }
#else
  #include <boost/shared_ptr.hpp>
  #include <boost/make_shared.hpp>
  #include <boost/function.hpp>
  namespace dm
  {
      namespace stdutil = boost;
  }
#endif


namespace dm {
namespace sql {

class StatementFieldBinder
{
    UTILCPP_DISABLE_COPY(StatementFieldBinder)

public:
    StatementFieldBinder(dbc::PreparedStatement::ptr& statement) :
        _statement(statement)
    { }

    template <typename T>
    void visitField(const Field<T>& , const T& field)
    {
        // TODO: *_statement[label] = field
        *_statement << field;
    }

private:
    dbc::PreparedStatement::ptr& _statement;
};

class ObjectFieldBinder
{
    UTILCPP_DISABLE_COPY(ObjectFieldBinder)

public:
    ObjectFieldBinder(const dbc::ResultSet& result) :
        _result(result),
        // index is 0-based, skip id, which is already set
        _counter(1)
    {}

    template <typename T>
    void visitField(const Field<T>& , T& field)
    {
        // TODO: field = *_result[label]
        field = _result.get<T>(_counter++);
    }

private:
    const dbc::ResultSet& _result;
    unsigned int _counter;
};


/**
 * Repository transfers domain entities and their collections to and from
 * the database.
 *
 * Relies on Return Value Optimization and returns entities and collections by
 * copy.
 */
template <class Entity, class Mapping>
class Repository
{
public:
    typedef std::vector<Entity> Entities;
    typedef std::vector<stdutil::shared_ptr<Entity> > EntitiesPtr;
    typedef SqlStatementBuilder<Entity, Mapping> EntitySqlBuilder;

    static void CreateTable(bool enableTransaction = true)
    {
        Transaction transaction(enableTransaction);

        ExecuteStatement(EntitySqlBuilder::CreateTableStatement());

        transaction.commit();
    }

    static void Save(Entities& entities,
                     bool enableTransaction = true)
    {
        Transaction transaction(enableTransaction);

        for (size_t i = 0; i < entities.size(); ++i)
            Save(entities[i], false);

        transaction.commit();
    }

    static void Save(Entity& entity, bool enableTransaction = true)
    {
        dbc::PreparedStatement::ptr statement;
        bool update = entity.id > 0;

        if (update)
        {
            prepareStatement(_updateEntityStatement,
                             &EntitySqlBuilder::UpdateStatement);
            statement = _updateEntityStatement;
        }
        else
        {
            prepareStatement(_insertEntityStatement,
                             &EntitySqlBuilder::InsertStatement);
            statement = _insertEntityStatement;
        }

        StatementFieldBinder fieldbinder(statement);
        Mapping::accept(fieldbinder, entity);

        if (update)
            // update needs to to have ID bound as well
            *statement << entity.id;

        Transaction transaction(enableTransaction);

        int howmany = statement->executeUpdate();
        if (howmany != 1)
        {
            std::ostringstream msg;
            msg << howmany << " rows affected while saving single entity "
                << "instead of 1";
            throw NotOneError(msg.str());
        }

        if (!update)
            // insert needs to set the object id after insert
            entity.id = statement->getLastInsertId();

        transaction.commit();
    }

    static void Delete(Entity& entity,
                bool enableTransaction = true,
                bool checkOneDeleted = true)
    {
        if (entity.id < 1)
            throw std::invalid_argument("Entity ID is less than 1");

        Delete(entity.id, enableTransaction, checkOneDeleted);

        entity.id = -1;
    }

    static void Delete(__int64 id,
                bool enableTransaction = true,
                bool checkOneDeleted = true)
    {
        prepareStatement(_deleteEntityStatement,
                         &EntitySqlBuilder::DeleteByIdStatement);
        *_deleteEntityStatement << id;

        Transaction transaction(enableTransaction);

        int howmany = _deleteEntityStatement->executeUpdate();
        if (checkOneDeleted && howmany != 1)
        {
            std::ostringstream msg;
            msg << howmany << " rows affected while deleting single entity "
                << "instead of 1";
            throw NotOneError(msg.str());
        }

        transaction.commit();
    }

	template <typename Value>
	static void DeleteByField(std::string field,
				const Value &value,
                bool enableTransaction = true)
    {
		Statement statement = PrepareStatement(EntitySqlBuilder::DeleteByFieldStatement(field));
        *statement << value;

        Transaction transaction(enableTransaction);

        statement->executeUpdate();

        transaction.commit();
    }

    static void DeleteAll(bool enableTransaction = true)
    {
        Transaction transaction(enableTransaction);

        ExecuteStatement(EntitySqlBuilder::DeleteAllStatement());

        transaction.commit();
    }

    static Entity Get(__int64 id)
    {
        // note that SELECTs are outside transactions and
        // mixing them with ongoing transactions may cause problems

        if (id < 1)
            throw std::invalid_argument("ID is less than 1");

        prepareStatement(_getEntityByIdStatement,
                         &EntitySqlBuilder::SelectByIdStatement);
        *_getEntityByIdStatement << id;

        return GetByQueryImpl(_getEntityByIdStatement, false, id);
    }

    template <typename Value>
    static Entity GetByField(const std::string& fieldname, const Value& value,
            bool allowMany = false)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname));
        *statement << value;
        return GetByQueryImpl(statement, allowMany, -1);
    }

    static Entity GetByQuery(const std::string& sql,
            bool allowMany = false)
    {
        Statement statement = PrepareStatement(sql);
        return GetByQueryImpl(statement, allowMany, -1);
    }

	static Entity GetByQuery(const std::wstring& sql,
			bool allowMany = false)
	{
		return GetByQuery(static_cast<const char*>(toMBStr(sql)), allowMany);
		//toMBStr is included from SqlStatementBuilder.h
	}

    static Entity GetByQuery(Statement& statement,
            bool allowMany = false)
    {
        return GetByQueryImpl(statement, allowMany, -1);
    }

    static Entities GetAll()
    {
        prepareStatement(_getAllEntitiesStatement,
                         &EntitySqlBuilder::SelectAllStatement);

        return GetManyByQuery(_getAllEntitiesStatement);
    }

    static EntitiesPtr GetAllPtr()
    {
        prepareStatement(_getAllEntitiesStatement,
                         &EntitySqlBuilder::SelectAllStatement);

        return GetManyByQueryPtr(_getAllEntitiesStatement);
    }

    template <typename Value>
	static EntitiesPtr GetManyByFieldPtr(const std::string& fieldname, Value value)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname));
        *statement << value;

        return GetManyByQueryPtr(statement);
    }

    template <typename Value>
    static Entities GetManyByField(const std::string& fieldname, Value value)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname));
        *statement << value;

        return GetManyByQuery(statement);
    }

    template <typename Value1, typename Value2>
	static EntitiesPtr GetManyByFieldPtr(const std::string& fieldname1, Value1 value1,
		const std::string& fieldname2, Value2 value2)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname1, fieldname2));
        *statement << value1 << value2;

        return GetManyByQueryPtr(statement);
    }

	template <typename Value1, typename Value2>
	static Entities GetManyByField(const std::string& fieldname1, Value1 value1,
		const std::string& fieldname2, Value2 value2)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname1, fieldname2));
        *statement << value1 << value2;

        return GetManyByQuery(statement);
    }

	template <typename Value1, typename Value2, typename Value3>
	static EntitiesPtr GetManyByFieldPtr(const std::string& fieldname1, Value1 value1,
		const std::string& fieldname2, Value2 value2, const std::string& fieldname3, Value3 value3)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname1, fieldname2, fieldname3));
        *statement << value1 << value2 << value3;

        return GetManyByQueryPtr(statement);
    }

	template <typename Value1, typename Value2, typename Value3>
	static Entities GetManyByField(const std::string& fieldname1, Value1 value1,
		const std::string& fieldname2, Value2 value2, const std::string& fieldname3, Value3 value3)
    {
        Statement statement = PrepareStatement(
                EntitySqlBuilder::SelectByFieldStatement(fieldname1, fieldname2, fieldname3));
        *statement << value1 << value2 << value3;

        return GetManyByQuery(statement);
    }

    static Entities GetManyByQuery(const std::string& sql)
    {
        Statement statement = PrepareStatement(sql);
        return GetManyByQuery(statement);
    }

	static Entities GetManyByQuery(const std::wstring& sql)
    {
        Statement statement = PrepareStatement(toMBStr(sql));
		//toMBStr is included from SqlStatementBuilder.h
        return GetManyByQuery(statement);
    }

    static Entities GetManyByQuery(Statement& statement)
    {
        Entities entities;
        dbc::ResultSet::ptr result(statement->executeQuery());

        while (result->next())
        {
            Entity entity;
            entity.id = (*result)[0];

            ObjectFieldBinder fieldbinder(*result);
            Mapping::accept(fieldbinder, entity);

            entities.push_back(entity);
        }

        return entities;
    }

    static EntitiesPtr GetManyByQueryPtr(Statement& statement)
    {
        EntitiesPtr entities;
        dbc::ResultSet::ptr result(statement->executeQuery());

        while (result->next())
        {
            stdutil::shared_ptr<Entity> entity(stdutil::make_shared<Entity>());
            entity->id = (*result)[0];

            ObjectFieldBinder fieldbinder(*result);
            Mapping::accept(fieldbinder, *entity);

            entities.push_back(entity);
        }

        return entities;
    }

    static dbc::ResultSet::ptr ExecuteQuery(std::string sql)
    {
        Statement statement;
    }

    static void ResetStatements()
    {
        // Free the resources associated with prepared statments.
        // The statements are phoenix singletons that spring to life
        // as needed.
        _insertEntityStatement.reset();
        _updateEntityStatement.reset();
        _deleteEntityStatement.reset();
        _getEntityByIdStatement.reset();
        _getAllEntitiesStatement.reset();
    }

private:
    Repository();

    static Statement _insertEntityStatement;
    static Statement _updateEntityStatement;
    static Statement _deleteEntityStatement;
    static Statement _getEntityByIdStatement;
    static Statement _getAllEntitiesStatement;

    inline static void prepareStatement(Statement& statement,
            stdutil::function<std::string (void)> createSqlStatement)
    {
        if (!statement)
        {
            statement = PrepareStatement(createSqlStatement());
        }
        else
        {
            statement->reset();
            statement->clear();
        }
    }

    inline static Entity GetByQueryImpl(Statement& statement,
            bool allowMany, __int64 id)
    {
        Entity entity;

        dbc::ResultSet::ptr result(statement->executeQuery());
        result->next();

        try
        {
            // TODO: entity.id << *result;
            entity.id = (*result)[0];
        }
        catch (const dbc::NoResultsError&)
        {
            std::ostringstream msg;
            msg << "No " << Mapping::getLabel() << " exists for query '"
                << statement->getSQL() << "'";
            throw DoesNotExistError(msg.str());
        }

        ObjectFieldBinder fieldbinder(*result);
        Mapping::accept(fieldbinder, entity);

        if (!allowMany && result->next())
        {
            std::ostringstream msg;
            msg << "More than one result for ";
            if (id > 0)
                msg << "ID " << id;
            else
                msg << "query '" << statement->getSQL() << "'";
            throw NotOneError(msg.str());
        }

        return entity;
    }

};

template <class Entity, class Mapping>
dbc::PreparedStatement::ptr Repository<Entity, Mapping>::_insertEntityStatement;

template <class Entity, class Mapping>
dbc::PreparedStatement::ptr Repository<Entity, Mapping>::_updateEntityStatement;

template <class Entity, class Mapping>
dbc::PreparedStatement::ptr Repository<Entity, Mapping>::_deleteEntityStatement;

template <class Entity, class Mapping>
dbc::PreparedStatement::ptr Repository<Entity, Mapping>::_getEntityByIdStatement;

template <class Entity, class Mapping>
dbc::PreparedStatement::ptr Repository<Entity, Mapping>::_getAllEntitiesStatement;

} }