diff --git a/library/Data/DatabaseExtender.cs b/library/Data/DatabaseExtender.cs
index 91453c27..b503e5d8 100644
--- a/library/Data/DatabaseExtender.cs
+++ b/library/Data/DatabaseExtender.cs
@@ -198,202 +198,6 @@ namespace PkmnFoundations.Data
         }
         #endregion
 
-        #region MS-SQL
-        // I can't find anything like a "parameter factory" in ADO.NET nor a virutal clone method,
-        // so we need an implementation of these for each database engine.
-
-        /// <summary>
-        /// Creates a clone of the SqlParameter collection
-        /// </summary>
-        /// <param name="collection">Collection to be cloned</param>
-        public static SqlParameter[] Clone(this IEnumerable<SqlParameter> collection)
-        {
-            int count = collection.Count();
-            SqlParameter[] result = new SqlParameter[count];
-
-            int x = 0;
-            foreach (SqlParameter p in collection)
-            {
-                SqlParameter param = new SqlParameter(p.ParameterName, (SqlDbType)p.DbType, p.Size, p.Direction, p.IsNullable, p.Precision, p.Scale, p.SourceColumn, p.SourceVersion, p.Value);
-                param.DbType = p.DbType;
-                result[x] = param;
-                x++;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Runs a proc and returns its return value.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="return_type">Return value's expected type</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static object ExecuteProcedure(this SqlConnection db, String name, SqlDbType return_type, params SqlParameter[] _params)
-        {
-            return ExecuteProcedureInternal(db.CreateCommand(), name, return_type, _params);
-        }
-
-        /// <summary>
-        /// Runs a proc.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static int ExecuteProcedure(this SqlConnection db, String name, params SqlParameter[] _params)
-        {
-            SqlCommand cmd = db.CreateCommand();
-            cmd.CommandText = name;
-            cmd.CommandType = CommandType.StoredProcedure;
-            cmd.Parameters.AddRange(_params);
-            return cmd.ExecuteNonQuery();
-        }
-
-        /// <summary>
-        /// Runs a proc and returns its return value.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="return_type">Return value's expected type</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static object ExecuteProcedure(this SqlTransaction tran, String name, SqlDbType return_type, params SqlParameter[] _params)
-        {
-            SqlCommand cmd = tran.Connection.CreateCommand();
-            cmd.Transaction = tran;
-            return ExecuteProcedureInternal(cmd, name, return_type, _params);
-        }
-
-        /// <summary>
-        /// Runs a proc.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static int ExecuteProcedure(this SqlTransaction tran, String name, params SqlParameter[] _params)
-        {
-            SqlCommand cmd = tran.Connection.CreateCommand();
-            cmd.CommandText = name;
-            cmd.Transaction = tran;
-            cmd.CommandType = CommandType.StoredProcedure;
-            cmd.Parameters.AddRange(_params);
-            return cmd.ExecuteNonQuery();
-        }
-
-        private static object ExecuteProcedureInternal(SqlCommand cmd, String name, SqlDbType return_type, SqlParameter[] _params)
-        {
-            cmd.CommandText = name;
-            cmd.CommandType = CommandType.StoredProcedure;
-            cmd.Parameters.AddRange(_params);
-            string pname = "result";
-            while (cmd.Parameters.Contains("@" + pname)) pname = "x" + pname;
-            pname = "@" + pname;
-            SqlParameter p = new SqlParameter(pname, return_type);
-            p.Direction = ParameterDirection.ReturnValue;
-            cmd.Parameters.Add(p);
-            cmd.ExecuteNonQuery();
-            return cmd.Parameters[pname].Value;
-        }
-        #endregion
-
-        #region MySQL
-        // I can't find anything like a "parameter factory" in ADO.NET nor a virutal clone method,
-        // so we need an implementation of these for each database engine.
-
-        /// <summary>
-        /// Creates a clone of the SqlParameter collection
-        /// </summary>
-        /// <param name="collection">Collection to be cloned</param>
-        public static MySqlParameter[] Clone(this IEnumerable<MySqlParameter> collection)
-        {
-            int count = collection.Count();
-            MySqlParameter[] result = new MySqlParameter[count];
-
-            int x = 0;
-            foreach (MySqlParameter p in collection)
-            {
-                MySqlParameter param = new MySqlParameter(p.ParameterName, (MySqlDbType)p.DbType, p.Size, p.Direction, p.IsNullable, p.Precision, p.Scale, p.SourceColumn, p.SourceVersion, p.Value);
-                param.DbType = p.DbType;
-                result[x] = param;
-                x++;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Runs a proc and returns its return value.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="return_type">Return value's expected type</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static object ExecuteProcedure(this MySqlConnection db, String name, MySqlDbType return_type, params MySqlParameter[] _params)
-        {
-            return ExecuteProcedureInternal(db.CreateCommand(), name, return_type, _params);
-        }
-
-        /// <summary>
-        /// Runs a proc.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static int ExecuteProcedure(this MySqlConnection db, String name, params MySqlParameter[] _params)
-        {
-            MySqlCommand cmd = db.CreateCommand();
-            cmd.CommandText = name;
-            cmd.CommandType = CommandType.StoredProcedure;
-            cmd.Parameters.AddRange(_params);
-            return cmd.ExecuteNonQuery();
-        }
-
-        /// <summary>
-        /// Runs a proc and returns its return value.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="return_type">Return value's expected type</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static object ExecuteProcedure(this MySqlTransaction tran, String name, MySqlDbType return_type, params MySqlParameter[] _params)
-        {
-            MySqlCommand cmd = tran.Connection.CreateCommand();
-            cmd.Transaction = tran;
-            return ExecuteProcedureInternal(cmd, name, return_type, _params);
-        }
-
-        /// <summary>
-        /// Runs a proc.
-        /// </summary>
-        /// <param name="db">Open data connection</param>
-        /// <param name="sqlstr">SQL string</param>
-        /// <param name="_params">List of parameters to use with the SQL</param>
-        public static int ExecuteProcedure(this MySqlTransaction tran, String name, params MySqlParameter[] _params)
-        {
-            MySqlCommand cmd = tran.Connection.CreateCommand();
-            cmd.CommandText = name;
-            cmd.Transaction = tran;
-            cmd.CommandType = CommandType.StoredProcedure;
-            cmd.Parameters.AddRange(_params);
-            return cmd.ExecuteNonQuery();
-        }
-
-        private static object ExecuteProcedureInternal(MySqlCommand cmd, String name, MySqlDbType return_type, MySqlParameter[] _params)
-        {
-            cmd.CommandText = name;
-            cmd.CommandType = CommandType.StoredProcedure;
-            cmd.Parameters.AddRange(_params);
-            string pname = "result";
-            while (cmd.Parameters.Contains("@" + pname)) pname = "x" + pname;
-            pname = "@" + pname;
-            MySqlParameter p = new MySqlParameter(pname, return_type);
-            p.Direction = ParameterDirection.ReturnValue;
-            cmd.Parameters.Add(p);
-            cmd.ExecuteNonQuery();
-            return cmd.Parameters[pname].Value;
-        }
-        #endregion
-
         #region DataReader convenience
         /// <summary>
         /// Obtains a string value or returns a default value if null.
diff --git a/library/Data/MySqlDatabaseExtender.cs b/library/Data/MySqlDatabaseExtender.cs
new file mode 100644
index 00000000..03c5fa52
--- /dev/null
+++ b/library/Data/MySqlDatabaseExtender.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+using MySql.Data.MySqlClient;
+
+namespace PkmnFoundations.Data
+{
+    public static class MySqlDatabaseExtender
+    {
+        // I can't find anything like a "parameter factory" in ADO.NET nor a virutal clone method,
+        // so we need an implementation of these for each database engine.
+
+        /// <summary>
+        /// Creates a clone of the SqlParameter collection
+        /// </summary>
+        /// <param name="collection">Collection to be cloned</param>
+        public static MySqlParameter[] CloneParameters(this IEnumerable<MySqlParameter> collection)
+        {
+            int count = collection.Count();
+            MySqlParameter[] result = new MySqlParameter[count];
+
+            int x = 0;
+            foreach (MySqlParameter p in collection)
+            {
+                MySqlParameter param = new MySqlParameter(p.ParameterName, (MySqlDbType)p.DbType, p.Size, p.Direction, p.IsNullable, p.Precision, p.Scale, p.SourceColumn, p.SourceVersion, p.Value);
+                param.DbType = p.DbType;
+                result[x] = param;
+                x++;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Runs a proc and returns its return value.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="return_type">Return value's expected type</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static object ExecuteProcedure(this MySqlConnection db, String name, MySqlDbType return_type, params MySqlParameter[] _params)
+        {
+            return ExecuteProcedureInternal(db.CreateCommand(), name, return_type, _params);
+        }
+
+        /// <summary>
+        /// Runs a proc.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static int ExecuteProcedure(this MySqlConnection db, String name, params MySqlParameter[] _params)
+        {
+            MySqlCommand cmd = db.CreateCommand();
+            cmd.CommandText = name;
+            cmd.CommandType = CommandType.StoredProcedure;
+            cmd.Parameters.AddRange(_params);
+            return cmd.ExecuteNonQuery();
+        }
+
+        /// <summary>
+        /// Runs a proc and returns its return value.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="return_type">Return value's expected type</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static object ExecuteProcedure(this MySqlTransaction tran, String name, MySqlDbType return_type, params MySqlParameter[] _params)
+        {
+            MySqlCommand cmd = tran.Connection.CreateCommand();
+            cmd.Transaction = tran;
+            return ExecuteProcedureInternal(cmd, name, return_type, _params);
+        }
+
+        /// <summary>
+        /// Runs a proc.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static int ExecuteProcedure(this MySqlTransaction tran, String name, params MySqlParameter[] _params)
+        {
+            MySqlCommand cmd = tran.Connection.CreateCommand();
+            cmd.CommandText = name;
+            cmd.Transaction = tran;
+            cmd.CommandType = CommandType.StoredProcedure;
+            cmd.Parameters.AddRange(_params);
+            return cmd.ExecuteNonQuery();
+        }
+
+        private static object ExecuteProcedureInternal(MySqlCommand cmd, String name, MySqlDbType return_type, MySqlParameter[] _params)
+        {
+            cmd.CommandText = name;
+            cmd.CommandType = CommandType.StoredProcedure;
+            cmd.Parameters.AddRange(_params);
+            string pname = "result";
+            while (cmd.Parameters.Contains("@" + pname)) pname = "x" + pname;
+            pname = "@" + pname;
+            MySqlParameter p = new MySqlParameter(pname, return_type);
+            p.Direction = ParameterDirection.ReturnValue;
+            cmd.Parameters.Add(p);
+            cmd.ExecuteNonQuery();
+            return cmd.Parameters[pname].Value;
+        }
+    }
+}
diff --git a/library/Data/SqlDatabaseExtender.cs b/library/Data/SqlDatabaseExtender.cs
new file mode 100644
index 00000000..00c6eadc
--- /dev/null
+++ b/library/Data/SqlDatabaseExtender.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+
+namespace PkmnFoundations.Data
+{
+    public static class SqlDatabaseExtender
+    {
+        // I can't find anything like a "parameter factory" in ADO.NET nor a virutal clone method,
+        // so we need an implementation of these for each database engine.
+
+        /// <summary>
+        /// Creates a clone of the SqlParameter collection
+        /// </summary>
+        /// <param name="collection">Collection to be cloned</param>
+        public static SqlParameter[] CloneParameters(this IEnumerable<SqlParameter> collection)
+        {
+            int count = collection.Count();
+            SqlParameter[] result = new SqlParameter[count];
+
+            int x = 0;
+            foreach (SqlParameter p in collection)
+            {
+                SqlParameter param = new SqlParameter(p.ParameterName, (SqlDbType)p.DbType, p.Size, p.Direction, p.IsNullable, p.Precision, p.Scale, p.SourceColumn, p.SourceVersion, p.Value);
+                param.DbType = p.DbType;
+                result[x] = param;
+                x++;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Runs a proc and returns its return value.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="return_type">Return value's expected type</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static object ExecuteProcedure(this SqlConnection db, String name, SqlDbType return_type, params SqlParameter[] _params)
+        {
+            return ExecuteProcedureInternal(db.CreateCommand(), name, return_type, _params);
+        }
+
+        /// <summary>
+        /// Runs a proc.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static int ExecuteProcedure(this SqlConnection db, String name, params SqlParameter[] _params)
+        {
+            SqlCommand cmd = db.CreateCommand();
+            cmd.CommandText = name;
+            cmd.CommandType = CommandType.StoredProcedure;
+            cmd.Parameters.AddRange(_params);
+            return cmd.ExecuteNonQuery();
+        }
+
+        /// <summary>
+        /// Runs a proc and returns its return value.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="return_type">Return value's expected type</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static object ExecuteProcedure(this SqlTransaction tran, String name, SqlDbType return_type, params SqlParameter[] _params)
+        {
+            SqlCommand cmd = tran.Connection.CreateCommand();
+            cmd.Transaction = tran;
+            return ExecuteProcedureInternal(cmd, name, return_type, _params);
+        }
+
+        /// <summary>
+        /// Runs a proc.
+        /// </summary>
+        /// <param name="db">Open data connection</param>
+        /// <param name="sqlstr">SQL string</param>
+        /// <param name="_params">List of parameters to use with the SQL</param>
+        public static int ExecuteProcedure(this SqlTransaction tran, String name, params SqlParameter[] _params)
+        {
+            SqlCommand cmd = tran.Connection.CreateCommand();
+            cmd.CommandText = name;
+            cmd.Transaction = tran;
+            cmd.CommandType = CommandType.StoredProcedure;
+            cmd.Parameters.AddRange(_params);
+            return cmd.ExecuteNonQuery();
+        }
+
+        private static object ExecuteProcedureInternal(SqlCommand cmd, String name, SqlDbType return_type, SqlParameter[] _params)
+        {
+            cmd.CommandText = name;
+            cmd.CommandType = CommandType.StoredProcedure;
+            cmd.Parameters.AddRange(_params);
+            string pname = "result";
+            while (cmd.Parameters.Contains("@" + pname)) pname = "x" + pname;
+            pname = "@" + pname;
+            SqlParameter p = new SqlParameter(pname, return_type);
+            p.Direction = ParameterDirection.ReturnValue;
+            cmd.Parameters.Add(p);
+            cmd.ExecuteNonQuery();
+            return cmd.Parameters[pname].Value;
+        }
+    }
+}
diff --git a/library/Library.csproj b/library/Library.csproj
index 66563cdf..6d3bf6c9 100644
--- a/library/Library.csproj
+++ b/library/Library.csproj
@@ -58,6 +58,8 @@
     <Compile Include="Data\DatabaseExtender.cs" />
     <Compile Include="Data\DataMysql.cs" />
     <Compile Include="Data\DataSqlite.cs" />
+    <Compile Include="Data\MySqlDatabaseExtender.cs" />
+    <Compile Include="Data\SqlDatabaseExtender.cs" />
     <Compile Include="Pokedex\Ability.cs" />
     <Compile Include="Pokedex\Evolution.cs" />
     <Compile Include="Pokedex\FormStats.cs" />