2 files changed, 190 insertions, 537 deletions

diff --git a/src/modules/extra/m_mysql.cpp b/src/modules/extra/m_mysql.cpp
index 731753d9b..08f71c929 100644
--- a/src/modules/extra/m_mysql.cpp
+++ b/src/modules/extra/m_mysql.cpp
@@ -16,13 +16,13 @@
 
 #include "inspircd.h"
 #include <mysql.h>
-#include "m_sqlv2.h"
+#include "sql.h"
 
 #ifdef WINDOWS
 #pragma comment(lib, "mysqlclient.lib")
 #endif
 
-/* VERSION 2 API: With nonblocking (threaded) requests */
+/* VERSION 3 API: With nonblocking (threaded) requests */
 
 /* $ModDesc: SQL Service Provider module for all other m_sql* modules */
 /* $CompileFlags: exec("mysql_config --include") */
@@ -63,47 +63,48 @@
  * For a diagram of this system please see http://wiki.inspircd.org/Mysql2
  */
 
-
 class SQLConnection;
+class MySQLresult;
 class DispatcherThread;
 
-typedef std::map<std::string, SQLConnection*> ConnMap;
-typedef std::deque<SQLresult*> ResultQueue;
-
-static unsigned long count(const char * const str, char a)
+struct QueueItem
 {
-	unsigned long n = 0;
-	for (const char *p = str; *p; ++p)
-	{
-		if (*p == '?')
-			++n;
-	}
-	return n;
-}
+	SQLQuery* q;
+	SQLConnection* c;
+	QueueItem(SQLQuery* Q, SQLConnection* C) : q(Q), c(C) {}
+};
 
+typedef std::map<std::string, SQLConnection*> ConnMap;
+typedef std::deque<QueueItem> QueryQueue;
+typedef std::deque<MySQLresult*> ResultQueue;
 
 /** MySQL module
  *  */
 class ModuleSQL : public Module
 {
  public:
-	int currid;
-	bool rehashing;
 	DispatcherThread* Dispatcher;
-	Mutex ResultsMutex;
-	Mutex LoggingMutex;
-	Mutex ConnMutex;
-	ServiceProvider sqlserv;
+	QueryQueue qq;
+	ResultQueue rq;
+	ConnMap connections;
 
 	ModuleSQL();
 	void init();
 	~ModuleSQL();
-	unsigned long NewID();
-	void OnRequest(Request& request);
 	void OnRehash(User* user);
 	Version GetVersion();
 };
 
+class DispatcherThread : public SocketThread
+{
+ private:
+	ModuleSQL* const Parent;
+ public:
+	DispatcherThread(ModuleSQL* CreatorModule) : Parent(CreatorModule) { }
+	~DispatcherThread() { }
+	virtual void Run();
+	virtual void OnNotify();
+};
 
 #if !defined(MYSQL_VERSION_ID) || MYSQL_VERSION_ID<32224
 #define mysql_field_count mysql_num_fields
@@ -111,23 +112,18 @@ class ModuleSQL : public Module
 
 /** Represents a mysql result set
  */
-class MySQLresult : public SQLresult
+class MySQLresult : public SQLResult
 {
+ public:
+	SQLQuery* query;
+	SQLerror err;
 	int currentrow;
-	std::vector<std::string> colnames;
-	std::vector<SQLfieldList> fieldlists;
-	SQLfieldMap* fieldmap;
-	SQLfieldMap fieldmap2;
-	SQLfieldList emptyfieldlist;
 	int rows;
- public:
+	std::vector<std::string> colnames;
+	std::vector<SQLEntries> fieldlists;
 
-	MySQLresult(Module* self, Module* to, MYSQL_RES* res, int affected_rows, unsigned int rid) : SQLresult(self, to, rid), currentrow(0), fieldmap(NULL)
+	MySQLresult(SQLQuery* q, MYSQL_RES* res, int affected_rows) : query(q), err(SQL_NO_ERROR), currentrow(0), rows(0)
 	{
-		/* A number of affected rows from from mysql_affected_rows.
-		 */
-		fieldlists.clear();
-		rows = 0;
 		if (affected_rows >= 1)
 		{
 			rows = affected_rows;
@@ -154,10 +150,11 @@ class MySQLresult : public SQLresult
 					while (field_count < mysql_num_fields(res))
 					{
 						std::string a = (fields[field_count].name ? fields[field_count].name : "");
-						std::string b = (row[field_count] ? row[field_count] : "");
-						SQLfield sqlf(b, !row[field_count]);
+						if (row[field_count])
+							fieldlists[n].push_back(SQLEntry(row[field_count]));
+						else
+							fieldlists[n].push_back(SQLEntry());
 						colnames.push_back(a);
-						fieldlists[n].push_back(sqlf);
 						field_count++;
 					}
 					n++;
@@ -169,10 +166,9 @@ class MySQLresult : public SQLresult
 		}
 	}
 
-	MySQLresult(Module* self, Module* to, SQLerror e, unsigned int rid) : SQLresult(self, to, rid), currentrow(0)
+	MySQLresult(SQLQuery* q, SQLerror& e) : query(q), err(e)
 	{
-		rows = 0;
-		error = e;
+
 	}
 
 	~MySQLresult()
@@ -184,135 +180,48 @@ class MySQLresult : public SQLresult
 		return rows;
 	}
 
