System.Data.SqlClient.SqlConnection.CreateCommand()

private string GetHealthStatus()
        {
            string status = "failed"; 
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Master)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = System.Data.CommandType.Text;
                        cmd.CommandText = @"select top 1 'normal' as healthStatus";
                        cmd.CommandTimeout = 5;
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            status = config.DatabaseValue<string>(reader["healthStatus"]);
                        }
                        reader.Close();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error($@"GetHealthStatus failed : {ex.Message}, healthStatus : {status}");
            }

            return status;
        }

private string GetHealthStatus()
        {
            string status = "failed";
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Master)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = System.Data.CommandType.Text;
                        cmd.CommandText = @"select top 1 'normal' as healthStatus";
                        cmd.CommandTimeout = 5;
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            status = config.DatabaseValue<string>(reader["healthStatus"]);
                        }
                        reader.Close();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error($@"GetHealthStatus failed : {ex.Message}, healthStatus : {status}");
            }

            return status;
        }

public void ExecuteBackup()
        {
            log.Warn("Fullbackup Execute");
            if (Path.Substring(Path.Length - 1).Equals(@"\"))
                Path = Path.Substring(0, Path.Length - 1);

            if (!Directory.Exists(Path))
                Directory.CreateDirectory(Path);

            foreach (var a in targets)
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Master)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        string stringmaxtransfersize = (maxtransfersize.Equals("0") || maxtransfersize.Equals("")) ? "" : $", MAXTRANSFERSIZE = {maxtransfersize}";
                        string stringbuffercount = (buffercount.Equals("0") || buffercount.Equals("")) ? "" : $", BUFFERCOUNT = {buffercount}";
                        string stringcompression = (!compressionYN.Equals("Y", StringComparison.OrdinalIgnoreCase)) ? "" : ", compression";
                        string option = stringcompression + stringmaxtransfersize + stringbuffercount;
                        string filename = $"{a.SERVERNAME.Replace(@"/", "-")}__{a.DATABASE_NAME}__{DateTime.Now.ToString("yyyyMMddHHmmss")}.full";
                        string query = $@"backup database [{a.DATABASE_NAME}] to disk = '{Path}/{filename}' with init{option}";
                        log.Warn(query);
                        a.BACKUP_FILE_NAME = filename;
                        cmd.CommandText = query;
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandTimeout = 60 * 60 * 24;
                        cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
                if (!IsRunning) break;
            }
        }

public void GetData()
        {
            log.Warn("get log backup target");
            using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Master)))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = logBackupTargetQuery;
                    cmd.CommandType = CommandType.Text;
                    cmd.Parameters.Add("@HACHECKYN", SqlDbType.VarChar, 1).Value = HaCompleteCheckYN;
                    SqlDataReader reader = cmd.ExecuteReader();
                    while (reader.Read())
                    {
                        targets.Add
                            (
                                new Target
                                {
                                    SERVERNAME = config.DatabaseValue<string>(reader["SERVERNAME"]),
                                    DATABASE_NAME = config.DatabaseValue<string>(reader["DATABASE_NAME"])
                                }
                            );
                        if (!IsRunning) break;
                    }
                }
                conn.Close();
            }
        }

public void ExecuteBackup()
        {
            log.Warn("log backup Execute");

            if (Path.Substring(Path.Length - 1).Equals(@"\"))
                Path = Path.Substring(0, Path.Length - 1);

            if (!Directory.Exists(Path))
                Directory.CreateDirectory(Path);
            
            foreach (var a in targets)
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Master)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        string filename = $"{a.SERVERNAME.Replace(@"/", "_")}__{a.DATABASE_NAME}__{DateTime.Now.ToString("yyyyMMddHHmmss")}.log";
                        string query = $@"backup log [{a.DATABASE_NAME}] to disk = '{Path}\{filename}' with init";
                        log.Warn(query);
                        a.BACKUP_FILE_NAME = filename;
                        cmd.CommandText = query;
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandTimeout = 60 * 60 * 1;
                        cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
                if (!IsRunning) break;
            }
        }

private bool IsExistsCounterDetails()
        {
            bool bReturn = false;
            int CounterDetailCnt = 0;
            DateTime endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));
            while (true) // wait for sql repository ready
            {
                try
                {
                    bool preStepHasError = false;
                    endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));  // 10초마다 동작 

                    using (SqlConnection conn = new SqlConnection(GetConnectionString(InitialCatalog.Repository)))
                    {
                        conn.Open();
                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = @"SELECT count(*) cnt FROM INFORMATION_SCHEMA.TABLES where TABLE_NAME = 'CounterDetails'";
                            SqlDataReader reader = cmd.ExecuteReader();
                            while (reader.Read())
                            {
                                CounterDetailCnt = DatabaseValue<int>(reader["cnt"]);
                            }
                            if (CounterDetailCnt == 0)
                                preStepHasError = true;
                            reader.Close();
                        }
                        if (!preStepHasError)
                        {
                            using (SqlCommand cmd = conn.CreateCommand())
                            {
                                cmd.CommandType = CommandType.Text;
                                cmd.CommandText = @"SELECT count(*) cnt FROM dbo.CounterDetails";
                                SqlDataReader reader = cmd.ExecuteReader();
                                while (reader.Read())
                                {
                                    CounterDetailCnt = DatabaseValue<int>(reader["cnt"]);
                                }
                                if (CounterDetailCnt >= 1)
                                    bReturn = true;
                                else
                                    bReturn = false;
                                reader.Close();
                            }
                        }
                        conn.Close();
                        break; 
                    }
                }
                catch (Exception ex)
                {
                    log.Error($"IsExistsCounterDetails  {ex.Message}");
                }

                while (DateTime.Now < endTime)
                {
                    if (DbConfigLoaded) break;
                    Thread.Sleep(200);
                }
            }
            return bReturn;
        }

private bool IsExistsRepository(string initialCatalog)
        {

            bool bReturn = false;
            DateTime endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));
            while (true) // wait for sql instance ready
            {
                try
                {
                    endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));  // 10초마다 동작 
                    using (SqlConnection conn = new SqlConnection(GetConnectionString(InitialCatalog.Master)))
                    {
                        conn.Open();
                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = @"select name from master.dbo.sysdatabases where name = @initialCatalog";
                            cmd.Parameters.Add("@initialCatalog", SqlDbType.NVarChar, 100).Value = initialCatalog;
                            SqlDataReader reader = cmd.ExecuteReader();
                            bReturn = reader.HasRows;
                        }
                        conn.Close();
                        break; 
                    }
                }
                catch (Exception ex)
                {
                    log.Error($"IsExistsRepository Error {ex.Message}");
                }

                while (DateTime.Now < endTime)
                {
                    if (DbConfigLoaded) break;
                    Thread.Sleep(200);
                }
            }
            return bReturn;
        }

private string GetPort()
        {
            string port = string.Empty;
            try
            {
                if (LogClient.Config.Instance.GetValue(LogClient.Category.Repository, LogClient.Key.SqlDataSource).IndexOf(",")>0)
                {
                    port = LogClient.Config.Instance.GetValue(LogClient.Category.Repository, LogClient.Key.SqlDataSource).Split(',')[1].Trim();
                }
                else
                {
                    using (SqlConnection conn = new SqlConnection(GetConnectionString(InitialCatalog.Repository)))
                    {
                        conn.Open();
                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = @"SELECT top 1 port FROM sys.dm_tcp_listener_states WHERE is_ipv4 = 1 AND [type] = 0 AND ip_address <> '127.0.0.1'";
                            SqlDataReader reader = cmd.ExecuteReader();
                            if (reader.HasRows)
                            {
                                while (reader.Read())
                                {
                                    port = DatabaseValue<int>(reader["port"]).ToString();
                                }
                            }
                            reader.Close();
                        }
                        conn.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return port;
        }

private void SetSqlVersion()
        {
            DateTime endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));
            while (true)
            {
                endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));  // 10초마다 동작 
                try
                {
                    using (SqlConnection conn = new SqlConnection(GetConnectionString(InitialCatalog.Master)))
                    {
                        conn.Open();
                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = @"
SELECT
  CASE 
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '8%' THEN		'2000'
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '9%' THEN		'2005'
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '10.0%' THEN	'2008'
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '10.5%' THEN	'2008R2'
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '11%' THEN		'2012'
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '12%' THEN		'2014'
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '13%' THEN		'2016'     
     WHEN CONVERT(VARCHAR(128), SERVERPROPERTY ('productversion')) like '14%' THEN		'2017' 
     ELSE 'unknown'
  END AS Version
";
                            SqlDataReader reader = cmd.ExecuteReader();
                            if (reader.HasRows)
                            {
                                while (reader.Read())
                                {
                                    dicData.Add(
                                        new Tuple<Category, Key>(
                                            (Category)Enum.Parse(typeof(Category), "SqlServer")
                                            , (Key)Enum.Parse(typeof(Key), "Version")
                                            )
                                        , DatabaseValue<string>(reader["Version"]));
                                }
                            }
                            reader.Close();
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                }

                while (DateTime.Now < endTime)
                {
                    Thread.Sleep(200);
                }
            }

        }

