Statement(MYSQL *conn, const std::string &format, const std::string &statement);

				~Statement();

				int execute();

				int fetch();

				// Pushes new data used as input for the statement.

				template <typename T>

				Statement& operator << (const T& t);

				Statement& operator << (const std::string& str);

				// Pulls fetched data by previous execute(); call.

				template <typename T>

				Statement& operator >> (T& t);

				Statement& operator >> (std::string& t);

			private:

				MYSQL_STMT *m_stmt;

				MYSQL *m_conn;

				std::vector<MYSQL_BIND> m_params;

				std::vector<MYSQL_BIND> m_results;

				int m_error;

				unsigned m_offset;

				std::string m_string;

		};

		MYSQL m_conn;

		Config *m_config;

		std::string m_prefix;

		// statements

// 		MYSQL_STMT *m_setUser;

		Statement *m_setUser;

		Statement *m_getUser;

		Statement *m_getUserSetting;

		Statement *m_setUserSetting;

		Statement *m_updateUserSetting;

		Statement *m_removeUser;

		Statement *m_removeUserBuddies;

		Statement *m_removeUserSettings;

		Statement *m_removeUserBuddiesSettings;

		Statement *m_addBuddy;

		Statement *m_removeBuddy;

		Statement *m_removeBuddySettings;

		Statement *m_updateBuddy;

		Statement *m_updateBuddySetting;

 * (at your option) any later version.

 *

 * 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 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 Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#ifdef WITH_MYSQL

#include "transport/MySQLBackend.h"

#include "transport/Util.h"

#include "transport/Logging.h"

#include <boost/bind.hpp>

#define EXEC(STMT, METHOD) \

	{\

	int ret = STMT->execute(); \

	if (ret == 0) \

		exec_ok = true; \

		LOG4CXX_INFO(logger, "MySQL connection lost. Reconnecting...");\

		disconnect(); \

		connect(); \

		return METHOD; \

	} \

	else \

		exec_ok = false; \

	}