-	virtual int Cols()
-	{
-		return colnames.size();
-	}
-
-	virtual std::string ColName(int column)
-	{
-		if (column < (int)colnames.size())
-		{
-			return colnames[column];
-		}
-		else
-		{
-			throw SQLbadColName();
-		}
-		return "";
-	}
-
-	virtual int ColNum(const std::string &column)
+	virtual void GetCols(std::vector<std::string>& result)
 	{
-		for (unsigned int i = 0; i < colnames.size(); i++)
-		{
-			if (column == colnames[i])
-				return i;
-		}
-		throw SQLbadColName();
-		return 0;
+		result.assign(colnames.begin(), colnames.end());
 	}
 
-	virtual SQLfield GetValue(int row, int column)
+	virtual SQLEntry GetValue(int row, int column)
 	{
-		if ((row >= 0) && (row < rows) && (column >= 0) && (column < Cols()))
+		if ((row >= 0) && (row < rows) && (column >= 0) && (column < (int)fieldlists[row].size()))
 		{
 			return fieldlists[row][column];
 		}
-
-		throw SQLbadColName();
-
-		/* XXX: We never actually get here because of the throw */
-		return SQLfield("",true);
+		return SQLEntry();
 	}
 
-	virtual SQLfieldList& GetRow()
+	virtual bool GetRow(SQLEntries& result)
 	{
 		if (currentrow < rows)
-			return fieldlists[currentrow++];
-		else
-			return emptyfieldlist;
-	}
-
-	virtual SQLfieldMap& GetRowMap()
-	{
-		fieldmap2.clear();
-
-		if (currentrow < rows)
 		{
-			for (int i = 0; i < Cols(); i++)
-			{
-				fieldmap2.insert(std::make_pair(colnames[i],GetValue(currentrow, i)));
-			}
-			currentrow++;
-		}
-
-		return fieldmap2;
-	}
-
-	virtual SQLfieldList* GetRowPtr()
-	{
-		SQLfieldList* fieldlist = new SQLfieldList();
-
-		if (currentrow < rows)
-		{
-			for (int i = 0; i < Rows(); i++)
-			{
-				fieldlist->push_back(fieldlists[currentrow][i]);
-			}
+			result.assign(fieldlists[currentrow].begin(), fieldlists[currentrow].end());
 			currentrow++;
+			return true;
 		}
-		return fieldlist;
-	}
-
-	virtual SQLfieldMap* GetRowMapPtr()
-	{
-		fieldmap = new SQLfieldMap();
-
-		if (currentrow < rows)
+		else
 		{
-			for (int i = 0; i < Cols(); i++)
-			{
-				fieldmap->insert(std::make_pair(colnames[i],GetValue(currentrow, i)));
-			}
-			currentrow++;
+			result.clear();
+			return false;
 		}
-
-		return fieldmap;
-	}
-
-	virtual void Free(SQLfieldMap* fm)
-	{
-		delete fm;
-	}
-
-	virtual void Free(SQLfieldList* fl)
-	{
-		delete fl;
 	}
 };
 
 /** Represents a connection to a mysql database
  */