public void DbConfigLoad()
        {
            if (!DbConfigLoaded)
            {
                DateTime endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));

                while (true)
                {
                    try
                    {
                        endTime = DateTime.Now.Add(new TimeSpan(0, 0, 10));  // 10초마다 동작 
                        using (SqlConnection conn = new SqlConnection(GetConnectionString(InitialCatalog.Repository)))
                        {
                            conn.Open();
                            using (SqlCommand cmd = conn.CreateCommand())
                            {
                                cmd.CommandType = CommandType.Text;
                                cmd.CommandText = @"select @@servicename servicename";
                                SqlDataReader reader = cmd.ExecuteReader();
                                if (reader.HasRows)
                                {
                                    while (reader.Read())
                                    {
                                        dicData.Add(
                                        new Tuple<Category, Key>(
                                            (Category)Enum.Parse(typeof(Category), "GLOBAL")
                                            , (Key)Enum.Parse(typeof(Key), "servicename")
                                            )
                                        , DatabaseValue<string>(reader["servicename"])
                                        );
                                    }
                                }
                                reader.Close();
                            }

                            using (SqlCommand cmd = conn.CreateCommand())
                            {
                                cmd.CommandType = CommandType.Text;
                                cmd.CommandText = @"select type, name, value from dbo.config";
                                SqlDataReader reader = cmd.ExecuteReader();
                                if (reader.HasRows)
                                {
                                    while (reader.Read())
                                    {
                                        dicData.Add(
                                        new Tuple<Category, Key>(
                                            (Category)Enum.Parse(typeof(Category), DatabaseValue<string>(reader["type"]))
                                            , (Key)Enum.Parse(typeof(Key), DatabaseValue<string>(reader["name"]))
                                            )
                                        , DatabaseValue<string>(reader["value"])
                                        );

                                        log.Warn(string.Format("database configuration loading... {0}, {1}, {2}"
                                            , DatabaseValue<string>(reader["type"])
                                            , DatabaseValue<string>(reader["name"])
                                            , DatabaseValue<string>(reader["value"])));
                                    }
                                }
                                reader.Close();
                            }

                            conn.Close();
                            DbConfigLoaded = true;
                            break; 
                        }
                    }
                    catch (Exception ex)
                    {
                        log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                    }

                    
                    while (DateTime.Now < endTime)
                    {
                        if (DbConfigLoaded) break;
                        Thread.Sleep(200);
                    }
                    log.Warn("!DbConfigLoaded while....");
                }
            }
        }

private SqlServerLicenseData GetSqlServerLicenseData (string serverName)
        {
            string batchRequestsPerSec = "";
            string onlineDbCnt = "";
            string cpuCnt = "";
            string hyperthreadRatio = "";
            string physicalMemoryKb = "";

            SqlServerLicenseData sld = new SqlServerLicenseData();

            try
            {
                AsyncHelpers.RunSync(() => fileDb.ReadTable(FileDb.TableName.TBL_SERVER));
                TBL_SERVER_VALUE tbl_server_value = new TBL_SERVER_VALUE();
                if (fileDb.TBL_SERVER.Data.ContainsKey(new TBL_SERVER_KEY { serverName = serverName }))
                {
                    tbl_server_value = fileDb.TBL_SERVER.Data[new TBL_SERVER_KEY { serverName = serverName }];
                }

                string connString = string.Empty;

                if (tbl_server_value != null)
                {
                    try
                    {
                        string decryptedPreplacedword = TranString.DecodeRijndael(
                            tbl_server_value.serverPreplacedword,
                            LogClient.Config.Instance.GetCryptionKey());

                        connString = new SqlConnectionStringBuilder
                        {
                            DataSource = tbl_server_value.serverPublicIp + "," + tbl_server_value.serverPort,
                            UserID = tbl_server_value.serverUserId,
                            Preplacedword = decryptedPreplacedword,
                            InitialCatalog = "master",
                            ConnectTimeout = 5,
                        }.ConnectionString;

                        using (SqlConnection conn = new SqlConnection(connString))
                        {
                            conn.Open();
                            using (SqlCommand cmd = conn.CreateCommand())
                            {
                                cmd.CommandType = System.Data.CommandType.Text;
                                cmd.CommandText =
@"
set nocount on 
set transaction isolation level read uncommitted 
declare @pre int, @post int, @BatchRequestsPerSec int, @OnlineDbCnt int, @CpuCnt int, @HyperthreadRatio int, @PhysicalMemoryKb int
begin try 
    select @CpuCnt = cpu_count, @HyperthreadRatio = hyperthread_ratio, @PhysicalMemoryKb = physical_memory_kb from [sys].[dm_os_sys_info]
    select @OnlineDbCnt = count(*) from sys.databases where name not in ('master', 'tempdb', 'model', 'msdb', 'LazyLog') and state_desc = 'ONLINE'
    select @pre = cntr_value from sys.dm_os_performance_counters WHERE counter_name  ='Batch Requests/sec'
    waitfor delay '00:00:01.000'
    select @post = cntr_value from sys.dm_os_performance_counters WHERE counter_name  ='Batch Requests/sec'
    select @BatchRequestsPerSec = (@post - @pre)
end try 
begin catch 
end catch 
select 
    cast(@BatchRequestsPerSec as varchar(100)) batchRequestsPerSec 
    , cast(@OnlineDbCnt as varchar(100)) onlineDbCnt
    , cast(@CpuCnt as varchar(100)) cpuCnt
    , cast(@HyperthreadRatio as varchar(100)) hyperthreadRatio
    , cast(@PhysicalMemoryKb as varchar(100)) physicalMemoryKb
";
                                cmd.CommandTimeout = 5;
                                SqlDataReader reader = cmd.ExecuteReader();
                                while (reader.Read())
                                {
                                    batchRequestsPerSec = config.DatabaseValue<string>(reader["batchRequestsPerSec"]);
                                    onlineDbCnt = config.DatabaseValue<string>(reader["onlineDbCnt"]);
                                    cpuCnt = config.DatabaseValue<string>(reader["cpuCnt"]);
                                    hyperthreadRatio = config.DatabaseValue<string>(reader["hyperthreadRatio"]);
                                    physicalMemoryKb = config.DatabaseValue<string>(reader["physicalMemoryKb"]);
                                }
                                reader.Close();
                            }
                            conn.Close();
                        }

                        GetClusterInfo(GetServerName(), out string loadBalancerInstanceNo, out string serverInstanceNo, out string clusterName, out string publicIp, out string privateIp, out string serverRole);

                        sld.loadBalancerInstanceNo = loadBalancerInstanceNo;
                        sld.loadBalancerInstanceName = clusterName; 
                        sld.serverName = serverName;
                        sld.serverInstanceNo = serverInstanceNo;
                        sld.privateIp = privateIp;
                        sld.serverRole = serverRole;
                        sld.batchRequestsPerSec = batchRequestsPerSec;
                        sld.onlineDbCnt = onlineDbCnt;
                        sld.cpuCnt = cpuCnt;
                        sld.hyperthreadRatio = hyperthreadRatio;
                        sld.physicalMemoryKb = physicalMemoryKb;

                        

                    }
                    catch (Exception ex)
                    {
                        log.Error(string.Format("get licensedata error {0}, {1}", ex.Message, ex.StackTrace));
                    }
                }
                
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return sld;
        }

private void PartnerOffAndRestoreDatabase()
        {
            try
            {
                string connString = config.GetConnectionString(InitialCatalog.Master);
                using (SqlConnection conn = new SqlConnection(connString))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = System.Data.CommandType.Text;
                        cmd.CommandText = queryPartneroffAndRestoreDatabase;
                        cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                    log.Warn("PartnerOffAndRestoreDatabase completed!");
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                throw;
            }
        }

private bool QueryExecuter(string listStringQuery, int commandTimeout = 30)
        {
            bool bReturn = false;
            sbResultAll.Clear();
            List<string> querys = TranString.ReadQuery(listStringQuery);

            sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
            sbResultAll.Append(DateTime.Now + Environment.NewLine);
            sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);

            foreach (var query in querys)
            {
                try
                {
                    sbResultAll.Append("-->>---------------------------------");
                    sbResultAll.Append(query + Environment.NewLine);
                    sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);
                    if (query.Trim().ToUpper().StartsWith("USE"))
                    {
                        string[] database = query.Trim().Split(new[] { Environment.NewLine, " " }, StringSplitOptions.None);
                        connectionString = SetConnectionString(database[1]);
                        comboBoxDatabase.InvokeIfRequired(s =>
                        {
                            s.Text = "";
                            s.SelectedText = database[1].ToString();
                        });
                    }
                    string result = string.Empty;
                    using (SqlConnection conn = new SqlConnection(connectionString))
                    {
                        conn.Open();
                        conn.InfoMessage += Conn_InfoMessage; // message hook (like backup message) 

                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.StatementCompleted += Cmd_StatementCompleted; // retrive row count
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = query;
                            cmd.CommandTimeout = commandTimeout;
                            SqlDataReader reader = cmd.ExecuteReader();
                            int recordsAffected = reader.RecordsAffected;

                            do
                            {
                                StringBuilder sb = new StringBuilder();
                                string Header = string.Empty;
                                string Line = string.Empty;
                                DataTable schemaTable = reader.GetSchemaTable();
                                if (schemaTable != null)
                                {
                                    try
                                    {
                                        foreach (DataRow row in schemaTable.Rows)
                                        {
                                            foreach (DataColumn column in schemaTable.Columns)
                                            {
                                                if (column.ColumnName == "ColumnName")
                                                {
                                                    Header = Header + row[column] + "\t";
                                                    Line = Line + "------- ";
                                                }
                                            }
                                        }
                                        Header = Header + Environment.NewLine;
                                        Line = Line + Environment.NewLine;
                                        sb.Append(Header);
                                        sb.Append(Line);

                                        while (reader.Read())
                                        {
                                            for (int i = 0; i < reader.FieldCount; i++)
                                            {
                                                if (reader.GetValue(i).ToString() == "System.Byte[]")
                                                    sb.Append("0x" + BitConverter.ToString((byte[])reader.GetValue(i)).Replace("-", ""));
                                                else
                                                    sb.Append(reader.GetValue(i).ToString());
                                                sb.Append("\t");
                                            }
                                            sb.Append(Environment.NewLine);
                                        }

                                    }
                                    catch (SqlException ex)
                                    {
                                        errorCnt++;
                                        sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                                        sbResultAll.Append("--SQL Exception" + Environment.NewLine);
                                        sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                                        for (int i = 0; i < ex.Errors.Count; i++)
                                        {
                                            sbResultAll.Append("Inner SqlException No #" + i + Environment.NewLine +
                                            "Message: " + ex.Errors[i].Message + Environment.NewLine +
                                            "Source: " + ex.Errors[i].Source + Environment.NewLine +
                                            "Procedure: " + ex.Errors[i].Procedure + Environment.NewLine);
                                        }
                                    }
                                    finally
                                    {
                                        sb.Append(Environment.NewLine);
                                        sbResultAll.Append(sb);
                                        sbResultAll.Append(string.Format("({0} {1} affected)" + Environment.NewLine + Environment.NewLine, recordCount, (recordCount == 1) ? "row" : "rows"));
                                    }
                                }
                                else
                                {
                                    string[] Query = query.Trim().Split(new[] { Environment.NewLine, " " }, StringSplitOptions.None);
                                    if (
                                        Query[0].Equals("update", StringComparison.OrdinalIgnoreCase)
                                        || Query[0].Equals("insert", StringComparison.OrdinalIgnoreCase)
                                        || Query[0].Equals("delete", StringComparison.OrdinalIgnoreCase)
                                        || Query[1].Equals("update", StringComparison.OrdinalIgnoreCase)
                                        || Query[1].Equals("insert", StringComparison.OrdinalIgnoreCase)
                                        || Query[1].Equals("delete", StringComparison.OrdinalIgnoreCase)
                                        )
                                        sbResultAll.Append(string.Format("({0} {1} affected)" + Environment.NewLine + Environment.NewLine, recordCount, (recordCount == 1) ? "row" : "rows"));
                                    else
                                        sbResultAll.Append(string.Format("Commands completed successfully." + Environment.NewLine + Environment.NewLine));
                                }
                                reader.NextResult();
                            } while (reader.HasRows);
                        }
                        conn.Close();
                        bReturn = true;
                    }

                    if (checkBoxResultUpdateByGo.Checked)
                        fastColoredTextBoxResult.InvokeIfRequired(s =>
                        {
                            s.Text = sbResultAll.ToString();
                        });
                }

                catch (SqlException ex)
                {
                    errorCnt++;
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                    sbResultAll.Append("--SQL Exception" + Environment.NewLine);
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);

                    for (int i = 0; i < ex.Errors.Count; i++)
                    {
                        sbResultAll.Append("SqlException No #" + i + Environment.NewLine +
                        "Message: " + ex.Errors[i].Message + Environment.NewLine +
                        "Source: " + ex.Errors[i].Source + Environment.NewLine +
                        "Procedure: " + ex.Errors[i].Procedure + Environment.NewLine);
                    }

                    sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);

                    if (checkBoxResultUpdateByGo.Checked)
                        fastColoredTextBoxResult.InvokeIfRequired(s =>
                        {
                            s.Text = sbResultAll.ToString();
                        });

                    bReturn = false;
                }
                catch (Exception ex)
                {
                    errorCnt++;
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                    sbResultAll.Append("--Exception" + Environment.NewLine);
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                    sbResultAll.Append(ex.Message);
                    sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);

                    if (checkBoxResultUpdateByGo.Checked)
                        fastColoredTextBoxResult.InvokeIfRequired(s =>
                        {
                            s.Text = sbResultAll.ToString();
                        });

                    bReturn = false;
                }
            }

            fastColoredTextBoxResult.InvokeIfRequired(s =>
            {
                s.Text = sbResultAll.ToString();
            });

            return bReturn;
        }