namespace Transport {

DEFINE_LOGGER(logger, "MySQLBackend");

static bool exec_ok;

MySQLBackend::Statement::Statement(MYSQL *conn, const std::string &format, const std::string &statement) {

	m_resultOffset = -1;

	m_conn = conn;

	m_offset = 0;

	m_string = statement;

	m_stmt = mysql_stmt_init(conn);

	if (mysql_stmt_prepare(m_stmt, statement.c_str(), statement.size())) {

		return;

	}

	for (unsigned i = 0; i < format.length() && m_resultOffset == -1; i++) {

		switch (format.at(i)) {

			case 's':

				m_params.resize(m_params.size() + 1);

				memset(&m_params.back(), 0, sizeof(MYSQL_BIND));

				m_params.back().buffer_type= MYSQL_TYPE_STRING;

				m_params.back().buffer= (char *) malloc(sizeof(char) * 4096);

				m_params.back().buffer_length= 4096;

				m_params.back().is_null= 0;

				m_params.back().length= (unsigned long *) malloc(sizeof(unsigned long));

				break;

			case 'i':

				m_params.resize(m_params.size() + 1);

				memset(&m_params.back(), 0, sizeof(MYSQL_BIND));

				m_params.back().buffer_type= MYSQL_TYPE_LONG;

				m_params.back().buffer= (int *) malloc(sizeof(int));

				m_params.back().is_null= 0;

				m_params.back().length= (unsigned long *) malloc(sizeof(unsigned long));

				break;

				m_results.back().length= (unsigned long *) malloc(sizeof(unsigned long));

				break;

			case 'i':

				m_results.resize(m_results.size() + 1);

				memset(&m_results.back(), 0, sizeof(MYSQL_BIND));

				m_results.back().buffer_type= MYSQL_TYPE_LONG;

				m_results.back().buffer= (int *) malloc(sizeof(int));

				m_results.back().is_null= 0;

				m_results.back().length= (unsigned long *) malloc(sizeof(unsigned long));

				break;

			case 'b':

				m_results.resize(m_results.size() + 1);

				memset(&m_results.back(), 0, sizeof(MYSQL_BIND));

				m_results.back().buffer_type= MYSQL_TYPE_TINY;

				m_results.back().buffer= (int *) malloc(sizeof(int));

				m_results.back().is_null= 0;

				m_results.back().length= (unsigned long *) malloc(sizeof(unsigned long));

				break;

		}

	}

	if (mysql_stmt_bind_param(m_stmt, &m_params.front())) {

	}

	if (m_resultOffset < 0)

		m_resultOffset = format.size();

	else {

		if (mysql_stmt_bind_result(m_stmt, &m_results.front())) {

		}

	}

	m_resultOffset = 0;

}

MySQLBackend::Statement::~Statement() {

	for (unsigned i = 0; i < m_params.size(); i++) {

		free(m_params[i].buffer);

		free(m_params[i].length);

	}

	for (unsigned i = 0; i < m_results.size(); i++) {

		free(m_results[i].buffer);

		free(m_results[i].length);

	}

	if(m_stmt != NULL) {

		mysql_stmt_close(m_stmt);

	}

}

int MySQLBackend::Statement::execute() {

	// If statement has some input and doesn't have any output, we have

	// to clear the offset now, because operator>> will not be called.

	m_offset = 0;

	m_resultOffset = 0;

	if (++m_resultOffset == m_results.size())

		m_resultOffset = 0;

	return *this;

}

MySQLBackend::Statement& MySQLBackend::Statement::operator >> (std::string& t) {

// 	std::cout << "getting " << m_resultOffset << "\n";

	if (m_resultOffset > m_results.size())

		return *this;

	if (!m_results[m_resultOffset].is_null) {

		t = (char *) m_results[m_resultOffset].buffer;

	}

	if (++m_resultOffset == m_results.size())

		m_resultOffset = 0;

	return *this;

}

MySQLBackend::MySQLBackend(Config *config) {

	m_config = config;

	m_prefix = CONFIG_STRING(m_config, "database.prefix");

	mysql_init(&m_conn);

}

MySQLBackend::~MySQLBackend(){

	disconnect();

}

void MySQLBackend::disconnect() {

	LOG4CXX_INFO(logger, "Disconnecting");

	delete m_setUser;

	delete m_getUser;

	delete m_removeUser;

	delete m_removeUserBuddies;

	delete m_removeUserSettings;

	delete m_removeUserBuddiesSettings;

	delete m_addBuddy;

	delete m_removeBuddy;

	delete m_removeBuddySettings;

	delete m_updateBuddy;

	delete m_getBuddies;

	delete m_getBuddiesSettings;

	delete m_getUserSetting;

	delete m_setUserSetting;

	delete m_updateUserSetting;

	delete m_updateBuddySetting;

	delete m_getBuddySetting;

	delete m_setUserOnline;

	delete m_getOnlineUsers;

	delete m_getUsers;

}

bool MySQLBackend::connect() {

	LOG4CXX_INFO(logger, "Connecting MySQL server " << CONFIG_STRING(m_config, "database.server") << ", user " <<

		CONFIG_STRING(m_config, "database.user") << ", database " << CONFIG_STRING(m_config, "database.database") <<

		", port " << CONFIG_INT(m_config, "database.port")

	);

	if (!mysql_real_connect(&m_conn, CONFIG_STRING(m_config, "database.server").c_str(),

					   CONFIG_STRING(m_config, "database.user").c_str(),

					   CONFIG_STRING(m_config, "database.password").c_str(),

					   CONFIG_STRING(m_config, "database.database").c_str(),

					   CONFIG_INT(m_config, "database.port"), NULL, 0)) {

		LOG4CXX_ERROR(logger, "Can't connect database: " << mysql_error(&m_conn));

		return false;

	}

	if (!mysql_set_character_set(&m_conn, "utf8")) {

		LOG4CXX_INFO(logger, "New client character set: " << mysql_character_set_name(&m_conn));

	}

	createDatabase();

	m_setUser = new Statement(&m_conn, "sssssbss", "INSERT INTO " + m_prefix + "users (jid, uin, password, language, encoding, last_login, vip) VALUES (?, ?, ?, ?, ?, NOW(), ?) ON DUPLICATE KEY UPDATE uin=?, password=?");