Leahnaya/pkmn-classic-framework
1
0
Fork 0
mirror of https://github.com/mm201/pkmn-classic-framework.git synced 2026-08-28 05:04:16 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Broke off database engine specific extension methods to their own classes.

Browse Source
This commit is contained in:
Greg Edwards
2015-07-02 13:17:50 -04:00
parent 23b2eda332
commit 9ab595604b
4 changed files with 218 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
library/Data/DatabaseExtender.cs
View File

@@ -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.

108
library/Data/MySqlDatabaseExtender.cs Normal file
View File

@@ -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;
}
}
}

108
library/Data/SqlDatabaseExtender.cs Normal file
View File

@@ -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;
}
}
}

2
library/Library.csproj
View File

@@ -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" />