private void DbListUpdate()
        {
            try
            {
                if (!textBoxIP.Text.Equals("") &&
                    !textBoxPort.Text.Equals("") &&
                    !textBoxUserId.Text.Equals("") &&
                    !textBoxPreplacedword.Text.Equals(""))
                    {

                    connectionString = SetConnectionString(comboBoxDatabase.Text);

                    comboBoxDatabase.Items.Clear();
                    using (SqlConnection conn = new SqlConnection(connectionString))
                    {
                        conn.Open();
                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = "select name from master.dbo.sysdatabases";
                            cmd.CommandTimeout = 5;
                            SqlDataReader reader = cmd.ExecuteReader();
                            if (reader.HasRows)
                            {
                                while (reader.Read())
                                {
                                    comboBoxDatabase.Items.Add(reader.GetValue(0).ToString());
                                }
                                reader.Close();
                            }
                        }
                        conn.Close();
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

public async Task<bool> LastConnectionTest(string serverName)
        {
            bool returnValue = false;
            await fileDb.ReadTable(FileDb.TableName.TBL_SERVER);
            TBL_SERVER_VALUE tbl_server_value = new TBL_SERVER_VALUE();
            if (fileDb.TBL_SERVER.Data.ContainsKey(new TBL_SERVER_KEY { serverName = serverName }))
            {
                tbl_server_value = fileDb.TBL_SERVER.Data[new TBL_SERVER_KEY { serverName = serverName }];
            }

            string connString = string.Empty;

            if (tbl_server_value != null)
            {
                try
                {
                    string decryptedPreplacedword = TranString.DecodeRijndael(
                        tbl_server_value.serverPreplacedword,
                        LogClient.Config.Instance.GetCryptionKey());

                    connString = new SqlConnectionStringBuilder
                    {
                        DataSource = tbl_server_value.serverPublicIp + "," + tbl_server_value.serverPort,
                        UserID = tbl_server_value.serverUserId,
                        Preplacedword = decryptedPreplacedword,
                        InitialCatalog = "master",
                        ConnectTimeout = 5,
                    }.ConnectionString;

                    using (SqlConnection conn = new SqlConnection(connString))
                    {
                        conn.Open();
                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.CommandType = System.Data.CommandType.Text;
                            cmd.CommandText = @"select top 1 'normal' as healthStatus";
                            cmd.CommandTimeout = 5;
                            SqlDataReader reader = cmd.ExecuteReader();
                            while (reader.Read())
                            {
                                config.DatabaseValue<string>(reader["healthStatus"]);
                            }
                            reader.Close();
                            returnValue = true;
                        }
                        conn.Close();
                        log.Warn("last connection test success!");
                    }
                }
                catch (Exception ex)
                {
                    log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                }
            }
            return returnValue;
        }

public void GetData()
        {
            log.Warn("get fullbackup target");
            using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Master)))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = fullBackupTargetQuery;
                    cmd.CommandType = CommandType.Text;
                    cmd.Parameters.Add("@HACHECKYN", SqlDbType.VarChar, 1).Value = HaCompleteCheckYN;
                    SqlDataReader reader = cmd.ExecuteReader();
                    while (reader.Read())
                    {
                        targets.Add
                            (
                                new Target
                                {
                                    SERVERNAME = config.DatabaseValue<string>(reader["SERVERNAME"]),
                                    DATABASE_NAME = config.DatabaseValue<string>(reader["DATABASE_NAME"])
                                }
                            );
                        if (!IsRunning) break;
                    }
                }
                conn.Close();
            }
        }

private List<PerfmonTypeA> GetPerfmonData()
        {
            List<PerfmonTypeA> ListPerfmonTypeA = new List<PerfmonTypeA>();
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = string.Format(PerfmonQuery, CounterDataOriginCurrentTableName);
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            ListPerfmonTypeA.Add(new PerfmonTypeA
                            {
                                Ip = LocalIp,
                                MachineName = config.DatabaseValue<string>(reader["MachineName"]),
                                ObjectName = config.DatabaseValue<string>(reader["ObjectName"]),
                                CounterName = config.DatabaseValue<string>(reader["CounterName"]),
                                InstanceName = config.DatabaseValue<string>(reader["InstanceName"]),
                                CounterValue = config.DatabaseValue<double>(reader["CounterValue"]).ToString("R"),
                                CounterDateTime = string.Format("{0:yyyy-MM-dd HH:mm:ss}", config.DatabaseValue<DateTime>(reader["CounterDateTime"]))
                            });
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return ListPerfmonTypeA;
        }

