Convert SQLite driver to SQLv3

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@12603 e03df62e-2008-0410-955e-edbf42e46eb7

1 files changed, 106 insertions, 474 deletions

diff --git a/src/modules/extra/m_sqlite3.cpp b/src/modules/extra/m_sqlite3.cpp
index 902355a23..4a0538bc8 100644
--- a/src/modules/extra/m_sqlite3.cpp
+++ b/src/modules/extra/m_sqlite3.cpp
@@ -13,52 +13,24 @@
 
 #include "inspircd.h"
 #include <sqlite3.h>
-#include "m_sqlv2.h"
+#include "sql.h"
 
 /* $ModDesc: sqlite3 provider */
 /* $CompileFlags: pkgconfversion("sqlite3","3.3") pkgconfincludes("sqlite3","/sqlite3.h","") */
 /* $LinkerFlags: pkgconflibs("sqlite3","/libsqlite3.so","-lsqlite3") */
-/* $ModDep: m_sqlv2.h */
 /* $NoPedantic */
 
 class SQLConn;
-class SQLite3Result;
-class ResultNotifier;
-class SQLiteListener;
-class ModuleSQLite3;
+typedef std::map<std::string, reference<SQLConn> > ConnMap;
 
-typedef std::map<std::string, SQLConn*> ConnMap;
-typedef std::deque<classbase*> paramlist;
-typedef std::deque<SQLite3Result*> ResultQueue;
-
-static unsigned long count(const char * const str, char a)
+class SQLite3Result : public SQLResult
 {
-	unsigned long n = 0;
-	for (const char *p = str; *p; ++p)
-	{
-		if (*p == '?')
-			++n;
-	}
-	return n;
-}
-
-class SQLite3Result : public SQLresult
-{
- private:
+ public:
 	int currentrow;
 	int rows;
-	int cols;
+	std::vector<std::vector<std::string> > fieldlists;
 
-	std::vector<std::string> colnames;
-	std::vector<SQLfieldList> fieldlists;
-	SQLfieldList emptyfieldlist;
-
-	SQLfieldList* fieldlist;
-	SQLfieldMap* fieldmap;
-
- public:
-	SQLite3Result(Module* self, Module* to, unsigned int rid)
-	: SQLresult(self, to, rid), currentrow(0), rows(0), cols(0), fieldlist(NULL), fieldmap(NULL)
+	SQLite3Result() : currentrow(0), rows(0)
 	{
 	}
 
@@ -66,391 +38,169 @@ class SQLite3Result : public SQLresult
 	{
 	}
 
-	void AddRow(int colsnum, char **dat, char **colname)
-	{
-		colnames.clear();
-		cols = colsnum;
-		for (int i = 0; i < colsnum; i++)
-		{
-			fieldlists.resize(fieldlists.size()+1);
-			colnames.push_back(colname[i]);
-			SQLfield sf(dat[i] ? dat[i] : "", dat[i] ? false : true);
-			fieldlists[rows].push_back(sf);
-		}
-		rows++;
-	}
-
-	void UpdateAffectedCount()
-	{
-		rows++;
-	}
-
 	virtual int Rows()
 	{
 		return rows;
 	}
 
-	virtual int Cols()
+	virtual bool GetRow(std::vector<std::string>& result)
 	{
-		return cols;
-	}
-
-	virtual std::string ColName(int column)
-	{
-		if (column < (int)colnames.size())
+		if (currentrow < rows)
 		{
-			return colnames[column];
+			result.assign(fieldlists[currentrow].begin(), fieldlists[currentrow].end());
+			currentrow++;
+			return true;
 		}
 		else
 		{
-			throw SQLbadColName();
+			result.clear();
+			return false;
 		}
-		return "";
 	}
+};
 
-	virtual int ColNum(const std::string &column)
-	{
-		for (unsigned int i = 0; i < colnames.size(); i++)
-		{
-			if (column == colnames[i])
-				return i;
-		}
-		throw SQLbadColName();
-		return 0;
-	}
+class SQLConn : public refcountbase
+{
+ private:
+	sqlite3* conn;
+	reference<ConfigTag> config;
 
-	virtual SQLfield GetValue(int row, int column)
+ public:
+	SQLConn(ConfigTag* tag) : config(tag)
 	{
-		if ((row >= 0) && (row < rows) && (column >= 0) && (column < Cols()))
+		std::string host = tag->getString("hostname");
+		if (sqlite3_open_v2(host.c_str(), &conn, SQLITE_OPEN_READWRITE, 0) != SQLITE_OK)
 		{
-			return fieldlists[row][column];
+			ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + tag->getString("id"));
+			conn = NULL;
 		}
-
-		throw SQLbadColName();
-
-		/* XXX: We never actually get here because of the throw */
-		return SQLfield("",true);
 	}
 