-class SQLConnection : public classbase
+class SQLConnection : public SQLProvider
 {
- protected:
-	MYSQL *connection;
-	MYSQL_RES *res;
-	MYSQL_ROW *row;
-	SQLhost host;
-	std::map<std::string,std::string> thisrow;
-	bool Enabled;
-	ModuleSQL* Parent;
-	std::string initquery;
-
  public:
-
-	QueryQueue queue;
-	ResultQueue rq;
+	reference<ConfigTag> config;
+	MYSQL *connection;
+	bool active;
 
 	// This constructor creates an SQLConnection object with the given credentials, but does not connect yet.
-	SQLConnection(const SQLhost &hi, ModuleSQL* Creator) : connection(NULL), host(hi), Enabled(false), Parent(Creator)
+	SQLConnection(Module* p, ConfigTag* tag) : SQLProvider(p, "SQL/" + tag->getString("id")),
+		config(tag), active(false)
 	{
 	}
 
@@ -328,167 +237,109 @@ class SQLConnection : public classbase
 		unsigned int timeout = 1;
 		connection = mysql_init(connection);
 		mysql_options(connection,MYSQL_OPT_CONNECT_TIMEOUT,(char*)&timeout);
-		return mysql_real_connect(connection, host.host.c_str(), host.user.c_str(), host.pass.c_str(), host.name.c_str(), host.port, NULL, 0);
-	}
-
-	void DoLeadingQuery()
-	{
-		if (!CheckConnection())
-			return;
-
-		if( !initquery.empty() )
-			mysql_query(connection,initquery.c_str());
-
-		/* Parse the command string and dispatch it to mysql */
-		SQLrequest* req = queue.front();
-
-		/* Pointer to the buffer we screw around with substitution in */
-		char* query;
-
-		/* Pointer to the current end of query, where we append new stuff */
-		char* queryend;
-
-		/* Total length of the unescaped parameters */
-		unsigned long maxparamlen, paramcount;
-
-		/* The length of the longest parameter */
-		maxparamlen = 0;
-
-		for(ParamL::iterator i = req->query.p.begin(); i != req->query.p.end(); i++)
+		std::string host = config->getString("host");
+		std::string user = config->getString("user");
+		std::string pass = config->getString("pass");
+		std::string dbname = config->getString("name");
+		int port = config->getInt("port");
+		bool rv = mysql_real_connect(connection, host.c_str(), user.c_str(), pass.c_str(), dbname.c_str(), port, NULL, 0);
+		if (!rv)
+			return rv;
+		std::string initquery;
+		if (config->readString("initialquery", initquery))
 		{
-			if (i->size() > maxparamlen)
-				maxparamlen = i->size();
+			mysql_query(connection,initquery.c_str());
 		}
+		return true;
+	}
 