private string GetPerfmonData()
        {
            StringBuilder jsonResult = new StringBuilder();
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        //cmd.CommandText = PerfmonQuery.Replace("{0}", CounterDataOriginCurrentTableName);
                        cmd.CommandText = PerfmonQuery;
                        cmd.CommandTimeout = 10;
                        cmd.Parameters.Add("@private_ip", SqlDbType.NVarChar, 100).Value = private_ip;
                        cmd.Parameters.Add("@hostname", SqlDbType.NVarChar, 100).Value = hostname;
                        cmd.Parameters.Add("@ncp_mbr_no", SqlDbType.NVarChar, 100).Value = ncp_mbr_no;
                        cmd.Parameters.Add("@ncp_group_no", SqlDbType.NVarChar, 100).Value = ncp_group_no;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                jsonResult.Append(config.DatabaseValue<string>(reader[0]));
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return jsonResult.ToString();
        }

private void UpdateInsertCounterDetailsAutoUpdated(
            string MachineName
            , string ObjectName
            , string CounterName
            , int CounterType
            , int DefaultScale
            , string InstanceName
            , int InstanceIndex
            , string ParentName
            , int ParentObjectId
            , int TimeBaseA
            , int TimeBaseB)
        {
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText =
                            @"
                            set nocount on 
                            set transaction isolation level read uncommitted 
                            if not exists (
	                            select * 
	                            from [dbo].[CounterDetailsAutoUpdated]  with (nolock)
	                            where MachineName = @MachineName
	                            and ObjectName = @ObjectName
	                            and CounterName = @CounterName
	                            and InstanceName = @InstanceName
                            ) 
                            begin
	                            insert into  [dbo].[CounterDetailsAutoUpdated] 
	                            (MachineName, ObjectName, CounterName, CounterType, DefaultScale
	                            , InstanceName, InstanceIndex, ParentName, ParentObjectId, TimeBaseA
	                            , TimeBaseB, IsEnabledYN)
	                            values 
	                            (@MachineName, @ObjectName, @CounterName, @CounterType, @DefaultScale
	                            , @InstanceName, @InstanceIndex, @ParentName, @ParentObjectId, @TimeBaseA
	                            , @TimeBaseB, @IsEnabledYN) option(recompile)
                            end 
                            ";
                        cmd.CommandType = CommandType.Text;
                        cmd.Parameters.Clear();
                        cmd.Parameters.Add("@MachineName", SqlDbType.VarChar, 100).Value = MachineName;
                        cmd.Parameters.Add("@ObjectName", SqlDbType.VarChar, 100).Value = ObjectName;
                        cmd.Parameters.Add("@CounterName", SqlDbType.VarChar, 100).Value = CounterName;
                        cmd.Parameters.Add("@CounterType", SqlDbType.Int).Value = CounterType;
                        cmd.Parameters.Add("@DefaultScale", SqlDbType.Int).Value = DefaultScale;
                        cmd.Parameters.Add("@InstanceName", SqlDbType.VarChar, 100).Value = InstanceName;
                        cmd.Parameters.Add("@InstanceIndex", SqlDbType.Int).Value = InstanceIndex;
                        cmd.Parameters.Add("@ParentName", SqlDbType.VarChar, 100).Value = ParentName;
                        cmd.Parameters.Add("@ParentObjectId", SqlDbType.Int).Value = ParentObjectId;
                        cmd.Parameters.Add("@TimeBaseA", SqlDbType.Int).Value = TimeBaseA;
                        cmd.Parameters.Add("@TimeBaseB", SqlDbType.Int).Value = TimeBaseB;
                        cmd.Parameters.Add("@IsEnabledYN", SqlDbType.VarChar, 1).Value = "N";
                        cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

private List<Tuple<string,string>> LoadCounterDetailsFilterInfoFromRepository()
        {
            List<Tuple<string, string>> CounterDetailsFilterInfos = new List<Tuple<string, string>>();
            try
            {
                
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"select FilterType, ObjectName from [dbo].[CounterDetailsFilterInfo]";
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            CounterDetailsFilterInfos.Add(
                                new Tuple<string, string>(
                                    config.DatabaseValue<string>(reader["FilterType"])
                                    , config.DatabaseValue<string>(reader["ObjectName"])
                                ));
                        }
                    }
                    conn.Close();
                }
                log.Warn("PerfmonInit Step 3 : Load CounterDetailsFilterInfo Success");
                
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return CounterDetailsFilterInfos;
        }

private bool GetCounterData_CurrentTableName(out string CurrentTableName)
        {
            bool bReturn = false;
            string CounterDataOrigin_CurrentTableName = string.Empty; 
            try
            {

                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"
select top 1 TABLE_NAME
from INFORMATION_SCHEMA.TABLES
where TABLE_NAME like 'CounterDataOrigin[_]%' 
order by TABLE_NAME desc ";

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                CounterDataOrigin_CurrentTableName = config.DatabaseValue<string>(reader["TABLE_NAME"]);
                            }
                            bReturn = true; 
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                CounterDataOrigin_CurrentTableName = "";
            }
            CurrentTableName = CounterDataOrigin_CurrentTableName; 
            return bReturn;
        }

private void GetCounterDataInfo(out string GUID, out int RecordIndex, out string CounterDateTime)
        {
            GUID = string.Empty;
            RecordIndex = 0;
            CounterDateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            try
            {
                
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = string.Format(
@"
set nocount on 
declare @GUID nvarchar(100) 
declare @RecordIndex int 
select @GUID = GUID from [dbo].[DisplayToID]
select @RecordIndex = isnull(max(RecordIndex), 0) + 1 from {0}
select @GUID GUID, @RecordIndex RecordIndex
"
, CounterDataOriginCurrentTableName);
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            GUID = config.DatabaseValue<string>(reader["GUID"]);
                            RecordIndex = config.DatabaseValue<int>(reader["RecordIndex"]);
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

private void GenerateCounter()
        {
            log.Warn("PerfmonProbe Step 1 : GenerateCounter Start");
            
            counters.Clear();
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"SELECT [ObjectName] ,[CounterName] ,[InstanceName], [CounterID] FROM [dbo].[CounterDetails]";
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            string ObjectName = string.Empty;
                            string CounterName = string.Empty;
                            string InstanceName = string.Empty;
                            try
                            {
                                ObjectName = config.DatabaseValue<string>(reader["ObjectName"]);
                                CounterName = config.DatabaseValue<string>(reader["CounterName"]);
                                InstanceName = config.DatabaseValue<string>(reader["InstanceName"]);

                                counters.Add(
                                    new Tuple<string, string, string, int>(
                                        config.DatabaseValue<string>(reader["ObjectName"])
                                        , config.DatabaseValue<string>(reader["CounterName"])
                                        , config.DatabaseValue<string>(reader["InstanceName"])
                                        , config.DatabaseValue<int>(reader["CounterID"]))
                                    , new PerformanceCounter(ObjectName
                                        , CounterName
                                        , InstanceName
                                        )
                                    );
                            }
                            catch (Exception ex)
                            {
                                log.Error(string.Format("PerfmonProbe Step 1 : {0} : {1},{2},{3}", ex.Message, ObjectName, CounterName, InstanceName));
                            }

                        }
                    }
                    conn.Close();
                }
                log.Warn("PerfmonProbe Step 1 : GenerateCounter End");
                
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override string GetData()
        {
            try
            {
                list_dm_exec_query_stats_data_typeA.Clear();
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        //cmd.CommandText = string.Format(GetDataQuery, CurrentTableName);
                        cmd.CommandText = GetDataQuery;
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                list_dm_exec_query_stats_data_typeA.Add(
                                    new dm_exec_query_stats_typeA
                                    {
                                        ip = LocalIp,
                                        port = LocalPort,
                                        probe_time = ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"),
                                        execution_count = config.DatabaseValue<long>(reader["execution_count"]),
                                        total_worker_time = config.DatabaseValue<long>(reader["total_worker_time"]),
                                        total_logical_reads = config.DatabaseValue<long>(reader["total_logical_reads"]),
                                        total_physical_reads = config.DatabaseValue<long>(reader["total_physical_reads"]),
                                        total_logical_writes = config.DatabaseValue<long>(reader["total_logical_writes"]),
                                        total_elapsed_time = config.DatabaseValue<long>(reader["total_elapsed_time"]),
                                        total_grant_kb = config.DatabaseValue<long>(reader["total_grant_kb"]),
                                        sql_handle = config.DatabaseValue<string>(reader["sql_handle"]),
                                        statement_start_offset = config.DatabaseValue<int>(reader["statement_start_offset"]),
                                        statement_end_offset = config.DatabaseValue<int>(reader["statement_end_offset"]),
                                        plan_handle = config.DatabaseValue<string>(reader["plan_handle"]),
                                        query_hash = config.DatabaseValue<string>(reader["query_hash"]),
                                        query_plan_hash = config.DatabaseValue<string>(reader["query_plan_hash"])
                                    });
                            }
                        }
                    }
                    conn.Close();
                }

            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            var settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };

            var json = JsonConvert.SerializeObject(list_dm_exec_query_stats_data_typeA, settings);
            return json;
        }

private string GetStatementData()
        {
            try
            {
                list_dm_exec_query_stats_statement_TypeA.Clear();
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataStatementQuery;
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                list_dm_exec_query_stats_statement_TypeA.Add(
                                    new dm_exec_query_stats_statement_TypeA
                                    {
                                        ip = LocalIp,
                                        port = LocalPort,
                                        probe_time = ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"),
                                        query_hash = config.DatabaseValue<string>(reader["query_hash"]),
                                        query_statement = config.DatabaseValue<string>(reader["query_statement"])
                                    });
                            }
                        }
                    }
                    conn.Close();
                }

            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            var settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };

            var json = JsonConvert.SerializeObject(list_dm_exec_query_stats_statement_TypeA, settings);
            return json;

        }

