C#数据库帮助类，包括新建数据库，删除数据库，还原数据库
数据库连接字符串从配置文件读取。
代码
using
System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Data.Common;
using System.Collections.Generic;
namespace Maticsoft.DBUtility
{
/// <summary>
/// 数据访问抽象基础类
/// </summary>
public abstract class DbHelperSQL
{
// <?xml version="1.0" encoding="utf-8" ?>
// <configuration>
// <appSettings>
// <!--连接主程序的字符串-->
// <add key="connection" value="server=CONTRON-CAD9158;uid=sa;pwd=sa;database=syt"/>
// <!---->
// <add key="connectionzt" value="server=CONTRON-CAD9158;uid=sa;pwd=sa;database=syt_qwerthjkl"/>
// <!--连接主SQLServer 的字符串-->
// <add key="ConnectServer" value="server=CONTRON-CAD9158;uid=sa;pwd=sa;database=master"/>
// <!--建立数据库的连接字符串-->
// <add key="connInit" value="data source=CONTRON-CAD9158;user id=sa;password=sa;persist security info=false;packet size=4096"/>
// <!--SQLServer安装目录-->
// <add key="sqlServerData" value="C:\Program Files\Microsoft SQL Server\MSSQL\Data"/>
// </appSettings>
// </configuration>
// 数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
public static string connectionString = PubConstant.ConnectionString;
public static string connectionString = System.Configuration.ConfigurationSettings.AppSettings[ " connection " ];
public static string connInitStr = System.Configuration.ConfigurationSettings.AppSettings[ " connInit " ];
public static string sqlServerPath = System.Configuration.ConfigurationSettings.AppSettings[ " sqlServerData " ];
public static string connectServer = ConfigurationSettings.AppSettings[ " ConnectServer " ];
public DbHelperSQL()
{
}
#region 公用方法
/// <summary>
/// 判断是否存在某表的某个字段
/// </summary>
/// <param name="tableName"> 表名称 </param>
/// <param name="columnName"> 列名称 </param>
/// <returns> 是否存在 </returns>
public static bool ColumnExists( string tableName, string columnName)
{
string sql = " select count(1) from syscolumns where [id]=object_id(' " + tableName + " ') and [name]=' " + columnName + " ' " ;
object res = GetSingle(sql);
if (res == null )
{
return false ;
}
return Convert.ToInt32(res) > 0 ;
}
public static int GetMaxID( string FieldName, string TableName)
{
string strsql = " select max( " + FieldName + " )+1 from " + TableName;
object obj = GetSingle(strsql);
if (obj == null )
{
return 1 ;
}
else
{
return int .Parse(obj.ToString());
}
}
public static bool Exists( string strSql)
{
object obj = GetSingle(strSql);
int cmdresult;
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0 ;
}
else
{
cmdresult = int .Parse(obj.ToString());
}
if (cmdresult == 0 )
{
return false ;
}
else
{
return true ;
}
}
/// <summary>
/// 表是否存在
/// </summary>
/// <param name="TableName"></param>
/// <returns></returns>
public static bool TabExists( string TableName)
{
string strsql = " select count(*) from sysobjects where id = object_id(N'[ " + TableName + " ]') and OBJECTPROPERTY(id, N'IsUserTable') = 1 " ;
// string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[" + TableName + "]') AND type in (N'U')";
object obj = GetSingle(strsql);
int cmdresult;
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0 ;
}
else
{
cmdresult = int .Parse(obj.ToString());
}
if (cmdresult == 0 )
{
return false ;
}
else
{
return true ;
}
}
public static bool Exists( string strSql, params SqlParameter[] cmdParms)
{
object obj = GetSingle(strSql, cmdParms);
int cmdresult;
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0 ;
}
else
{
cmdresult = int .Parse(obj.ToString());
}
if (cmdresult == 0 )
{
return false ;
}
else
{
return true ;
}
}
#endregion
#region 执行简单SQL语句
/// <summary>
/// 执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSql( string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
public static int ExecuteSqlByTime( string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
cmd.CommandTimeout = Times;
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
/// <summary>
/// 执行Sql和Oracle滴混合事务
/// </summary>
/// <param name="list"> SQL命令行列表 </param>
/// <param name="oracleCmdSqlList"> Oracle命令行列表 </param>
/// <returns> 执行结果 0-由于SQL造成事务失败 -1 由于Oracle造成事务失败 1-整体事务执行成功 </returns>
public static int ExecuteSqlTran(List < CommandInfo > list, List < CommandInfo > oracleCmdSqlList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
foreach (CommandInfo myDE in list)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
PrepareCommand(cmd, conn, tx, cmdText, cmdParms);
if (myDE.EffentNextType == EffentNextType.SolicitationEvent)
{
if (myDE.CommandText.ToLower().IndexOf( " count( " ) == - 1 )
{
tx.Rollback();
throw new Exception( " 违背要求 " + myDE.CommandText + " 必须符合select count(..的格式 " );
// return 0;
}
object obj = cmd.ExecuteScalar();
bool isHave = false ;
if (obj == null && obj == DBNull.Value)
{
isHave = false ;
}
isHave = Convert.ToInt32(obj) > 0 ;
if (isHave)
{
// 引发事件
myDE.OnSolicitationEvent();
}
}
if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
{
if (myDE.CommandText.ToLower().IndexOf( " count( " ) == - 1 )
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 必须符合select count(..的格式 " );
// return 0;
}
object obj = cmd.ExecuteScalar();
bool isHave = false ;
if (obj == null && obj == DBNull.Value)
{
isHave = false ;
}
isHave = Convert.ToInt32(obj) > 0 ;
if (myDE.EffentNextType == EffentNextType.WhenHaveContine && ! isHave)
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 返回值必须大于0 " );
// return 0;
}
if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 返回值必须等于0 " );
// return 0;
}
continue ;
}
int val = cmd.ExecuteNonQuery();
if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0 )
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 必须有影响行 " );
// return 0;
}
cmd.Parameters.Clear();
}
string oraConnectionString = PubConstant.GetConnectionString( " ConnectionStringPPC " );
bool res = OracleHelper.ExecuteSqlTran(oraConnectionString, oracleCmdSqlList);
if ( ! res)
{
tx.Rollback();
throw new Exception( " Oracle执行失败 " );
// return -1;
}
tx.Commit();
return 1 ;
}
catch (System.Data.SqlClient.SqlException e)
{
tx.Rollback();
throw e;
}
catch (Exception e)
{
tx.Rollback();
throw e;
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> 多条SQL语句 </param>
public static int ExecuteSqlTran(List < String > SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
int count = 0 ;
for ( int n = 0 ; n < SQLStringList.Count; n ++ )
{
string strsql = SQLStringList[n];
if (strsql.Trim().Length > 1 )
{
cmd.CommandText = strsql;
count += cmd.ExecuteNonQuery();
}
}
tx.Commit();
return count;
}
catch
{
tx.Rollback();
return 0 ;
}
}
}
/// <summary>
/// 执行带一个存储过程参数的的SQL语句。
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <param name="content"> 参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSql( string SQLString, string content)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(SQLString, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter( " @content " , SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 执行带一个存储过程参数的的SQL语句。
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <param name="content"> 参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加 </param>
/// <returns> 影响的记录数 </returns>
public static object ExecuteSqlGet( string SQLString, string content)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(SQLString, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter( " @content " , SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
/// </summary>
/// <param name="strSQL"> SQL语句 </param>
/// <param name="fs"> 图像字节,数据库的字段类型为image的情况 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSqlInsertImg( string strSQL, byte [] fs)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(strSQL, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter( " @fs " , SqlDbType.Image);
myParameter.Value = fs;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString"> 计算查询结果语句 </param>
/// <returns> 查询结果（object） </returns>
public static object GetSingle( string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
public static object GetSingle( string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
cmd.CommandTimeout = Times;
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
/// <summary>
/// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
/// </summary>
/// <param name="strSQL"> 查询语句 </param>
/// <returns> SqlDataReader </returns>
public static SqlDataReader ExecuteReader( string strSQL)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand(strSQL, connection);
try
{
connection.Open();
SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
return myReader;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString"> 查询语句 </param>
/// <returns> DataSet </returns>
public static DataSet Query( string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.Fill(ds, " ds " );
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
public static DataSet Query( string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.SelectCommand.CommandTimeout = Times;
command.Fill(ds, " ds " );
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
#endregion
#region 执行带参数的SQL语句
/// <summary>
/// 执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSql( string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
int rows = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static void ExecuteSqlTran(Hashtable SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
// 循环
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static int ExecuteSqlTran(System.Collections.Generic.List < CommandInfo > cmdList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{ int count = 0 ;
// 循环
foreach (CommandInfo myDE in cmdList)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
{
if (myDE.CommandText.ToLower().IndexOf( " count( " ) == - 1 )
{
trans.Rollback();
return 0 ;
}
object obj = cmd.ExecuteScalar();
bool isHave = false ;
if (obj == null && obj == DBNull.Value)
{
isHave = false ;
}
isHave = Convert.ToInt32(obj) > 0 ;
if (myDE.EffentNextType == EffentNextType.WhenHaveContine && ! isHave)
{
trans.Rollback();
return 0 ;
}
if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
{
trans.Rollback();
return 0 ;
}
continue ;
}
int val = cmd.ExecuteNonQuery();
count += val;
if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0 )
{
trans.Rollback();
return 0 ;
}
cmd.Parameters.Clear();
}
trans.Commit();
return count;
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static void ExecuteSqlTranWithIndentity(System.Collections.Generic.List < CommandInfo > SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int indentity = 0 ;
// 循环
foreach (CommandInfo myDE in SQLStringList)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.InputOutput)
{
q.Value = indentity;
}
}
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.Output)
{
indentity = Convert.ToInt32(q.Value);
}
}
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int indentity = 0 ;
// 循环
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.InputOutput)
{
q.Value = indentity;
}
}
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.Output)
{
indentity = Convert.ToInt32(q.Value);
}
}
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString"> 计算查询结果语句 </param>
/// <returns> 查询结果（object） </returns>
public static object GetSingle( string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
object obj = cmd.ExecuteScalar();
cmd.Parameters.Clear();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
}
}
/// <summary>
/// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
/// </summary>
/// <param name="strSQL"> 查询语句 </param>
/// <returns> SqlDataReader </returns>
public static SqlDataReader ExecuteReader( string SQLString, params SqlParameter[] cmdParms)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return myReader;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
// finally
// {
// cmd.Dispose();
// connection.Close();
// }
}
/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString"> 查询语句 </param>
/// <returns> DataSet </returns>
public static DataSet Query( string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
try
{
da.Fill(ds, " ds " );
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
}
private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
{
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trans != null )
cmd.Transaction = trans;
cmd.CommandType = CommandType.Text; // cmdType;
if (cmdParms != null )
{
foreach (SqlParameter parameter in cmdParms)
{
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null ))
{
parameter.Value = DBNull.Value;
}
cmd.Parameters.Add(parameter);
}
}
}
#endregion
#region 存储过程操作
/// <summary>
/// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <returns> SqlDataReader </returns>
public static SqlDataReader RunProcedure( string storedProcName, IDataParameter[] parameters)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlDataReader returnReader;
connection.Open();
SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.CommandType = CommandType.StoredProcedure;
returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
return returnReader;
}
/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <param name="tableName"> DataSet结果中的表名 </param>
/// <returns> DataSet </returns>
public static DataSet RunProcedure( string storedProcName, IDataParameter[] parameters, string tableName)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet dataSet = new DataSet();
connection.Open();
SqlDataAdapter sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
sqlDA.Fill(dataSet, tableName);
connection.Close();
return dataSet;
}
}
public static DataSet RunProcedure( string storedProcName, IDataParameter[] parameters, string tableName, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet dataSet = new DataSet();
connection.Open();
SqlDataAdapter sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
sqlDA.SelectCommand.CommandTimeout = Times;
sqlDA.Fill(dataSet, tableName);
connection.Close();
return dataSet;
}
}
/// <summary>
/// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
/// </summary>
/// <param name="connection"> 数据库连接 </param>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <returns> SqlCommand </returns>
private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
{
SqlCommand command = new SqlCommand(storedProcName, connection);
command.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
if (parameter != null )
{
// 检查未分配值的输出参数,将其分配以DBNull.Value.
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null ))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
}
}
return command;
}
/// <summary>
/// 执行存储过程，返回影响的行数
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <param name="rowsAffected"> 影响的行数 </param>
/// <returns></returns>
public static int RunProcedure( string storedProcName, IDataParameter[] parameters, out int rowsAffected)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
int result;
connection.Open();
SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
rowsAffected = command.ExecuteNonQuery();
result = ( int )command.Parameters[ " ReturnValue " ].Value;
// Connection.Close();
return result;
}
}
/// <summary>
/// 创建 SqlCommand 对象实例(用来返回一个整数值)
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <returns> SqlCommand 对象实例 </returns>
private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
{
SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.Parameters.Add( new SqlParameter( " ReturnValue " ,
SqlDbType.Int, 4 , ParameterDirection.ReturnValue,
false , 0 , 0 , string .Empty, DataRowVersion.Default, null ));
return command;
}
#endregion
#region 还原与备份数据库
/// <summary>
/// 还原数据库
/// </summary>
/// <param name="backfile"> 数据库文件 </param>
/// <returns> 还原成功与否提示 </returns>
public static bool RestoreDatabase( string dbName, string backfile)
{
/// 杀死原来所有的数据库连接进程
///
bool flag = false ;
SqlConnection conn = new SqlConnection();
conn.ConnectionString = connectServer;
conn.Open();
string sql = " SELECT spid FROM sysprocesses ,sysdatabases WHERE sysprocesses.dbid=sysdatabases.dbid AND sysdatabases.Name='pubs' " ;
SqlCommand cmd1 = new SqlCommand(sql, conn);
SqlDataReader dr;
ArrayList list = new ArrayList();
try
{
dr = cmd1.ExecuteReader();
while (dr.Read())
{
list.Add(dr.GetInt16( 0 ));
}
dr.Close();
}
catch (SqlException eee)
{
flag = false ;
Debug.Print(eee.ToString());
throw eee;
}
finally
{
conn.Close();
}
Debug.Print( " 使用的线程数 " + list.Count.ToString());
for ( int i = 0 ; i < list.Count; i ++ )
{
cmd1 = new SqlCommand( string .Format( " KILL {0} " , list[i].ToString()), conn);
cmd1.ExecuteNonQuery();
Debug.Print( " you have killed thread " + list[i].ToString());
}
string killThread = string .Format( " declare hcforeach cursor global for " +
" select 'kill '+rtrim(spid) from master.dbo.sysprocesses where dbid=db_id(N'{0}') exec sp_msforeach_worker '?' " , dbName);
// 还原前，kill进程
using (SqlConnection connServer = new SqlConnection(connectServer))
{
connServer.Open();
SqlCommand cmdServer = new SqlCommand(killThread, connServer);
cmdServer.ExecuteNonQuery();
}
// 这里一定要是master数据库，而不能是要还原的数据库，因为这样便变成了有其它进程
// 占用了数据库。
string constr = connectServer;
string BACKUP = String.Format( " RESTORE DATABASE {0} FROM DISK = '{1}' " , dbName, backfile);
SqlConnection con = new SqlConnection(constr);
SqlCommand cmd = new SqlCommand(BACKUP, con);
con.Open();
try
{
flag = true ;
cmd.ExecuteNonQuery();
Debug.Print( " 还原成功 " );
}
catch (SqlException ee)
{
flag = false ;
throw (ee);
Debug.Print( " 还原失败 " );
Debug.Print(ee.ToString());
}
finally
{
con.Close();
}
return flag;
}
/// <summary>
/// 备份数据库
/// </summary>
/// <returns> 是否备份成功 </returns>
public static bool BackDb( string dbName, string dbFileName)
{
bool flag = false ;
// 备份前，Kill掉进程
string killThread = string .Format( " declare hcforeach cursor global for " +
" select 'kill '+rtrim(spid) from master.dbo.sysprocesses where dbid=db_id(N'{0}') exec sp_msforeach_worker '?' " , dbName);
// 还原前，kill进程
using (SqlConnection connServer = new SqlConnection(connectServer))
{
connServer.Open();
SqlCommand cmdServer = new SqlCommand(killThread, connServer);
cmdServer.ExecuteNonQuery();
}
SqlConnection conn;
SqlCommand cmd;
string strsql = "" ;
strsql = string .Format( " backup database {0} to disk = '{1}' " , dbName, dbFileName);
try
{
string strConn = connectServer;
conn = new SqlConnection(strConn);
conn.Open();
cmd = new SqlCommand(strsql, conn);
int index = cmd.ExecuteNonQuery();
if (index != 0 )
{
flag = true ;
}
conn.Close();
}
catch (Exception e)
{
flag = false ;
throw new Exception( " 数据库备份时出错了！ " );
}
return flag;
}
#endregion
#region 建立于删除数据库
/// <summary>
/// 新建立数据库
/// </summary>
/// <param name="databaseName"> 数据库名 </param>
public static void NewDataBase( string databaseName)
{
// 调用ExecuteNonQuery()来创建数据库
string sql = string .Format( " CREATE DATABASE {0} " , databaseName);
ExecuteSql(connInitStr, " master " , sql);
}
/// <summary>
/// 删除数据库
/// </summary>
public static void DropDataBase( string databaseName)
{
string killThread = string .Format( " declare hcforeach cursor global for " +
" select 'kill '+rtrim(spid) from master.dbo.sysprocesses where dbid=db_id(N'{0}') exec sp_msforeach_worker '?' " , databaseName);
// 删除前，Kill掉进程
ExecuteSql(connInitStr, " master " , killThread);
// 调用ExecuteNonQuery()来删除数据库
string sqlQuery = string .Format( " DROP DATABASE {0} " , databaseName);
ExecuteSql(connInitStr, " master " , sqlQuery);
}
private static void ExecuteSql( string conn, string dataBase, string sql)
{
System.Data.SqlClient.SqlConnection mySqlConnection = new System.Data.SqlClient.SqlConnection(conn);
System.Data.SqlClient.SqlCommand command = new System.Data.SqlClient.SqlCommand(sql, mySqlConnection);
command.Connection.Open();
command.Connection.ChangeDatabase(dataBase);
try
{
command.ExecuteNonQuery();
}
catch (Exception exp)
{
throw exp;
}
finally
{
mySqlConnection.Close();
}
}
#endregion
}
}
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Data.Common;
using System.Collections.Generic;
namespace Maticsoft.DBUtility
{
/// <summary>
/// 数据访问抽象基础类
/// </summary>
public abstract class DbHelperSQL
{
// <?xml version="1.0" encoding="utf-8" ?>
// <configuration>
// <appSettings>
// <!--连接主程序的字符串-->
// <add key="connection" value="server=CONTRON-CAD9158;uid=sa;pwd=sa;database=syt"/>
// <!---->
// <add key="connectionzt" value="server=CONTRON-CAD9158;uid=sa;pwd=sa;database=syt_qwerthjkl"/>
// <!--连接主SQLServer 的字符串-->
// <add key="ConnectServer" value="server=CONTRON-CAD9158;uid=sa;pwd=sa;database=master"/>
// <!--建立数据库的连接字符串-->
// <add key="connInit" value="data source=CONTRON-CAD9158;user id=sa;password=sa;persist security info=false;packet size=4096"/>
// <!--SQLServer安装目录-->
// <add key="sqlServerData" value="C:\Program Files\Microsoft SQL Server\MSSQL\Data"/>
// </appSettings>
// </configuration>
// 数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
public static string connectionString = PubConstant.ConnectionString;
public static string connectionString = System.Configuration.ConfigurationSettings.AppSettings[ " connection " ];
public static string connInitStr = System.Configuration.ConfigurationSettings.AppSettings[ " connInit " ];
public static string sqlServerPath = System.Configuration.ConfigurationSettings.AppSettings[ " sqlServerData " ];
public static string connectServer = ConfigurationSettings.AppSettings[ " ConnectServer " ];
public DbHelperSQL()
{
}
#region 公用方法
/// <summary>
/// 判断是否存在某表的某个字段
/// </summary>
/// <param name="tableName"> 表名称 </param>
/// <param name="columnName"> 列名称 </param>
/// <returns> 是否存在 </returns>
public static bool ColumnExists( string tableName, string columnName)
{
string sql = " select count(1) from syscolumns where [id]=object_id(' " + tableName + " ') and [name]=' " + columnName + " ' " ;
object res = GetSingle(sql);
if (res == null )
{
return false ;
}
return Convert.ToInt32(res) > 0 ;
}
public static int GetMaxID( string FieldName, string TableName)
{
string strsql = " select max( " + FieldName + " )+1 from " + TableName;
object obj = GetSingle(strsql);
if (obj == null )
{
return 1 ;
}
else
{
return int .Parse(obj.ToString());
}
}
public static bool Exists( string strSql)
{
object obj = GetSingle(strSql);
int cmdresult;
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0 ;
}
else
{
cmdresult = int .Parse(obj.ToString());
}
if (cmdresult == 0 )
{
return false ;
}
else
{
return true ;
}
}
/// <summary>
/// 表是否存在
/// </summary>
/// <param name="TableName"></param>
/// <returns></returns>
public static bool TabExists( string TableName)
{
string strsql = " select count(*) from sysobjects where id = object_id(N'[ " + TableName + " ]') and OBJECTPROPERTY(id, N'IsUserTable') = 1 " ;
// string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[" + TableName + "]') AND type in (N'U')";
object obj = GetSingle(strsql);
int cmdresult;
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0 ;
}
else
{
cmdresult = int .Parse(obj.ToString());
}
if (cmdresult == 0 )
{
return false ;
}
else
{
return true ;
}
}
public static bool Exists( string strSql, params SqlParameter[] cmdParms)
{
object obj = GetSingle(strSql, cmdParms);
int cmdresult;
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0 ;
}
else
{
cmdresult = int .Parse(obj.ToString());
}
if (cmdresult == 0 )
{
return false ;
}
else
{
return true ;
}
}
#endregion
#region 执行简单SQL语句
/// <summary>
/// 执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSql( string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
public static int ExecuteSqlByTime( string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
cmd.CommandTimeout = Times;
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
/// <summary>
/// 执行Sql和Oracle滴混合事务
/// </summary>
/// <param name="list"> SQL命令行列表 </param>
/// <param name="oracleCmdSqlList"> Oracle命令行列表 </param>
/// <returns> 执行结果 0-由于SQL造成事务失败 -1 由于Oracle造成事务失败 1-整体事务执行成功 </returns>
public static int ExecuteSqlTran(List < CommandInfo > list, List < CommandInfo > oracleCmdSqlList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
foreach (CommandInfo myDE in list)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
PrepareCommand(cmd, conn, tx, cmdText, cmdParms);
if (myDE.EffentNextType == EffentNextType.SolicitationEvent)
{
if (myDE.CommandText.ToLower().IndexOf( " count( " ) == - 1 )
{
tx.Rollback();
throw new Exception( " 违背要求 " + myDE.CommandText + " 必须符合select count(..的格式 " );
// return 0;
}
object obj = cmd.ExecuteScalar();
bool isHave = false ;
if (obj == null && obj == DBNull.Value)
{
isHave = false ;
}
isHave = Convert.ToInt32(obj) > 0 ;
if (isHave)
{
// 引发事件
myDE.OnSolicitationEvent();
}
}
if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
{
if (myDE.CommandText.ToLower().IndexOf( " count( " ) == - 1 )
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 必须符合select count(..的格式 " );
// return 0;
}
object obj = cmd.ExecuteScalar();
bool isHave = false ;
if (obj == null && obj == DBNull.Value)
{
isHave = false ;
}
isHave = Convert.ToInt32(obj) > 0 ;
if (myDE.EffentNextType == EffentNextType.WhenHaveContine && ! isHave)
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 返回值必须大于0 " );
// return 0;
}
if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 返回值必须等于0 " );
// return 0;
}
continue ;
}
int val = cmd.ExecuteNonQuery();
if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0 )
{
tx.Rollback();
throw new Exception( " SQL:违背要求 " + myDE.CommandText + " 必须有影响行 " );
// return 0;
}
cmd.Parameters.Clear();
}
string oraConnectionString = PubConstant.GetConnectionString( " ConnectionStringPPC " );
bool res = OracleHelper.ExecuteSqlTran(oraConnectionString, oracleCmdSqlList);
if ( ! res)
{
tx.Rollback();
throw new Exception( " Oracle执行失败 " );
// return -1;
}
tx.Commit();
return 1 ;
}
catch (System.Data.SqlClient.SqlException e)
{
tx.Rollback();
throw e;
}
catch (Exception e)
{
tx.Rollback();
throw e;
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> 多条SQL语句 </param>
public static int ExecuteSqlTran(List < String > SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
int count = 0 ;
for ( int n = 0 ; n < SQLStringList.Count; n ++ )
{
string strsql = SQLStringList[n];
if (strsql.Trim().Length > 1 )
{
cmd.CommandText = strsql;
count += cmd.ExecuteNonQuery();
}
}
tx.Commit();
return count;
}
catch
{
tx.Rollback();
return 0 ;
}
}
}
/// <summary>
/// 执行带一个存储过程参数的的SQL语句。
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <param name="content"> 参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSql( string SQLString, string content)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(SQLString, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter( " @content " , SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 执行带一个存储过程参数的的SQL语句。
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <param name="content"> 参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加 </param>
/// <returns> 影响的记录数 </returns>
public static object ExecuteSqlGet( string SQLString, string content)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(SQLString, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter( " @content " , SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
/// </summary>
/// <param name="strSQL"> SQL语句 </param>
/// <param name="fs"> 图像字节,数据库的字段类型为image的情况 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSqlInsertImg( string strSQL, byte [] fs)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(strSQL, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter( " @fs " , SqlDbType.Image);
myParameter.Value = fs;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString"> 计算查询结果语句 </param>
/// <returns> 查询结果（object） </returns>
public static object GetSingle( string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
public static object GetSingle( string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
cmd.CommandTimeout = Times;
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
/// <summary>
/// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
/// </summary>
/// <param name="strSQL"> 查询语句 </param>
/// <returns> SqlDataReader </returns>
public static SqlDataReader ExecuteReader( string strSQL)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand(strSQL, connection);
try
{
connection.Open();
SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
return myReader;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString"> 查询语句 </param>
/// <returns> DataSet </returns>
public static DataSet Query( string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.Fill(ds, " ds " );
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
public static DataSet Query( string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.SelectCommand.CommandTimeout = Times;
command.Fill(ds, " ds " );
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
#endregion
#region 执行带参数的SQL语句
/// <summary>
/// 执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="SQLString"> SQL语句 </param>
/// <returns> 影响的记录数 </returns>
public static int ExecuteSql( string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
int rows = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static void ExecuteSqlTran(Hashtable SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
// 循环
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static int ExecuteSqlTran(System.Collections.Generic.List < CommandInfo > cmdList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{ int count = 0 ;
// 循环
foreach (CommandInfo myDE in cmdList)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
{
if (myDE.CommandText.ToLower().IndexOf( " count( " ) == - 1 )
{
trans.Rollback();
return 0 ;
}
object obj = cmd.ExecuteScalar();
bool isHave = false ;
if (obj == null && obj == DBNull.Value)
{
isHave = false ;
}
isHave = Convert.ToInt32(obj) > 0 ;
if (myDE.EffentNextType == EffentNextType.WhenHaveContine && ! isHave)
{
trans.Rollback();
return 0 ;
}
if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
{
trans.Rollback();
return 0 ;
}
continue ;
}
int val = cmd.ExecuteNonQuery();
count += val;
if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0 )
{
trans.Rollback();
return 0 ;
}
cmd.Parameters.Clear();
}
trans.Commit();
return count;
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static void ExecuteSqlTranWithIndentity(System.Collections.Generic.List < CommandInfo > SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int indentity = 0 ;
// 循环
foreach (CommandInfo myDE in SQLStringList)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.InputOutput)
{
q.Value = indentity;
}
}
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.Output)
{
indentity = Convert.ToInt32(q.Value);
}
}
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList"> SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]） </param>
public static void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int indentity = 0 ;
// 循环
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.InputOutput)
{
q.Value = indentity;
}
}
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.Output)
{
indentity = Convert.ToInt32(q.Value);
}
}
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw ;
}
}
}
}
/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString"> 计算查询结果语句 </param>
/// <returns> 查询结果（object） </returns>
public static object GetSingle( string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
object obj = cmd.ExecuteScalar();
cmd.Parameters.Clear();
if ((Object.Equals(obj, null )) || (Object.Equals(obj, System.DBNull.Value)))
{
return null ;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
}
}
/// <summary>
/// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
/// </summary>
/// <param name="strSQL"> 查询语句 </param>
/// <returns> SqlDataReader </returns>
public static SqlDataReader ExecuteReader( string SQLString, params SqlParameter[] cmdParms)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return myReader;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
// finally
// {
// cmd.Dispose();
// connection.Close();
// }
}
/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString"> 查询语句 </param>
/// <returns> DataSet </returns>
public static DataSet Query( string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, connection, null , SQLString, cmdParms);
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
try
{
da.Fill(ds, " ds " );
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
}
private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
{
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trans != null )
cmd.Transaction = trans;
cmd.CommandType = CommandType.Text; // cmdType;
if (cmdParms != null )
{
foreach (SqlParameter parameter in cmdParms)
{
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null ))
{
parameter.Value = DBNull.Value;
}
cmd.Parameters.Add(parameter);
}
}
}
#endregion
#region 存储过程操作
/// <summary>
/// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <returns> SqlDataReader </returns>
public static SqlDataReader RunProcedure( string storedProcName, IDataParameter[] parameters)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlDataReader returnReader;
connection.Open();
SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.CommandType = CommandType.StoredProcedure;
returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
return returnReader;
}
/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <param name="tableName"> DataSet结果中的表名 </param>
/// <returns> DataSet </returns>
public static DataSet RunProcedure( string storedProcName, IDataParameter[] parameters, string tableName)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet dataSet = new DataSet();
connection.Open();
SqlDataAdapter sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
sqlDA.Fill(dataSet, tableName);
connection.Close();
return dataSet;
}
}
public static DataSet RunProcedure( string storedProcName, IDataParameter[] parameters, string tableName, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet dataSet = new DataSet();
connection.Open();
SqlDataAdapter sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
sqlDA.SelectCommand.CommandTimeout = Times;
sqlDA.Fill(dataSet, tableName);
connection.Close();
return dataSet;
}
}
/// <summary>
/// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
/// </summary>
/// <param name="connection"> 数据库连接 </param>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <returns> SqlCommand </returns>
private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
{
SqlCommand command = new SqlCommand(storedProcName, connection);
command.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
if (parameter != null )
{
// 检查未分配值的输出参数,将其分配以DBNull.Value.
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null ))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
}
}
return command;
}
/// <summary>
/// 执行存储过程，返回影响的行数
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <param name="rowsAffected"> 影响的行数 </param>
/// <returns></returns>
public static int RunProcedure( string storedProcName, IDataParameter[] parameters, out int rowsAffected)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
int result;
connection.Open();
SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
rowsAffected = command.ExecuteNonQuery();
result = ( int )command.Parameters[ " ReturnValue " ].Value;
// Connection.Close();
return result;
}
}
/// <summary>
/// 创建 SqlCommand 对象实例(用来返回一个整数值)
/// </summary>
/// <param name="storedProcName"> 存储过程名 </param>
/// <param name="parameters"> 存储过程参数 </param>
/// <returns> SqlCommand 对象实例 </returns>
private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
{
SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.Parameters.Add( new SqlParameter( " ReturnValue " ,
SqlDbType.Int, 4 , ParameterDirection.ReturnValue,
false , 0 , 0 , string .Empty, DataRowVersion.Default, null ));
return command;
}
#endregion
#region 还原与备份数据库
/// <summary>
/// 还原数据库
/// </summary>
/// <param name="backfile"> 数据库文件 </param>
/// <returns> 还原成功与否提示 </returns>
public static bool RestoreDatabase( string dbName, string backfile)
{
/// 杀死原来所有的数据库连接进程
///
bool flag = false ;
SqlConnection conn = new SqlConnection();
conn.ConnectionString = connectServer;
conn.Open();
string sql = " SELECT spid FROM sysprocesses ,sysdatabases WHERE sysprocesses.dbid=sysdatabases.dbid AND sysdatabases.Name='pubs' " ;
SqlCommand cmd1 = new SqlCommand(sql, conn);
SqlDataReader dr;
ArrayList list = new ArrayList();
try
{
dr = cmd1.ExecuteReader();
while (dr.Read())
{
list.Add(dr.GetInt16( 0 ));
}
dr.Close();
}
catch (SqlException eee)
{
flag = false ;
Debug.Print(eee.ToString());
throw eee;
}
finally
{
conn.Close();
}
Debug.Print( " 使用的线程数 " + list.Count.ToString());
for ( int i = 0 ; i < list.Count; i ++ )
{
cmd1 = new SqlCommand( string .Format( " KILL {0} " , list[i].ToString()), conn);
cmd1.ExecuteNonQuery();
Debug.Print( " you have killed thread " + list[i].ToString());
}
string killThread = string .Format( " declare hcforeach cursor global for " +
" select 'kill '+rtrim(spid) from master.dbo.sysprocesses where dbid=db_id(N'{0}') exec sp_msforeach_worker '?' " , dbName);
// 还原前，kill进程
using (SqlConnection connServer = new SqlConnection(connectServer))
{
connServer.Open();
SqlCommand cmdServer = new SqlCommand(killThread, connServer);
cmdServer.ExecuteNonQuery();
}
// 这里一定要是master数据库，而不能是要还原的数据库，因为这样便变成了有其它进程
// 占用了数据库。
string constr = connectServer;
string BACKUP = String.Format( " RESTORE DATABASE {0} FROM DISK = '{1}' " , dbName, backfile);
SqlConnection con = new SqlConnection(constr);
SqlCommand cmd = new SqlCommand(BACKUP, con);
con.Open();
try
{
flag = true ;
cmd.ExecuteNonQuery();
Debug.Print( " 还原成功 " );
}
catch (SqlException ee)
{
flag = false ;
throw (ee);
Debug.Print( " 还原失败 " );
Debug.Print(ee.ToString());
}
finally
{
con.Close();
}
return flag;
}
/// <summary>
/// 备份数据库
/// </summary>
/// <returns> 是否备份成功 </returns>
public static bool BackDb( string dbName, string dbFileName)
{
bool flag = false ;
// 备份前，Kill掉进程
string killThread = string .Format( " declare hcforeach cursor global for " +
" select 'kill '+rtrim(spid) from master.dbo.sysprocesses where dbid=db_id(N'{0}') exec sp_msforeach_worker '?' " , dbName);
// 还原前，kill进程
using (SqlConnection connServer = new SqlConnection(connectServer))
{
connServer.Open();
SqlCommand cmdServer = new SqlCommand(killThread, connServer);
cmdServer.ExecuteNonQuery();
}
SqlConnection conn;
SqlCommand cmd;
string strsql = "" ;
strsql = string .Format( " backup database {0} to disk = '{1}' " , dbName, dbFileName);
try
{
string strConn = connectServer;
conn = new SqlConnection(strConn);
conn.Open();
cmd = new SqlCommand(strsql, conn);
int index = cmd.ExecuteNonQuery();
if (index != 0 )
{
flag = true ;
}
conn.Close();
}
catch (Exception e)
{
flag = false ;
throw new Exception( " 数据库备份时出错了！ " );
}
return flag;
}
#endregion
#region 建立于删除数据库
/// <summary>
/// 新建立数据库
/// </summary>
/// <param name="databaseName"> 数据库名 </param>
public static void NewDataBase( string databaseName)
{
// 调用ExecuteNonQuery()来创建数据库
string sql = string .Format( " CREATE DATABASE {0} " , databaseName);
ExecuteSql(connInitStr, " master " , sql);
}
/// <summary>
/// 删除数据库
/// </summary>
public static void DropDataBase( string databaseName)
{
string killThread = string .Format( " declare hcforeach cursor global for " +
" select 'kill '+rtrim(spid) from master.dbo.sysprocesses where dbid=db_id(N'{0}') exec sp_msforeach_worker '?' " , databaseName);
// 删除前，Kill掉进程
ExecuteSql(connInitStr, " master " , killThread);
// 调用ExecuteNonQuery()来删除数据库
string sqlQuery = string .Format( " DROP DATABASE {0} " , databaseName);
ExecuteSql(connInitStr, " master " , sqlQuery);
}
private static void ExecuteSql( string conn, string dataBase, string sql)
{
System.Data.SqlClient.SqlConnection mySqlConnection = new System.Data.SqlClient.SqlConnection(conn);
System.Data.SqlClient.SqlCommand command = new System.Data.SqlClient.SqlCommand(sql, mySqlConnection);
command.Connection.Open();
command.Connection.ChangeDatabase(dataBase);
try
{
command.ExecuteNonQuery();
}
catch (Exception exp)
{
throw exp;
}
finally
{
mySqlConnection.Close();
}
}
#endregion
}
}