-		/* How many params are there in the query? */
-		paramcount = count(req->query.q.c_str(), '?');
-
-		/* This stores copy of params to be inserted with using numbered params 1;3B*/
-		ParamL paramscopy(req->query.p);
-
-		/* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.
-		 * sizeofquery + (maxtotalparamlength*2) + 1
-		 *
-		 * The +1 is for null-terminating the string for mysql_real_escape_string
-		 */
-
-		query = new char[req->query.q.length() + (maxparamlen*paramcount*2) + 1];
-		queryend = query;
-
-		/* Okay, now we have a buffer large enough we need to start copying the query into it and escaping and substituting
-		 * the parameters into it...
-		 */
-
-		for(unsigned long i = 0; i < req->query.q.length(); i++)
+	virtual std::string FormatQuery(const std::string& q, const ParamL& p)
+	{
+		std::string res;
+		unsigned int param = 0;
+		for(std::string::size_type i = 0; i < q.length(); i++)
 		{
-			if(req->query.q[i] == '?')
+			if (q[i] != '?')
+				res.push_back(q[i]);
+			else
 			{
-				/* We found a place to substitute..what fun.
-				 * use mysql calls to escape and write the
-				 * escaped string onto the end of our query buffer,
-				 * then we "just" need to make sure queryend is
-				 * pointing at the right place.
-				 */
-
-				/* Is it numbered parameter?
-				 */
-
-				bool numbered;
-				numbered = false;
-
-				/* Numbered parameter number :|
-				 */
-				unsigned int paramnum;
-				paramnum = 0;
-
-				/* Let's check if it's a numbered param. And also calculate it's number.
-				 */
-
-				while ((i < req->query.q.length() - 1) && (req->query.q[i+1] >= '0') && (req->query.q[i+1] <= '9'))
+				// TODO numbered parameter support ('?1')
+				if (param < p.size())
 				{
-					numbered = true;
-					++i;
-					paramnum = paramnum * 10 + req->query.q[i] - '0';
-				}
-
-				if (paramnum > paramscopy.size() - 1)
-				{
-					/* index is out of range!
-					 */
-					numbered = false;
-				}
-
-				if (numbered)
-				{
-					unsigned long len = mysql_real_escape_string(connection, queryend, paramscopy[paramnum].c_str(), paramscopy[paramnum].length());
-
-					queryend += len;
-				}
-				else if (req->query.p.size())
-				{
-					unsigned long len = mysql_real_escape_string(connection, queryend, req->query.p.front().c_str(), req->query.p.front().length());
-
-					queryend += len;
-					req->query.p.pop_front();
+					std::string parm = p[param++];
+					char buffer[MAXBUF];
+					mysql_escape_string(buffer, parm.c_str(), parm.length());
+//					mysql_real_escape_string(connection, queryend, paramscopy[paramnum].c_str(), paramscopy[paramnum].length());
+					res.append(buffer);
 				}
-				else
-					break;
 			}
+		}
+		return res;
+	}
+
+	std::string FormatQuery(const std::string& q, const ParamM& p)
+	{
+		std::string res;
+		for(std::string::size_type i = 0; i < q.length(); i++)
+		{
+			if (q[i] != '$')
+				res.push_back(q[i]);
 			else
 			{
-				*queryend = req->query.q[i];
-				queryend++;
+				std::string field;
+				i++;
+				while (i < q.length() && isalpha(q[i]))
+					field.push_back(q[i++]);
+				i--;
+
+				ParamM::const_iterator it = p.find(field);
+				if (it != p.end())
+				{
+					std::string parm = it->second;
+					char buffer[MAXBUF];
+					mysql_escape_string(buffer, parm.c_str(), parm.length());
+					res.append(buffer);
+				}
 			}
 		}
+		return res;
+	}
 
-		*queryend = 0;
-
-		req->query.q = query;
+	ModuleSQL* Parent()
+	{
+		return (ModuleSQL*)(Module*)creator;
+	}
 
-		if (!mysql_real_query(connection, req->query.q.data(), req->query.q.length()))
+	void DoBlockingQuery(SQLQuery* req)
+	{
+		/* Parse the command string and dispatch it to mysql */
+		if (CheckConnection() && !mysql_real_query(connection, req->query.data(), req->query.length()))
 		{
 			/* Successfull query */
-			res = mysql_use_result(connection);
+			MYSQL_RES* res = mysql_use_result(connection);
 			unsigned long rows = mysql_affected_rows(connection);
-			MySQLresult* r = new MySQLresult(Parent, req->source, res, rows, req->id);
-			r->dbid = this->GetID();
-			r->query = req->query.q;
-			/* Put this new result onto the results queue.
-			 * XXX: Remember to mutex the queue!
-			 */
-			Parent->ResultsMutex.Lock();
-			rq.push_back(r);
-			Parent->ResultsMutex.Unlock();
+			MySQLresult* r = new MySQLresult(req, res, rows);
+			Parent()->Dispatcher->LockQueue();
+			Parent()->rq.push_back(r);
+			Parent()->Dispatcher->NotifyParent();
+			Parent()->Dispatcher->UnlockQueue();
 		}
 		else
 		{
 			/* XXX: See /usr/include/mysql/mysqld_error.h for a list of
 			 * possible error numbers and error messages */
 			SQLerror e(SQL_QREPLY_FAIL, ConvToStr(mysql_errno(connection)) + std::string(": ") + mysql_error(connection));
-			MySQLresult* r = new MySQLresult(Parent, req->source, e, req->id);
-			r->dbid = this->GetID();
-			r->query = req->query.q;
-
-			Parent->ResultsMutex.Lock();
-			rq.push_back(r);
-			Parent->ResultsMutex.Unlock();
+			MySQLresult* r = new MySQLresult(req, e);
+			Parent()->Dispatcher->LockQueue();
+			Parent()->rq.push_back(r);
+			Parent()->Dispatcher->NotifyParent();
+			Parent()->Dispatcher->UnlockQueue();
 		}
-
-		delete[] query;
-	}
-
-	bool ConnectionLost()
-	{
-		if (&connection)
-		{
-			return (mysql_ping(connection) != 0);
-		}
-		else return false;
 	}
 
 	bool CheckConnection()
 	{
-		if (ConnectionLost())
+		if (mysql_ping(connection) != 0)
 		{
 			return Connect();
 		}
@@ -500,290 +351,106 @@ class SQLConnection : public classbase
 		return mysql_error(connection);
 	}
 