-	virtual SQLfieldList& GetRow()
+	~SQLConn()
 	{
-		if (currentrow < rows)
-			return fieldlists[currentrow];
-		else
-			return emptyfieldlist;
+		sqlite3_interrupt(conn);
+		sqlite3_close(conn);
 	}
 
-	virtual SQLfieldMap& GetRowMap()
+	void Query(SQLQuery* query)
 	{
-		/* In an effort to reduce overhead we don't actually allocate the map
-		 * until the first time it's needed...so...
-		 */
-		if(fieldmap)
+		SQLite3Result res;
+		sqlite3_stmt *stmt;
+		int err = sqlite3_prepare_v2(conn, query->query.c_str(), query->query.length(), &stmt, NULL);
+		if (err != SQLITE_OK)
 		{
-			fieldmap->clear();
+			SQLerror error(SQL_QSEND_FAIL, sqlite3_errmsg(conn));
+			query->OnError(error);
+			return;
 		}
-		else
+		int cols = sqlite3_column_count(stmt);
+		while (1)
 		{
-			fieldmap = new SQLfieldMap;
-		}
-
-		if (currentrow < rows)
-		{
-			for (int i = 0; i < Cols(); i++)
+			err = sqlite3_step(stmt);
+			if (err == SQLITE_ROW)
 			{
-				fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));
+				// Add the row
+				res.fieldlists.resize(res.rows + 1);
+				res.fieldlists[res.rows].resize(cols);
+				for(int i=0; i < cols; i++)
+				{
+					const char* txt = (const char*)sqlite3_column_text(stmt, i);
+					res.fieldlists[res.rows][i] = txt ? txt : "";
+				}
+				res.rows++;
 			}
-			currentrow++;
-		}
-
-		return *fieldmap;
-	}
-
-	virtual SQLfieldList* GetRowPtr()
-	{
-		fieldlist = new SQLfieldList();
-
-		if (currentrow < rows)
-		{
-			for (int i = 0; i < Rows(); i++)
+			else if (err == SQLITE_DONE)
 			{
-				fieldlist->push_back(fieldlists[currentrow][i]);
+				query->OnResult(res);
+				break;
 			}
-			currentrow++;
-		}
-		return fieldlist;
-	}
-
-	virtual SQLfieldMap* GetRowMapPtr()
-	{
-		fieldmap = new SQLfieldMap();
-
-		if (currentrow < rows)
-		{
-			for (int i = 0; i < Cols(); i++)
+			else
 			{
-				fieldmap->insert(std::make_pair(colnames[i],GetValue(currentrow, i)));
+				SQLerror error(SQL_QREPLY_FAIL, sqlite3_errmsg(conn));
+				query->OnError(error);
+				break;
 			}
-			currentrow++;
 		}
-
-		return fieldmap;
+		sqlite3_finalize(stmt);
 	}
-
-	virtual void Free(SQLfieldMap* fm)
-	{
-		delete fm;
-	}
-
-	virtual void Free(SQLfieldList* fl)
-	{
-		delete fl;
-	}
-
-
 };
 
-class SQLConn : public classbase
+class SQLiteProvider : public SQLProvider
 {
- private:
-	ResultQueue results;
-	Module* mod;
-	SQLhost host;
-	sqlite3* conn;
-
  public:
-	SQLConn(Module* m, const SQLhost& hi)
-	: mod(m), host(hi)
-	{
-		if (OpenDB() != SQLITE_OK)
-		{
-			ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + host.id);
-			CloseDB();
-		}
-	}
+	ConnMap hosts;
 
-	~SQLConn()
-	{
-		CloseDB();
-	}
+	SQLiteProvider(Module* Parent) : SQLProvider(Parent, "SQL/SQLite") {}
 