protected override string GetData()
        {
            // WebApi 로 데이터 전송 
            StringBuilder sb = new StringBuilder();
            try
            {
                
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        //cmd.CommandText = string.Format(GetLatestResultsInJsonQuery, CurrentTableName );
                        cmd.CommandText = GetLatestResultsInJsonQuery;
                        cmd.Parameters.Add("@hostname", SqlDbType.NVarChar, 100).Value = this.MachineName;
                        cmd.Parameters.Add("@private_ip", SqlDbType.NVarChar, 100).Value = this.LocalIp; 
                        cmd.Parameters.Add("@ncp_mbr_no", SqlDbType.NVarChar, 100).Value = config.GetValue(Category.NPOT, Key.ncp_mbr_no);
                        cmd.Parameters.Add("@ncp_group_no", SqlDbType.NVarChar, 100).Value = config.GetValue(Category.NPOT, Key.ncp_group_no);
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                sb.Append(config.DatabaseValue<string>(reader[0]));
                            }
                        }
                    }
                    conn.Close();
                }
                
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return sb.ToString();
        }

private string GetStatementData()
        {
            // WebApi 로 데이터 전송 
            StringBuilder sb = new StringBuilder();
            try
            {
                
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetStatementResultsInJsonQuery;
                        cmd.Parameters.Add("@Machinename", SqlDbType.NVarChar, 100).Value = this.MachineName;
                        cmd.Parameters.Add("@private_ip", SqlDbType.NVarChar, 100).Value = this.LocalIp;
                        cmd.Parameters.Add("@logtypes", SqlDbType.NVarChar, 100).Value = this.ClaLogTypes;
                        cmd.Parameters.Add("@clauserkey", SqlDbType.NVarChar, 100).Value = this.ClaUserKey;
                        cmd.Parameters.Add("@subject", SqlDbType.NVarChar, 100).Value = "dm_exec_query_stats2";
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                sb.Append(config.DatabaseValue<string>(reader[0]));
                            }
                        }
                    }
                    conn.Close();
                }
                
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return sb.ToString();
        }

protected override string GetData()
        {
            try
            {
                list_dm_os_workers_data_TypeA.Clear();
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                list_dm_os_workers_data_TypeA.Add(
                                    new dm_os_workers_data_TypeA
                                    {
                                        ip = LocalIp,
                                        port = LocalPort,
                                        probe_time = ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"),
                                        session_limit = config.DatabaseValue<int>(reader["session_limit"]),
                                        current_session_cnt = config.DatabaseValue<int>(reader["current_session_cnt"]),
                                        max_worker_thread = config.DatabaseValue<int>(reader["max_worker_thread"]),
                                        current_worker_cnt = config.DatabaseValue<int>(reader["current_worker_cnt"]),
                                        scheduler_id = config.DatabaseValue<int>(reader["scheduler_id"]),
                                        quantum_used = config.DatabaseValue<long>(reader["quantum_used"]),
                                        is_preemptive = config.DatabaseValue<bool>(reader["is_preemptive"]).ToString(),
                                        context_switch_count = config.DatabaseValue<long>(reader["context_switch_count"]),
                                        state = config.DatabaseValue<string>(reader["state"]),
                                        last_wait_type = config.DatabaseValue<string>(reader["last_wait_type"]),
                                        processor_group = config.DatabaseValue<short>(reader["processor_group"]),
                                        tasks_processed_count = config.DatabaseValue<int>(reader["tasks_processed_count"]),
                                        task_address = config.DatabaseValue<string>(reader["task_address"]),
                                        session_id = config.DatabaseValue<int>(reader["session_id"]),
                                        original_login_name = config.DatabaseValue<string>(reader["original_login_name"]),
                                        host_name = config.DatabaseValue<string>(reader["host_name"]),
                                        program_name = config.DatabaseValue<string>(reader["program_name"]),
                                        command = config.DatabaseValue<string>(reader["command"]),
                                        cpu_time = config.DatabaseValue<long>(reader["cpu_time"]),
                                        total_elapsed_time = config.DatabaseValue<long>(reader["total_elapsed_time"]),
                                        reads = config.DatabaseValue<long>(reader["reads"]),
                                        writes = config.DatabaseValue<long>(reader["writes"]),
                                        logical_reads = config.DatabaseValue<long>(reader["logical_reads"]),
                                        query_hash = config.DatabaseValue<string>(reader["query_hash"]),
                                        sql_handle = config.DatabaseValue<string>(reader["sql_handle"]),
                                        statement_start_offset = config.DatabaseValue<int>(reader["statement_start_offset"]),
                                        statement_end_offset = config.DatabaseValue<int>(reader["statement_end_offset"]),
                                        database_id = config.DatabaseValue<short>(reader["database_id"]),
                                        blocking_session_id = config.DatabaseValue<int>(reader["blocking_session_id"]),
                                        open_transaction_count = config.DatabaseValue<int>(reader["open_transaction_count"]),
                                        percent_complete = config.DatabaseValue<Single>(reader["percent_complete"]),
                                        transaction_isolation_level = config.DatabaseValue<short>(reader["transaction_isolation_level"]),
                                        query_plan_hash = config.DatabaseValue<string>(reader["query_plan_hash"]),
                                        plan_handle = config.DatabaseValue<string>(reader["plan_handle"]),
                                        query_text = config.DatabaseValue<string>(reader["query_text"]),
                                    });
                            }
                        }
                    }
                    conn.Close();
                }

            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }

            var settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };

            var json = JsonConvert.SerializeObject(list_dm_os_workers_data_TypeA, settings);
            return json;
        }

protected override string GetData()
        {
            // WebApi 로 데이터 전송 
            StringBuilder sb = new StringBuilder();
            try
            {
                
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        //cmd.CommandText = string.Format(GetLatestResultsInJsonQuery, CurrentTableName, ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        cmd.CommandText = GetLatestResultsInJsonQuery;
                        cmd.Parameters.Add("@hostname", SqlDbType.NVarChar, 100).Value = this.MachineName;
                        cmd.Parameters.Add("@clauserkey", SqlDbType.NVarChar, 100).Value = this.ClaUserKey;
                        cmd.Parameters.Add("@logtypes", SqlDbType.NVarChar, 100).Value = this.ClaLogTypes;
                        cmd.Parameters.Add("@subject", SqlDbType.NVarChar, 100).Value = BaseTableName;
                        cmd.Parameters.Add("@private_ip", SqlDbType.NVarChar, 100).Value = this.LocalIp;
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                //single 관련 에러 없는지 볼것 
                                sb.Append(config.DatabaseValue<string>(reader[0]));
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return sb.ToString();
        }

protected override string GetData()
        {
            try
            {
                list_sp_loc2_TypeA.Clear();
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        SqlDataReader reader = cmd.ExecuteReader();
                        
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                list_sp_loc2_TypeA.Add(
                                    new sp_lock2_TypeA
                                    {
                                        ip = LocalIp,
                                        port = LocalPort,
                                        probe_time = ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"),
                                        hh_mm_ss     = config.DatabaseValue<string>(reader["hh_mm_ss"]),
                                        wait_sec     = config.DatabaseValue<long>(reader["wait_sec"]),
                                        locktree     = config.DatabaseValue<string>(reader["locktree"]).Trim(),
                                        spid         = config.DatabaseValue<int>(reader["spid"]),
                                        kpid         = config.DatabaseValue<int>(reader["kpid"]),
                                        blocked      = config.DatabaseValue<int>(reader["blocked"]),
                                        waittype     = config.DatabaseValue<string>(reader["waittype"]),
                                        waittime     = config.DatabaseValue<long>(reader["waittime"]),
                                        lastwaittype = config.DatabaseValue<string>(reader["lastwaittype"]).Trim(),
                                        waitresource = config.DatabaseValue<string>(reader["waitresource"]).Trim(),
                                        dbid         = config.DatabaseValue<int>(reader["dbid"]),
                                        uid          = config.DatabaseValue<int>(reader["uid"]),
                                        cpu          = config.DatabaseValue<long>(reader["cpu"]),
                                        physical_io  = config.DatabaseValue<long>(reader["physical_io"]),
                                        memusage     = config.DatabaseValue<long>(reader["memusage"]),
                                        login_time   = config.DatabaseValue<DateTime>(reader["login_time"]),
                                        last_batch   = config.DatabaseValue<DateTime>(reader["last_batch"]),
                                        ecid         = config.DatabaseValue<int>(reader["ecid"]),
                                        open_tran    = config.DatabaseValue<int>(reader["open_tran"]),
                                        status       = config.DatabaseValue<string>(reader["status"]).Trim(),
                                        sid          = config.DatabaseValue<string>(reader["sid"]).Trim(),
                                        hostname     = config.DatabaseValue<string>(reader["hostname"]).Trim(),
                                        program_name = config.DatabaseValue<string>(reader["program_name"]).Trim(),
                                        hostprocess  = config.DatabaseValue<string>(reader["hostprocess"]).Trim(),
                                        cmd          = config.DatabaseValue<string>(reader["cmd"]).Trim(),
                                        nt_domain    = config.DatabaseValue<string>(reader["nt_domain"]).Trim(),
                                        nt_username  = config.DatabaseValue<string>(reader["nt_username"]).Trim(),
                                        net_address  = config.DatabaseValue<string>(reader["net_address"]).Trim(),
                                        net_library  = config.DatabaseValue<string>(reader["net_library"]).Trim(),
                                        loginame     = config.DatabaseValue<string>(reader["loginame"]).Trim(),
                                        context_info = config.DatabaseValue<string>(reader["context_info"]).Trim(),
                                        sql_handle   = config.DatabaseValue<string>(reader["sql_handle"]).Trim(),
                                        stmt_start   = config.DatabaseValue<int>(reader["stmt_start"]),
                                        stmt_end     = config.DatabaseValue<int>(reader["stmt_end"]),
                                        request_id   = config.DatabaseValue<int>(reader["request_id"]),
                                        number       = config.DatabaseValue<int>(reader["number"]),
                                        encrypted    = config.DatabaseValue<string>(reader["encrypted"]).Trim(),
                                        text         = config.DatabaseValue<string>(reader["text"])
                                    });
                            }
                        }
                    }
                    conn.Close();
                }

            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            var settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };

            var json = JsonConvert.SerializeObject(list_sp_loc2_TypeA, settings);
            return json;
        }