-	const std::string& GetID()
-	{
-		return host.id;
-	}
-
-	std::string GetHost()
-	{
-		return host.host;
-	}
-
-	void setInitialQuery(std::string init)
-	{
-		initquery = init;
-	}
-
-	void SetEnable(bool Enable)
-	{
-		Enabled = Enable;
-	}
-
-	bool IsEnabled()
-	{
-		return Enabled;
-	}
-
 	void Close()
 	{
 		mysql_close(connection);
 	}
 
-	const SQLhost& GetConfHost()
+	void submit(SQLQuery* q)
 	{
-		return host;
+		Parent()->Dispatcher->LockQueue();
+		Parent()->qq.push_back(QueueItem(q, this));
+		Parent()->Dispatcher->UnlockQueueWakeup();
 	}
-
 };
 
-ConnMap Connections;
-
-bool HasHost(const SQLhost &host)
+ModuleSQL::ModuleSQL()
 {
-	for (ConnMap::iterator iter = Connections.begin(); iter != Connections.end(); iter++)
-	{
-		if (host == iter->second->GetConfHost())
-			return true;
-	}
-	return false;
+	Dispatcher = NULL;
 }
 
-bool HostInConf(const SQLhost &h)
+void ModuleSQL::init()
 {
-	ConfigReader conf;
-	for(int i = 0; i < conf.Enumerate("database"); i++)
-	{
-		SQLhost host;
-		host.id		= conf.ReadValue("database", "id", i);
-		host.host	= conf.ReadValue("database", "hostname", i);
-		host.port	= conf.ReadInteger("database", "port", i, true);
-		host.name	= conf.ReadValue("database", "name", i);
-		host.user	= conf.ReadValue("database", "username", i);
-		host.pass	= conf.ReadValue("database", "password", i);
-		host.ssl	= conf.ReadFlag("database", "ssl", i);
-		if (h == host)
-			return true;
-	}
-	return false;
-}
+	Dispatcher = new DispatcherThread(this);
+	ServerInstance->Threads->Start(Dispatcher);
 
-void ClearOldConnections()
-{
-	ConnMap::iterator i,safei;
-	for (i = Connections.begin(); i != Connections.end(); i++)
-	{
-		if (!HostInConf(i->second->GetConfHost()))
-		{
-			delete i->second;
-			safei = i;
-			--i;
-			Connections.erase(safei);
-		}
-	}
+	Implementation eventlist[] = { I_OnRehash };
+	ServerInstance->Modules->Attach(eventlist, this, 1);
 }
 
-void ClearAllConnections()
+ModuleSQL::~ModuleSQL()
 {
-	ConnMap::iterator i;
-	while ((i = Connections.begin()) != Connections.end())
+	if (Dispatcher)
 	{
-		Connections.erase(i);
-		delete i->second;
+		Dispatcher->join();
+		Dispatcher->OnNotify();
+		delete Dispatcher;
 	}
-}
-
-void ConnectDatabases(ModuleSQL* Parent)
-{
-	for (ConnMap::iterator i = Connections.begin(); i != Connections.end(); i++)
+	for(ConnMap::iterator i = connections.begin(); i != connections.end(); i++)
 	{
-		if (i->second->IsEnabled())
-			continue;
-
-		i->second->SetEnable(true);
-		if (!i->second->Connect())
-		{
-			/* XXX: MUTEX */
-			Parent->LoggingMutex.Lock();
-			ServerInstance->Logs->Log("m_mysql",DEFAULT,"SQL: Failed to connect database "+i->second->GetHost()+": Error: "+i->second->GetError());
-			i->second->SetEnable(false);
-			Parent->LoggingMutex.Unlock();
-		}
+		delete i->second;
 	}
 }
 