-	SQLerror Query(SQLrequest &req)
+	std::string FormatQuery(std::string q, ParamL p)
 	{
-		/* 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 res;
+		unsigned int param = 0;
+		for(std::string::size_type i = 0; i < q.length(); i++)
 		{
-			if (i->size() > maxparamlen)
-				maxparamlen = i->size();
-		}
-
-		/* 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
-		 */
-
-		query = new char[req.query.q.length() + (maxparamlen*paramcount*2) + 1];
-		queryend = query;
-
-		for(unsigned long i = 0; i < req.query.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 sqlite 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'))
-				{
-					numbered = true;
-					++i;
-					paramnum = paramnum * 10 + req.query.q[i] - '0';
-				}
-
-				if (paramnum > paramscopy.size() - 1)
+				// TODO numbered parameter support ('?1')
+				if (param < p.size())
 				{
-					/* index is out of range!
-					 */
-					numbered = false;
-				}
-
-
-				if (numbered)
-				{
-					char* escaped;
-					escaped = sqlite3_mprintf("%q", paramscopy[paramnum].c_str());
-					for (char* n = escaped; *n; n++)
-					{
-						*queryend = *n;
-						queryend++;
-					}
+					char* escaped = sqlite3_mprintf("%q", p[param++].c_str());
+					res.append(escaped);
 					sqlite3_free(escaped);
 				}
-				else if (req.query.p.size())
-				{
-					char* escaped;
-					escaped = sqlite3_mprintf("%q", req.query.p.front().c_str());
-					for (char* n = escaped; *n; n++)
-					{
-						*queryend = *n;
-						queryend++;
-					}
-					sqlite3_free(escaped);
-					req.query.p.pop_front();
-				}
-				else
-					break;
-			}
-			else
-			{
-				*queryend = req.query.q[i];
-				queryend++;
 			}
 		}
-		*queryend = 0;
-		req.query.q = query;
-
-		SQLite3Result* res = new SQLite3Result(mod, req.source, req.id);
-		res->dbid = host.id;
-		res->query = req.query.q;
-		paramlist params;
-		params.push_back(this);
-		params.push_back(res);
-
-		char *errmsg = 0;
-		sqlite3_update_hook(conn, QueryUpdateHook, &params);
-		if (sqlite3_exec(conn, req.query.q.data(), QueryResult, &params, &errmsg) != SQLITE_OK)
-		{
-			std::string error(errmsg);
-			sqlite3_free(errmsg);
-			delete[] query;
-			delete res;
-			return SQLerror(SQL_QSEND_FAIL, error);
-		}
-		delete[] query;
-
-		results.push_back(res);
-		SendResults();
-		return SQLerror();
-	}
-
-	static int QueryResult(void *params, int argc, char **argv, char **azColName)
-	{
-		paramlist* p = (paramlist*)params;
-		((SQLConn*)(*p)[0])->ResultReady(((SQLite3Result*)(*p)[1]), argc, argv, azColName);
-		return 0;
-	}
-
-	static void QueryUpdateHook(void *params, int eventid, char const * azSQLite, char const * azColName, sqlite_int64 rowid)
-	{
-		paramlist* p = (paramlist*)params;
-		((SQLConn*)(*p)[0])->AffectedReady(((SQLite3Result*)(*p)[1]));
-	}
-
-	void ResultReady(SQLite3Result *res, int cols, char **data, char **colnames)
-	{
-		res->AddRow(cols, data, colnames);
+		return res;
 	}
 
-	void AffectedReady(SQLite3Result *res)
+	std::string FormatQuery(std::string q, ParamM p)
 	{
-		res->UpdateAffectedCount();
-	}
-
-	int OpenDB()
-	{
-		return sqlite3_open_v2(host.host.c_str(), &conn, SQLITE_OPEN_READWRITE, 0);
-	}
-
-	void CloseDB()
-	{
-		sqlite3_interrupt(conn);
-		sqlite3_close(conn);
-	}
-
-	SQLhost GetConfHost()
-	{
-		return host;
-	}
-
-	void SendResults()
-	{
-		while (results.size())
+		std::string res;
+		for(std::string::size_type i = 0; i < q.length(); i++)
 		{
-			SQLite3Result* res = results[0];
-			if (res->dest)
-			{
-				res->Send();
-			}
+			if (q[i] != '$')
+				res.push_back(q[i]);
 			else
 			{
-				/* If the client module is unloaded partway through a query then the provider will set
-				 * the pointer to NULL. We cannot just cancel the query as the result will still come
-				 * through at some point...and it could get messy if we play with invalid pointers...
-				 */
-				delete res;
+				std::string field;
+				i++;
+				while (i < q.length() && isalpha(q[i]))
+					field.push_back(q[i++]);
+				i--;
+
+				char* escaped = sqlite3_mprintf("%q", p[field].c_str());
+				res.append(escaped);
+				sqlite3_free(escaped);
 			}
-			results.pop_front();
 		}
+		return res;
 	}
