CNAS/CnasSynchronusDAL/DAL/PostgreSqlDAL.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;

using CnasSynchronousCommon;
using CnasSynchrousModel;
using System.Reflection;
using Devart.Common;
using Npgsql;

namespace CnasSynchronusDAL
{
    public class PostgreSqlDAL
    {
        public void CreateConnectString(string strIP, string strPort, string strName, string strUser, string strPwd)
        {
            PostgreSQLHelper.InitConnectionString(strIP, strPort, strName, strUser, strPwd);
        }

        public void CreateConnectString(string strConnectString)
        {
            PostgreSQLHelper.InitConnectionString(strConnectString);
        }

        //获取所有表单名称
        public DataTable GetTableNames(string strName)
        {
            DataTable dt = new DataTable();

            //string strSql = string.Format("SELECT table_name as TABNAME FROM information_schema.TABLES WHERE table_schema='{0}'", strName);
            string strSql = string.Format("SELECT table_name as TABNAME FROM information_schema.TABLES WHERE table_catalog='{0}'  and table_schema='public'", strName);
            try
            {
                dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return dt;
        }

        /// <summary>
        /// 获取某表的表结构
        /// </summary>
        /// <param name="strTableName"></param>
        /// <returns></returns>
        public DataTable GetTableStruct(string strTableName, string strViewName, string strViewSql)
        {
            DataTable dt = new DataTable();
            if (strTableName.Length <= 0) return dt;
            string strSql = "";
            if (strViewName == strTableName && !string.IsNullOrWhiteSpace(strViewName))
                strSql = strViewSql + " where 0=1";
            else
                strSql = string.Format("SELECT * FROM {0} Where 0=1", strTableName);
            try
            {
                AppLog.Error("===-222-===" + strTableName + strSql);
                dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
                AppLog.Error("===-333-===" + strTableName + "PostgreSQLHelper.ExecuteDataSet(strSql)" + dt);
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return dt;
        }

        /// <summary>
        /// 获取某表的表结构和类型长度
        /// </summary>
        /// <param name="strTableName"></param>
        /// <returns></returns>
        public DataTable GetTableTypeAndLenth(string strTableName)
        {
            DataTable dt = new DataTable();
            string strSql = string.Format("select COLUMN_NAME AS 'ColumnName',IS_NULLABLE AS 'IsNullable',DATA_TYPE AS 'DataType',CHARACTER_MAXIMUM_LENGTH AS 'CharMaxLenth',CHARACTER_OCTET_LENGTH AS 'CharOcterLenth',NUMERIC_PRECISION AS 'NumericPrecision',NUMERIC_SCALE AS 'NumericScale' FROM information_schema.COLUMNS WHERE TABLE_NAME LIKE '{0}'", strTableName);
            try
            {
                dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return dt;
        }


        /// <summary>
        /// 逐行批量插入数据
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public int InsertCnasData(DataTable dt, List<SyncParamasInfo> syncParamasInfos, List<CnasConditionMapValue> lstFixedValue, string strInsumentColumn)
        {
            int iReturn = 0;
            if (dt.Rows.Count <= 0) return 0;
            try
            {
                //获取唯一健组(关键字段)
                var query = from p in syncParamasInfos
                            where p.IfPrimaryKey == true
                            select new
                            {
                                p.TargetField
                            };
                List<string> lstKeyColumns = new List<string>();
                foreach (var item in query)
                {
                    lstKeyColumns.Add(item.TargetField);
                }

                //构建SQL语句
                string strSql_part1 = "";
                string strSql_part2 = "";
                List<string> lstColumnName = new List<string>();
                foreach (var item in syncParamasInfos)
                {
                    if (!lstColumnName.Contains(item.TargetField.ToLower()))
                    {
                        strSql_part1 += item.TargetField + ",";
                        strSql_part2 += string.Format("@{0},", item.TargetField.ToLower());
                        lstColumnName.Add(item.TargetField.ToLower());
                    }
                }

                //如果映射列中不包含固定列，则需要将这些列添加到SQL语句中
                if (lstFixedValue != null)
                {
                    foreach (var cnasfield in lstFixedValue)
                    {
                        if (cnasfield.TableName != syncParamasInfos[0].TargetTable) continue;
                        if (!lstColumnName.Contains(cnasfield.ColumnName.ToLower()))
                        {
                            strSql_part1 += cnasfield.ColumnName + ",";
                            strSql_part2 += string.Format("@{0},", cnasfield.ColumnName.ToLower());

                            lstColumnName.Add(cnasfield.ColumnName.ToLower());
                        }
                    }
                }
                //增加仪器编号数据
                if (!string.IsNullOrWhiteSpace(strInsumentColumn) && !lstColumnName.Contains(strInsumentColumn.ToLower()))
                {
                    strSql_part1 += strInsumentColumn + ",";
                    strSql_part2 += string.Format("@{0},", strInsumentColumn);

                    lstColumnName.Add(strInsumentColumn.ToLower());
                }

                string strInsertSql = string.Format("insert into {0}({1}) values({2})", syncParamasInfos[0].TargetTable, strSql_part1.Substring(0, strSql_part1.Length - 1), strSql_part2.Substring(0, strSql_part2.Length - 1));
                string strUpdateSql = "";
                DataTable dtSelect = new DataTable();
                foreach (DataRow dr in dt.Rows)
                {
                    //插入参数值
                    NpgsqlParameter[] parameters = new NpgsqlParameter[lstColumnName.Count];
                    int i = 0;
                    foreach (var item in lstColumnName)
                    {
                        parameters[i++] = new NpgsqlParameter(item, dr[item]);
                    }
                    //插入时发现已经在数据库中存在该值，则进行更新操作
                    int ifHavaValue = ExistSingleCnasData(lstKeyColumns, syncParamasInfos[0].TargetTable, dr, ref dtSelect);
                    if (ifHavaValue == 1)
                    {
                        if (dtSelect.Rows.Count == 1)
                        {
                            //比对获取的数据跟准备更新的数据是否一样
                            if (!CompareObjectOperation.DataRowCompare(dtSelect.Rows[0], dr, lstColumnName))
                            {
                                //构造更新语句
                                strUpdateSql = GetUpdateSql(lstColumnName, lstKeyColumns, syncParamasInfos[0].TargetTable, dr);
                                //执行UpdateSql语句
                                iReturn += PostgreSQLHelper.ExecuteNonQuery(strUpdateSql, parameters);
                            }
                            else
                            {
                                iReturn = -2;
                                AppLog.Info("更新时发现在数据库中相同关键字段数据一致。");
                            }
                        }
                        else
                        {
                            AppLog.Error("更新时发现在数据库中多条相同关键字段数据,请重新配置关键字段。");
                        }
                    }
                    else if (ifHavaValue == 0)
                    {
                        //执行InsertSQL语句
                        iReturn += PostgreSQLHelper.ExecuteNonQuery(strInsertSql, parameters);
                    }
                }
            }
            catch (Exception ex)
            {
                if (!LinkCnasTest())
                {
                    iReturn = -1;   //用于表示插入时无法正常数据库连接问题
                }
                //此处添加错误日志
                AppLog.Error(ex.Message);
            }
            return iReturn;
        }

        /// <summary>
        /// 拼接Update语句
        /// </summary>
        /// <param name="lstColumnName"></param>
        /// <param name="lstPrimaryColumn"></param>
        /// <param name="dr"></param>
        private string GetUpdateSql(List<string> lstColumnName, List<string> lstPrimaryColumn, string strTableName, DataRow dr)
        {
            //构造关键字段条件
            string strsql_partial = "";
            foreach (var item in lstPrimaryColumn)
            {
                if (dr.Table.Columns.Contains(item.ToString()))
                    if (dr[item.ToString()].ToString() != "")
                        strsql_partial += $"{item.ToString()}='{dr[item.ToString()].ToString()}' and ";
                    else
                        strsql_partial += $"({item.ToString()}='{dr[item.ToString()].ToString()}' or {item.ToString()} is null) and ";
            }

            //构造Update语句
            string strUpdateSql = "";
            string strsql_partial2 = "";
            foreach (var item in lstColumnName)
            {
                strsql_partial2 += $"{item}=@{item},";
            }

            if (strsql_partial.Length > 3 && strsql_partial2.Length > 0)
                strUpdateSql = $"update {strTableName} set {strsql_partial2.Substring(0, strsql_partial2.Length - 1)} where {strsql_partial.Substring(0, strsql_partial.Length - 4)}";

            return strUpdateSql;
        }

        internal bool CheckMacMessage(string strMac)
        {
            bool bIfChecked = false;
            string strSql = string.Format("select *  FROM macaddress WHERE MAC_ADDRESS='{0}'", strMac);
            try
            {
                DataTable dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
                if (dt != null && dt.Rows.Count > 0)
                {
                    bIfChecked = true;
                }
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return bIfChecked;
        }

        /// <summary>
        /// 是否数据库中已经存在数据，如果存在返回1，并且传递返回的数据；如果不存在，返回0；如果发生了异常，返回-1
        /// </summary>
        /// <param name="lstPrimaryColumn"></param>
        /// <param name="strTableName"></param>
        /// <param name="dr"></param>
        /// <param name="dtSelect"></param>
        /// <returns></returns>
        private int ExistSingleCnasData(List<string> lstPrimaryColumn, string strTableName, DataRow dr, ref DataTable dtSelect)
        {
            int bIfHaveValue = 0;  //如果存在，返回1；如果不存在，返回0；如果发生了异常，返回-1
            string strsql_partial = "";
            string strSql = "";
            foreach (var item in lstPrimaryColumn)
            {
                if (dr.Table.Columns.Contains(item.ToString()))
                    if (dr[item.ToString()].ToString() != "")
                        strsql_partial += $"{item.ToString()}='{dr[item.ToString()].ToString()}' and ";
                    else
                        strsql_partial += $"({item.ToString()}='{dr[item.ToString()].ToString()}' or {item.ToString()} is null) and ";
            }
            if (strsql_partial.Length > 3)
                strSql = $"select * from {strTableName} where {strsql_partial.Substring(0, strsql_partial.Length - 4)}";

            if (strsql_partial.Length > 3 && (strTableName.Equals("tcoalweight") || strTableName.Equals("TCOALWEIGHT")))
                strSql = $"select * from {strTableName} where (idbatch is null or idbatch = '') and {strsql_partial.Substring(0, strsql_partial.Length - 4)}";

            if (strSql != "")
            {
                DataTable dt = PostgreSQLHelper.ExecuteDataTable(strSql, new NpgsqlParameter[] { });
                if (dt != null && dt.Rows.Count > 0)
                {
                    bIfHaveValue = 1;
                    dtSelect = dt;
                    AppLog.Info($"插入前查询时存在重复数据：{strSql}");
                }
                else if (dt == null)
                {
                    bIfHaveValue = -1;
                    AppLog.Info($"插入前查询时发生了异常：{strSql}");
                }
            }
            return bIfHaveValue;
        }
        internal DataTable GetLoginNameByPwd(string strUserName, string strPwd)
        {
            DataTable dt = new DataTable();
            string strSql = string.Format("select *  FROM user WHERE userid='{0}' and password='{1}'", strUserName, strPwd);
            try
            {
                dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return dt;
        }

        public bool LinkCnasTest()
        {
            return PostgreSQLHelper.TestConnectPostgreSQL();
        }

        /// <summary>
        /// 获得表中该列中最大时间
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public string GetMaxTimeByTableName(string strTableName, string strDateColumn, string strInstrumentColumn, string strInstrumentValue)
        {
            string strReturnTime = "";
            //因为数据库用varchar存储日期字段，从而格式不固定，需要使用多种格式读取
            try
            {
                #region 旧的获取时间方法
                ////string strSql_1 = string.Format("SELECT max(STR_TO_DATE({0},'%Y-%m-%d %H:%i:%s')) FROM {1} ", strDateColumn, strTableName);
                ////string strSql_2 = string.Format("SELECT max(STR_TO_DATE({0},'%Y/%m/%d %H:%i:%s')) FROM {1} ", strDateColumn, strTableName);
                //string strSql_2 = string.Format("SELECT max(Convert({0},datetime)) FROM {1} ", strDateColumn, strTableName);

                ////string strDateTime_1 = GetMaxTimeByTableName(strSql_1);
                //string strDateTime_2= GetMaxTimeByTableName(strSql_2);

                ////AppLog.Info($"读取到最大的时间（1）：表-{strTableName},列-{strDateColumn},值-{strDateTime_1}");
                //AppLog.Info($"读取到最大的时间（2）：表-{strTableName},列-{strDateColumn},值-{strDateTime_2}");

                //List<DateTime> lstTime = new List<DateTime>();
                ////DateTime dateTime_1 = DateTime.Now;
                //DateTime dateTime_2 = DateTime.Now;
                ////if (DateTime.TryParse(strDateTime_1, out dateTime_1))
                ////{
                ////    lstTime.Add(dateTime_1);
                ////}
                //if (DateTime.TryParse(strDateTime_2, out dateTime_2))
                //{
                //    if (!lstTime.Contains(dateTime_2))
                //        lstTime.Add(dateTime_2);
                //}

                //if (lstTime.Count > 0)
                //{
                //    strReturnTime = lstTime.Max<DateTime>().ToString();

                //    AppLog.Info($"返回最大的时间（3）：表-{strTableName},列-{strDateColumn},值-{strReturnTime}");
                //}
                # endregion

                string strSql = string.Format("SELECT Convert(max(Convert({0},datetime)) using utf8) FROM {1}", strDateColumn, strTableName, strInstrumentColumn, strInstrumentValue);
                if (!string.IsNullOrWhiteSpace(strInstrumentColumn) && !string.IsNullOrWhiteSpace(strInstrumentValue))
                    strSql += string.Format(" where {0}='{1}'", strInstrumentColumn, strInstrumentValue);
                string strDateTime = GetMaxTimeByTableName(strSql);
                DateTime dateTime = DateTime.Now;
                if (DateTime.TryParse(strDateTime, out dateTime))
                {
                    strReturnTime = strDateTime;
                }
            }
            catch (Exception ex)
            {
                //if (!LinkCnasTest())
                //{
                //    strReturnTime = "1899-1-1";   //用于表示插入时无法正常数据库连接问题
                //}
                //只要发生异常，就返回这个结果
                strReturnTime = "1899-1-1";
                AppLog.Error(ex.Message);
            }
            return strReturnTime;
        }

        internal DataTable GetDataByDateColumn(string strDBName, string strViewName, string strViewSql, string strTableName, string strDateColumn, string strDate)
        {
            DataTable dtReturn = new DataTable();
            try
            {
                string strSql = "";
                if (strViewName == strTableName && !string.IsNullOrWhiteSpace(strViewName))
                    //strSql = strViewSql + $" where {strDateColumn} >convert( '{strDate}',datetime)";
                    strSql = strViewSql + $" where \"{strDateColumn}\" >TO_TIMESTAMP('{strDate}',  'YYYY-MM-DD HH24:MI:SS');";
                else
                    strSql = $"select * from {strDBName}.public.{strTableName} where \"{strDateColumn}\">TO_TIMESTAMP('{strDate}',  'YYYY-MM-DD HH24:MI:SS');";
                DataTable dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];

                Dictionary<string, string> dictFiled = GetSpecialOperaField(strDBName, strTableName);
                if (dictFiled.Count > 0)
                    dtReturn = DateAndTimeTypeOpera(dt, dictFiled);
                else
                    dtReturn = dt;
            }
            catch (Exception ex)
            {
                //发生异常，写入日志
                AppLog.Error(ex.Message);
                throw ex;
            }
            return dtReturn;
        }

        internal Dictionary<string, DataTable> GetAllTableNameAndStructure(string strDBName)
        {
            Dictionary<string, DataTable> dictTables = new Dictionary<string, DataTable>();
            try
            {
                DataTable TablesName = GetTableNames(strDBName);//得到所有表
                foreach (DataRow dr in TablesName.Rows)
                {
                    string strTableName = dr[0].ToString();
                    AppLog.Error("===---===" + strTableName + "GetTableStruct(strTableName, )");
                    dictTables.Add(strTableName, GetTableStruct(strTableName, "", ""));
                }

            }
            catch (Exception ex)
            {
                //发生异常，写入日志
                AppLog.Error(ex.Message);
                //throw ex;
            }
            return dictTables;
        }

        public string GetMaxTimeByTableName(string strSql)
        {
            string strDateTime = "";
            try
            {

                DataTable dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
                AppLog.Info($"执行语句获得最晚时间:{strSql}");
                if (dt != null && dt.Rows.Count == 1)
                {
                    strDateTime = dt.Rows[0][0].ToString();
                    AppLog.Info($"执行语句获得最晚时间:行数-({dt.Rows.Count}),列数-({dt.Columns.Count}),值-({strDateTime})");
                }
            }
            catch (Exception ex)
            {
                if (!LinkCnasTest())
                {
                    strDateTime = "1899-1-1";   //用于表示插入时无法正常数据库连接问题
                }
                AppLog.Error(ex.Message);
            }
            return strDateTime;
        }


        /// <summary>
        /// 获取所有数据字段，然后记录其中是否存在需要特殊处理的字段
        /// </summary>
        /// <returns></returns>
        private static Dictionary<string, string> GetSpecialOperaField(string strDBName, string strTableName)
        {
            Dictionary<string, string> DictFiled = new Dictionary<string, string>();
            DataTable dt = new DataTable();
            try
            {
                string sql = string.Format("SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='{0}' and table_schema='{1}'", strTableName, strDBName); //查询字符串
                dt = PostgreSQLHelper.ExecuteDataSet(sql).Tables[0];

                foreach (DataRow dr in dt.Rows)
                {
                    if (dr["data_type"].ToString().ToLower() == "date" || dr["data_type"].ToString().ToLower() == "time")
                    {
                        DictFiled.Add(dr["column_name"].ToString(), dr["data_type"].ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                //发生异常，写入日志
                AppLog.Error(ex.Message);
            }
            return DictFiled;
        }

        /// <summary>
        /// 获取数据时，单独处理某些（Date和Time）类型数据，并把数据类型转换为字符串类型
        /// </summary>
        private static DataTable DateAndTimeTypeOpera(DataTable dt, Dictionary<string, string> DictSpecialField)
        {
            DataTable dtNewFormat = new DataTable();

            //添加列
            foreach (DataColumn dc in dt.Columns)
            {
                if (DictSpecialField.ContainsKey(dc.ColumnName))
                {
                    string strDateType = DictSpecialField[dc.ColumnName];
                    switch (strDateType.ToUpper())
                    {
                        case "DATE":
                        case "TIME":
                            dtNewFormat.Columns.Add(dc.ColumnName, typeof(string));  //使用字符串来存储该字段，而不是采用它的数据库格式（C#无法区分Date, Time，DateTime，前两种格式会自动补充数据，导致数据的不准确）
                            break;
                        default:
                            dtNewFormat.Columns.Add(dc.ColumnName, dc.DataType);
                            break;
                    }
                }
                else
                {
                    dtNewFormat.Columns.Add(dc.ColumnName, dc.DataType);
                }
            }

            //添加数据行
            foreach (DataRow dr in dt.Rows)
            {
                DataRow drNewRow = dtNewFormat.NewRow();
                foreach (DataColumn dc in dtNewFormat.Columns)
                {
                    if (!DictSpecialField.ContainsKey(dc.ColumnName))
                        drNewRow[dc.ColumnName] = dr[dc.ColumnName];
                    else
                    {
                        switch (DictSpecialField[dc.ColumnName].ToUpper())
                        {
                            case "DATE":
                                if (dr[dc.ColumnName] != null && dr[dc.ColumnName].ToString() != "")
                                    drNewRow[dc.ColumnName] = Convert.ToDateTime(dr[dc.ColumnName]).ToString("yyyy-MM-dd");
                                break;
                            case "TIME":
                                if (dr[dc.ColumnName] != null && dr[dc.ColumnName].ToString() != "")
                                    drNewRow[dc.ColumnName] = Convert.ToDateTime(dr[dc.ColumnName].ToString()).ToString("HH:mm:ss");
                                break;
                            default:
                                drNewRow[dc.ColumnName] = dr[dc.ColumnName];
                                break;
                        }
                    }
                }
                dtNewFormat.Rows.Add(drNewRow);
            }

            //返回数据
            return dtNewFormat;
        }

        /// <summary>
        /// 获取某个表的数据
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public DataTable GetTableData(string strSql)
        {
            DataTable dt = new DataTable();
            try
            {
                dt = PostgreSQLHelper.ExecuteDataSet(strSql).Tables[0];
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return dt;
        }

        /// <summary>
        /// 插入某个表的数据
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public bool InsertTableData(string strSql)
        {

            try
            {
                return PostgreSQLHelper.ExecuteNonQuery(strSql) > 0;
            }
            catch (Exception ex)
            {
                AppLog.Error(ex.Message);
            }
            return false;
        }

    }
}