-void LoadDatabases(ModuleSQL* Parent)
+void ModuleSQL::OnRehash(User* user)
 {
-	ConfigReader conf;
-	Parent->ConnMutex.Lock();
-	ClearOldConnections();
-	for (int j =0; j < conf.Enumerate("database"); j++)
+	Dispatcher->LockQueue();
+	ConnMap conns;
+	ConfigTagList tags = ServerInstance->Config->ConfTags("database");
+	for(ConfigIter i = tags.first; i != tags.second; i++)
 	{
-		SQLhost host;
-		host.id		= conf.ReadValue("database", "id", j);
-		host.host	= conf.ReadValue("database", "hostname", j);
-		host.port	= conf.ReadInteger("database", "port", j, true);
-		host.name	= conf.ReadValue("database", "name", j);
-		host.user	= conf.ReadValue("database", "username", j);
-		host.pass	= conf.ReadValue("database", "password", j);
-		host.ssl	= conf.ReadFlag("database", "ssl", j);
-		std::string initquery = conf.ReadValue("database", "initialquery", j);
-
-		if (HasHost(host))
+		if (i->second->getString("module", "mysql") != "mysql")
 			continue;
-
-		if (!host.id.empty() && !host.host.empty() && !host.name.empty() && !host.user.empty() && !host.pass.empty())
+		std::string id = i->second->getString("id");
+		ConnMap::iterator curr = connections.find(id);
+		if (curr == connections.end())
 		{
-			SQLConnection* ThisSQL = new SQLConnection(host, Parent);
-			Connections[host.id] = ThisSQL;
-
-			ThisSQL->setInitialQuery(initquery);
+			SQLConnection* conn = new SQLConnection(this, i->second);
+			conns.insert(std::make_pair(id, conn));
+			ServerInstance->Modules->AddService(*conn);
 		}
-	}
-	ConnectDatabases(Parent);
-	Parent->ConnMutex.Unlock();
-}
-
-char FindCharId(const std::string &id)
-{
-	char i = 1;
-	for (ConnMap::iterator iter = Connections.begin(); iter != Connections.end(); ++iter, ++i)
-	{
-		if (iter->first == id)
+		else
 		{
-			return i;
+			conns.insert(*curr);
+			connections.erase(curr);
 		}
 	}
-	return 0;
-}
-
-ConnMap::iterator GetCharId(char id)
-{
-	char i = 1;
-	for (ConnMap::iterator iter = Connections.begin(); iter != Connections.end(); ++iter, ++i)
-	{
-		if (i == id)
-			return iter;
-	}
-	return Connections.end();
-}
-
-class DispatcherThread : public SocketThread
-{
- private:
-	ModuleSQL* const Parent;
- public:
-	DispatcherThread(ModuleSQL* CreatorModule) : Parent(CreatorModule) { }
-	~DispatcherThread() { }
-	virtual void Run();
-	virtual void OnNotify();
-};
-
-ModuleSQL::ModuleSQL() : rehashing(false), sqlserv(this, "SQL/mysql", SERVICE_DATA)
-{
-	currid = 0;
-	Dispatcher = NULL;
-}
-
-void ModuleSQL::init()
-{
-	ServerInstance->Modules->AddService(sqlserv);
-
-	Dispatcher = new DispatcherThread(this);
-	ServerInstance->Threads->Start(Dispatcher);
-
-	Implementation eventlist[] = { I_OnRehash };
-	ServerInstance->Modules->Attach(eventlist, this, 1);
-}
-
-ModuleSQL::~ModuleSQL()
-{
-	delete Dispatcher;
-	ClearAllConnections();
-}
-
-unsigned long ModuleSQL::NewID()
-{
-	if (currid+1 == 0)
-		currid++;
-	return ++currid;
-}
-
-void ModuleSQL::OnRequest(Request& request)
-{
-	if(strcmp(SQLREQID, request.id) == 0)
+	for(ConnMap::iterator i = connections.begin(); i != connections.end(); i++)
 	{
-		SQLrequest* req = (SQLrequest*)&request;
-
-		ConnMap::iterator iter;
-
-		Dispatcher->LockQueue();
-		ConnMutex.Lock();
-		if((iter = Connections.find(req->dbid)) != Connections.end())
+		if (i->second->active)
 		{
-			req->id = NewID();
-			iter->second->queue.push(new SQLrequest(*req));
+			// can't delete it now. Next rehash will try to kill it again
+			conns.insert(*i);
 		}
 		else
 		{
-			req->error.Id(SQL_BAD_DBID);
+			ServerInstance->Modules->DelService(*i->second);
+			delete i->second;
 		}
-
-		ConnMutex.Unlock();
-		Dispatcher->UnlockQueueWakeup();
-		/* Yes, it's possible this will generate a spurious wakeup.
-		 * That's fine, it'll just get ignored.
-		 */
 	}
-}
-
-void ModuleSQL::OnRehash(User* user)
-{
-	Dispatcher->LockQueue();
-	rehashing = true;
-	Dispatcher->UnlockQueueWakeup();
+	connections.swap(conns);
+	Dispatcher->UnlockQueue();
 }
 
 Version ModuleSQL::GetVersion()
 {
-	return Version("SQL Service Provider module for all other m_sql* modules", VF_VENDOR);
+	return Version("MySQL support", VF_VENDOR);
 }
 
 void DispatcherThread::Run()
 {
-	LoadDatabases(Parent);
-
-	SQLConnection* conn = NULL;
-
 	this->LockQueue();
 	while (!this->GetExitFlag())
 	{
-		if (Parent->rehashing)
-		{
-			Parent->rehashing = false;
-			LoadDatabases(Parent);
-		}
-
-		conn = NULL;
-		Parent->ConnMutex.Lock();
-		for (ConnMap::iterator i = Connections.begin(); i != Connections.end(); i++)
+		if (!Parent->qq.empty())
 		{
-			if (i->second->queue.totalsize())
-			{
-				conn = i->second;
-				break;
-			}
-		}
-		Parent->ConnMutex.Unlock();
-
-		if (conn)
-		{
-			/* There's an item! */
+			QueueItem i = Parent->qq.front();
+			Parent->qq.pop_front();
+			i.c->active = true;
 			this->UnlockQueue();
-			conn->DoLeadingQuery();
-			this->NotifyParent();
+			i.c->DoBlockingQuery(i.q);
 			this->LockQueue();
-			conn->queue.pop();
+			i.c->active = false;
 		}
 		else
 		{
@@ -798,35 +465,20 @@ void DispatcherThread::Run()
 
 void DispatcherThread::OnNotify()
 {
-	SQLConnection* conn;
-	while (1)
+	// this could unlock during the dispatch, but OnResult isn't expected to take that long
+	this->LockQueue();
+	for(ResultQueue::iterator i = Parent->rq.begin(); i != Parent->rq.end(); i++)
 	{
-		conn = NULL;
-		Parent->ConnMutex.Lock();
-		for (ConnMap::iterator iter = Connections.begin(); iter != Connections.end(); iter++)
-		{
-			if (!iter->second->rq.empty())
-			{
-				conn = iter->second;
-				break;
-			}
-		}
-		Parent->ConnMutex.Unlock();
-
-		if (!conn)
-			break;
-
-		Parent->ResultsMutex.Lock();
-		ResultQueue::iterator n = conn->rq.begin();
-		Parent->ResultsMutex.Unlock();
-
-		(*n)->Send();
-		delete (*n);
-
-		Parent->ResultsMutex.Lock();
-		conn->rq.pop_front();
-		Parent->ResultsMutex.Unlock();
+		MySQLresult* res = *i;
+		if (res->err.id == SQL_NO_ERROR)
+			res->query->OnResult(*res);
+		else
+			res->query->OnError(res->err);
+		delete res->query;
+		delete res;
 	}
+	Parent->rq.clear();
+	this->UnlockQueue();
 }
 
 MODULE_INIT(ModuleSQL)
diff --git a/src/modules/extra/m_sqlite3.cpp b/src/modules/extra/m_sqlite3.cpp
index e4b1e7266..b13d42bca 100644
--- a/src/modules/extra/m_sqlite3.cpp
+++ b/src/modules/extra/m_sqlite3.cpp
@@ -58,6 +58,7 @@ class SQLite3Result : public SQLResult
 			return false;
 		}
 	}
+
 	virtual void GetCols(std::vector<std::string>& result)
 	{
 		result.assign(columns.begin(), columns.end());