Spring Cleaning, Part Ichi (1)

Various minor things done to project files
Updated sample extension project file and updated makefile to the new unified version (more changes likely on the way)
Updated regex project file and makefile

--HG--
extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401971

extensions/mysql/mysql/MyBasicResults.cpp

@@ -0,0 +1,367 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+#include <stdlib.h>
+#include "MyBasicResults.h"
+
+MyBasicResults::MyBasicResults(MYSQL_RES *res)
+: m_pRes(res)
+{
+	Update();
+}
+
+MyBasicResults::~MyBasicResults()
+{
+}
+
+void MyBasicResults::Update()
+{
+	if (m_pRes)
+	{
+		m_ColCount = (unsigned int)mysql_num_fields(m_pRes);
+		m_RowCount = (unsigned int)mysql_num_rows(m_pRes);
+		m_CurRow = 0;
+		m_Row = NULL;
+	}
+}
+
+unsigned int MyBasicResults::GetRowCount()
+{
+	return m_RowCount;
+}
+
+unsigned int MyBasicResults::GetFieldCount()
+{
+	return m_ColCount;
+}
+
+bool MyBasicResults::FieldNameToNum(const char *name, unsigned int *columnId)
+{
+	unsigned int total = GetFieldCount();
+
+	for (unsigned int i=0; i<total; i++)
+	{
+		if (strcmp(FieldNumToName(i), name) == 0)
+		{
+			*columnId = i;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+const char *MyBasicResults::FieldNumToName(unsigned int colId)
+{
+	if (colId >= GetFieldCount())
+	{
+		return NULL;
+	}
+
+	MYSQL_FIELD *field = mysql_fetch_field_direct(m_pRes, colId);
+	return field ? (field->name ? field->name : "") : "";
+}
+
+bool MyBasicResults::MoreRows()
+{
+	return (m_CurRow < m_RowCount);
+}
+
+IResultRow *MyBasicResults::FetchRow()
+{
+	if (m_CurRow >= m_RowCount)
+	{
+		/* Put us one after so we know to block CurrentRow() */
+		m_CurRow = m_RowCount + 1;
+		return NULL;
+	}
+	m_Row = mysql_fetch_row(m_pRes);
+	m_Lengths = mysql_fetch_lengths(m_pRes);
+	m_CurRow++;
+	return this;
+}
+
+IResultRow *MyBasicResults::CurrentRow()
+{
+	if (!m_pRes
+		|| !m_CurRow
+		|| m_CurRow > m_RowCount)
+	{
+		return NULL;
+	}
+	
+	return this;
+}
+
+bool MyBasicResults::Rewind()
+{
+	mysql_data_seek(m_pRes, 0);
+	m_CurRow = 0;
+	return true;
+}
+
+DBType MyBasicResults::GetFieldType(unsigned int field)
+{
+	if (field >= m_ColCount)
+	{
+		return DBType_Unknown;
+	}
+
+	MYSQL_FIELD *fld = mysql_fetch_field_direct(m_pRes, field);
+	if (!fld)
+	{
+		return DBType_Unknown;
+	}
+
+	return GetOurType(fld->type);
+}
+
+DBType MyBasicResults::GetFieldDataType(unsigned int field)
+{
+	DBType type = GetFieldType(field);
+	if (type == DBType_Blob)
+	{
+		return DBType_Blob;
+	} else {
+		return DBType_String;
+	}
+}
+
+bool MyBasicResults::IsNull(unsigned int columnId)
+{
+	if (columnId >= m_ColCount)
+	{
+		return true;
+	}
+
+	return (m_Row[columnId] == NULL);
+}
+
+DBResult MyBasicResults::GetString(unsigned int columnId, const char **pString, size_t *length)
+{
+	if (columnId >= m_ColCount)
+	{
+		return DBVal_Error;
+	} else if (m_Row[columnId] == NULL) {
+		*pString = "";
+		if (length)
+		{
+			*length = 0;
+		}
+		return DBVal_Null;
+	}
+
+	*pString = m_Row[columnId];
+
+	if (length)
+	{
+		*length = (size_t)m_Lengths[columnId];
+	}
+
+	return DBVal_Data;
+}
+
+DBResult MyBasicResults::CopyString(unsigned int columnId, 
+									char *buffer, 
+									size_t maxlength, 
+									size_t *written)
+{
+	DBResult res;
+	const char *str;
+	if ((res=GetString(columnId, &str, NULL)) == DBVal_Error)
+	{
+		return DBVal_Error;
+	}
+
+	size_t wr = strncopy(buffer, str, maxlength);
+	if (written)
+	{
+		*written = wr;
+	}
+
+	return res;
+}
+
+size_t MyBasicResults::GetDataSize(unsigned int columnId)
+{
+	if (columnId >= m_ColCount)
+	{
+		return 0;
+	}
+
+	return (size_t)m_Lengths[columnId];
+}
+
+DBResult MyBasicResults::GetFloat(unsigned int col, float *fval)
+{
+	if (col >= m_ColCount)
+	{
+		return DBVal_Error;
+	} else if (m_Row[col] == NULL) {
+		*fval = 0.0f;
+		return DBVal_Null;
+	}
+
+	*fval = (float)atof(m_Row[col]);
+
+	return DBVal_Data;
+}
+
+DBResult MyBasicResults::GetInt(unsigned int col, int *val)
+{
+	if (col >= m_ColCount)
+	{
+		return DBVal_Error;
+	} else if (m_Row[col] == NULL) {
+		*val = 0;
+		return DBVal_Null;
+	}
+
+	*val = atoi(m_Row[col]);
+
+	return DBVal_Data;
+}
+
+DBResult MyBasicResults::GetBlob(unsigned int col, const void **pData, size_t *length)
+{
+	if (col >= m_ColCount)
+	{
+		return DBVal_Error;
+	} else if (m_Row[col] == NULL) {
+		*pData = NULL;
+		if (length)
+		{
+			*length = 0;
+		}
+		return DBVal_Null;
+	}
+
+	*pData = m_Row[col];
+
+	if (length)
+	{
+		*length = (size_t)m_Lengths[col];
+	}
+
+	return DBVal_Data;
+}
+
+DBResult MyBasicResults::CopyBlob(unsigned int columnId, void *buffer, size_t maxlength, size_t *written)
+{
+	const void *addr;
+	size_t length;
+	DBResult res;
+
+	if ((res=GetBlob(columnId, &addr, &length)) == DBVal_Error)
+	{
+		return DBVal_Error;
+	}
+
+	if (addr == NULL)
+	{
+		return DBVal_Null;
+	}
+
+	if (length > maxlength)
+	{
+		length = maxlength;
+	}
+
+	memcpy(buffer, addr, length);
+	if (written)
+	{
+		*written = length;
+	}
+
+	return res;
+}
+
+MyQuery::MyQuery(MyDatabase *db, MYSQL_RES *res)
+: m_pParent(db), m_rs(res)
+{
+	m_pParent->IncReferenceCount();
+}
+
+IResultSet *MyQuery::GetResultSet()
+{
+	if (m_rs.m_pRes == NULL)
+	{
+		return NULL;
+	}
+
+	return &m_rs;
+}
+
+bool MyQuery::FetchMoreResults()
+{
+	if (m_rs.m_pRes == NULL)
+	{
+		return false;
+	} else if (!mysql_more_results(m_pParent->m_mysql)) {
+		return false;
+	}
+
+	mysql_free_result(m_rs.m_pRes);
+	m_rs.m_pRes = NULL;
+
+	if (mysql_next_result(m_pParent->m_mysql) != 0)
+	{
+		return false;
+	}
+
+	m_rs.m_pRes = mysql_store_result(m_pParent->m_mysql);
+	m_rs.Update();
+
+	return (m_rs.m_pRes != NULL);
+}
+
+void MyQuery::Destroy()
+{
+	/* :TODO: All this rot should be moved into the destructor,
+	 * and the Update() function needs to not be so stupid.
+	 */
+
+	while (FetchMoreResults())
+	{
+		/* Spin until all are gone */
+	}
+
+	/* Free the last, if any */
+	if (m_rs.m_pRes != NULL)
+	{
+		mysql_free_result(m_rs.m_pRes);
+	}
+
+	/* Tell our parent we're done */
+	m_pParent->Close();
+
+	/* Self destruct */
+	delete this;
+}

extensions/mysql/mysql/MyBasicResults.h

@@ -0,0 +1,95 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SM_MYSQL_BASIC_RESULTS_H_
+#define _INCLUDE_SM_MYSQL_BASIC_RESULTS_H_
+
+#include "MyDatabase.h"
+
+class MyQuery;
+
+class MyBasicResults : 
+	public IResultSet,
+	public IResultRow
+{
+	friend class MyQuery;
+public:
+	MyBasicResults(MYSQL_RES *res);
+	~MyBasicResults();
+public: //IResultSet
+	unsigned int GetRowCount();
+	unsigned int GetFieldCount();
+	const char *FieldNumToName(unsigned int columnId);
+	bool FieldNameToNum(const char *name, unsigned int *columnId);
+	bool MoreRows();
+	IResultRow *FetchRow();
+	bool Rewind();
+	DBType GetFieldType(unsigned int field);
+	DBType GetFieldDataType(unsigned int field);
+	IResultRow *CurrentRow();
+public: //IResultRow
+	DBResult GetString(unsigned int columnId, const char **pString, size_t *length);
+	DBResult GetFloat(unsigned int columnId, float *pFloat);
+	DBResult GetInt(unsigned int columnId, int *pInt);
+	bool IsNull(unsigned int columnId);
+	DBResult GetBlob(unsigned int columnId, const void **pData, size_t *length);
+	DBResult CopyBlob(unsigned int columnId, void *buffer, size_t maxlength, size_t *written);
+	DBResult CopyString(unsigned int columnId, 
+						char *buffer, 
+						size_t maxlength, 
+						size_t *written);
+	size_t GetDataSize(unsigned int columnId);
+protected:
+	void Update();
+private:
+	MYSQL_RES *m_pRes;
+	unsigned int m_CurRow;
+	MYSQL_ROW m_Row;
+	unsigned long *m_Lengths;
+	unsigned int m_ColCount;
+	unsigned int m_RowCount;
+};
+
+class MyQuery : public IQuery
+{
+	friend class MyBasicResults;
+public:
+	MyQuery(MyDatabase *db, MYSQL_RES *res);
+public:
+	IResultSet *GetResultSet();
+	bool FetchMoreResults();
+	void Destroy();
+private:
+	MyDatabase *m_pParent;
+	MyBasicResults m_rs;
+};
+
+#endif //_INCLUDE_SM_MYSQL_BASIC_RESULTS_H_

extensions/mysql/mysql/MyBoundResults.cpp

@@ -0,0 +1,668 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include "MyBoundResults.h"
+
+#define DEFAULT_BUFFER_SIZE		5
+
+/* :IDEA: When we have to refetch a buffer to do type changes, should we rebind
+ * the buffer so the next fetch will predict the proper cast?  Probably yes since
+ * these things are done in standard iterations, but maybe users should be punished
+ * for not using the API as it was intended?  Maybe it should be an option set to 
+ * on by default to catch the bad users?
+ */
+
+enum_field_types GetTheirType(DBType type)
+{
+	switch (type)
+	{
+	case DBType_Float:
+		{
+			return MYSQL_TYPE_FLOAT;
+		}
+	case DBType_Integer:
+		{
+			return MYSQL_TYPE_LONG;
+		}
+	case DBType_String:
+		{
+			return MYSQL_TYPE_STRING;
+		}
+	case DBType_Blob:
+		{
+			return MYSQL_TYPE_BLOB;
+		}
+	case DBType_Unknown:
+		{
+			return MYSQL_TYPE_STRING;
+		}
+	}
+
+	return MYSQL_TYPE_STRING;
+}
+
+MyBoundResults::MyBoundResults(MYSQL_STMT *stmt, MYSQL_RES *res)
+: m_stmt(stmt), m_pRes(res), m_Initialized(false), m_RowCount(0), m_CurRow(0)
+{
+	/**
+	 * Important things to note here: 
+	 * 1) We're guaranteed at least one field.
+	 * 2) The field information should never change, and thus we
+	 *    never rebuild it.  If someone ALTERs the table during
+	 *    a prepared query's lifetime, it's their own death.
+	 */
+
+	m_ColCount = (unsigned int)mysql_num_fields(m_pRes);
+
+	/* Allocate buffers */
+	m_bind = (MYSQL_BIND *)malloc(sizeof(MYSQL_BIND) * m_ColCount);
+	m_pull = (ResultBind *)malloc(sizeof(ResultBind) * m_ColCount);
+
+	/* Zero data */
+	memset(m_bind, 0, sizeof(MYSQL_BIND) * m_ColCount);
+	memset(m_pull, 0, sizeof(ResultBind) * m_ColCount);
+}
+
+MyBoundResults::~MyBoundResults()
+{
+	if (m_Initialized)
+	{
+		/* Make sure we free our internal buffers */
+		for (unsigned int i=0; i<m_ColCount; i++)
+		{
+			delete [] m_pull[i].blob;
+		}
+	}
+
+	free(m_pull);
+	free(m_bind);
+}
+
+void MyBoundResults::Update()
+{
+	m_RowCount = (unsigned int)mysql_stmt_num_rows(m_stmt);
+	m_CurRow = 0;
+}
+
+bool MyBoundResults::Initialize()
+{
+	/* Check if we need to build our result binding information */
+	if (!m_Initialized)
+	{
+		for (unsigned int i=0; i<m_ColCount; i++)
+		{
+			MYSQL_FIELD *field = mysql_fetch_field_direct(m_pRes, i);
+			DBType type = GetOurType(field->type);
+
+			m_bind[i].length = &(m_pull[i].my_length);
+			m_bind[i].is_null = &(m_pull[i].my_null);
+
+			if (type == DBType_Integer)
+			{
+				m_bind[i].buffer_type = MYSQL_TYPE_LONG;
+				m_bind[i].buffer = &(m_pull[i].data.ival);
+			} else if (type == DBType_Float) {
+				m_bind[i].buffer_type = MYSQL_TYPE_FLOAT;
+				m_bind[i].buffer = &(m_pull[i].data.ival);
+			} else if (type == DBType_String || type == DBType_Blob) {
+				m_bind[i].buffer_type = GetTheirType(type);
+
+				/* We bound this to 2048 bytes.  Otherwise a MEDIUMBLOB
+				 * or something could allocate horrible amounts of memory
+				 * because MySQL is incompetent.  
+				 */
+				size_t creat_length = (size_t)field->length;
+				if (!creat_length || creat_length > DEFAULT_BUFFER_SIZE)
+				{
+					creat_length = DEFAULT_BUFFER_SIZE;
+				}
+				m_pull[i].blob = new unsigned char[creat_length];
+				m_pull[i].length = creat_length;
+
+				m_bind[i].buffer = m_pull[i].blob;
+				m_bind[i].buffer_length = (unsigned long)creat_length;
+			} else {
+				return false;
+			}
+		}
+		m_Initialized = true;
+	}
+
+	/* Do the actual bind */
+	return (mysql_stmt_bind_result(m_stmt, m_bind) == 0);
+}
+
+unsigned int MyBoundResults::GetRowCount()
+{
+	return m_RowCount;
+}
+
+unsigned int MyBoundResults::GetFieldCount()
+{
+	return m_ColCount;
+}
+
+const char *MyBoundResults::FieldNumToName(unsigned int columnId)
+{
+	if (columnId >= m_ColCount)
+	{
+		return NULL;
+	}
+
+	MYSQL_FIELD *field = mysql_fetch_field_direct(m_pRes, columnId);
+
+	return field ? (field->name ? field->name : "") : "";
+}
+
+bool MyBoundResults::FieldNameToNum(const char *name, unsigned int *columnId)
+{
+	for (unsigned int i=0; i<m_ColCount; i++)
+	{
+		if (strcmp(name, FieldNumToName(i)) == 0)
+		{
+			*columnId = i;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool MyBoundResults::MoreRows()
+{
+	return (m_CurRow < m_RowCount);
+}
+
+IResultRow *MyBoundResults::FetchRow()
+{
+	if (!MoreRows())
+	{
+		m_CurRow = m_RowCount + 1;
+		return NULL;
+	}
+
+	m_CurRow++;
+
+	/* We should be able to get another row */
+	int err = mysql_stmt_fetch(m_stmt);
+	if (err == 0 || err == MYSQL_DATA_TRUNCATED)
+	{
+		return this;
+	}
+
+	if (err == MYSQL_NO_DATA && m_CurRow == m_RowCount)
+	{
+		return this;
+	}
+
+	/* Some sort of error occurred */
+	return NULL;
+}
+
+IResultRow *MyBoundResults::CurrentRow()
+{
+	if (!m_CurRow || m_CurRow > m_RowCount)
+	{
+		return NULL;
+	}
+
+	return this;
+}
+
+bool MyBoundResults::Rewind()
+{
+	mysql_stmt_data_seek(m_stmt, 0);
+	m_CurRow = 0;
+	return true;
+}
+
+DBType MyBoundResults::GetFieldType(unsigned int field)
+{
+	if (field >= m_ColCount)
+	{
+		return DBType_Unknown;
+	}
+
+	MYSQL_FIELD *fld = mysql_fetch_field_direct(m_pRes, field);
+	return GetOurType(fld->type);
+}
+
+DBType MyBoundResults::GetFieldDataType(unsigned int field)
+{
+	return GetFieldType(field);
+}
+
+void ResizeBuffer(ResultBind *bind, size_t len)
+{
+	if (!bind->blob)
+	{
+		bind->blob = new unsigned char[len];
+		bind->length = len;
+	} else if (bind->length < len) {
+		delete [] bind->blob;
+		bind->blob = new unsigned char[len];
+		bind->length = len;
+	}
+}
+
+bool RefetchField(MYSQL_STMT *stmt, 
+				  ResultBind *rbind, 
+				  unsigned int id,
+				  size_t initSize,
+				  enum_field_types type)
+{
+	/* Make sure there is a buffer to pull into */
+	ResizeBuffer(rbind, initSize);
+
+	MYSQL_BIND bind;
+
+	/* Initialize bind info */
+	memset(&bind, 0, sizeof(MYSQL_BIND));
+	bind.buffer = rbind->blob;
+	bind.buffer_type = type;
+	bind.buffer_length = (unsigned long)rbind->length;
+	bind.length = &(rbind->my_length);
+	bind.is_null = &(rbind->my_null);
+
+	/* Attempt to fetch */
+	return (mysql_stmt_fetch_column(stmt, &bind, id, 0) == 0);
+}
+
+DBResult RefetchSize4Field(MYSQL_STMT *stmt,
+						unsigned int id,
+						void *buffer,
+						enum_field_types type)
+{
+	MYSQL_BIND bind;
+	my_bool is_null;
+
+	/* Initialize bind info  */
+	memset(&bind, 0, sizeof(MYSQL_BIND));
+	bind.buffer = buffer;
+	bind.buffer_type = type;
+	bind.is_null = &is_null;
+
+	/* Attempt to fetch */
+	if (mysql_stmt_fetch_column(stmt, &bind, id, 0) != 0)
+	{
+		return DBVal_TypeMismatch;
+	}
+
+	return is_null ? DBVal_Null : DBVal_Data;
+}
+
+
+bool RefetchUserField(MYSQL_STMT *stmt,
+					  unsigned int id,
+					  void *userbuf,
+					  size_t userlen,
+					  enum_field_types type,
+					  my_bool &is_null,
+					  size_t *written)
+{
+	MYSQL_BIND bind;
+	unsigned long length;
+
+	/* Initialize bind info */
+	memset(&bind, 0, sizeof(MYSQL_BIND));
+	bind.buffer = userbuf;
+	bind.buffer_type = type;
+	bind.length = &length;
+	bind.is_null = &is_null;
+	bind.buffer_length = (unsigned long)userlen;
+
+	if (mysql_stmt_fetch_column(stmt, &bind, id, 0) != 0)
+	{
+		return false;
+	}
+
+	if (is_null)
+	{
+		return true;
+	}
+
+	if (type == MYSQL_TYPE_STRING && (size_t)length == userlen)
+	{
+		/* Enforce null termination in case MySQL forgot.
+		 * Note we subtract one from the length (which must be >= 1)
+		 * so we can pass the number of bytes written below.
+		 */
+		char *data = (char *)userbuf;
+		data[--userlen] = '\0';
+	}
+
+	if (written)
+	{
+		/* In the case of strings, they will never be equal */
+		*written = (userlen < length) ? userlen : length;
+	}
+
+	return true;
+}
+
+#define BAD_COL_CHECK() \
+	if (id >= m_ColCount) \
+		return DBVal_Error;
+
+#define STR_NULL_CHECK_0(var) \
+	if (var) { \
+		*pString = NULL; \
+		if (length) \
+			*length = 0; \
+		return DBVal_Null; \
+	}
+
+DBResult MyBoundResults::GetString(unsigned int id, const char **pString, size_t *length)
+{
+	BAD_COL_CHECK();
+
+	STR_NULL_CHECK_0(m_pull[id].my_null);
+
+	if (m_bind[id].buffer_type != MYSQL_TYPE_STRING)
+	{
+		/* Ugh, we have to re-get this as a string.  Sigh, stupid user.
+		 * We're going to disallow conversions from blobs.
+		 */
+		if (m_bind[id].buffer_type == MYSQL_TYPE_BLOB)
+		{
+			return DBVal_TypeMismatch;
+		}
+
+		/* Attempt to refetch the string */
+		if (!RefetchField(m_stmt, &m_pull[id], id, 128, MYSQL_TYPE_STRING))
+		{
+			return DBVal_TypeMismatch;
+		}
+
+		/* Check if we have a new null */
+		STR_NULL_CHECK_0(m_pull[id].my_null);
+	}
+
+	/* Okay, we should now have a blob type whether we originally wanted one or not. */
+
+	/* Check if the size is too small.  Note that MySQL will not null terminate small buffers,
+	 * and it returns the size without the null terminator.  This means we need to add an extra
+	 * byte onto the end to accept the terminator until there is a workaround.
+	 *
+	 * Note that we do an >= check because MySQL appears to want the null terminator included,
+	 * so just to be safe and avoid its inconsistencies, we make sure we'll always have room.
+	 */
+	if ((size_t)(m_pull[id].my_length) >= m_pull[id].length)
+	{
+		/* Yes, we need to refetch. */
+		if (!RefetchField(m_stmt, &m_pull[id], id, m_pull[id].my_length + 1, MYSQL_TYPE_STRING))
+		{
+			return DBVal_Error;
+		}
+	}
+
+	/* Finally, we can return.  We're guaranteed to have a properly NULL-terminated string
+	 * here because we have refetched the string to a bigger length.
+	 */
+	*pString = (const char *)m_pull[id].blob;
+	if (length)
+	{
+		*length = (size_t)m_pull[id].my_length;
+	}
+
+	return DBVal_Data;
+}
+
+#define STR_NULL_CHECK_1(var) \
+	if (var) { \
+		buffer[0] = '\0'; \
+		if (written) \
+			*written = 0; \
+		return DBVal_Null; \
+	} 
+
+DBResult MyBoundResults::CopyString(unsigned int id, char *buffer, size_t maxlength, size_t *written)
+{
+	BAD_COL_CHECK();
+
+	STR_NULL_CHECK_1(m_pull[id].my_null);
+
+	if (!buffer || !maxlength)
+	{
+		return DBVal_Error;
+	}
+
+	if (m_bind[id].buffer_type != MYSQL_TYPE_STRING)
+	{
+		/* We're going to disallow conversions from blobs. */
+		if (m_bind[id].buffer_type == MYSQL_TYPE_BLOB)
+		{
+			return DBVal_TypeMismatch;
+		}
+
+		/* Re-fetch this for the user.  This call will guarantee NULL termination. */
+		my_bool is_null;
+		if (!RefetchUserField(m_stmt, id, buffer, maxlength, MYSQL_TYPE_STRING, is_null, written))
+		{
+			return DBVal_TypeMismatch;
+		}
+
+		STR_NULL_CHECK_1(is_null);
+
+		return DBVal_Data;
+	}
+
+	size_t pull_length = (size_t)m_pull[id].my_length;
+	size_t orig_length = m_pull[id].length;
+
+	/* If there's more data in the buffer, we have to look at two cases. */
+	if (pull_length >= orig_length)
+	{
+		/* If the user supplied a bigger buffer, just refetch for them. */
+		if (maxlength > orig_length)
+		{
+			my_bool is_null;
+			RefetchUserField(m_stmt, id, buffer, maxlength, MYSQL_TYPE_STRING, is_null, written);
+			STR_NULL_CHECK_1(is_null);
+			return DBVal_Data;
+		}
+		/* Otherwise, we should enforce null termination from MySQL. */
+		else if (pull_length == orig_length)
+		{
+			char *data = (char *)m_pull[id].blob;
+			data[pull_length] = '\0';
+		}
+	}
+
+	/* If we got here, we need to copy the resultant string to the user and be done with it.
+	 * Null termination is guaranteed from the pulled string.
+	 */
+	size_t wr = strncopy(buffer, (const char *)m_pull[id].blob, maxlength);
+	if (written)
+	{
+		*written = wr;
+	}
+
+	return DBVal_Data;
+}
+
+DBResult MyBoundResults::GetFloat(unsigned int id, float *pFloat)
+{
+	BAD_COL_CHECK();
+
+	if (m_pull[id].my_null)
+	{
+		*pFloat = 0.0f;
+		return DBVal_Null;
+	}
+
+	if (m_bind[id].buffer_type != MYSQL_TYPE_FLOAT)
+	{
+		if (m_bind[id].buffer_type == MYSQL_TYPE_BLOB)
+		{
+			return DBVal_TypeMismatch;
+		}
+		/* We have to convert... */
+		return RefetchSize4Field(m_stmt, id, pFloat, MYSQL_TYPE_FLOAT);
+	}
+
+	*pFloat = m_pull[id].data.fval;
+
+	return DBVal_Data;
+}
+
+DBResult MyBoundResults::GetInt(unsigned int id, int *pInt)
+{
+	BAD_COL_CHECK();
+
+	if (m_pull[id].my_null)
+	{
+		*pInt = 0;
+		return DBVal_Null;
+	}
+
+	if (m_bind[id].buffer_type != MYSQL_TYPE_LONG)
+	{
+		if (m_bind[id].buffer_type == MYSQL_TYPE_BLOB)
+		{
+			return DBVal_TypeMismatch;
+		}
+		/* We have to convert... */
+		return RefetchSize4Field(m_stmt, id, pInt, MYSQL_TYPE_LONG);
+	}
+
+	*pInt = m_pull[id].data.ival;
+
+	return DBVal_Data;
+}
+
+bool MyBoundResults::IsNull(unsigned int id)
+{
+	if (id >= m_ColCount)
+	{
+		return true;
+	}
+
+	return m_pull[id].my_null ? true : false;
+}
+
+#define BLOB_CHECK_NULL_0() \
+	if (m_pull[id].my_null) { \
+		*pData = NULL; \
+		if (length) \
+			*length = 0; \
+		return DBVal_Null; \
+	}
+
+DBResult MyBoundResults::GetBlob(unsigned int id, const void **pData, size_t *length)
+{
+	BAD_COL_CHECK();
+
+	BLOB_CHECK_NULL_0();
+
+	/* We only want blobs to be read as blobs */
+	if (m_bind[id].buffer_type != MYSQL_TYPE_BLOB)
+	{
+		return DBVal_TypeMismatch;
+	}
+
+	if ((size_t)m_pull[id].my_length > m_pull[id].length)
+	{
+		if (!RefetchField(m_stmt, &m_pull[id], id, m_pull[id].my_length, MYSQL_TYPE_BLOB))
+		{
+			return DBVal_TypeMismatch;
+		}
+		BLOB_CHECK_NULL_0();
+	}
+
+	*pData = m_pull[id].blob;
+	if (length)
+	{
+		*length = (size_t)m_pull[id].my_length;
+	}
+
+	return DBVal_Data;
+}
+
+#define BLOB_CHECK_NULL_1(var) \
+	if (var) { \
+		if (written) \
+			*written = 0; \
+		return DBVal_Null; \
+	}
+
+DBResult MyBoundResults::CopyBlob(unsigned int id, void *buffer, size_t maxlength, size_t *written)
+{
+	BAD_COL_CHECK();
+
+	/* We only want blobs to be read as blobs */
+	if (m_bind[id].buffer_type != MYSQL_TYPE_BLOB)
+	{
+		return DBVal_TypeMismatch;
+	}
+
+	BLOB_CHECK_NULL_1(m_pull[id].my_null);
+
+	size_t pull_size = (size_t)m_pull[id].my_length;
+	size_t push_size = m_pull[id].length;
+
+	/* Check if we can do a resize and copy in one step */
+	if (pull_size > push_size
+		&& maxlength > push_size)
+	{
+		my_bool is_null;
+		if (!RefetchUserField(m_stmt, id, buffer, maxlength, MYSQL_TYPE_BLOB, is_null, written))
+		{
+			return DBVal_TypeMismatch;
+		}
+		BLOB_CHECK_NULL_1(is_null);
+		return DBVal_Data;
+	}
+
+	/* If we got here, either there is no more data to refetch,
+	 * or our buffer is too small to receive the refetched data.
+	 */
+	size_t buf_bytes = pull_size > push_size ? push_size : pull_size;
+	size_t to_copy = buf_bytes > maxlength ? maxlength : buf_bytes;
+
+	memcpy(buffer, m_pull[id].blob, to_copy);
+	if (written)
+	{
+		*written = to_copy;
+	}
+
+	return DBVal_Data;
+}
+
+size_t MyBoundResults::GetDataSize(unsigned int id)
+{
+	if (id >= m_ColCount)
+	{
+		return 0;
+	}
+
+	return (size_t)m_pull[id].my_length;
+}

extensions/mysql/mysql/MyBoundResults.h

@@ -0,0 +1,97 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SM_MYSQL_BOUND_RESULTS_H_
+#define _INCLUDE_SM_MYSQL_BOUND_RESULTS_H_
+
+#include "MyDatabase.h"
+
+class MyStatement;
+
+struct ResultBind
+{
+	my_bool my_null;
+	unsigned long my_length;
+	union
+	{
+		int ival;
+		float fval;
+	} data;
+	unsigned char *blob;
+	size_t length;
+};
+
+class MyBoundResults : 
+	public IResultSet,
+	public IResultRow
+{
+	friend class MyStatement;
+public:
+	MyBoundResults(MYSQL_STMT *stmt, MYSQL_RES *res);
+	~MyBoundResults();
+public: //IResultSet
+	unsigned int GetRowCount();
+	unsigned int GetFieldCount();
+	const char *FieldNumToName(unsigned int columnId);
+	bool FieldNameToNum(const char *name, unsigned int *columnId);
+	bool MoreRows();
+	IResultRow *FetchRow();
+	bool Rewind();
+	DBType GetFieldType(unsigned int field);
+	DBType GetFieldDataType(unsigned int field);
+	IResultRow *CurrentRow();
+public: //IResultRow
+	DBResult GetString(unsigned int id, const char **pString, size_t *length);
+	DBResult CopyString(unsigned int id, 
+		char *buffer, 
+		size_t maxlength, 
+		size_t *written);
+	DBResult GetFloat(unsigned int id, float *pFloat);
+	DBResult GetInt(unsigned int id, int *pInt);
+	bool IsNull(unsigned int id);
+	size_t GetDataSize(unsigned int id);
+	DBResult GetBlob(unsigned int id, const void **pData, size_t *length);
+	DBResult CopyBlob(unsigned int id, void *buffer, size_t maxlength, size_t *written);
+public:
+	bool Initialize();
+	void Update();
+private:
+	MYSQL_STMT *m_stmt;
+	MYSQL_RES *m_pRes;
+	MYSQL_BIND *m_bind;
+	ResultBind *m_pull;
+	unsigned int m_ColCount;
+	bool m_Initialized;
+	unsigned int m_RowCount;
+	unsigned int m_CurRow;
+};
+
+#endif //_INCLUDE_SM_MYSQL_BOUND_RESULTS_H_

extensions/mysql/mysql/MyDatabase.cpp

@@ -0,0 +1,318 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include "MyDatabase.h"
+#include "smsdk_ext.h"
+#include "MyBasicResults.h"
+#include "MyStatement.h"
+
+DBType GetOurType(enum_field_types type)
+{
+	switch (type)
+	{
+	case MYSQL_TYPE_DOUBLE:
+	case MYSQL_TYPE_FLOAT:
+		{
+			return DBType_Float;
+		}
+	case MYSQL_TYPE_TINY:
+	case MYSQL_TYPE_SHORT:
+	case MYSQL_TYPE_LONG:
+	case MYSQL_TYPE_INT24:
+	case MYSQL_TYPE_YEAR:
+	case MYSQL_TYPE_BIT:
+		{
+			return DBType_Integer;
+		}
+	case MYSQL_TYPE_LONGLONG:
+	case MYSQL_TYPE_DATE:
+	case MYSQL_TYPE_TIME:
+	case MYSQL_TYPE_DATETIME:
+	case MYSQL_TYPE_TIMESTAMP:
+	case MYSQL_TYPE_NEWDATE:
+	case MYSQL_TYPE_VAR_STRING:
+	case MYSQL_TYPE_VARCHAR:
+	case MYSQL_TYPE_STRING:
+	case MYSQL_TYPE_NEWDECIMAL:
+	case MYSQL_TYPE_DECIMAL:
+	case MYSQL_TYPE_ENUM:
+	case MYSQL_TYPE_SET:
+		{
+			return DBType_String;
+		}
+
+	case MYSQL_TYPE_TINY_BLOB:
+	case MYSQL_TYPE_MEDIUM_BLOB:
+	case MYSQL_TYPE_LONG_BLOB:
+	case MYSQL_TYPE_BLOB:
+	case MYSQL_TYPE_GEOMETRY:
+		{
+			return DBType_Blob;
+		}
+	default:
+		{
+			return DBType_String;
+		}
+	}
+
+	return DBType_Unknown;
+}
+
+MyDatabase::MyDatabase(MYSQL *mysql, const DatabaseInfo *info, bool persistent)
+: m_mysql(mysql), m_refcount(1), m_pFullLock(NULL), m_bPersistent(persistent)
+{
+	m_Host.assign(info->host);
+	m_Database.assign(info->database);
+	m_User.assign(info->user);
+	m_Pass.assign(info->pass);
+
+	m_Info.database = m_Database.c_str();
+	m_Info.host = m_Host.c_str();
+	m_Info.user = m_User.c_str();
+	m_Info.pass = m_Pass.c_str();
+	m_Info.driver = NULL;
+	m_Info.maxTimeout = info->maxTimeout;
+	m_Info.port = info->port;
+
+	m_pRefLock = threader->MakeMutex();
+}
+
+MyDatabase::~MyDatabase()
+{
+	mysql_close(m_mysql);
+	m_mysql = NULL;
+
+	m_pRefLock->DestroyThis();
+	if (m_pFullLock)
+	{
+		m_pFullLock->DestroyThis();
+	}
+}
+
+void MyDatabase::IncReferenceCount()
+{
+	m_pRefLock->Lock();
+	m_refcount++;
+	m_pRefLock->Unlock();
+}
+
+bool MyDatabase::Close()
+{
+	m_pRefLock->Lock();
+	if (m_refcount > 1)
+	{
+		m_refcount--;
+		m_pRefLock->Unlock();
+		return false;
+	}
+	m_pRefLock->Unlock();
+
+	/* Remove us from the search list */
+	if (m_bPersistent)
+	{
+		g_MyDriver.RemoveFromList(this, true);
+	}
+
+	/* Finally, free our resource(s) */
+	delete this;
+
+	return true;
+}
+
+const DatabaseInfo &MyDatabase::GetInfo()
+{
+	return m_Info;
+}
+
+unsigned int MyDatabase::GetInsertID()
+{
+	return (unsigned int)mysql_insert_id(m_mysql);
+}
+
+unsigned int MyDatabase::GetAffectedRows()
+{
+	return (unsigned int)mysql_affected_rows(m_mysql);
+}
+
+const char *MyDatabase::GetError(int *errCode)
+{
+	if (errCode)
+	{
+		*errCode = mysql_errno(m_mysql);
+	}
+
+	return mysql_error(m_mysql);
+}
+
+bool MyDatabase::QuoteString(const char *str, char buffer[], size_t maxlength, size_t *newSize)
+{
+	unsigned long size = static_cast<unsigned long>(strlen(str));
+	unsigned long needed = size * 2 + 1;
+
+	if (maxlength < needed)
+	{
+		if (newSize)
+		{
+			*newSize = (size_t)needed;
+		}
+		return false;
+	}
+
+	needed = mysql_real_escape_string(m_mysql, buffer, str, size);
+	if (newSize)
+	{
+		*newSize = (size_t)needed;
+	}
+
+	return true;
+}
+
+bool MyDatabase::DoSimpleQuery(const char *query)
+{
+	IQuery *pQuery = DoQuery(query);
+	if (!pQuery)
+	{
+		return false;
+	}
+	pQuery->Destroy();
+	return true;
+}
+
+IQuery *MyDatabase::DoQuery(const char *query)
+{
+	if (mysql_real_query(m_mysql, query, strlen(query)) != 0)
+	{
+		return NULL;
+	}
+
+	MYSQL_RES *res = NULL;
+	if (mysql_field_count(m_mysql))
+	{
+		res = mysql_store_result(m_mysql);
+		if (!res)
+		{
+			return NULL;
+		}
+	}
+
+	return new MyQuery(this, res);
+}
+
+bool MyDatabase::DoSimpleQueryEx(const char *query, size_t len)
+{
+	IQuery *pQuery = DoQueryEx(query, len);
+	if (!pQuery)
+	{
+		return false;
+	}
+	pQuery->Destroy();
+	return true;
+}
+
+IQuery *MyDatabase::DoQueryEx(const char *query, size_t len)
+{
+	if (mysql_real_query(m_mysql, query, len) != 0)
+	{
+		return NULL;
+	}
+
+	MYSQL_RES *res = NULL;
+	if (mysql_field_count(m_mysql))
+	{
+		res = mysql_store_result(m_mysql);
+		if (!res)
+		{
+			return NULL;
+		}
+	}
+
+	return new MyQuery(this, res);
+}
+
+IPreparedQuery *MyDatabase::PrepareQuery(const char *query, char *error, size_t maxlength, int *errCode)
+{
+	MYSQL_STMT *stmt = mysql_stmt_init(m_mysql);
+	if (!stmt)
+	{
+		if (error)
+		{
+			strncopy(error, GetError(errCode), maxlength);
+		} else if (errCode) {
+			*errCode = mysql_errno(m_mysql);
+		}
+		return NULL;
+	}
+
+	if (mysql_stmt_prepare(stmt, query, strlen(query)) != 0)
+	{
+		if (error)
+		{
+			strncopy(error, mysql_stmt_error(stmt), maxlength);
+		}
+		if (errCode)
+		{
+			*errCode = mysql_stmt_errno(stmt);
+		}
+		mysql_stmt_close(stmt);
+		return NULL;
+	}
+
+	return new MyStatement(this, stmt);
+}
+
+bool MyDatabase::LockForFullAtomicOperation()
+{
+	if (!m_pFullLock)
+	{
+		m_pFullLock = threader->MakeMutex();
+		if (!m_pFullLock)
+		{
+			return false;
+		}
+	}
+
+	m_pFullLock->Lock();
+
+	return true;
+}
+
+void MyDatabase::UnlockFromFullAtomicOperation()
+{
+	if (m_pFullLock)
+	{
+		m_pFullLock->Unlock();
+	}
+}
+
+IDBDriver *MyDatabase::GetDriver()
+{
+	return &g_MyDriver;
+}

extensions/mysql/mysql/MyDatabase.h

@@ -0,0 +1,82 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SM_MYSQL_DATABASE_H_
+#define _INCLUDE_SM_MYSQL_DATABASE_H_
+
+#include "MyDriver.h"
+#include <IThreader.h>
+
+class MyQuery;
+class MyStatement;
+
+class MyDatabase : public IDatabase
+{
+	friend class MyQuery;
+	friend class MyStatement;
+public:
+	MyDatabase(MYSQL *mysql, const DatabaseInfo *info, bool persistent);
+	~MyDatabase();
+public: //IDatabase
+	bool Close();
+	const char *GetError(int *errorCode=NULL);
+	bool DoSimpleQuery(const char *query);
+	IQuery *DoQuery(const char *query);
+	IPreparedQuery *PrepareQuery(const char *query, char *error, size_t maxlength, int *errCode=NULL);
+	bool QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newSize);
+	unsigned int GetAffectedRows();
+	unsigned int GetInsertID();
+	bool LockForFullAtomicOperation();
+	void UnlockFromFullAtomicOperation();
+	void IncReferenceCount();
+	IDBDriver *GetDriver();
+	bool DoSimpleQueryEx(const char *query, size_t len);
+	IQuery *DoQueryEx(const char *query, size_t len);
+public:
+	const DatabaseInfo &GetInfo();
+private:
+	MYSQL *m_mysql;
+	unsigned int m_refcount;
+	IMutex *m_pFullLock;
+	IMutex *m_pRefLock;
+
+	/* ---------- */
+	DatabaseInfo m_Info;
+	String m_Host;
+	String m_Database;
+	String m_User;
+	String m_Pass;
+	bool m_bPersistent;
+};
+
+DBType GetOurType(enum_field_types type);
+
+#endif //_INCLUDE_SM_MYSQL_DATABASE_H_

extensions/mysql/mysql/MyDriver.cpp

@@ -0,0 +1,233 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include "MyDriver.h"
+#include "MyDatabase.h"
+#include "sdk/smsdk_ext.h"
+
+MyDriver g_MyDriver;
+
+MyDriver::MyDriver()
+{
+	m_MyHandle = BAD_HANDLE;
+}
+
+void CloseDBList(List<MyDatabase *> &l)
+{
+	List<MyDatabase *>::iterator iter;
+	for (iter=l.begin(); iter!=l.end(); iter++)
+	{
+		MyDatabase *db = (*iter);
+		while (!db->Close())
+		{
+			/* Spool until it closes  */
+		}
+	}
+	l.clear();
+}
+
+void MyDriver::Shutdown()
+{
+	List<MyDatabase *>::iterator iter;
+	CloseDBList(m_PermDbs);
+
+	if (m_MyHandle != BAD_HANDLE)
+	{
+		dbi->ReleaseHandle(m_MyHandle, DBHandle_Driver, myself->GetIdentity());
+		m_MyHandle = BAD_HANDLE;
+	}
+}
+
+const char *MyDriver::GetIdentifier()
+{
+	return "mysql";
+}
+
+Handle_t MyDriver::GetHandle()
+{
+	if (m_MyHandle == BAD_HANDLE)
+	{
+		m_MyHandle = dbi->CreateHandle(DBHandle_Driver, this, myself->GetIdentity());
+	}
+
+	return m_MyHandle;
+}
+
+IdentityToken_t *MyDriver::GetIdentity()
+{
+	return myself->GetIdentity();
+}
+
+const char *MyDriver::GetProductName()
+{
+	return "MySQL";
+}
+
+MYSQL *Connect(const DatabaseInfo *info, char *error, size_t maxlength)
+{
+	MYSQL *mysql = mysql_init(NULL);
+	const char *host = NULL, *socket = NULL;
+
+	if (info->maxTimeout > 0)
+	{
+		mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (const char *)&(info->maxTimeout));
+	}
+
+	/* Have MySQL automatically reconnect if it times out or loses connection.
+	 * This will prevent "MySQL server has gone away" errors after a while.
+	 */
+	my_bool my_true = true;
+	mysql_options(mysql, MYSQL_OPT_RECONNECT, (const char *)&my_true);
+
+	if (info->host[0] == '/')
+	{
+		host = "localhost";
+		socket = info->host;
+	}
+	else
+	{
+		host = info->host;
+		socket = NULL;
+	}
+
+	if (!mysql_real_connect(mysql,
+		host,
+		info->user, 
+		info->pass,
+		info->database,
+		info->port,
+		socket,
+		M_CLIENT_MULTI_RESULTS))
+	{
+		/* :TODO: expose UTIL_Format from smutil! */
+		snprintf(error, maxlength, "[%d]: %s", mysql_errno(mysql), mysql_error(mysql));
+		mysql_close(mysql);
+		return NULL;
+	}
+
+	return mysql;
+}
+
+bool CompareField(const char *str1, const char *str2)
+{
+	if ((str1 == NULL && str2 != NULL)
+		|| (str1 != NULL && str2 == NULL))
+	{
+		return false;
+	}
+
+	if (str1 == NULL && str2 == NULL)
+	{
+		return true;
+	}
+
+	return (strcmp(str1, str2) == 0);
+}
+
+IDatabase *MyDriver::Connect(const DatabaseInfo *info, bool persistent, char *error, size_t maxlength)
+{
+	if (persistent)
+	{
+		/* Try to find a matching persistent connection */
+		List<MyDatabase *>::iterator iter;
+		for (iter=m_PermDbs.begin();
+			 iter!=m_PermDbs.end();
+			 iter++)
+		{
+			MyDatabase *db = (*iter);
+			const DatabaseInfo &other = db->GetInfo();
+			if (CompareField(info->host, other.host)
+				&& CompareField(info->user, other.user)
+				&& CompareField(info->pass, other.pass)
+				&& CompareField(info->database, other.database)
+				&& (info->port == other.port))
+			{
+				db->IncReferenceCount();
+				return db;
+			}
+		}
+	}
+
+	MYSQL *mysql = ::Connect(info, error, maxlength);
+	if (!mysql)
+	{
+		return NULL;
+	}
+
+	MyDatabase *db = new MyDatabase(mysql, info, persistent);
+
+	if (persistent)
+	{
+		m_PermDbs.push_back(db);
+	}
+	
+	return db;
+}
+
+void MyDriver::RemoveFromList(MyDatabase *pdb, bool persistent)
+{
+	if (persistent)
+	{
+		m_PermDbs.remove(pdb);
+	}
+}
+
+bool MyDriver::IsThreadSafe()
+{
+	return (mysql_thread_safe() != 0);
+}
+
+bool MyDriver::InitializeThreadSafety()
+{
+	return (mysql_thread_init() == 0);
+}
+
+void MyDriver::ShutdownThreadSafety()
+{
+	mysql_thread_end();
+}
+
+unsigned int strncopy(char *dest, const char *src, size_t count)
+{
+	if (!count)
+	{
+		return 0;
+	}
+
+	char *start = dest;
+	while ((*src) && (--count))
+	{
+		*dest++ = *src++;
+	}
+	*dest = '\0';
+
+	return (dest - start);
+}

extensions/mysql/mysql/MyDriver.h

@@ -0,0 +1,79 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SM_MYSQL_DRIVER_H_
+#define _INCLUDE_SM_MYSQL_DRIVER_H_
+
+#include <IDBDriver.h>
+#include <sm_platform.h>
+#if defined PLATFORM_WINDOWS
+#include <winsock.h>
+#endif
+
+#include <mysql.h>
+
+#include <sh_string.h>
+#include <sh_list.h>
+
+using namespace SourceMod;
+using namespace SourceHook;
+
+#define M_CLIENT_MULTI_RESULTS    ((1) << 17)  /* Enable/disable multi-results */
+
+class MyDatabase;
+
+class MyDriver : public IDBDriver
+{
+public:
+	MyDriver();
+public: //IDBDriver
+	IDatabase *Connect(const DatabaseInfo *info, bool persistent, char *error, size_t maxlength);
+	const char *GetIdentifier();
+	const char *GetProductName();
+	Handle_t GetHandle();
+	IdentityToken_t *GetIdentity();
+	bool IsThreadSafe();
+	bool InitializeThreadSafety();
+	void ShutdownThreadSafety();
+public:
+	void Shutdown();
+	void RemoveFromList(MyDatabase *pdb, bool persistent);
+private:
+	Handle_t m_MyHandle;
+	List<MyDatabase *> m_TempDbs;
+	List<MyDatabase *> m_PermDbs;
+};
+
+extern MyDriver g_MyDriver;
+
+unsigned int strncopy(char *dest, const char *src, size_t count);
+
+#endif //_INCLUDE_SM_MYSQL_DRIVER_H_

extensions/mysql/mysql/MyStatement.cpp

@@ -0,0 +1,288 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include "MyStatement.h"
+#include "MyBoundResults.h"
+
+MyStatement::MyStatement(MyDatabase *db, MYSQL_STMT *stmt)
+: m_mysql(db->m_mysql), m_pParent(db), m_stmt(stmt), m_rs(NULL), m_Results(false)
+{
+	m_Params = (unsigned int)mysql_stmt_param_count(m_stmt);
+
+	if (m_Params)
+	{
+		m_pushinfo = (ParamBind *)malloc(sizeof(ParamBind) * m_Params);
+		memset(m_pushinfo, 0, sizeof(ParamBind) * m_Params);
+		m_bind = (MYSQL_BIND *)malloc(sizeof(MYSQL_BIND) * m_Params);
+		memset(m_bind, 0, sizeof(MYSQL_BIND) * m_Params);
+	} else {
+		m_pushinfo = NULL;
+		m_bind = NULL;
+	}
+
+	m_pParent->IncReferenceCount();
+
+	m_pRes = mysql_stmt_result_metadata(stmt);
+	m_Results = false;
+}
+
+MyStatement::~MyStatement()
+{
+	/* Free result set structures */
+	delete m_rs;
+
+	/* Free old blobs */
+	for (unsigned int i=0; i<m_Params; i++)
+	{
+		free(m_pushinfo[i].blob);
+	}
+
+	/* Free our allocated arrays */
+	free(m_pushinfo);
+	free(m_bind);
+	
+	/* Close our mysql handles */
+	if (m_pRes)
+	{
+		mysql_free_result(m_pRes);
+	}
+	mysql_stmt_close(m_stmt);
+
+	/* Tell the parent database that we're done referencing it */
+	m_pParent->Close();
+}
+
+void MyStatement::Destroy()
+{
+	delete this;
+}
+
+bool MyStatement::FetchMoreResults()
+{
+	/* Multiple result sets are not supported by statements,
+	 * thank god.
+	 */
+	return false;
+}
+
+void *MyStatement::CopyBlob(unsigned int param, const void *blobptr, size_t length)
+{
+	void *copy_ptr = NULL;
+
+	if (m_pushinfo[param].blob != NULL)
+	{
+		if (m_pushinfo[param].length < length)
+		{
+			free(m_pushinfo[param].blob);
+		} else {
+			copy_ptr = m_pushinfo[param].blob;
+		}
+	}
+
+	if (copy_ptr == NULL)
+	{
+		copy_ptr = malloc(length);
+		m_pushinfo[param].blob = copy_ptr;
+		m_pushinfo[param].length = length;
+	}
+
+	memcpy(copy_ptr, blobptr, length);
+
+	return copy_ptr;
+}
+
+bool MyStatement::BindParamInt(unsigned int param, int num, bool signd)
+{
+	if (param >= m_Params)
+	{
+		return false;
+	}
+
+	m_pushinfo[param].data.ival = num;
+	m_bind[param].buffer_type = MYSQL_TYPE_LONG;
+	m_bind[param].buffer = &(m_pushinfo[param].data.ival);
+	m_bind[param].is_unsigned = signd ? 0 : 1;
+	m_bind[param].length = NULL;
+
+	return true;
+}
+
+bool MyStatement::BindParamFloat(unsigned int param, float f)
+{
+	if (param >= m_Params)
+	{
+		return false;
+	}
+
+	m_pushinfo[param].data.fval = f;
+	m_bind[param].buffer_type = MYSQL_TYPE_FLOAT;
+	m_bind[param].buffer = &(m_pushinfo[param].data.fval);
+	m_bind[param].length = NULL;
+
+	return true;
+}
+
+bool MyStatement::BindParamString(unsigned int param, const char *text, bool copy)
+{
+	if (param >= m_Params)
+	{
+		return false;
+	}
+
+	const void *final_ptr;
+	size_t len;
+
+	if (copy)
+	{
+		len = strlen(text);
+		final_ptr = CopyBlob(param, text, len+1);
+	} else {
+		len = strlen(text);
+		final_ptr = text;
+	}
+
+	m_bind[param].buffer_type = MYSQL_TYPE_STRING;
+	m_bind[param].buffer = (void *)final_ptr;
+	m_bind[param].buffer_length = (unsigned long)len;
+	m_bind[param].length = &(m_bind[param].buffer_length);
+
+	return true;
+}
+
+bool MyStatement::BindParamBlob(unsigned int param, const void *data, size_t length, bool copy)
+{
+	if (param >= m_Params)
+	{
+		return false;
+	}
+
+	const void *final_ptr;
+	
+	if (copy)
+	{
+		final_ptr = CopyBlob(param, data, length);
+	} else {
+		final_ptr = data;
+	}
+
+	m_bind[param].buffer_type = MYSQL_TYPE_BLOB;
+	m_bind[param].buffer = (void *)final_ptr;
+	m_bind[param].buffer_length = (unsigned long)length;
+	m_bind[param].length = &(m_bind[param].buffer_length);
+
+	return true;
+}
+
+bool MyStatement::BindParamNull(unsigned int param)
+{
+	if (param >= m_Params)
+	{
+		return false;
+	}
+
+	m_bind[param].buffer_type = MYSQL_TYPE_NULL;
+
+	return true;
+}
+
+bool MyStatement::Execute()
+{
+	/* Clear any past result first! */
+	m_Results = false;
+
+	/* Bind the parameters */
+	if (m_Params)
+	{
+		if (mysql_stmt_bind_param(m_stmt, m_bind) != 0)
+		{
+			return false;
+		}
+	}
+
+	if (mysql_stmt_execute(m_stmt) != 0)
+	{
+		return false;
+	}
+
+	/* Skip away if we don't have data */
+	if (!m_pRes)
+	{
+		return true;
+	}
+
+	/* If we don't have a result manager, create one. */
+	if (!m_rs)
+	{
+		m_rs = new MyBoundResults(m_stmt, m_pRes);
+	}
+
+	/* Tell the result set to update its bind info,
+	 * and initialize itself if necessary.
+	 */
+	if (!(m_Results = m_rs->Initialize()))
+	{
+		return false;
+	}
+
+	/* Try precaching the results. */
+	m_Results = (mysql_stmt_store_result(m_stmt) == 0);
+
+	/* Update now that the data is known. */
+	m_rs->Update();
+
+	/* Return indicator */
+	return m_Results;
+}
+
+const char *MyStatement::GetError(int *errCode/* =NULL */)
+{
+	if (errCode)
+	{
+		*errCode = mysql_stmt_errno(m_stmt);
+	}
+
+	return mysql_stmt_error(m_stmt);
+}
+
+unsigned int MyStatement::GetAffectedRows()
+{
+	return (unsigned int)mysql_stmt_affected_rows(m_stmt);
+}
+
+unsigned int MyStatement::GetInsertID()
+{
+	return (unsigned int)mysql_stmt_insert_id(m_stmt);
+}
+
+IResultSet *MyStatement::GetResultSet()
+{
+	return (m_Results ? m_rs : NULL);
+}

extensions/mysql/mysql/MyStatement.h

@@ -0,0 +1,82 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod MySQL Extension
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SM_MYSQL_STATEMENT_H_
+#define _INCLUDE_SM_MYSQL_STATEMENT_H_
+
+#include "MyDatabase.h"
+#include "MyBoundResults.h"
+
+struct ParamBind
+{
+	union
+	{
+		float fval;
+		int ival;
+	} data;
+	void *blob;
+	size_t length;
+};
+
+class MyStatement : public IPreparedQuery
+{
+public:
+	MyStatement(MyDatabase *db, MYSQL_STMT *stmt);
+	~MyStatement();
+public: //IQuery
+	IResultSet *GetResultSet();
+	bool FetchMoreResults();
+	void Destroy();
+public: //IPreparedQuery
+	bool BindParamInt(unsigned int param, int num, bool signd=true);
+	bool BindParamFloat(unsigned int param, float f);
+	bool BindParamNull(unsigned int param);
+	bool BindParamString(unsigned int param, const char *text, bool copy);
+	bool BindParamBlob(unsigned int param, const void *data, size_t length, bool copy);
+	bool Execute();
+	const char *GetError(int *errCode=NULL);
+	unsigned int GetAffectedRows();
+	unsigned int GetInsertID();
+private:
+	void *CopyBlob(unsigned int param, const void *blobptr, size_t length);
+private:
+	MYSQL *m_mysql;
+	MyDatabase *m_pParent;
+	MYSQL_STMT *m_stmt;
+	MYSQL_BIND *m_bind;
+	MYSQL_RES *m_pRes;
+	ParamBind *m_pushinfo;
+	unsigned int m_Params;
+	MyBoundResults *m_rs;
+	bool m_Results;
+};
+
+#endif //_INCLUDE_SM_MYSQL_STATEMENT_H_