protected override string GetData()
        {
            StringBuilder sb = new StringBuilder();
            try
            {
                
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = string.Format(GetLatestResultsInJsonQuery, CurrentTableName);
                        cmd.Parameters.Add("@clauserkey", SqlDbType.NVarChar, 100).Value = this.ClaUserKey;
                        cmd.Parameters.Add("@logtypes", SqlDbType.NVarChar, 100).Value = this.ClaLogTypes;
                        cmd.Parameters.Add("@hostname", SqlDbType.NVarChar, 100).Value = this.MachineName; 
                        cmd.Parameters.Add("@subject", SqlDbType.NVarChar, 100).Value = BaseTableName;
                        cmd.Parameters.Add("@private_ip", SqlDbType.NVarChar, 100).Value = this.LocalIp;
                        cmd.Parameters.Add("@ProbeTime", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000")); 
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                sb.Append(config.DatabaseValue<string>(reader[0]));
                            }
                        }
                    }
                    conn.Close();
                }

            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return sb.ToString();
        }

protected virtual bool GetCurrentTableName(string BaseTableName, out string CurrentTableName)
        {
            bool bReturn = false;
            string TableName = string.Empty;
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"
select top 1 TABLE_NAME
from INFORMATION_SCHEMA.TABLES
where TABLE_NAME like @BaseTableName+'[_]________[_]______' 
order by TABLE_NAME desc 
option (recompile)
";
                        cmd.Parameters.Add("@BaseTableName", SqlDbType.NVarChar, 100).Value = BaseTableName;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                TableName = config.DatabaseValue<string>(reader["TABLE_NAME"]);
                            }
                            bReturn = true;
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                TableName = "";
            }

            CurrentTableName = TableName;
            return bReturn;
        }

protected virtual bool ExistTable(string TableName)
        {
            bool bReturn = false;
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"
select top 1 TABLE_NAME
from INFORMATION_SCHEMA.TABLES
where TABLE_NAME = @TableName
order by TABLE_NAME desc ";
                        cmd.Parameters.Add("@TableName", SqlDbType.NVarChar, 100).Value = TableName;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            bReturn = true;
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
            return bReturn;
        }