-
-	void ClearResults()
+	
+	void submit(SQLQuery* query)
 	{
-		while (results.size())
+		ConnMap::iterator iter = hosts.find(query->dbid);
+		if (iter == hosts.end())
+		{
+			SQLerror err(SQL_BAD_DBID);
+			query->OnError(err);
+		}
+		else
 		{
-			SQLite3Result* res = results[0];
-			delete res;
-			results.pop_front();
+			iter->second->Query(query);
 		}
+		delete query;
 	}
-
 };
 
-
 class ModuleSQLite3 : public Module
 {
  private:
-	ConnMap connections;
-	unsigned long currid;
-	ServiceProvider sqlserv;
+	SQLiteProvider sqlserv;
 
  public:
 	ModuleSQLite3()
-	: currid(0), sqlserv(this, "SQL/sqlite", SERVICE_DATA)
+	: sqlserv(this)
 	{
 	}
 
@@ -466,145 +216,27 @@ class ModuleSQLite3 : public Module
 
 	virtual ~ModuleSQLite3()
 	{
-		ClearQueue();
-		ClearAllConnections();
-	}
-
-	void ClearQueue()
-	{
-		for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
-		{
-			iter->second->ClearResults();
-		}
-	}
-
-	bool HasHost(const SQLhost &host)
-	{
-		for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
-		{
-			if (host == iter->second->GetConfHost())
-				return true;
-		}
-		return false;
-	}
-
-	bool HostInConf(const SQLhost &h)
-	{
-		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);
-			if (h == host)
-				return true;
-		}
-		return false;
 	}
 
 	void ReadConf()
 	{
-		ClearOldConnections();
-
-		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);
-
-			if (HasHost(host))
-				continue;
-
-			this->AddConn(host);
-		}
-	}
-
-	void AddConn(const SQLhost& hi)
-	{
-		if (HasHost(hi))
+		sqlserv.hosts.clear();
+		ConfigTagList tags = ServerInstance->Config->ConfTags("database");
+		for(ConfigIter i = tags.first; i != tags.second; i++)
 		{
-			ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: A sqlite connection with id: %s already exists. Aborting database open attempt.", hi.id.c_str());
-			return;
+			sqlserv.hosts.insert(std::make_pair(i->second->getString("id"), new SQLConn(i->second)));
 		}
-
-		SQLConn* newconn;
-
-		newconn = new SQLConn(this, hi);
-
-		connections.insert(std::make_pair(hi.id, newconn));
 	}
 
-	void ClearOldConnections()
-	{
-		ConnMap::iterator iter,safei;
-		for (iter = connections.begin(); iter != connections.end(); iter++)
-		{
-			if (!HostInConf(iter->second->GetConfHost()))
-			{
-				delete iter->second;
-				safei = iter;
-				--iter;
-				connections.erase(safei);
-			}
-		}
-	}
-
-	void ClearAllConnections()
-	{
-		ConnMap::iterator i;
-		while ((i = connections.begin()) != connections.end())
-		{
-			connections.erase(i);
-			delete i->second;
-		}
-	}
-
-	virtual void OnRehash(User* user)
+	void OnRehash(User* user)
 	{
 		ReadConf();
 	}
 
-	void OnRequest(Request& request)
-	{
-		if(strcmp(SQLREQID, request.id) == 0)
-		{
-			SQLrequest* req = (SQLrequest*)&request;
-			ConnMap::iterator iter;
-			if((iter = connections.find(req->dbid)) != connections.end())
-			{
-				req->id = NewID();
-				req->error = iter->second->Query(*req);
-			}
-			else
-			{
-				req->error.Id(SQL_BAD_DBID);
-			}
-		}
-	}
-
-	unsigned long NewID()
-	{
-		if (currid+1 == 0)
-			currid++;
-
-		return ++currid;
-	}
-
-	virtual Version GetVersion()
+	Version GetVersion()
 	{
 		return Version("sqlite3 provider", VF_VENDOR);
 	}
-
 };
 
 MODULE_INIT(ModuleSQLite3)