initial import of sqlitex

dlls/sqlite/sqlitepp/ISQLDriver.h

@@ -0,0 +1,136 @@
+#ifndef _INCLUDE_SOURCEMOD_DATABASE2_H
+#define _INCLUDE_SOURCEMOD_DATABASE2_H
+
+#include <stdarg.h>
+
+namespace SourceMod
+{
+	class IResultRow
+	{
+	public:
+		/**
+		 * This will return NULL if the entry is NULL.
+		 * Remember that in SQL, a field can have NULL 
+		 *  entries, which are not the same as 0 or "".
+		 */
+		virtual const char *GetString(unsigned int columnId) =0;
+		virtual double GetDouble(unsigned int columnId) =0;
+		virtual float GetFloat(unsigned int columnId) =0;
+		virtual int GetInt(unsigned int columnId) =0;
+		virtual bool IsNull(unsigned int columnId) =0;
+		/**
+		 * NULL can be returned.  The length will be zero if so.
+		 */
+		virtual const char *GetRaw(unsigned int columnId, size_t *length) =0;
+	};
+
+	class IResultSet
+	{
+	public:
+		//free the handle if necessary (see IQuery).
+		virtual void FreeHandle() =0;
+	public: //Basic stuff
+		virtual unsigned int RowCount() =0;
+		virtual unsigned int FieldCount() =0;
+		virtual const char *FieldNumToName(unsigned int num) =0;
+		virtual bool FieldNameToNum(const char *name, unsigned int *columnId) =0;
+	public: //iteration
+		/**
+		 * Returns true if there are no more handles left.
+		 */
+		virtual bool IsDone() =0;
+		/**
+		 * Returns the current row.  If "IsDone()" is false
+		 *  this is guaranteed to return non-NULL.
+		 * Handles to IResultRow are guaranteed to not leak
+		 *  (you don't need to free them), however,
+		 *  they should be considered volatile - don't cache
+		 *  them.
+		 */
+		virtual IResultRow *GetRow() =0;
+		/**
+		 * Advances to the next row.  Note that you need to
+		 *  call IsDone() after each call to NextRow().
+		 */
+		virtual void NextRow() =0;
+	};
+
+	struct QueryInfo
+	{
+		IResultSet *rs;
+		unsigned long long affected_rows;
+		int errorcode;
+		bool success;
+	};
+
+	class IQuery
+	{
+	public:
+		//you must free the handle when done
+		virtual void FreeHandle() =0;
+	public:
+		/**
+		 * Executes the query.  Specify optional error string buffer.
+		 * If "info" is NULL, no results will be stored.
+		 * Returns false on failure.
+		 * Calling Execute() multiple times will cause each result handle
+		 *  to be freed in succession.  That means that you do not need to 
+		 *  explicitly free IResultSets when using Execute(), but their
+		 *  handles are deep-invalidated on succesive calls, and
+		 *  thus Execute() is also not thread safe.
+		 */
+		virtual bool Execute(QueryInfo *info, char *error, size_t maxlength) =0;
+		/**
+		 * Same as above, except result handles are not freed for you.
+		 */
+		virtual bool ExecuteR(QueryInfo *info, char *error, size_t maxlength) =0;
+	};
+
+	class ISQLDriver;
+
+	class IDatabase
+	{
+	public:
+		/** 
+		 * Closes the database and frees the handle.
+		 */
+		virtual void FreeHandle() =0;
+		/**
+		 * Returns the parent driver.
+		 */
+		virtual ISQLDriver *Driver() =0;
+	public:
+		/**
+		 * Query preparation.
+		 */
+		virtual IQuery *PrepareQueryFmt(const char *fmt, ...) =0;
+		virtual IQuery *PrepareQueryFmt(const char *fmt, va_list ap) =0;
+		virtual IQuery *PrepareQuery(const char *query) =0;
+		/**
+		 * Quotes a string properly.
+		 * Returns 0 on success.  On failure, returns
+		 *  the size of the buffer needed, or a negative number
+		 *  on internal failure.
+		 */
+		virtual int QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newsize) =0;
+	};
+
+	struct DatabaseInfo
+	{
+		const char *host;
+		const char *database;
+		const char *user;
+		const char *pass;
+		unsigned int port;
+	};
+
+	class ISQLDriver
+	{
+	public:
+		virtual IDatabase *Connect(DatabaseInfo *info, int *errcode, char *error, size_t maxlength) =0;
+		virtual const char *NameString() =0;
+		virtual bool IsCompatDriver(const char *namestring) =0;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_DATABASE2_H

dlls/sqlite/sqlitepp/SqliteDatabase.cpp

@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <string.h>
+#include "SqliteDriver.h"
+#include "SqliteDatabase.h"
+#include "SqliteQuery.h"
+
+#if defined WIN32 && !defined vsnprintf
+#define vsnprintf _vsnprintf
+#endif
+
+using namespace SourceMod;
+
+SqliteDatabase::SqliteDatabase(sqlite3 *sql, SqliteDriver *drvr) : 
+	m_pSql(sql), m_pParent(drvr)
+{
+}
+
+SqliteDatabase::~SqliteDatabase()
+{
+	Disconnect();
+}
+
+void SqliteDatabase::Disconnect()
+{
+	if (m_pSql)
+	{
+		sqlite3_close(m_pSql);
+		m_pSql = NULL;
+	}
+}
+
+void SqliteDatabase::FreeHandle()
+{
+	delete this;
+}
+
+ISQLDriver *SqliteDatabase::Driver()
+{
+	return static_cast<ISQLDriver *>(m_pParent);
+}
+
+IQuery *SqliteDatabase::PrepareQuery(const char *query)
+{
+	SqliteQuery *pQuery = new SqliteQuery(this, query);
+	return static_cast<IQuery *>(pQuery);
+}
+
+IQuery *SqliteDatabase::PrepareQueryFmt(const char *fmt, va_list ap)
+{
+	char buffer[4096];
+
+	vsnprintf(buffer, sizeof(buffer)-1, fmt, ap);
+	
+	return PrepareQuery(buffer);
+}
+
+IQuery *SqliteDatabase::PrepareQueryFmt(const char *fmt, ...)
+{
+	va_list ap;
+	IQuery *qry;
+
+	va_start(ap, fmt);
+	qry = PrepareQueryFmt(fmt, ap);
+	va_end(ap);
+
+	return qry;
+}
+
+int SqliteDatabase::QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newsize)
+{
+	unsigned long size = static_cast<unsigned long>(strlen(str));
+	unsigned long needed = size*2 + 1;
+
+	if (size < needed)
+		return (int)needed;
+
+	sqlite3_snprintf(static_cast<int>(maxlen), buffer, "%q", str);
+
+	return 0;
+}

