SQL和Oracle通用的SQLHelper

/// <summary>通用数据库接口</P>
/// </summary>
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 Legalsoft.Wizard.DBUtility
{
    public enum EffentNextType
    {
        /// <summary>
        /// 对其他语句无任何影响
        /// </summary>
        None,
        /// <summary>
        /// 当前语句必须为"SELECT COUNT（1） FROM .."格式，如果存在则继续执行，不存在回滚事务
        /// </summary>
        WhenHaveContine,
        /// <summary>
        /// 当前语句必须为"SELECT COUNT（1） FROM .."格式，如果不存在则继续执行，存在回滚事务
        /// </summary>
        WhenNoHaveContine,
        /// <summary>
        /// 当前语句影响到的行数必须大于0，否则回滚事务
        /// </summary>
        ExcuteEffectRows,
        /// <summary>
        /// 引发事件-当前语句必须为"SELECT COUNT（1） FROM .."格式，如果不存在则继续执行，存在回滚事务
        /// </summary>
        SolicitationEvent
    }
    public class CommandInfo
    {
        public object ShareObject = null;
        public object OriginalData = null;
        event EventHandler _solicitationEvent;
        public event EventHandler SolicitationEvent
        {
            add
            {
                _solicitationEvent += value;
            }
            remove
            {
                _solicitationEvent -= value;
            }
        }
        public void OnSolicitationEvent（）
        {
            if （_solicitationEvent ！= null）
            {
                _solicitationEvent（this, new EventArgs（））;
            }
        }
        public string CommandText;
        public System.Data.Common.DbParameter[] Parameters;
        public EffentNextType EffentNextType = EffentNextType.None;
        public CommandInfo（）
        {
        }
        public CommandInfo（string sqlText, SqlParameter[] para）
        {
            this.CommandText = sqlText;
            this.Parameters = para;
        }
        public CommandInfo（string sqlText, SqlParameter[] para, EffentNextType type）
        {
            this.CommandText = sqlText;
            this.Parameters = para;
            this.EffentNextType = type;
        }
    }
    /// <summary>
    /// 数据访问抽象基础类
    /// </summary>
    public abstract class SQLHelper
    {
        //数据库连接字符串（web.config来配置），可以动态更改connectionString支持多数据库.

        public static readonly string connectionString = ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString;
        public SQLHelper（）
        {

        }
        #region 公用方法
        /// <summary>
        /// 读取指定图片的二进制信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public object LoadImage（int id）
        {
            SqlConnection myConnection = new SqlConnection（connectionString）;
            SqlCommand myCommand = new SqlCommand（"SELECT [bImage] FROM [tblCAIPIAO_NEWS_IMG] WHERE id=@id", myConnection）;
            myCommand.CommandType = CommandType.Text;
            myCommand.Parameters.Add（new SqlParameter（"@id", id））;
            myConnection.Open（）;
            object result = myCommand.ExecuteScalar（）;
            try
            {
                return new System.IO.MemoryStream（（byte[]）result）;
            }
            catch （ArgumentNullException e）
            {
                return null;
            }
            finally
            {
                myConnection.Close（）;
            }
        }
        /// <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 = SQLHelper.GetSingle（strsql）;
            if （obj == null）
            {
                return 1;
            }
            else
            {
                return int.Parse（obj.ToString（））;
            }
        }
        public static bool Exists（string strSql）
        {
            object obj = SQLHelper.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 = SQLHelper.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 = SQLHelper.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;