private void GetQueryStatement()
        {
            log.Warn("GetQueryStatement");

            try
            {
                DateTime DatetimeNow = DateTime.Now;
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetQueryStatementQuery;
                        cmd.Parameters.Add("@last_porbe_time", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        cmd.Parameters.Add("@delete_from_day", SqlDbType.Int).Value = 3;
                        cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

private void LocalSaveDeltaValue()
        {
            log.Warn("LocalSaveDeltaValue");

            try
            {
                DateTime DatetimeNow = DateTime.Now;
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = LocalSaveDeltaQuery;
                        cmd.Parameters.Add("@probe_time", SqlDbType.DateTime).Value = Convert.ToDateTime(ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000"));
                        cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override void GetData()
        {
            // 데이터를 구한다. 
            log.Warn(string.Format("{0} GetData started", BaseTableName));
            try
            {
                DateTime DatetimeNow = DateTime.Now;
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                buffer.Add(new dm_exec_query_stats_data
                                {
                                    execution_count = config.DatabaseValue<long>(reader["execution_count"]),
                                    total_worker_time = config.DatabaseValue<long>(reader["total_worker_time"]),
                                    total_logical_reads = config.DatabaseValue<long>(reader["total_logical_reads"]),
                                    total_physical_reads = config.DatabaseValue<long>(reader["total_physical_reads"]),
                                    total_logical_writes = config.DatabaseValue<long>(reader["total_logical_writes"]),
                                    total_elapsed_time = config.DatabaseValue<long>(reader["total_elapsed_time"]),
                                    total_grant_kb = config.DatabaseValue<long>(reader["total_grant_kb"]),
                                    sql_handle = config.DatabaseValue<byte[]>(reader["sql_handle"]),
                                    statement_start_offset = config.DatabaseValue<int>(reader["statement_start_offset"]),
                                    statement_end_offset = config.DatabaseValue<int>(reader["statement_end_offset"]),
                                    plan_handle = config.DatabaseValue<byte[]>(reader["plan_handle"]),
                                    query_hash = config.DatabaseValue<byte[]>(reader["query_hash"]),
                                    query_plan_hash = config.DatabaseValue<byte[]>(reader["query_plan_hash"])
                                });
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override void GetData()
        {
            // 데이터를 구한다. 
            log.Warn(string.Format("{0} GetData started", BaseTableName));
            try
            {
                string probe_time = ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000");
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                buffer.Add(new dm_os_workers_data
                                {
                                    probe_time = Convert.ToDateTime(probe_time),

                                    session_limit = config.DatabaseValue<int>(reader["session_limit"]),
                                    current_session_cnt = config.DatabaseValue<int>(reader["current_session_cnt"]),
                                    max_worker_thread = config.DatabaseValue<int>(reader["max_worker_thread"]),
                                    current_worker_cnt = config.DatabaseValue<int>(reader["current_worker_cnt"]),
                                    scheduler_id = config.DatabaseValue<int>(reader["scheduler_id"]),
                                    quantum_used = config.DatabaseValue<long>(reader["quantum_used"]),

                                    is_preemptive = config.DatabaseValue<bool>(reader["is_preemptive"]),
                                    context_switch_count = config.DatabaseValue<int>(reader["context_switch_count"]),
                                    state = config.DatabaseValue<string>(reader["state"]),
                                    last_wait_type = config.DatabaseValue<string>(reader["last_wait_type"]),
                                    processor_group = config.DatabaseValue<short>(reader["processor_group"]),

                                    tasks_processed_count = config.DatabaseValue<int>(reader["tasks_processed_count"]),
                                    task_address = config.DatabaseValue<byte[]>(reader["task_address"]),
                                    session_id = config.DatabaseValue<short>(reader["session_id"]),
                                    original_login_name = config.DatabaseValue<string>(reader["original_login_name"]),
                                    host_name = config.DatabaseValue<string>(reader["host_name"]),

                                    program_name = config.DatabaseValue<string>(reader["program_name"]),
                                    command = config.DatabaseValue<string>(reader["command"]),
                                    cpu_time = config.DatabaseValue<int>(reader["cpu_time"]),
                                    total_elapsed_time = config.DatabaseValue<int>(reader["total_elapsed_time"]),
                                    reads = config.DatabaseValue<long>(reader["reads"]),

                                    writes = config.DatabaseValue<long>(reader["writes"]),
                                    logical_reads = config.DatabaseValue<long>(reader["logical_reads"]),
                                    query_hash = config.DatabaseValue<byte[]>(reader["query_hash"]),
                                    sql_handle = config.DatabaseValue<byte[]>(reader["sql_handle"]),
                                    statement_start_offset = config.DatabaseValue<int>(reader["statement_start_offset"]),

                                    statement_end_offset = config.DatabaseValue<int>(reader["statement_end_offset"]),
                                    database_id = config.DatabaseValue<short>(reader["database_id"]),
                                    blocking_session_id = config.DatabaseValue<short>(reader["blocking_session_id"]),
                                    open_transaction_count = config.DatabaseValue<int>(reader["open_transaction_count"]),
                                    percent_complete = config.DatabaseValue<Single>(reader["percent_complete"]),

                                    transaction_isolation_level = config.DatabaseValue<short>(reader["transaction_isolation_level"]),
                                    query_plan_hash = config.DatabaseValue<byte[]>(reader["query_plan_hash"]),
                                    plan_handle = config.DatabaseValue<byte[]>(reader["plan_handle"]),
                                    query_text = config.DatabaseValue<string>(reader["query_text"])

                                });
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override void GetData()
        {
            // 데이터를 구한다. 
            log.Warn(string.Format("{0} GetData started", BaseTableName));
            try
            {
                string probe_time = ProbeTime.ToString("yyyy-MM-dd HH:mm:ss.000");
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                buffer.Add(new sp_lock2_data
                                {
                                    //MachineName = config.GetValue(Category.GLOBAL, Key.hostname),
                                    //FullInstanceName = config.DatabaseValue<string>(reader["servicename"]),
                                    //MachinePrivateIp = config.GetValue(Category.GLOBAL, Key.private_ip),
                                    probe_time = Convert.ToDateTime(probe_time),
                                    hh_mm_ss = config.DatabaseValue<string>(reader["hh_mm_ss"]),
                                    wait_sec = config.DatabaseValue<long>(reader["wait_sec"]),
                                    locktree = config.DatabaseValue<string>(reader["locktree"]),
                                    spid = config.DatabaseValue<short>(reader["spid"]),
                                    kpid = config.DatabaseValue<short>(reader["kpid"]),
                                    blocked = config.DatabaseValue<short>(reader["blocked"]),
                                    waittype = config.DatabaseValue<byte[]>(reader["waittype"]),
                                    waittime = config.DatabaseValue<long>(reader["waittime"]),
                                    lastwaittype = config.DatabaseValue<string>(reader["lastwaittype"]),
                                    waitresource = config.DatabaseValue<string>(reader["waitresource"]),
                                    dbid = config.DatabaseValue<short>(reader["dbid"]),
                                    uid = config.DatabaseValue<short>(reader["uid"]),
                                    cpu = config.DatabaseValue<int>(reader["cpu"]),
                                    physical_io = config.DatabaseValue<long>(reader["physical_io"]),
                                    memusage = config.DatabaseValue<int>(reader["memusage"]),
                                    login_time = config.DatabaseValue<DateTime>(reader["login_time"]),
                                    last_batch = config.DatabaseValue<DateTime>(reader["last_batch"]),
                                    ecid = config.DatabaseValue<short>(reader["ecid"]),
                                    open_tran = config.DatabaseValue<short>(reader["open_tran"]),
                                    status = config.DatabaseValue<string>(reader["status"]),
                                    sid = config.DatabaseValue<byte[]>(reader["sid"]),
                                    hostname = config.DatabaseValue<string>(reader["hostname"]),
                                    program_name = config.DatabaseValue<string>(reader["program_name"]),
                                    hostprocess = config.DatabaseValue<string>(reader["hostprocess"]),
                                    cmd = config.DatabaseValue<string>(reader["cmd"]),
                                    nt_domain = config.DatabaseValue<string>(reader["nt_domain"]),
                                    nt_username = config.DatabaseValue<string>(reader["nt_username"]),
                                    net_address = config.DatabaseValue<string>(reader["net_address"]),
                                    net_library = config.DatabaseValue<string>(reader["net_library"]),
                                    loginame = config.DatabaseValue<string>(reader["loginame"]),
                                    context_info = config.DatabaseValue<byte[]>(reader["context_info"]),
                                    sql_handle = config.DatabaseValue<byte[]>(reader["sql_handle"]),
                                    stmt_start = config.DatabaseValue<int>(reader["stmt_start"]),
                                    stmt_end = config.DatabaseValue<int>(reader["stmt_end"]),
                                    request_id = config.DatabaseValue<int>(reader["request_id"]),
                                    objectid = config.DatabaseValue<int>(reader["objectid"]),
                                    number = config.DatabaseValue<short>(reader["number"]),
                                    encrypted = config.DatabaseValue<bool>(reader["encrypted"]),
                                    text = config.DatabaseValue<string>(reader["text"])
                                    //죽 다 넣어준다. 
                                });
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override bool GetCurrentTableName(string BaseTableName, out string CurrentTableName)
        {
            bool bReturn = false;
            string TableName = string.Empty;
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"
select top 1 TABLE_NAME
from INFORMATION_SCHEMA.TABLES
where TABLE_NAME like @BaseTableName+'SendHist' 
order by TABLE_NAME desc ";
                        cmd.Parameters.Add("@BaseTableName", SqlDbType.NVarChar, 100).Value = BaseTableName;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                TableName = config.DatabaseValue<string>(reader["TABLE_NAME"]);
                            }
                            bReturn = true;
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                TableName = "";
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }

            CurrentTableName = TableName;
            return bReturn;
        }

private void LoadLastSentData()
        {
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = string.Format(@"
select 
	  LogDate
	, ErrorLevel
	, Text
from [dbo].[{0}SendHist]
", BaseTableName);
                        cmd.Parameters.Add("@BaseTableName", SqlDbType.NVarChar, 100).Value = BaseTableName;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                xpLogTableBuffer.Add(new Tuple<DateTime, string, string>
                                (
                                    config.DatabaseValue<DateTime>(reader["LogDate"]),
                                    config.DatabaseValue<string>(reader["ErrorLevel"]),
                                    config.DatabaseValue<string>(reader["Text"])
                                ), "");
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override void GetData()
        {
            // 데이터를 구한다. 

            log.Warn(string.Format("{0} GetData started", BaseTableName));
            try
            {
                if (xpLogTableBuffer.Count > 0)
                {
                    maxDateTime = xpLogTableBuffer.Max(x => x.Key.Item1);
                }

                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        cmd.Parameters.Add("@LogStartTime", SqlDbType.DateTime).Value = maxDateTime;
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                try
                                {
                                    if (!xpLogNewBuffer.ContainsKey(new Tuple<DateTime, string, string>
                                    (
                                        config.DatabaseValue<DateTime>(reader["LogDate"]),
                                        config.DatabaseValue<string>(reader["ProcessInfo"]),
                                        config.DatabaseValue<string>(reader["Text"])
                                    )))
                                        xpLogNewBuffer.Add(new Tuple<DateTime, string, string>
                                        (
                                            config.DatabaseValue<DateTime>(reader["LogDate"]),
                                            config.DatabaseValue<int>(reader["ErrorLevel"]).ToString(),
                                            config.DatabaseValue<string>(reader["Text"])
                                        ), "");
                                }
                                catch (Exception ex) { log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace)); }
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override bool GetCurrentTableName(string BaseTableName, out string CurrentTableName)
        {
            bool bReturn = false;
            string TableName = string.Empty;
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = @"
select top 1 TABLE_NAME
from INFORMATION_SCHEMA.TABLES
where TABLE_NAME like @BaseTableName+'SendHist' 
order by TABLE_NAME desc ";
                        cmd.Parameters.Add("@BaseTableName", SqlDbType.NVarChar, 100).Value = BaseTableName;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                TableName = config.DatabaseValue<string>(reader["TABLE_NAME"]);
                            }
                            bReturn = true;
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                TableName = "";
            }

            CurrentTableName = TableName;
            return bReturn;
        }

private void LoadLastSentData()
        {
            try
            {
                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = string.Format(@"
select 
	  LogDate
	, ProcessInfo
	, Text
from [dbo].[{0}SendHist]
", BaseTableName);
                        cmd.Parameters.Add("@BaseTableName", SqlDbType.NVarChar, 100).Value = BaseTableName;

                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                xpLogTableBuffer.Add(new Tuple<DateTime, string, string>
                                (
                                    config.DatabaseValue<DateTime>(reader["LogDate"]),
                                    config.DatabaseValue<string>(reader["ProcessInfo"]),
                                    config.DatabaseValue<string>(reader["Text"])
                                ), "");
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

protected override void GetData()
        {
            // 데이터를 구한다. 
            
            log.Warn(string.Format("{0} GetData started", BaseTableName));
            try
            {
                if (xpLogTableBuffer.Count > 0)
                {
                    maxDateTime = xpLogTableBuffer.Max(x => x.Key.Item1);
                }

                using (SqlConnection conn = new SqlConnection(config.GetConnectionString(InitialCatalog.Repository)))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandType = CommandType.Text;
                        cmd.CommandText = GetDataQuery;
                        cmd.Parameters.Add("@LogStartTime", SqlDbType.DateTime).Value = maxDateTime;
                        SqlDataReader reader = cmd.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                try
                                {
                                    if (!xpLogNewBuffer.ContainsKey(new Tuple<DateTime, string, string>
                                        (
                                            config.DatabaseValue<DateTime>(reader["LogDate"]),
                                            config.DatabaseValue<string>(reader["ProcessInfo"]),
                                            config.DatabaseValue<string>(reader["Text"])
                                        )))
                                    xpLogNewBuffer.Add(new Tuple<DateTime, string, string>
                                        (
                                            config.DatabaseValue<DateTime>(reader["LogDate"]),
                                            config.DatabaseValue<string>(reader["ProcessInfo"]),
                                            config.DatabaseValue<string>(reader["Text"])
                                        ), "");
                                }
                                catch (Exception ex)
                                {
                                    log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
                                } 
                            }
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                log.Error(string.Format("{0}, {1}", ex.Message, ex.StackTrace));
            }
        }

bool QueryExecuter(string listStringQuery, int connectionTimeout = 5, int commandTimeout = 30, string queryEchoYN="N", string countYN="N", string headerYN = "N")
        {
            bool bReturn = false;
            sbResultAll.Clear();
            
            List<string> querys = TranString.ReadQuery(listStringQuery);
            if (queryEchoYN.Equals("Y", StringComparison.OrdinalIgnoreCase))
            {
                sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                sbResultAll.Append(DateTime.Now + Environment.NewLine);
                sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);
            }
            foreach (var query in querys)
            {
                try
                {
                    if (queryEchoYN.Equals("Y", StringComparison.OrdinalIgnoreCase))
                    {
                        sbResultAll.Append("-->>---------------------------------");
                        sbResultAll.Append(query + Environment.NewLine);
                        sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);
                    }
                    if (query.Trim().ToUpper().StartsWith("USE"))
                    {
                        string[] database = query.Trim().Split(new[] { Environment.NewLine, " " }, StringSplitOptions.None);
                        connectionString = SetConnectionString(database[1], connectionTimeout);
                        //comboBoxDatabase.InvokeIfRequired(s =>
                        //{
                        //    s.Text = "";
                        //    s.SelectedText = database[1].ToString();
                        //});
                    }
                    string result = string.Empty;
                    using (SqlConnection conn = new SqlConnection(connectionString))
                    {
                        conn.Open();
                        conn.InfoMessage += Conn_InfoMessage; // message hook (like backup message) 

                        using (SqlCommand cmd = conn.CreateCommand())
                        {
                            cmd.StatementCompleted += Cmd_StatementCompleted; // retrive row count
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = query;
                            cmd.CommandTimeout = commandTimeout;
                            SqlDataReader reader = cmd.ExecuteReader();
                            int recordsAffected = reader.RecordsAffected;

                            do
                            {
                                StringBuilder sb = new StringBuilder();
                                string Header = string.Empty;
                                string Line = string.Empty;
                                DataTable schemaTable = reader.GetSchemaTable();
                                if (schemaTable != null)
                                {

                                    try
                                    {
                                        if (headerYN.Equals("Y", StringComparison.OrdinalIgnoreCase))
                                        {
                                            foreach (DataRow row in schemaTable.Rows)
                                            {
                                                foreach (DataColumn column in schemaTable.Columns)
                                                {
                                                    if (column.ColumnName == "ColumnName")
                                                    {
                                                        Header = Header + row[column] + "\t";
                                                        Line = Line + "------- ";
                                                    }
                                                }
                                            }
                                            Header = Header + Environment.NewLine;
                                            Line = Line + Environment.NewLine;
                                            sb.Append(Header);
                                            sb.Append(Line);
                                        }

                                        while (reader.Read())
                                        {
                                            for (int i = 0; i < reader.FieldCount; i++)
                                            {
                                                if (reader.GetValue(i).ToString() == "System.Byte[]")
                                                    sb.Append("0x" + BitConverter.ToString((byte[])reader.GetValue(i)).Replace("-", ""));
                                                else
                                                    sb.Append(reader.GetValue(i).ToString());
                                                sb.Append("\t");
                                            }
                                            sb.Append(Environment.NewLine);
                                        }

                                    }
                                    catch (SqlException ex)
                                    {
                                        errorCnt++;
                                        sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                                        sbResultAll.Append("--sql exception info : " + Environment.NewLine);
                                        sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                                        for (int i = 0; i < ex.Errors.Count; i++)
                                        {
                                            sbResultAll.Append("Inner SqlException No #" + i + Environment.NewLine +
                                            "Message: " + ex.Errors[i].Message + Environment.NewLine +
                                            "Source: " + ex.Errors[i].Source + Environment.NewLine +
                                            "Procedure: " + ex.Errors[i].Procedure + Environment.NewLine);
                                        }
                                    }
                                    finally
                                    {
                                        sb.Append(Environment.NewLine);
                                        sbResultAll.Append(sb);
                                        if (countYN.Equals("Y", StringComparison.OrdinalIgnoreCase))
                                        {
                                            sbResultAll.Append(string.Format("({0} {1} affected)" + Environment.NewLine + Environment.NewLine, recordCount, (recordCount == 1) ? "row" : "rows"));
                                        }
                                    }
                                }
                                else
                                {
                                    string[] Query = query.Trim().Split(new[] { Environment.NewLine, " " }, StringSplitOptions.None);
                                    if (
                                        Query[0].Equals("update", StringComparison.OrdinalIgnoreCase)
                                        || Query[0].Equals("insert", StringComparison.OrdinalIgnoreCase)
                                        || Query[0].Equals("delete", StringComparison.OrdinalIgnoreCase)
                                        || Query[1].Equals("update", StringComparison.OrdinalIgnoreCase)
                                        || Query[1].Equals("insert", StringComparison.OrdinalIgnoreCase)
                                        || Query[1].Equals("delete", StringComparison.OrdinalIgnoreCase)
                                        )
                                        sbResultAll.Append(string.Format("({0} {1} affected)" + Environment.NewLine + Environment.NewLine, recordCount, (recordCount == 1) ? "row" : "rows"));
                                    else
                                        sbResultAll.Append(string.Format("Commands completed successfully." + Environment.NewLine + Environment.NewLine));
                                }
                                reader.NextResult();
                            } while (reader.HasRows);
                        }
                        conn.Close();
                        bReturn = true;
                    }
                }

                catch (SqlException ex)
                {
                    errorCnt++;
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                    sbResultAll.Append("--sql exception info : " + Environment.NewLine);
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);

                    for (int i = 0; i < ex.Errors.Count; i++)
                    {
                        sbResultAll.Append("SqlException No #" + i + Environment.NewLine +
                        "Message: " + ex.Errors[i].Message + Environment.NewLine +
                        "Source: " + ex.Errors[i].Source + Environment.NewLine +
                        "Procedure: " + ex.Errors[i].Procedure + Environment.NewLine);
                    }

                    sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);
                    bReturn = false;
                }
                catch (Exception ex)
                {
                    errorCnt++;
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                    sbResultAll.Append("--exception info : " + Environment.NewLine);
                    sbResultAll.Append("-->>---------------------------------" + Environment.NewLine);
                    sbResultAll.Append(ex.Message);
                    sbResultAll.Append("---------------------------------<<--" + Environment.NewLine + Environment.NewLine);

                    bReturn = false;
                }
                finally
                {
                    if (syncAsync.Equals("Async", StringComparison.OrdinalIgnoreCase))
                        Common.FileLogWriteLine(logFileFullname, sbResultAll.ToString());

                }
            }

            if (syncAsync.Equals("Async", StringComparison.OrdinalIgnoreCase))
                Common.FileLogWriteLine(logFileFullname, "async cmd completed");

            return bReturn;
        }

public static bool Delete(int employeeId, int jobId)
        {
            Int32 rowsAffected = 0;
            SqlConnection cn = GetConnection();
            using (SqlCommand sqlCmd = cn.CreateCommand())
            {
                sqlCmd.CommandText = "DELETE FROM EmployeePayRate WHERE EmployeePayRateEmployeeId=" +
                    employeeId + " AND EmployeePayRateEmployeeJobId=" + jobId;
                rowsAffected = sqlCmd.ExecuteNonQuery();
            }
            FinishedWithConnection(cn);
            return (rowsAffected != 0);
        }

public static bool RemoveAllSettings(int employeeId)
        {
            Int32 rowsAffected = 0;
            SqlConnection cn = GetConnection();
            using (SqlCommand sqlCmd = cn.CreateCommand())
            {
                sqlCmd.CommandText = "DELETE FROM EmployeeSetting WHERE EmployeeSettingEmployeeId=@EmployeeSettingEmployeeId";

                BuildSqlParameter(sqlCmd, "@EmployeeSettingEmployeeId", SqlDbType.Int, employeeId);

                rowsAffected = sqlCmd.ExecuteNonQuery();
            }
            FinishedWithConnection(cn);
            return (rowsAffected != 0);
        }

private static void Delete(SqlConnection cn, int id)
        {
            Int32 rowsAffected = 0;
            using (SqlCommand sqlCmd = cn.CreateCommand())
            {
                sqlCmd.CommandText = "DELETE FROM EmployeeSetting WHERE EmployeeSettingId=@EmployeeSettingId";

                BuildSqlParameter(sqlCmd, "@EmployeeSettingId", SqlDbType.Int, id);

                rowsAffected = sqlCmd.ExecuteNonQuery();
            }
        }

private static void Update(SqlConnection cn, int id, string stringValue)
        {
            Int32 rowsAffected = 0;
            using (SqlCommand sqlCmd = cn.CreateCommand())
            {
                // UPDATE Setting SET SettingValue=stringValue WHERE SettingId=setting
                sqlCmd.CommandText = "UPDATE EmployeeSetting SET EmployeeSettingStringValue=@EmployeeSettingStringValue WHERE EmployeeSettingId=@EmployeeSettingId";

                BuildSqlParameter(sqlCmd, "@EmployeeSettingId", SqlDbType.Int, id);
                BuildSqlParameter(sqlCmd, "@EmployeeSettingStringValue", SqlDbType.Text, stringValue);

                rowsAffected = sqlCmd.ExecuteNonQuery();
            }
        }

private static void Update(SqlConnection cn, int id, int? intValue)
        {
            Int32 rowsAffected = 0;
            using (SqlCommand sqlCmd = cn.CreateCommand())
            {
                // UPDATE Setting SET SettingValue=stringValue WHERE SettingId=setting
                sqlCmd.CommandText = "UPDATE EmployeeSetting SET EmployeeSettingIntValue=@EmployeeSettingIntValue WHERE EmployeeSettingId=@EmployeeSettingId";

                BuildSqlParameter(sqlCmd, "@EmployeeSettingId", SqlDbType.Int, id);
                BuildSqlParameter(sqlCmd, "@EmployeeSettingIntValue", SqlDbType.Int, intValue);

                rowsAffected = sqlCmd.ExecuteNonQuery();
            }
        }

See More Examples