dlls/sqlite/sqlitepp/SqliteDatabase.h

@@ -0,0 +1,34 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_DATABASE_H
+#define _INCLUDE_SOURCEMOD_SQLITE_DATABASE_H
+
+#include "SqliteHeaders.h"
+#include "SqliteDriver.h"
+
+namespace SourceMod
+{
+	class SqliteDriver;
+
+	class SqliteDatabase : public IDatabase
+	{
+		friend class SqliteQuery;
+	public:
+		SqliteDatabase(sqlite3 *sql, SqliteDriver *drvr);
+		~SqliteDatabase();
+	public:
+		void FreeHandle();
+		ISQLDriver *Driver();
+	public:
+		IQuery *PrepareQueryFmt(const char *fmt, ...);
+		IQuery *PrepareQueryFmt(const char *fmt, va_list ap);
+		IQuery *PrepareQuery(const char *query);
+		int QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newsize);
+	private:
+		void Disconnect();
+	private:
+		sqlite3 *m_pSql;
+		SqliteDriver *m_pParent;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_DATABASE_H
+

dlls/sqlite/sqlitepp/SqliteDriver.cpp

@@ -0,0 +1,44 @@
+#include <string.h>
+#include <stdio.h>
+#include "SqliteHeaders.h"
+#include "SqliteDriver.h"
+#include "SqliteDatabase.h"
+
+#if defined WIN32
+#define snprintf _snprintf
+#define strncasecmp strnicmp
+#endif
+
+using namespace SourceMod;
+
+bool SqliteDriver::IsCompatDriver(const char *namestr)
+{
+	return (strncasecmp(namestr, "sqlite", 5) == 0);
+}
+
+const char *SqliteDriver::NameString()
+{
+	return "sqlite";
+}
+
+IDatabase *SqliteDriver::Connect(DatabaseInfo *info, int *errcode, char *error, size_t maxlength)
+{
+	sqlite3 *pSql;
+	int err = sqlite3_open(info->database, &pSql);
+	if (err != SQLITE_OK)
+	{
+		if (errcode)
+		{
+			*errcode = sqlite3_errcode(pSql);
+		}
+		if (error)
+		{
+			snprintf(error, maxlength, "%s", sqlite3_errmsg(pSql));
+		}
+		sqlite3_close(pSql);
+		return NULL;
+	} else {
+		SqliteDatabase *pDb = new SqliteDatabase(pSql, this);
+		return static_cast<IDatabase *>(pDb);
+	}
+}

dlls/sqlite/sqlitepp/SqliteDriver.h

@@ -0,0 +1,17 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_DRIVER_H
+#define _INCLUDE_SOURCEMOD_SQLITE_DRIVER_H
+
+#include "SqliteHeaders.h"
+
+namespace SourceMod
+{
+	class SqliteDriver : public ISQLDriver
+	{
+	public:
+		IDatabase *Connect(DatabaseInfo *info, int *errcode, char *error, size_t maxlength);
+		const char *NameString();
+		bool IsCompatDriver(const char *namestr);
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_DRIVER_H

dlls/sqlite/sqlitepp/SqliteHeaders.h

@@ -0,0 +1,17 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_HEADERS_H
+#define _INCLUDE_SOURCEMOD_SQLITE_HEADERS_H
+
+#if _MSC_VER >= 1400
+	/* disable deprecation warnings */
+	#if !defined _CRT_SECURE_NO_DEPRECATE
+		#define	_CRT_SECURE_NO_DEPRECATE
+	#endif
+
+	#pragma warning (disable:4996)
+#endif //_MSC_VER >= 1400
+
+#include <ISQLDriver.h>
+
+#include "sqlite3.h"
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_HEADERS_H

dlls/sqlite/sqlitepp/SqliteQuery.cpp

@@ -0,0 +1,93 @@
+#include <stdio.h>
+#include <string.h>
+#include "SqliteQuery.h"
+#include "SqliteDatabase.h"
+#include "SqliteResultSet.h"
+
+#if defined WIN32
+#define snprintf _snprintf
+#endif
+
+using namespace SourceMod;
+
+SqliteQuery::SqliteQuery(SqliteDatabase *db, const char *query) : 
+	m_pDatabase(db), m_LastRes(NULL)
+{
+	m_QueryString = new char[strlen(query)+1];
+	strcpy(m_QueryString, query);
+}
+
+SqliteQuery::~SqliteQuery()
+{
+	if (m_LastRes)
+	{
+		m_LastRes->FreeHandle();
+		m_LastRes = NULL;
+	}
+
+	delete [] m_QueryString;
+}
+
+void SqliteQuery::FreeHandle()
+{
+	delete this;
+}
+
+bool SqliteQuery::Execute(QueryInfo *info, char *error, size_t maxlength)
+{
+	bool res = ExecuteR(info, error, maxlength);
+	
+	if (m_LastRes)
+	{
+		m_LastRes->FreeHandle();
+	}
+
+	m_LastRes = (SqliteResultSet *)info->rs;
+
+	return res;
+}
+
+bool SqliteQuery::ExecuteR(QueryInfo *info, char *error, size_t maxlength)
+{
+	int err;
+	char *errmsg;
+	char **results;
+	int rows, cols;
+
+	err = sqlite3_get_table(m_pDatabase->m_pSql, m_QueryString, &results, &rows, &cols, &errmsg);
+
+	if (err != SQLITE_OK)
+	{
+		if (error && maxlength && errmsg)
+		{
+			snprintf(error, maxlength, "%s", errmsg);
+		}
+		info->affected_rows = 0;
+		info->errorcode = err;
+		info->rs = NULL;
+		info->success = false;
+	} else {
+		info->affected_rows = sqlite3_changes(m_pDatabase->m_pSql);
+		info->errorcode = 0;
+		info->success = true;
+		if (cols)
+		{
+			SqliteResults data;
+			data.cols = cols;
+			data.rows = rows;
+			data.results = results;
+
+			SqliteResultSet *pRes = new SqliteResultSet(data);
+			m_LastRes = pRes;
+			info->rs = static_cast<IResultSet *>(pRes);
+		} else {
+			info->rs = NULL;
+			if (results)
+			{
+				sqlite3_free_table(results);
+			}
+		}
+	}
+
+	return info->success;
+}

dlls/sqlite/sqlitepp/SqliteQuery.h

@@ -0,0 +1,34 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_QUERY_H
+#define _INCLUDE_SOURCEMOD_SQLITE_QUERY_H
+
+#include "SqliteHeaders.h"
+
+namespace SourceMod
+{
+	class SqliteDatabase;;
+	class SqliteResultSet;
+
+	class SqliteQuery : public IQuery
+	{
+	public:
+		struct SqliteResults
+		{
+			char **results;
+			int rows;
+			int cols;
+		};
+	public:
+		SqliteQuery(SqliteDatabase *db, const char *query);
+		~SqliteQuery();
+	public:
+		void FreeHandle();
+		bool Execute(QueryInfo *info, char *error, size_t maxlength);
+		bool ExecuteR(QueryInfo *info, char *error, size_t maxlength);
+	private:
+		SqliteDatabase *m_pDatabase;
+		SqliteResultSet *m_LastRes;
+		char *m_QueryString;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_QUERY_H

dlls/sqlite/sqlitepp/SqliteResultSet.cpp

@@ -0,0 +1,160 @@
+#include <string.h>
+#include <stdlib.h>
+#include "SqliteResultSet.h"
+
+using namespace SourceMod;
+
+SqliteResultSet::SqliteResultSet(SqliteQuery::SqliteResults &res)
+{
+	m_pResults = res.results;
+	m_Columns = res.cols;
+	m_Rows = res.rows;
+
+	m_CurRow = 1;
+	m_CurIndex = (m_CurRow * m_Columns);
+}
+
+SqliteResultSet::~SqliteResultSet()
+{
+	if (m_pResults)
+	{
+		sqlite3_free_table(m_pResults);
+		m_pResults = NULL;
+	}
+}
+
+const char *SqliteResultSet::GetStringSafe(unsigned int columnId)
+{
+	if (columnId > m_Columns)
+	{
+		return "";
+	}
+
+	const char *data = m_pResults[m_CurIndex + columnId];
+
+	return data ? data : "";
+}
+
+const char *SqliteResultSet::GetString(unsigned int columnId)
+{
+	if (columnId > m_Columns)
+	{
+		return NULL;
+	}
+
+	return m_pResults[m_CurIndex + columnId];
+}
+
+bool SqliteResultSet::IsNull(unsigned int columnId)
+{
+	return (GetString(columnId) == NULL);
+}
+
+double SqliteResultSet::GetDouble(unsigned int columnId)
+{
+	return atof(GetStringSafe(columnId));
+}
+
+float SqliteResultSet::GetFloat(unsigned int columnId)
+{
+	return (float)atof(GetStringSafe(columnId));
+}
+
+int SqliteResultSet::GetInt(unsigned int columnId)
+{
+	return atoi(GetStringSafe(columnId));
+}
+
+/**
+ * :TODO: - convert this whole beast to sqlite3_prepare/step
+ * that way we get finer control and actual raw/null data.
+ */
+const char *SqliteResultSet::GetRaw(unsigned int columnId, size_t *length)
+{
+	if (columnId >= m_Columns)
+	{
+		if (length)
+		{
+			*length = 0;
+		}
+		return NULL;
+	}
+
+	const char *str = GetString(columnId);
+	if (!str)
+	{
+		if (length)
+		{
+			*length = 0;
+		}
+		return NULL;
+	} else {
+		if (length)
+		{
+			*length = strlen(str);
+		}
+		return str;
+	}
+}
+
+void SqliteResultSet::FreeHandle()
+{
+	delete this;
+}
+
+IResultRow *SqliteResultSet::GetRow()
+{
+	return static_cast<IResultRow *>(this);
+}
+
+unsigned int SqliteResultSet::RowCount()
+{
+	return m_Rows;
+}
+
+const char *SqliteResultSet::FieldNumToName(unsigned int num)
+{
+	if (num >= m_Columns)
+	{
+		return NULL;
+	}
+
+	return m_pResults[num];
+}
+
+bool SqliteResultSet::FieldNameToNum(const char *name, unsigned int *columnId)
+{
+	for (unsigned int i=0; i<m_Columns; i++)
+	{
+		if (strcmp(m_pResults[i], name) == 0)
+		{
+			if (columnId)
+			{
+				*columnId = i;
+			}
+			return true;
+		}
+	}
+
+	if (columnId)
+	{
+		*columnId = -1;
+	}
+
+	return false;
+}
+
+unsigned int SqliteResultSet::FieldCount()
+{
+	return m_Columns;
+}
+
+bool SqliteResultSet::IsDone()
+{
+	return (m_CurRow > m_Rows);
+}
+
+void SqliteResultSet::NextRow()
+{
+	m_CurIndex = (++m_CurRow * m_Columns);
+}

dlls/sqlite/sqlitepp/SqliteResultSet.h

@@ -0,0 +1,53 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_RESULTSET_H
+#define _INCLUDE_SOURCEMOD_SQLITE_RESULTSET_H
+
+#include "SqliteHeaders.h"
+#include "SqliteDriver.h"
+#include "SqliteDatabase.h"
+#include "SqliteQuery.h"
+
+namespace SourceMod
+{
+	class SqliteResultSet : public IResultSet, public IResultRow
+	{
+		/** 
+		 * IResultSet
+		 */
+	public:
+		SqliteResultSet(SqliteQuery::SqliteResults &res);
+		~SqliteResultSet();
+	public:
+		void FreeHandle();
+	public: 
+		unsigned int RowCount();
+		unsigned int FieldCount();
+		const char *FieldNumToName(unsigned int num);
+		bool FieldNameToNum(const char *name, unsigned int *columnId);
+	public:
+		bool IsDone();
+		IResultRow *GetRow();
+		void NextRow();
+	public:
+		/** 
+		 * IResultRow
+		 */
+	public:
+		const char *GetString(unsigned int columnId);
+		double GetDouble(unsigned int columnId);
+		float GetFloat(unsigned int columnId);
+		int GetInt(unsigned int columnId);
+		bool IsNull(unsigned int columnId);
+		const char *GetRaw(unsigned int columnId, size_t *length);
+	private:
+		const char *GetStringSafe(unsigned int columnId);
+	private:
+		char **m_pResults;
+		unsigned int m_Columns;
+		unsigned int m_Rows;
+		unsigned int m_CurRow;
+		unsigned int m_CurIndex;
+	};
+};
+
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_RESULTSET_H