using System;
using System.Collections;
using System.Data;
using System.Data.SqlClient;
using System.Xml;
using System.Configuration;
using System.Data.Common;
using System.Collections.Generic;


namespace CommonLib {
    /// <summary>
    /// 数据库操作类
    /// </summary>
    public abstract class SqlHelper {
        #region 属性
        /// <summary>
        /// 数据库连接组件
        /// </summary>
        public static SqlConnection conn;
        public static int CommandTimeout = 0;
        public static string ParameterPrefix = "@";
        #endregion

        #region 构造函数
        protected SqlHelper() {
            setCommandTimeout();
        }
        #endregion

        #region ExecuteAdapter
        //获取适配器
        public static SqlDataAdapter ExecuteAdapter(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlDataAdapter adapter;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                adapter = new SqlDataAdapter(cmd);
            }
            catch {
                throw;
            }
            return adapter;
        }

        //获取适配器
        public static SqlDataAdapter ExecuteAdapter(CommandType cmdType, string cmdText) {
            SqlDataAdapter adapter;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
                adapter = new SqlDataAdapter(cmd);
            }
            catch {
                throw;
            }
            return adapter;
        }
        #endregion

        #region ExecuteDataTable
        /// <summary>
        /// 执行sql返回datatable
        /// </summary>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public static DataTable ExecuteDataTable(string cmdText)
        {
            return ExecuteDataSet(cmdText).Tables[0];
        }

        /// <summary>
        /// <para>说明：执行sql返回DataTable</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-07-24 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="cmdText">The command text.</param>
        /// <returns>DataTable.</returns>
        public static DataTable ExecuteDataTable(string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteDataSet(CommandType.Text, cmdText, "temp", commandParameters).Tables[0];
        }

        /// <summary>
        /// <para>说明：执行sql返回指定字段值</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-08-15 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="fieldName">Name of the field.</param>
        /// <param name="cmdText">The command text.</param>
        /// <returns>System.Object.</returns>
        public static string ExecuteString(string fieldName, string cmdText)
        {
            object obj = ExecuteObject(fieldName, cmdText);
            return obj == null ? "" : obj.ToString();
        }

        /// <summary>
        /// <para>说明：执行sql返回指定字段值</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-11-27 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="fieldName">Name of the field.</param>
        /// <param name="cmdText">The command text.</param>
        /// <param name="commandParameters">The command parameters.</param>
        /// <returns>System.String.</returns>
        public static string ExecuteString(string fieldName, string cmdText, params SqlParameter[] commandParameters)
        {
            object obj = ExecuteObject(fieldName, cmdText, commandParameters);
            return obj == null ? "" : obj.ToString();
        }

        /// <summary>
        /// <para>说明：执行sql返回指定字段值</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-11-27 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="fieldName">Name of the field.</param>
        /// <param name="cmdText">The command text.</param>
        /// <param name="commandParameters">The command parameters.</param>
        /// <returns>System.Object.</returns>
        public static object ExecuteObject(string fieldName, string cmdText, params SqlParameter[] commandParameters)
        {
            object result = null;
            try
            {
                result = ExecuteDataSet(CommandType.Text, cmdText, "temp", commandParameters).Tables[0].Rows[0][fieldName];
            }
            catch (Exception)
            {

            }
            return result;
        }

        #endregion

        #region ExecuteDataSet
        /// <summary>
        /// 查询结果集
        /// </summary>
        /// <param name="cmdType">语句类型存储过程或者sql语句</param>
        /// <param name="cmdText">执行内容</param>
        /// <param name="tabName">表名</param>
        /// <param name="commandParameters">参数</param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(int cmdType, string cmdText, string tabName, params SqlParameter[] commandParameters) {
            CommandType _cmdType = CommandType.Text;
            switch (cmdType) {
            case 4:
            _cmdType = CommandType.StoredProcedure;
            break;
            case 512:
            _cmdType = CommandType.TableDirect;
            break;
            }
            return ExecuteDataSet(_cmdType, cmdText, tabName, commandParameters);
        }
        /// <summary>
        /// 查询结果集
        /// </summary>
        /// <param name="cmdType">语句类型存储过程或者sql语句</param>
        /// <param name="cmdText">执行内容</param>
        /// <param name="tabName">表名</param>
        /// <param name="commandParameters">参数</param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(CommandType cmdType, string cmdText, string tabName, params SqlParameter[] commandParameters) {
            DataSet set2;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                DataSet dataSet = new DataSet();
                adapter.Fill(dataSet, tabName);
                //adapter.FillSchema(dataSet, SchemaType.Mapped, tabName);
                set2 = dataSet;
            }
            catch {
                throw;
            }
            finally {
                cmd.Dispose();
            }

            return set2;
        }
        /// <summary>
        /// 查询结果集
        /// </summary>
        /// <param name="cmdType">语句类型存储过程或者sql语句</param>
        /// <param name="cmdText">执行内容</param>
        /// <param name="tabName">表名</param>
        /// <param name="commandParameters">参数</param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(CommandType cmdType, string cmdText, string tabName) {
            DataSet set2;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
                SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                DataSet dataSet = new DataSet();
                adapter.Fill(dataSet, tabName);
                set2 = dataSet;
            }
            catch {
                throw;
            }
            return set2;
        }

        /// <summary>
        /// 查询结果集
        /// </summary>
        /// <param name="cmdType">语句类型存储过程或者sql语句</param>
        /// <param name="cmdText">执行内容</param>
        /// <param name="tabName">表名</param>
        /// <param name="commandParameters">参数</param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(string cmdText) {
            DataSet set2;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommand(cmd, conn, null, CommandType.Text, cmdText, null);
                SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                DataSet dataSet = new DataSet();
                adapter.Fill(dataSet, "temp");
                set2 = dataSet;
            }
            catch {
                throw;
            }
            return set2;
        }

        public static DataSet ExecuteDataSetForThread(string cmdText) { 
            DataSet set2;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommandForThread(cmd, null, CommandType.Text, cmdText, null);
                SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                DataSet dataSet = new DataSet();
                adapter.Fill(dataSet, "temp");
                set2 = dataSet;
            }
            catch {
                throw;
            }
            return set2;
        }

        /// <summary>
        /// 查询结果集
        /// </summary>
        /// <param name="cmdType">语句类型存储过程或者sql语句</param>
        /// <param name="cmdText">执行内容</param>
        /// <param name="tabName">表名</param>
        /// <param name="commandParameters">参数</param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(string procedureName, string tabName, string[] parameterNames, object[] parameterValues) {
            DataSet set2;
            try {
                SqlCommand cmd = new SqlCommand(procedureName, conn);
                cmd.CommandType = CommandType.StoredProcedure;

                if (parameterNames != null && parameterValues != null) {
                    for (int i = 0; i < parameterNames.Length && i < parameterValues.Length; i++) {
                        cmd.Parameters.AddWithValue(parameterNames[i], parameterValues[i]);
                    }
                }
                SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                DataSet dataSet = new DataSet();
                adapter.Fill(dataSet, tabName);
                set2 = dataSet;
            }
            catch {
                throw;
            }
            return set2;
        }
        #endregion

        #region ExecuteNonQuery
        /// <summary>
        /// 执行sql语句或者存储过程
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            int num = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return num;
        }

        /// <summary>
        /// 执行sql语句或者存储过程
        /// </summary>
        /// <param name="trans"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            int num = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return num;
        }

        /// <summary>
        /// 执行sql语句或者存储过程
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static int ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
            int num = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return num;
        }

        /// <summary>
        /// 执行sql语句或者存储过程
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public static int ExecuteNonQuery(CommandType cmdType, string cmdText) {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
            int num = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return num;
        }

        /// <summary>
        /// 执行sql语句或者存储过程
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public static int ExecuteNonQuery(string cmdText) {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, conn, null, CommandType.Text, cmdText, null);
            int num = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return num;
        }
        #endregion

        #region ExecuteReader
        /// <summary>
        /// 执行sql语句或者存储过程并返回结果集（只读、只进）
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlDataReader reader2;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                SqlDataReader reader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                reader2 = reader;
            }
            catch {
                throw;
            }
            return reader2;
        }

        /// <summary>
        /// 执行sql语句或者存储过程并返回结果集（只读、只进）
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText) {
            SqlDataReader reader2;
            SqlCommand cmd = new SqlCommand();
            try {
                PrepareCommandForThread(cmd, null, cmdType, cmdText, null);
                SqlDataReader reader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                reader2 = reader;
            }
            catch {
                throw;
            }
            return reader2;
        }
        #endregion

        #region ExecuteScalar
        /// <summary>
        /// 执行sql语句或者存储过程并返回结果集第一行第一列
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            object obj2 = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return obj2;
        }

        /// <summary>
        /// 执行sql语句或者存储过程并返回结果集第一行第一列
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
            SqlCommand cmd = new SqlCommand();
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                object obj2 = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return obj2;
            }
        }

        /// <summary>
        /// 执行sql语句或者存储过程并返回结果集第一行第一列
        /// </summary>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public static object ExecuteScalar(CommandType cmdType, string cmdText) {
            SqlCommand cmd = new SqlCommand();
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
                object obj2 = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return obj2;
            }
        }

        /// <summary>
        /// <para>说明：执行sql语句或者存储过程并返回结果集第一行第一列</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-08-21 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="cmdText">The command text.</param>
        /// <returns>System.Object.</returns>
        public static object ExecuteScalar(string cmdText)
        {
            SqlCommand cmd = new SqlCommand();
            {
                PrepareCommand(cmd, conn, null, CommandType.Text, cmdText, null);
                object obj2 = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return obj2;
            }
        }
        #endregion

        #region PrepareCommand
        /// <summary>
        /// sql参数处理
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="conn"></param>
        /// <param name="trans"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="cmdParms"></param>
        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms) {
            if (conn.State != ConnectionState.Open) {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandTimeout = CommandTimeout;
            cmd.CommandText = cmdText;
            if (trans != null) {
                cmd.Transaction = trans;
            }
            cmd.CommandType = cmdType;
            if (cmdParms != null) {
                foreach (SqlParameter parameter in cmdParms) {
                    cmd.Parameters.Add(parameter);
                }
            }
        }
        /// <summary>
        /// sql参数处理
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="conn"></param>
        /// <param name="trans"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="cmdParms"></param>
        private static void PrepareCommandForThread(SqlCommand cmd, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {
            SqlConnection conn = DBConfig.Instance.CreateNewConnection();
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandTimeout = CommandTimeout;
            cmd.CommandText = cmdText;
            if (trans != null)
            {
                cmd.Transaction = trans;
            }
            cmd.CommandType = cmdType;
            if (cmdParms != null)
            {
                foreach (SqlParameter parameter in cmdParms)
                {
                    cmd.Parameters.Add(parameter);
                }
            }
        }
        #endregion

        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="TableName"></param>
        /// <param name="fields"></param>
        /// <param name="where"></param>
        /// <returns></returns>
        public static int Update(string TableName, List<FieldModel> fields, String where) {
            if (fields == null) {
                throw new ArgumentNullException("fields");
            }
            string filed = string.Empty;
            foreach (FieldModel m in fields) {
                filed += m.FiledName + "='" + m.FiledValue + "',";
            }
            filed = filed.Trim(',');
            string strSql = string.Format("update {0} set {1} where {2}",
                    TableName, filed,
                    where);
            int obj = SqlHelper.ExecuteNonQuery(strSql.ToString());
            return 1;
        }

        /// <summary>
        /// 增加一条数据
        /// </summary>
        public static int Add(string TableName, List<FieldModel> fields) {
            if (fields == null) {
                throw new ArgumentNullException("fields");
            }
            string filed = string.Empty;
            foreach (FieldModel m in fields) {
                filed += "@" + m.FiledName + ",";
            }
            filed = filed.Trim(',');
            string strSql = string.Format("insert into {0}({1}) values ({2});select @@IDENTITY",
                    TableName, filed.Replace("@", ""),
                    filed);
            object obj = ExecuteScalar(CommandType.Text, strSql, GetAddParameters(fields));
            if (obj == null) {
                return 0;
            }
            else {
                return Convert.ToInt32(obj);
            }
        }

        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs) {
            System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
            myParameter.Value = fs;
            int result = 0;
            try {
                result = ExecuteNonQuery(CommandType.Text, strSQL, myParameter);
            }
            catch (System.Data.SqlClient.SqlException e) {
                throw e;
            }
            return result;
        }

        /// <summary>
        /// 获取新增记录的参数数组
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static SqlParameter[] GetAddParameters(List<FieldModel> list) {
            ArrayList parameters = new ArrayList();
            foreach (FieldModel item in list) {
                SqlParameter param = new SqlParameter(string.Format("{0}{1}", ParameterPrefix, item.FiledName),
                        DbTypeConverter.ConvertToSql(item.DataType));
                param.IsNullable = true;
                param.Value = item.FiledValue;
                parameters.Add(param);
            }
            return (SqlParameter[])parameters.ToArray(typeof(SqlParameter));
        }

        public static void AddLogTab(String DllCoid, String Type, String Content, String Object, String Operator) {
            List<FieldModel> fieldList = new List<FieldModel>();

            String sql = @"INSERT INTO P_LogTab
                           ([Coid]
                           ,[Type]
                           ,[Content]
                           ,[Object]
                           ,[stdt]
                           ,[eddt]
                           ,[Operator]
                           ,[Ws]
                           ,[systemtmp])
                     VALUES
                           (@Coid
                           ,@Type
                           ,@Content
                           ,@Object
                           ,getdate()
                           ,getdate()
                           ,@Operator
                           ,@Ws
                           ,getdate())";

            fieldList.Add(new FieldModel() {
                FiledName = "Coid",
                DataType = FieldType.VarChar,
                FiledValue = DllCoid
            });
            fieldList.Add(new FieldModel() {
                FiledName = "Type",
                DataType = FieldType.VarChar,
                FiledValue = Type
            });
            fieldList.Add(new FieldModel() {
                FiledName = "Content",
                DataType = FieldType.VarChar,
                FiledValue = Content
            });
            fieldList.Add(new FieldModel() {
                FiledName = "Object",
                DataType = FieldType.VarChar,
                FiledValue = Object
            });
            fieldList.Add(new FieldModel() {
                FiledName = "Operator",
                DataType = FieldType.VarChar,
                FiledValue = Operator
            });
            fieldList.Add(new FieldModel() {
                FiledName = "Ws",
                DataType = FieldType.VarChar,
                FiledValue = PubUtil.getHostName()
            });
            SqlHelper.ExecuteNonQuery(CommandType.Text, sql, GetAddParameters(fieldList));
        }

        private static void setCommandTimeout()
        {
            try
            {
                if (CommandTimeout == 0)
                {
                    string sqlValue = "select command_timeout from p_systemtab";
                    DataTable dtTable = ExecuteDataTable(sqlValue);
                    CommandTimeout = Convert.ToInt32(dtTable.Rows[0]["command_timeout"]);
                }
            }
            catch (Exception ex)
            {
                CommandTimeout = 30;
            }
        }
    }
}