#ifndef _WT_DBO_BACKEND_FIREBIRD_
#define _WT_DBO_BACKEND_FIREBIRD_
/*
 * Copyright (c) 2011,
 * Technical University Of Gdansk,
 * Faculty of Electronics, Telecommunications and Informatics,
 * Multimedia Systems Department
 * and/or its affiliates. All rights reserved.
 */

#include <Wt/Dbo/SqlConnection>
#include <Wt/Dbo/SqlStatement>

#include <ibpp.h>
namespace Wt
{
namespace Dbo
{
  namespace backend {
    using namespace Wt::Dbo;
    using namespace Wt;
    using namespace IBPP;

    /*! \class Firebird
     *  \brief A FirebirdSQL connection
     *
     * This class provides the backend implementation for FirebirdSQL databases.
     *
     * \ingroup dbo
     */
    class Firebird : public SqlConnection
    {
      public:
        /*! \brief Creates new FirebirdSQL backend connection.
         *
         * The connection is not yet open, and requires a connect() before it
         * can be used.
         */
        Firebird();

        /*! \brief Opens a new FirebirdSQL backend connection.
         *
         * The \p dm may be any connected database module.
         */
        Firebird(IBPP::Database db);

        /*! \brief Opens a new FirebirdSQL backend connection.
         *
         * The \p db may be any of the values supported by PQconnectdb().
         */
        Firebird(const std::string& ServerName,
            const std::string& DatabaseName, const std::string& UserName,
              const std::string& UserPassword, const std::string& RoleName,
                const std::string& CharSet, const std::string& CreateParams);

        /*! \brief Copies a FirebirdSQL connection.
         */
        Firebird(const Firebird& other);

        /*! \brief Destructor.
         *
         * Closes the connection.
         */
        virtual ~Firebird();

        virtual Firebird *clone() const;

        /*! \brief Tries to connect.
         *
         * Throws an exception if there was a problem, otherwise true.
         */
        bool connect(const std::string& ServerName,
            const std::string& DatabaseName, const std::string& UserName,
              const std::string& UserPassword, const std::string& RoleName,
                const std::string& CharSet, const std::string& CreateParams);

        /*! \brief Returns the underlying connection.
         */
        IBPP::Database connection()
        {
          return this->m_db;
        }

        virtual void executeSql(const std::string &sql);

        virtual void startTransaction();
        virtual void commitTransaction();
        virtual void rollbackTransaction();
        virtual IBPP::Transaction transaction()
        {
          return this->m_tra;
        }

        virtual SqlStatement *prepareStatement(const std::string& sql);

        /** @name Methods that return dialect information
         */
        //@{
        virtual std::string autoincrementSql() const;
        virtual std::string autoincrementType() const;
        virtual std::string autoincrementInsertSuffix() const;
        virtual const char *dateTimeType(SqlDateTimeType type) const;
        virtual const char *blobType() const;
        //@}

        virtual void        setWritableTransaction(bool amWrite)
        {
          this->m_writableTransaction = amWrite;
        }

        virtual bool usesRowsFromTo() const
        {
          return true;
        }

      private:

        IBPP::Database        m_db;
        IBPP::Transaction     m_tra;
        bool                  m_writableTransaction;
        bool                  m_dmOwned;
    };

  }
}
}

#endif /* _WT_DBO_BACKEND_FIREBIRD_ */

